https://www.commanderx16.com/forum/index.php?/home/

https://www.commanderx16.com/emulator/x16emu.html
• The evolution of 8-Bit

* Inexpensive, reliable, educational
* Unique, not a clone or a sequel
* A real CPU not emulation
* Classic chips on-board

The modern retro computer

• TRY IT ONLINE HERE

• Commander X16 is coming…

See FAQ & forum for announcements!
Pictured: Commander X16P concept art

https://www.argenox.com/library/msp430/msp430-uart-peripheral-chapter-8/

# MSP430 UART PERIPHERAL

## Physical Interface

From a pinout perspective, UART signals only require one line for unidirectional communications, although two are typically used for bi-directional transmit and receive. Being asynchronous, UART signals don’t require any other clock line because the two UART devices agree on a common baud rate, stop, start and data bits. This makes the receiver capable of decoding the data. UART is connected by crossing the TX and RX lines, as shown below:

UART transmits bits sequentially by pulling the UART line low for a fixed amount of time determined by the baud rate. The UART line when idle is high at the I/O level, 3.3V or whatever the VCC of the MSP430 is set. RS232, on the other hand, uses similar signaling to UART but also incompatible voltage levels (the voltages are high and some are negative) that will damage the MSP430. Therefore, never connect an RS232 device directly to the MSP430. Use a MAX232 or similar device to convert between the two signal levels.

The smallest element of transmission is the UART frame or character, which consists of the Start bit/s, data bits, stop bits and optional parity bits, as shown below:

 Bit number 1 2 3 4 5 6 7 8 9 10 11 Start bit Start bit Data Bit Data Bit Data Bit Data Bit Data Bit Data Bit Data Bit Data Bit Stop Bit Stop Bit

The start bits alerts the receiver that data is coming. Without it, if the first bit was a ‘1’, it would be seen as an idle line since an idle UART line is also high. The number of data bits is typically 8, but it can be configured for 7 bits as well. Although some UART receivers can use a different number of bits, only 8 or 8 bits are supported by the MSP430. After the data bits stop bits are sent along with an optional parity bit.

MSP430 families contain different peripherals capable of UART communications. Among these are USCI, USART and eUSCI modules. UART can also be generated using timers or even bit-banged. Some peripherals have sophisticated options that we will not cover since they are rarely used.

## Configuring the MSP430 for UART operation

We previously covered the issue of signal multiplexing. In order to use UART, specific pins that are connected to the UART module must be used, and the pin muxing must choose the Primary Peripheral mode. On the MSP430G2553 that is on the MSP430 Launchpad, UCA0 pins are present on pins P1.1 and P1.2 as UCA0RXD and UCA0TXD, respectively. Setting the pin muxing is simple since TI provides the information for the bit settings in the datasheet of the device. In this case, UART requires both PxSEL and PxSEL2 to be set to ‘1’. PxDIR does not need to be configured.

Configuring MSP430 Pin Muxing for UART

 
P1SEL |= (BIT1 | BIT2);
P1SEL2 |= (BIT1 | BIT2);




With the pins configured, we must configure the clocks for UART. The baudrate generation requires a clock of a certain precision. Although baudrates vary, 9600 and 115200 baud are the most common and we will focus on them. In order to generate a baud rate, we must feed a large enough clock so that it can be divided by the baud rate generator for the actual baud rate. For 9600 baud we can use both the slow 32.768kHz crystal if one is present, or a faster source such as the internal DCO or an external crystal. 115200 baud requires a fast clock, so only the DCO and a fast external clock can be used. Below we have the code needed to configure USCI_A0 for UART operation at 9600 baud:

Configuring MSP430 Pin Muxing for UART

 
#include <msp430.h>

int main(void)
{
WDTCTL = WDTPW + WDTHOLD; // Stop WDT

/* Use Calibration values for 1MHz Clock DCO*/
DCOCTL = 0;
BCSCTL1 = CALBC1_1MHZ;
DCOCTL = CALDCO_1MHZ;

/* Configure Pin Muxing P1.1 RXD and P1.2 TXD */
P1SEL = BIT1 | BIT2 ;
P1SEL2 = BIT1 | BIT2;

/* Place UCA0 in Reset to be configured */
UCA0CTL1 = UCSWRST;

/* Configure */
UCA0CTL1 |= UCSSEL_2; // SMCLK
UCA0BR0 = 104; // 1MHz 9600
UCA0BR1 = 0; // 1MHz 9600
UCA0MCTL = UCBRS0; // Modulation UCBRSx = 1

/* Take UCA0 out of reset */
UCA0CTL1 &= ~UCSWRST;

/* Enable USCI_A0 RX interrupt */
IE2 |= UCA0RXIE;

__bis_SR_register(LPM0_bits + GIE); // Enter LPM0, interrupts enabled
}

/* Echo back RXed character, confirm TX buffer is ready first */
#pragma vector=USCIAB0RX_VECTOR
__interrupt void USCI0RX_ISR(void)
{
while (!(IFG2&UCA0TXIFG)); // USCI_A0 TX buffer ready?
UCA0TXBUF = UCA0RXBUF; // TX -&gt; RXed character
}




The clock source for the UART baud generator is SMCLK sourcing the DCO running at 1MHz. Before we can configure the UART peripheral we need to place it in reset mode. Not all registers require this but it is best to do so when first configuring USCI, whether it’s for UART or any other mode. Notice that we use the assignment operator, so all the other bits are set to zero. With the reset in place, we make SMCLK the clock source for the UART. Being flexible, there are other possible options for the UCSSELx:

• 00b = UCAxCLK (external USCI clock)
• 01b = ACLK
• 10b = SMCLK
• 11b = SMCLK

UART can actually use a cloc

https://microcontrollerslab.com/uart-serial-communication-with-msp430-microcontroller/

# UART Serial communication with MSP430 microcontroller

To use UART communication module of MSP430 microcontroller, first you should understand what is UART communication? What is Serial communication? MSP430G2 launch Pad has on board MSP430G2553 microcontroller. MSP430G2553 microcontroller has one built in circuit for UART. So MSP430G2 launchpad has only on UART communication module which can be used to send and receive data serially.  This board also supports I2C and SPI communication protocols. SPI and I2C are also serial communication protocols.  UART communication is not a communication protocol but a physical dedicated circuit in the form of integrated circuit or embedded inside a microcontroller. On the other hand, both SPI and I2C are communication protocols. you may like to check getting started tutorials on MSP430:

### What is UART communication ?

• UART stand for Universal Asynchronous Receiver and Transmitter. UART can transfer data bit by bit serially.
• There are other parallel communication protocols exists which are used to transfer data in parallel mode like 8 bit at time.   It can transfer only one bit at a time.
• By parallel communication data can be transferred with high speed. But speed come with cost,  it required as many wires as many bits user want to transfer at a time.
• Serial communication consists of only two wires, transmission wire and receive wire.
• Receiver wire is used to receive data sequentially from other UART device.
• Transmitter wire is used to send data sequentially to other UART microcontroller or device.
• UART communication pins of MSP430G2 launchPad are shown in figure.
• Pin number three is transmission pin and pin number 4 is a receiver pin.

http://www.vdosplus.org/

### vDosPlus website URL: www.vDosPlus.org

vDosPlus (formerly vDos-lfn) is a free general-purpose non-gaming DOS emulator running on Windows, based on vDos and DOSBox. vDosPlus is designed to run non-gaming DOS applications in all current Windows versions. NTVDM (NT Virtual DOS Machine) is included in 32-bit Windows, but NOT in 64-bit Windows. However, most today’s Windows is now 64-bit, and to run DOS programs you need a DOS emulator. vDosPlus is exactly for this purpose, and like original vDos it provides advanced features such as support for file-locking (needed by multi-user applications) and printing to Windows-only (GDI) printers, but it also has many unique features such as a tighter integration with Windows and enhanced keyboard, mouse and display support. It was formerly known as vDos-lfn because its initial focus was added support for Windows-style long filenames or LFNs in addition to traditional DOS 8.3 file names, but now with a wide range of additional features there are much more than this. It is based on mature projects and also well tested by for example the XyWrite community and many normal or power users of various DOS applications, so it should be considered pretty stable as well.

## Highlights of vDosPlus’s Features:

– It runs in both 32-bit and 64-bit Windows, including Windows XP, Vista, 7, 8, 8.1 and 10 (all versions up to the latest release; Windows 2000 can be supported too)
– Run your DOS applications reliably in a DOS virtual machine; the text-mode DOS screen (either in a window or full-screen) is fully scalable with a TTF font
– Network support and multi-user environment friendly with file- and record locking; you can always run multiple DOS applications in different vDosPlus sessions
– Tight integration with Windows, including direct support for Windows-style long filenames (LFN), copying to and pasting from the Windows clipboard, and so on
– Support for multi-monitor setups, on-screen text styles (such as bold and italics), border/edge padding, mouse wheel scrolling, transparent window, and many more
– Built-in 4DOS 8.00 shell which provides powerful command-line and other functionalities; you can also find many useful information from its interactive help system
– You can customize the config settings easily by editing the configuration file, changing them on the fly, or you can simply use the default settings for vDosPlus
– Powerful printing functionalities to print to PCL and PostScript printers as well as Windows-only (GDI) printers directly; printing to PDF is also supported

## Screenshots of vDosPlus

Below are some screenshots of software running in vDosPlus.

 4DOS Help running in vDosPlus WordPerfect 6 running in vDosPlus XyWrite 4 running in vDosPlus

https://xkcd.com/

A webcomic of romance,
sarcasm, math, and language.

http://spektrum.ctu.cz/

# VYUŽITÍ RÁDIOVÉHO SPEKTRA

## VYHLEDÁVÁNÍ

https://www.mikrocontroller.net/articles/Entprellung

Welcome to the Mikrocontroller.net article collection. All articles here can be edited by everyone according to the wiki principle. To the main page of the article collection

# Development

## Problem Description

Mechanical live components such as switches and buttons tend to bounce when switched on and off , ie they quickly switch off and on several times, which is caused by mechanical vibrations of the switch contact, unless they are protected against it with complex mechanical measures. The encoders in particular are sensitive to this due to the detent positions and the movement of the operator. Optoelectronic components and chemical contact switches as well as liquid switches also have the problem.

Simply put, a voltage switched by a bouncing switch or button looks like this:

There are therefore several short switch-on pulses, which can be interpreted as multiple commands for push buttons and as wrong angular movements for rotary encoders. With switches, on the other hand, there are several resets and switch-on processes in the electronic assembly, which draw power unnecessarily or, in the worst case, stress or damage the circuit. Important switches and those that are supposed to carry high currents are protected by suitable measures such as redundancy, tap changer concepts or, in the case of gas and liquid switches, by electrochemical measures. This is saved with simple switches.

Since there is no safe way to avoid these effects with these simple, unprotected switches, the wrong signal must be evaluated sensibly by the electronics. There are different approaches for this:

## Hardwareentprellung

### Bounce-free switches

As already indicated, the electromechanical industry has various special constructions for special applications that generate clean switching states to the outside by using either mechanical damping in the form of a self-locking spring mechanism or an integrated electronic signal delay. However, such systems are expensive and are mostly used only in the performance range. In addition, they are not 100% safe and fail due to aging. Wherever possible, further measures are therefore taken to suppress bouncing.

### Changeover switch

A classic RS flip-flop can be used to debounce toggle switches . In this variant, in addition to two NAND gates, only two pull-up resistors are required.

Debounce buttons with NAND-RS flip-flop

In the switch position shown, level 0 is present at position / S. This sets the flip-flop and the output at level 1. If the switch between contacts 2 and 3 closes, level 0 is present at position / R. This means that the output of the flip-flop goes to level 0. As soon as the switch changes from one contact to the other, it usually begins to bounce. During the bouncing, the switch switches between the two states “switch touches contact” and “switch is free in the air”. The output of the flip-flop remains stable during this bounce time, since the switch never touches the opposite contact during the bounce and the RS flip-flop can keep its state alone. The bounce time is strongly dependent on the switch type and is between 0.1 and 10ms. The dimensioning of the resistors is relatively uncritical. 100kOhm can be used as a guideline.

#### Toggle switch without flip-flop

If you don’t have a flip-flop at hand, you can also use this circuit.

Changer debounce with capacitor

How it works: When switching, the capacitor is always immediately recharged. While the contact bounces, it is in the air and has no connection. During this time, the capacitor maintains the level.

Dimensioning: If the debounced button is connected to an IC, the input leakage current is the decisive current. If further currents flow, these must be taken into account. With a microcontroller from Atmel, 1µA is typical. The following applies:

dUdt=IC

Since a bruise lasts about 10ms and the voltage should drop by a maximum of 0.5V during this time, the following capacity is reached:

C=IdtdU=1μA10ms0,5V20 F

A resistor can be added to reduce current peaks. A time constant of 1µs to 1ms seems reasonable. So 500 Ohm to 500kOhm can be used, whereby the current peaks are higher at low resistance, and the pin current becomes disruptive at 500kOhm.

### Simple button

Even if the RS flip-flop is very effective, this variant of the debouncing is rarely used. The reason for this is that simple switches are used more often in circuits. These are often smaller and cheaper. To debounce simple push buttons / momentary switch, a simple RC low pass can be used. A capacitor is charged or discharged via a resistor depending on the switch position. The RC element forms a low pass, so that the voltage across the capacitor cannot jump from one level to the other.

Debounce buttons with RC debouncer

Emerging voltage curve

When the switch is open, the capacitor slowly charges to V cc through the two resistors R 1 and R 2 . When the switchover threshold is reached, the output jumps to level 0. If the switch is closed, the capacitor slowly discharges through resistor R 2 . Accordingly, the output of the inverter changes to level 1. While the button is bouncing, the voltage across the capacitor cannot change abruptly, since the charging and discharging takes place rather slowly via the resistors. In addition, the switching thresholds for the transition LOW-> HIGH and HIGH-> LOW are very different (hysteresis, see article Schmitt trigger). If the components are dimensioned correctly, the output of the inverter is thus free of bounce.

Please note that the inverter must be one with Schmitt trigger inputs, because the output is not defined for standard logic inputs in the range of typically 0.8V – 2.0V. For example, the 74HC14 or CD40106 (pin compatible) can be used as an inverter. Alternatively, a CD4093 can be used. The CD4093 is a NAND gate with Schmitt trigger inputs. To make an inverter out of a NAND gate, simply connect the two inputs or set one input to HIGH.

For a suitable dimensioning you have to juggle something with the standard formulas for a capacitor. The voltage across the capacitor during discharge is calculated according to:

UC(t)=U0etR2C1

For the output of the inverter to be stable, the voltage across the capacitor and thus the voltage at the input of the inverter must remain above the voltage at which the inverter switches. This threshold voltage is exactly the time-dependent voltage across the capacitor.

UC(t) Uth

By changing the formula:

R2=tC1⋅ UthU0)

A button usually bounces about 10ms. For safety reasons, a bounce time of 20ms can be assumed when calculating the resistance. U_0 is the operating voltage Vcc. The threshold voltage must be read from the data sheet of the Schmitt trigger used. The 74HC14 has a value of 2.0V. If you take 1µF for the capacitor and the operating voltage is 5V, the resistance is about 22kOhm.

If the switch is opened, the capacitor charges according to the following formula:

UC(t)=U0(1et(R1+R2)C1)

With U_th = U_C, the changeover to (R_1 + R_2) results in:

R1+R2=tC1⋅ ( 1 – UthU0)

A value of 2.3V can be read from the data sheet for the threshold voltage. With this value and the assumptions from above there is a value of 32kOhm for R_1 + R_2. This results in a value of approximately 10 kOhm for R_1.

Note: For Hitachi 74LS14 e.g. B. the upper and lower switching threshold values are different. Care must be taken that U_ {th} takes the lower threshold when unloading and U_ {th} takes the upper threshold when loading.

## Softwareentprellung

In times of electronic evaluation of buttons and switches, debouncing software is often cheaper than using an expensive switch. For this reason, computer keyboards, for example, are no longer equipped with low-bounce keys or debounce capacitors.

If you use the microcontroller that is already available in most devices, for example, you can save yourself the additional hardware, since debouncing in software works practically just as well. It should only be noted that additional computing power and, depending on the implementation, some hardware resources (eg timers) are required. But you have the advantage of short pulses, which obviously can not be a key press but z. B. caused by stray, easy to filter.

### Edge detection

There are 4 theoretical states for a push button:

• 1. was not pressed and is not pressed
• 2. was not pressed and is pressed (rising edge)
• 3. was pressed and is still pressed
• 4. was pressed and is no longer pressed (falling edge)

These individual states can now be easily queried / run through. The debouncing takes place through the entire duration of the program. The buttons are connected as active low to use the internal pull-ups.

This routine returns the value “1” for the “rising edge” state, otherwise “0”

#define TASTERPORT PINC
#define TASTERBIT PINC1

char taster(void)
{
static unsigned char zustand;
char rw = 0;

if ( state  ==  0  &&  ! ( KEY PORT  &  ( 1 << KEYBIT )))    // key is pressed (rising edge)
{
state  =  1 ;
rw  =  1 ;
}
else  if  ( state  ==  1  &&  ! ( BUTTON PORT  &  ( 1 << BUTTON BIT )))    // button is held
{
state  =  2 ;
rw  =  0;
}
else  if  ( state  ==  2  &&  ( KEY PORT  &  ( 1 << KEYBIT )))    //
key is released (falling edge) {
state  =  3 ;
rw  =  0 ;
}
else  if  ( state  ==  3  &&  ( BUTTON PORT  &  ( 1 << BUTTON BIT )))    // button released
{
state  =  0 ;
rw  = 0;
}

return rw;
}


An extension so that a button is recognized for as long as required can be implemented very simply as follows:

    // state can either be detected as held for the first time or every other time
else  if  ((( state  ==  1 )  ||  ( state  ==  2 ))  &&  ! ( TASTERPORT  &  ( 1 << TASTERBIT )))    / / Button is held
{
state  =  2 ;
rw  =  0 ;
}


### On hold procedure

If a microcontroller is to be used to count how often a contact or a relay is switched, the bouncing of the contact must be taken into account precisely – and differentiated from a desired multiple switching, as otherwise incorrect impulses may be counted or real switching processes may be skipped. This must be taken into account when writing the program with regard to scanning the contact.

In the following simple example of a debouncing, it should be noted that the AVR waits 200ms when a button is pressed, i.e. lies idle. A different method should be used for time-critical applications (e.g. querying the key states in a timer interrupt service routine).

#include <avr/io.h>
#include <inttypes.h>
#ifndef F_CPU
#warning "F_CPU was not yet defined, is now defined with 3686400"
#define F_CPU 3686400UL      / * quartz with 3.6864 Mhz * /
#endif
#include <util/delay.h>     /* bei alter avr-libc: #include <avr/delay.h> */

/ * Simple function for debouncing a button * /
inline  uint8_t  debounce ( volatile  uint8_t  * port ,  uint8_t  pin )
{
if  (  ! ( * Port  &  ( 1  <<  pin ))  )
{
/ * pin was pulled to ground, wait 100ms * /
_delay_ms ( 50 );    // maximum value of the parameter at _delay_ms
_delay_ms ( 50 );    // note, cf. Documentation of the avr-libc
if  (  * port &  ( 1  <<  pin )  )
{
/ * Give user time to release the button * /
_delay_ms ( 50 );
_delay_ms ( 50 );
return  1 ;
}
}
return  0 ;
}

int  main ( void )
{
DDRB  & =  ~ (  1  <<  PB0  );         / * PIN PB0 on input push button) * /
PORTB  | =  (  1  <<  PB0  );         / * Activate pull-up resistor * /
...
if  ( debounce ( & PINB ,  PB0 ))
{
/ * If button on PIN PB0 is pressed * /
/ * Switch LED on or off at port PD7: * /
PORTD  =  PORTD  ^  (  1  <<  PD7  );
}
...
}


Unfortunately, the above routine has several disadvantages:

• it only detects letting go (unergonomic)
• it always delays the main loop by 100ms when the button is pressed
• it loses keystrokes the more the mainloop has to do.

A similarly easy-to-use routine, but without all of these disadvantages, can be found in the forum thread debouncing for beginners

The DEBOUNCE command in the BASIC dialect BASCOM for AVR is also programmed according to the hold pattern method. The waiting time is 25 ms as standard, but can be overwritten by the user. See BASCOM online manual for DEBOUNCE .

A C implementation for a key query with a hold pattern can be found in the article AVR-GCC-Tutorial: IO registers as parameters and variables .

The disadvantage of this method is that the controller is blocked by the waiting loop. Implementation with a timer interrupt is cheaper.

#### Waiting loop variant with mask and pointer (according to Christian Riggenbach)

Here is another function for debouncing buttons: With the additional code, a debouncing time of 1-3ms on average (at least 8 * 150µs = 1ms) can be achieved. Basically, the function checks the level of the pins on a specific port. If the level was constant 8 times, the loop is exited. This function can be used very well to request buttons in an infinite loop because, as mentioned, it has a short waiting time.

void entprellung( volatile uint8_t *port, uint8_t maske ) {
uint8_t   port_puffer;
uint8_t   entprellungs_puffer;

for( entprellungs_puffer=0 ; entprellungs_puffer!=0xff ; ) {
entprellungs_puffer<<=1;
port_puffer = *port;
_delay_us(150);
entprellungs_puffer |= 0x01;
}
}


The function is called as follows:

  // Bugfix 20100414
// http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass
debouncing (  & PINB ,  ( 1 << PINB2 )  );  // wait for bouncing
if necessary (  PINB  &  ( 1 << PINB2 )  )            // then read in a stable value
{
// do something
else }
{ // do something else }



Any value can be transferred as a mask. It prevents buttons that are not used from negatively influencing the debounce time.

#### Debounce macro by Peter Dannegger

Peter Dannegger described the following simplified debouncing procedure in “Debouncing for Beginners” . The macro works in the original version with active low switches, but can be easily adapted for active high switches ( Tasty Reloaded ).

/************************************************************************/
/*                                                                      */
/*                      Not so powerful Debouncing Example              */
/*                      No Interrupt needed                             */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                                                                      */
/************************************************************************/
// Target: ATtiny13

#include <avr/io.h>
#define F_CPU 9.6e6
#include <util/delay.h>

#define debounce( port, pin )                                         \
({                                                                    \
static uint8_t flag = 0;     /* new variable on every macro usage */  \
uint8_t i = 0;                                                      \
\
if( flag ){                  /* check for key release: */           \
for(;;){                   /* loop ... */                         \
if( !(port & 1<<pin) ){  /* ... until key pressed or ... */     \
i = 0;                 /* 0 = bounce */                       \
break;                                                        \
}                                                               \
_delay_us( 98 );         /* * 256 = 25ms */                     \
if( --i == 0 ){          /* ... until key >25ms released */     \
flag = 0;              /* clear press flag */                 \
i = 0;                 /* 0 = key release debounced */        \
break;                                                        \
}                                                               \
}                                                                 \
}else{                       /* else check for key press: */        \
for(;;){                   /* loop ... */                         \
if( (port & 1<<pin) ){   /* ... until key released or ... */    \
i = 0;                 /* 0 = bounce */                       \
break;                                                        \
}                                                               \
_delay_us( 98 );         /* * 256 = 25ms */                     \
if( --i == 0 ){          /* ... until key >25ms pressed */      \
flag = 1;              /* set press flag */                   \
i = 1;                 /* 1 = key press debounced */          \
break;                                                        \
}                                                               \
}                                                                 \
}                                                                   \
i;                           /* return value of Macro */            \
})

/*
Testapplication
*/
int main(void)
{
DDRB  &= ~(1<<PB0);
PORTB |=   1<<PB0;
DDRB  |=   1<<PB2;
DDRB  &= ~(1<<PB1);
PORTB |=   1<<PB1;
DDRB  |=   1<<PB3;
for(;;){
if( debounce( PINB, PB1 ) )
PORTB ^= 1<<PB2;
if( debounce( PINB, PB0 ) )
PORTB ^= 1<<PB3;
}
}


If the macro for the same key (pin) is to be called up in several places, a function must be created so that both calls evaluate the same state variable flag [1] :

// Hilfsfunktion
uint8_t debounce_C1( void )
{
return debounce(PINC, PC1);
}

// Beispielanwendung
int main(void)
{
DDRB  |=   1<<PB2;
DDRB  |=   1<<PB3;
DDRC  &= ~(1<<PC1);
PORTC |=   1<<PC1; // Pullup für Taster

for(;;){
if( debounce_C1() )  // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB2;
if( debounce_C1() )  // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB3;
}
}


### Timer procedure (according to Peter Dannegger)

#### Grundroutine (AVR Assembler)

benefits

• particularly short code
• fast

In addition, 8 buttons (active low) can be processed at the same time, so they can all be pressed at exactly the same time. Other routines can e.g. B. only process one key, ie the first or last pressed key wins, or it comes out nonsense.

The actual reading and debouncing routine is only 8 instructions short. The debounced key state is in the key_state register . With only 2 further instructions, the change from key open to key pressed is recognized and stored in the key_press register . In the example code, 8 LEDs are then switched on and off. Each key corresponds to a bit in the registers, ie processing is done bit by bit with logical operations. For understanding, it is therefore advisable to paint the logic equations with gates for one bit = one key. The registers can be thought of as flip-flops that work with the debounce time as a clock. Ie you can do it z. B. in a GAL22V10.

In addition to the individual instructions, all 8 possible combinations of the 3 signals are shown as comments.

Example code for AVR (assembler):


.nolist
.include "c:\avr\inc\1200def.inc"
.list
.def  save_sreg         = r0
.def  iwr0              = r1
.def  iwr1              = r2

.def  key_old           = r3
.def  key_state         = r4
.def  key_press         = r5

.def  leds              = r16
.def  wr0               = r17

.equ  key_port          = pind
.equ  led_port          = portb

rjmp   init
in     save_sreg, SREG
get8key:                               ;/old      state     iwr1      iwr0
mov    iwr0, key_old             ;00110011  10101010            00110011
in     key_old, key_port         ;11110000
eor    iwr0, key_old             ;                              11000011
com    key_old                   ;00001111
mov    iwr1, key_state           ;                    10101010
or     key_state, iwr0           ;          11101011
and    iwr0, key_old             ;                              00000011
eor    key_state, iwr0           ;          11101000
and    iwr1, iwr0                ;                    00000010
or     key_press, iwr1           ;store key press detect
;
;			insert other timer functions here
;
out    SREG, save_sreg
networks
;-------------------------------------------------------------------------
init:
ldi wr0, 0xFF
out    ddrb, wr0
ldi    wr0, 1<<CS02 | 1<<CS00    ;divide by 1024 * 256
out    TCCR0, wr0
ldi    wr0, 1<<TOIE0             ;enable timer interrupt
out    TIMSK, wr0

clr    key_old
clr    key_state
clr    key_press
ldi    leds, 0xFF
main: cli
eor    leds, key_press           ;toggle LEDs
clr    key_press                 ;clear, if key press action done
be
out    led_port, leds
rjmp   main
;-------------------------------------------------------------

#### Comfort routine (C for AVR)

Note If instead of active-low (hibernation high) active-high (hibernation low) is used, a line must be changed see: entire post in the forum , position 1 in the post , ( position 2 in the post * does not have to be changed, since here the polarity has no influence).

Note 2 For initialization see forum

Functional principle as above plus additional features:

• Can save keys by different actions with short or long press
• Repeat function, e.g. B. for entering values

The program is written for avr-gcc / avr-libc, but can also be used with other compilers and microcontrollers with a few adjustments. A port for the AT91SAM7 can be found here (from the ARM MP3 / AAC Player project ).

/************************************************************************/
/*                                                                      */
/*                      Debouncing 8 Keys                               */
/*                      Sampling 4 Times                                */
/*                      With Repeat Function                            */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      danni@specs.de                                  */
/*                                                                      */
/************************************************************************/

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU           1000000                   // processor clock frequency
#warning kein F_CPU definiert
#endif

#define KEY_DDR         DDRB
#define KEY_PORT        PORTB
#define KEY_PIN         PINB
#define KEY0            0
#define KEY1            1
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY1 | 1<<KEY2)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     20                        // every 200ms

#define LED_DDR         DDRA
#define LED_PORT        PORTA
#define LED0            0
#define LED1            1
#define LED2            2

volatile uint8_t key_state;                                // debounced and inverted key state:
// bit = 1: key pressed
volatile uint8_t key_press;                                // key press detect

volatile uint8_t key_rpt;                                  // key long press and repeat

ISR( TIMER0_OVF_vect )                            // every 10ms
{
static uint8_t ct0 = 0xFF, ct1 = 0xFF, rpt;
uint8_t i;

TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms

i = key_state ^ ~KEY_PIN;                       // key changed ?
ct0 = ~( ct0 & i );                             // reset or count ct0
ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1
i &= ct0 & ct1;                                 // count until roll over ?
key_state ^= i;                                 // then toggle debounced state
key_press |= key_state & i;                     // 0->1: key press detect

if( (key_state & REPEAT_MASK) == 0 )            // check repeat function
rpt = REPEAT_START;                          // start delay
if( --rpt == 0 ){
rpt = REPEAT_NEXT;                            // repeat delay
}
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
{
cli();                                          // read and clear atomic !
key_press ^= key_mask;                          // clear key(s)
sei();
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
{
cli();                                          // read and clear atomic !
key_rpt ^= key_mask;                            // clear key(s)
sei();
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//

{
}

///////////////////////////////////////////////////////////////////
//
{
cli();                                          // read key state and key press atomic !
return get_key_press( ~key_state & key_mask );
}

///////////////////////////////////////////////////////////////////
//
{
}

int main( void )
{
LED_PORT = 0xFF;
LED_DDR = 0xFF;

// Configure debouncing routines
KEY_DDR &= ~ALL_KEYS;                // configure key port for input
KEY_PORT |= ALL_KEYS;                // and turn on pull up resistors

TCCR0 = (1<<CS02)|(1<<CS00);         // divide by 1024
TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5);  // preload for 10ms
TIMSK |= 1<<TOIE0;                   // enable timer interrupt

be ();

while(1){
if( get_key_short( 1<<KEY1 ))
LED_PORT ^= 1<<LED1;

if( get_key_long( 1<<KEY1 ))
LED_PORT ^= 1<<LED2;

// single press and repeat

if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
uint8_t i = LED_PORT;

i = (i & 0x07) | ((i << 1) & 0xF0);
if( i < 0xF0 )
i |= 0x08;
LED_PORT = i;
}
}
}


The single-press-and-repeat example does not work in every circuit; the following example should be more universal (single LED on / off):

// single press and repeat
if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 ))
LED_PORT ^=0x08;


Newer variant that allows the following functions for a button: https://www.mikrocontroller.net/topic/48465?goto=1753367#1753367

- get_key_press()
- get_key_rpt()
- get_key_press() mit get_key_rpt()
- get_key_short() mit get_key_long()
- get_key_short() mit get_key_long_r() und get_key_rpt_l()


Extension for the detection of two buttons pressed simultaneously: https://www.mikrocontroller.net/topic/48465?goto=1753367#1753367

- get_key_common()

##### functionality

The code is based on 8 parallel vertical counters, which are built up via the variables ct0 and ct1

8 vertical counters in 2 8-bit variables

where each bit in ct0 together with the equivalent bit in ct1 forms a 2-bit counter. The code that takes care of the 8 counters is written so that it treats all 8 counters together in parallel.

  i = key_state ^ ~KEY_PIN;                       // key changed ?


At this point, i contains a 1 bit for each key that has changed compared to the previous debounced state (keystate).

  ct0 = ~( ct0 & i );                             // reset or count ct0
ct1 = ct0 ^ (ct1 & i);                          // reset or count ct1


These two instructions decrease the 2-bit counter ct0 / ct1 by 1 for each bit that is set in i. If there is a 0 bit in the corresponding position in i (no change in status), the counter ct0 / ct1 is set to 1 for this bit. The basic state of the counter is as ct0 == 1 and ct1 == 1 (value 3). The counter therefore counts with every ISR call in which the key was identified as having changed compared to keystate

  ct1 ct0
1    1   // 3
1    0   // 2
0    1   // 1
0    0   // 0
1    1   // 3

  i &= ct0 & ct1;                                 // count until roll over ?


A 1 bit is only retained in i where a 1 bit is found in both ct1 and ct0, ie the counter in question could count to 3. The additional rounding with i intercepts the case where a constant counter value of 3 in i leaves a 1 bit. In the end, this means that only a counter change from 0 to 3 leads to a 1 bit at the relevant point in i, but only if there was also a 1 bit in i at this bit position (which in turn was 1 because: a change to the last known debounced state was found at this input port). All in all, this means that a key press is recognized when the key is found 4 times in a row in a different state than the last known debounced key state.

At this point i is therefore a vector of 8 bits, each of which provides information as to whether the corresponding key was found several times in succession in the same state that does not match the last known key state. If this is the case, a corresponding change in the key status is registered in key_state

  key_state ^= i;                                 // then toggle debounced state


and if the corresponding bit in key_state has changed from 0 to 1, this event is evaluated as ‘key has been depressed’.

  key_press |= key_state & i;                     // 0->1: key press detect


This debounces the key input. This applies both when a key is pressed and when it is released (so that the bouncer is not confused with the depression of a key when released). The rest of the code then only deals with the further processing of this debounced key state.

The code part looks relatively complex due to the use of the many bitwise operations. But if you keep in mind that some of the bit-wise like a ‘parallel if’ are used simultaneously on all 8 bits, a lot will be simplified. On

    key_press |= key_state & i;


is nothing more than one

    // test whether bit 0 is set in both key_state and i
// and set bit 0 in key_press if this is the case
if (  (  key_state  &  (  1  <<  0  )  )  &&
(  i  &  (  1  <<  0  )  )
key_press  | =  (  1  <<  0  );

// Bit 1
if( ( key_state & ( 1 << 1 ) ) &&
( i & ( 1 << 1 ) )
key_press |= ( 1 << 1 );

// Bit 2
if( ( key_state & ( 1 << 2 ) ) &&
( i & ( 1 << 2 ) )
key_press |= ( 1 << 2 );

...


only performed as a much more compact operation and for all 8 bits simultaneously. The brevity and efficiency of these few lines of code results from the fact that each bit in the variables stands for a key and all 8 (maximum possible) keys go through the operations simultaneously.

How the different modes work is explained using timelines: https://www.mikrocontroller.net/topic/48465?goto=1753367#1844458

“Walkthrough” of the different states of the individual variables by pressing a button (avrfreaks.net) http://www.avrfreaks.net/comment/726676#comment-726676

##### Reduced to just 1 button

Discussions in the forum show again and again that many dislike this code because it seems very complicated.

The code is not easy to analyze and pulls out all the stops to save both runtime and memory usage. You often hear the argument: I only need a debouncing for 1 button, is there anything easier?

Here is the ‘long form’ of the code, as you would write for just 1 key if you used the exact same debouncing method. You can see: There is no witchcraft involved: the last known debounced state of the key is held in key_state. The pin input is compared to this state and if the two differ, a counter is counted down. If this counts down produces an underflow of the counter, the key is considered debounced and if the key is also pressed then this is noted accordingly in key_press.

uint8_t key_state;
uint8_t key_counter;
volatile uint8_t key_press;

ISR( ... Overflow ... )
{
uint8_t input = KEY_PIN & ( 1 << KEY0 );

if( input != key_state ) {
key_counter--;
if( key_counter == 0xFF ) {
key_counter = 3;
key_state = input;
if( input )
key_press = TRUE;
}
}
else
key_counter = 3;

}

uint8_t get_key_press()
{
uint8_t result;

cli();
result = key_press;
key_press = FALSE;
sei();

return result;
}


However, the complete debounce code, as listed above, now impresses in that it is compiled smaller than this more descriptive variant for only 1 key. And all this with increased functionality. Because e.g. an autorepeat is not yet built into this code. And at the latest when you want to debounce a 2nd key, the SRAM memory consumption of this long form is higher than that of the original for 8 keys. It follows that even for just 1 key, the original routine is the better choice.

And because of the complexity, one question: Are you able to write an efficient sqrt () function like the one you find in the standard C library? No? Then, according to your reasoning, you shouldn’t actually use the library function sqrt (), instead you would have to write a root function yourself.

### Self-saturating filter (after Jürgen Schuhmacher)

By using discrete signal analysis in software, the functionality of a simple debouncing with a resistor, a capacitor and a Schmitt trigger can be simulated as in hardware by using an abstract IIR filter that emulates a capacitor charging curve. With the rule Y (t) = k Y (t-1) + input, a simple filter is generated that sluggishly follows the input value. If a certain value is exceeded, the output signal is switched with a simple query.

For assembler and VHDL with FPGAs, the following representation is suitable due to the easy-to-implement binary operations with a resolution of the filter value memory of only 8 bits: Value_New = Value_Alt – Value_Alt / 16 + 16 * (key = True). The filter value then maps the attenuated course of the input (flanked) and can suppress bouncing up to the limit for fast touching. The output value is then simply the most significant bit of the filter value.

To do this, the signal from the button should ideally be sampled 10-20 times faster than the highest desired typing speed. It is possible to scan even faster, but it leads to more bits being required for the filter. The Schmittrigger function can be formed by outputting a 1 at the output when, for example, a 55% limit is exceeded and a 0 when the 45% limit is undershot. The old value is kept in the intermediate area. The real limits of this hysteresis must be adapted to the application, since too narrow limits would otherwise be too sensitive to faults.

### Simple mean filter (according to Lothar Miller)

For digital circuits or PLDs, a FIR filter with flip-flops in a row is recommended. You push the input signal into a flip-flop chain and switch above the middle:

SignalInput -> FF1 -> FF2 -> FF3 -> FF4 -> FF5 -> FF6 -> FF7 -> FF8

If all FFs = 1 (sum of FFs = 8) then SignalOutput = 1
If all FFs = 0 (sum of FFs = 0) then SignalOutput = 0

This method can be mapped very simply in logic, because only one NOR or AND gate is required for the calculation of the output.

However, the real signal must be sampled slowly enough so that the filter period exceeds the bounce time to prevent an 8×1 from being seen in the middle of a passive phase of a bounce process. This makes the interation relatively slow.

## Comparison of the procedures

• HW – “debounced switch”: Very expensive, large design, subject to wear, low durability
• HW – “switch”: requires more complex switches, requires electronics
• HW – “switch without FF”: requires more complex switches and a small capacitor
• HW – “capacitor debouncing”: requires a little more space, copes with bad switches
• SW – edge method:
• SW – holding pattern: Due to the holding pattern, a not insignificant delay in the code. Especially when several buttons are to be monitored, not unproblematic
• SW timer: universal functionality that impresses with its low memory consumption, low computing time consumption and good function. At first glance, the ‘consumption’ of a timer looks worse than it is, because most programs use a basic timer for the time control of the program anyway, which can also be used for debouncing the buttons.
• SW filter: very little space required in FPGAs, relatively good effect
• SW filter 2: very small space requirement, good effect

# SerialSend

SerialSend is a little command line application I created to send text strings via a serial port. I mainly use it to send information to microcontroller circuits via a USB-to-serial converter, so it’s designed to work well in that context.

# Add MSP432 support to Arduino?

Does anyone know if MSP432 (black) can be added to the standard Arduino setup?

The reason: I’ve got an Adafruit Feather M0+ board working with Arduino, so the ARM Cortex-M compiler is “already there”. I’m hoping maybe I could remove Energia (since I don’t need the ‘430 support). If I add the JSON board file for the black MSP432 launch-pad, will the Arduino IDE get everything it needs to play with the MSP432?     https://energia.nu/packages/package_msp432_black_index.json

Also, is there a JSON file for the Tiva TM4C123 launch-pad?  (same reason, have a Tiva, want to move everything over to one IDE).

Thanks!

No, it is not possible as the Energia IDE includes specific features to support the multi-treading of the MSP432.

The black MSP432 is deprecated and no longer supported.

But I don’t care about that multitasking – does anyone know if it would work otherwise?

Yes, I know the black MSP432 has been abandoned, but I’m not going to throw away perfectly good hardware.

Thanks for the response!

On 1/11/2019 at 2:51 AM, mgh said:

Also, is there a JSON file for the Tiva TM4C123 launch-pad?  (same reason, have a Tiva, want to move everything over to one IDE).

Thanks!

not json but instructions given for linux

https://github.com/RickKimball/tivac-core

Assumes you have openocd and arm-none-eabi-gcc in your path. Probably won’t work for windows. Probably will work for OSX.

Although the Arduino IDE should be able to consume the Energia packages, there is a difference between the arduino-builder in Arduino and Energia which makes the msp432 package incompatible with the Arduino IDE. See the pull request here: https://github.com/arduino/arduino-builder/pull/119. I have it on my list to find a different solution and be able to use the stock arduino-builder at which point the Arduino IDE should be able to consume the Energia package.

For TivaC and MSP430, it is possible to use it in the Arduino IDE. Just put this in the preferences: http://energia.nu/packages/package_energia_index.json. Then pull up the board manager and install TivaC support.

Wow! Thank you Rick, thank you @energia! I’ll try some of these this weekend.

If you want to use one single IDE for all the different boards, try

All come as freemium: free for basic features; one-time-fee or subscription for more advanced features.

## Create an account

Register a new account

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

{
"packages": [
{
"name": "energia",
"maintainer": "Energia",
"websiteURL": "http://www.energia.nu/",
"email": "make@energia.nu",
"help": {
"online": "http://energia.nu/reference"
},
"platforms": [
{
"name": "Energia MSP430 boards",
"architecture": "msp430",
"version": "1.0.5",
"category": "Energia",
"archiveFileName": "msp430-1.0.5.tar.bz2",
"checksum": "SHA-256:f40371d7e5140be6ce671aa33ca686b6d0fdfe6fd480dcb5d8dd79a87ce23305",
"size": "2077472",
"boards": [
{"name": "MSP-EXP430F5529"},
{"name": "MSP-EXP430FR2433"},
{"name": "MSP-EXP430FR4133"},
{"name": "MSP-EXP430FR5969"},
{"name": "MSP-EXP430FR6989"},
{"name": "MSP-EXP430FR5739"},
{"name": "MSP-EXP430FR2355"},
{"name": "MSP-EXP430FR2231"},
{"name": "MSP-EXP430G2"},
{"name": "MSP-EXP430G2ET"},
{"name": "MSP-EXP430FR5994"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"msp430-gcc",
"version":"4.6.6"
},
{
"packager":"energia",
"name":"dslite",
"version":"8.2.0.1400"
},
{
"packager":"energia",
"name":"mspdebug",
"version":"0.24"
}
]
},
{
"name": "Energia MSP430 boards",
"architecture": "msp430",
"version": "1.0.4",
"category": "Energia",
"archiveFileName": "msp430-1.0.4.tar.bz2",
"checksum": "SHA-256:84f752999538be0da7305f25a87ccf487008510404182feecbd6e4276642e6f2",
"size": "2076765",
"boards": [
{"name": "MSP-EXP430F5529"},
{"name": "MSP-EXP430FR2433"},
{"name": "MSP-EXP430FR4133"},
{"name": "MSP-EXP430FR5969"},
{"name": "MSP-EXP430FR6989"},
{"name": "MSP-EXP430FR5739"},
{"name": "MSP-EXP430FR2355"},
{"name": "MSP-EXP430FR2231"},
{"name": "MSP-EXP430G2"},
{"name": "MSP-EXP430G2ET"},
{"name": "MSP-EXP430FR5994"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"msp430-gcc",
"version":"4.6.6"
},
{
"packager":"energia",
"name":"dslite",
"version":"8.2.0.1400"
},
{
"packager":"energia",
"name":"mspdebug",
"version":"0.24"
}
]
},
{
"name": "Energia MSP430 boards",
"architecture": "msp430",
"version": "1.0.3",
"category": "Energia",
"archiveFileName": "msp430-1.0.3.tar.bz2",
"checksum": "SHA-256:cc4902a2bcaa43850c0e9a852f10bb5662b3eb4d4388e693d7d71c97bbdcb18a",
"size": "2072767",
"boards": [
{"name": "MSP-EXP430F5529"},
{"name": "MSP-EXP430FR2433"},
{"name": "MSP-EXP430FR4133"},
{"name": "MSP-EXP430FR5969"},
{"name": "MSP-EXP430FR6989"},
{"name": "MSP-EXP430FR5739"},
{"name": "MSP-EXP430G2"},
{"name": "MSP-EXP430FR5994"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"msp430-gcc",
"version":"4.6.5"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.4.0.1099"
},
{
"packager":"energia",
"name":"mspdebug",
"version":"0.24"
}
]
},
{
"name": "Energia MSP430 boards",
"architecture": "msp430",
"version": "1.0.2",
"category": "Energia",
"archiveFileName": "msp430-1.0.2.tar.bz2",
"checksum": "SHA-256:855ff60aacc129f8633cb4406dc28d1f3102d2edd05da0ba0b3123468bd1d06e",
"size": "2243478",
"boards": [
{"name": "MSP-EXP430F5529LP"},
{"name": "MSP-EXP430FR4133"},
{"name": "MSP-EXP430FR5969"},
{"name": "MSP-EXP430FR6989"},
{"name": "MSP-EXP430G2"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"msp430-gcc",
"version":"4.6.4"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.2.0.2096"
},
{
"packager":"energia",
"name":"mspdebug",
"version":"0.24"
}
]
},
{
"name": "Energia MSP430 boards",
"architecture": "msp430",
"version": "1.0.1",
"category": "Energia",
"archiveFileName": "msp430-1.0.1.tar.bz2",
"checksum": "SHA-256:3d687d768013a46a580f0b24fb7e7458bc7175e9a60ecb212ea7cb4bfcd80261",
"size": "2115215",
"boards": [
{"name": "MSP-EXP430F5529LP"},
{"name": "MSP-EXP430FR4133"},
{"name": "MSP-EXP430FR5969"},
{"name": "MSP-EXP430FR6989"},
{"name": "MSP-EXP430G2"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"msp430-gcc",
"version":"4.6.3"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1594"
},
{
"packager":"energia",
"name":"mspdebug",
"version":"0.22"
}
]
},
{
"name": "Energia MSP432E Ethernet RED boards",
"architecture": "msp432e",
"version": "5.19.0",
"category": "Energia",
"archiveFileName": "msp432e-5.19.0.tar.bz2",
"checksum": "SHA-256:9d4a549ab2a5e810ee9da352dfe12b757d79a6ef2a0b9161a9c43e7fd0d42e33",
"size": "35290227",
"boards": [
{"name": "MSP_EXP432E401Y"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"8.0.0.1202"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.3"
}
]
},
{
"name": "Energia MSP432 EMT RED boards",
"architecture": "msp432r",
"version": "5.23.1",
"category": "Energia",
"archiveFileName": "msp432r-5.23.1.tar.bz2",
"checksum": "SHA-256:cda2b25b13920933336c95d90f555a30fc49dfbbd5477c0cf8c29523ffbd0ec3",
"size": "31990061",
"boards": [
{"name": "MSP_EXP432P401R"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"8.2.0.1400"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.4"
}
]
},
{
"name": "Energia MSP432 EMT RED boards",
"architecture": "msp432r",
"version": "5.6.3",
"category": "Energia",
"archiveFileName": "msp432r-5.6.3.tar.bz2",
"size": "28895842",
"boards": [
{"name": "MSP_EXP432P401R"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"8.2.0.1400"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.4"
}
]
},
{
"name": "Energia MSP432 EMT RED boards",
"architecture": "msp432r",
"version": "5.6.2",
"category": "Energia",
"archiveFileName": "msp432r-5.6.2.tar.bz2",
"checksum": "SHA-256:bcde9150f6a4a703dd74dfc5fde92aa4d3ace45300188bc37f9545723576ec06",
"size": "28893313",
"boards": [
{"name": "MSP_EXP432P401R"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.2.0.2096"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.3"
}
]
},
{
"name": "Energia MSP432 EMT RED boards",
"architecture": "msp432r",
"version": "5.6.1",
"category": "Energia",
"archiveFileName": "msp432r-5.6.1.tar.bz2",
"checksum": "SHA-256:b2c1d36b95e5f8a5feebca25d4895ce98a46fa7d91604d4439430b62c2c2bcbd",
"size": "28738809",
"boards": [
{"name": "MSP_EXP432P401R"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.2.0.2096"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.3"
}
]
},
{
"name": "Energia MSP432 EMT RED boards",
"architecture": "msp432r",
"version": "5.6.0",
"category": "Energia",
"archiveFileName": "msp432r-5.6.0.tar.bz2",
"checksum": "SHA-256:fd320297acacdb3787f23e23f790770ff6242dbf86ee96702e1aaf8932aeb02e",
"size": "28738891",
"boards": [
{"name": "MSP_EXP432P401R"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1624"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia MSP432 EMT RED boards",
"architecture": "msp432r",
"version": "4.9.1",
"category": "Energia",
"archiveFileName": "msp432r-4.9.1.tar.bz2",
"size": "21093293",
"boards": [
{"name": "MSP_EXP432P401R"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1624"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia MSP432 EMT RED boards",
"architecture": "msp432r",
"version": "4.9.0",
"category": "Energia",
"archiveFileName": "msp432r-4.9.0.tar.bz2",
"size": "21092774",
"boards": [
{"name": "MSP_EXP432P401R"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1624"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia TivaC boards",
"architecture": "tivac",
"version": "1.0.3",
"category": "Energia",
"archiveFileName": "tivac-1.0.3.tar.bz2",
"size": "2239118",
"boards": [
{"name": "EK-TM4C123GXL"},
{"name": "EK-TM4C1294XL"},
{"name": "EK-LM4F120XL"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.2.0.2096"
}
]
},
{
"name": "Energia TivaC boards",
"architecture": "tivac",
"version": "1.0.2",
"category": "Energia",
"archiveFileName": "tivac-1.0.2.tar.bz2",
"checksum": "SHA-256:932d7d66dddf9ce4e498b737157c671b668cb450536f7223186e03955ae08041",
"size": "2189817",
"boards": [
{"name": "EK-TM4C123GXL"},
{"name": "EK-TM4C1294XL"},
{"name": "EK-LM4F120XL"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{

"packager":"energia",
"name":"dslite",
"version":"6.2.1.1594"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "4.9.1",
"category": "Energia",
"archiveFileName": "cc13xx-4.9.1.tar.bz2",
"checksum": "SHA-256:9e1324c1f42ecb9b5f54b7eb33af40440809cda768e120e2d22a9d87a30d4b37",
"size": "24263837",
"boards": [
{"name": "LAUNCHXL_CC1310"},
{"name": "LAUNCHXL_CC1350"},
{"name": "CC1350STK"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.1.0.1917"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "4.9.0",
"category": "Energia",
"archiveFileName": "cc13xx-4.9.0.tar.bz2",
"checksum": "SHA-256:4cf43b44a52783bb55994feed5f305b0d26f6a0cee1746cfd14168023ab9c07b",
"size": "24260076",
"boards": [
{"name": "LAUNCHXL_CC1310"},
{"name": "LAUNCHXL_CC1350"},
{"name": "CC1350STK"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.1.0.1917"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "3.7.4",
"category": "Energia",
"archiveFileName": "cc13xx-3.7.4.tar.bz2",
"checksum": "SHA-256:b1fc52867179ac4b0bb69ef1f877de76ab0a8d2124d16df7bb1ed4585afba884",
"size": "5008614",
"boards": [
{"name": "LAUNCHXL_CC1310"},
{"name": "LAUNCHXL_CC1350"},
{"name": "CC1350STK"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.1.0.1917"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "3.7.3",
"category": "Energia",
"archiveFileName": "cc13xx-3.7.3.tar.bz2",
"checksum": "SHA-256:55c3cd4265f65119cc6ed60dc1920a5f9762850fa0d8810f6a7735f14453bb5c",
"size": "5008347",
"boards": [
{"name": "LAUNCHXL_CC1310"},
{"name": "LAUNCHXL_CC1350"},
{"name": "CC1350STK"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.1.0.1917"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "3.7.2",
"category": "Energia",
"archiveFileName": "cc13xx-3.7.2.tar.bz2",
"checksum": "SHA-256:0183e193755d6557e33d5d505c74d63f580dfbc3b424b028723e8242aa851484",
"size": "5007077",
"boards": [
{"name": "LAUNCHXL_CC1310"},
{"name": "LAUNCHXL_CC1350"},
{"name": "CC1350STK"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.1.0.1917"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "3.7.1",
"category": "Energia",
"archiveFileName": "cc13xx-3.7.1.tar.bz2",
"checksum": "SHA-256:4eebf0ac52fe10be6e88482debeb51727b25a6ab1f7b28ec2417260a9132cdaf",
"size": "5007403",
"boards": [
{"name": "LAUNCHXL_CC1310"},
{"name": "LAUNCHXL_CC1350"},
{"name": "CC1350STK"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1624"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "3.7.0",
"category": "Energia",
"archiveFileName": "cc13xx-3.7.0.tar.bz2",
"checksum": "SHA-256:9187d55612bf9681b76b1c20fd960021f93f869538e886cf6e109b31b7e5b0dc",
"size": "5007247",
"boards": [
{"name": "LAUNCHXL_CC1310"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1624"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC13xx boards",
"architecture": "cc13xx",
"version": "3.6.1",
"category": "Energia",
"archiveFileName": "cc13xx-3.6.1.tar.bz2",
"size": "4991866",
"boards": [
{"name": "LAUNCHXL_CC1310"}
],
"toolsDependencies": [
{
"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1624"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC3220 EMT boards",
"architecture": "cc3220emt",
"version": "5.6.2",
"category": "Energia",
"archiveFileName": "cc3220emt-5.6.2.tar.bz2",
"checksum": "SHA-256:be0c700217218db893a504234c5dea5b9618ab7e23dfe9a370db59784de2994e",
"size": "25967822",
"boards": [
{"name": "CC3220S-LAUNCHXL"},
{"name": "CC3220SF-LAUNCHXL"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.4.0.1099"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.3"
}
]
},
{
"name": "Energia CC3220 EMT boards",
"architecture": "cc3220emt",
"version": "5.6.1",
"category": "Energia",
"archiveFileName": "cc3220emt-5.6.1.tar.bz2",
"checksum": "SHA-256:192561fd563691c6e1559f35d8cfa8b335d77172264d491b55c000d580608110",
"size": "25969772",
"boards": [
{"name": "CC3220S-LAUNCHXL"},
{"name": "CC3220SF-LAUNCHXL"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.4.0.1099"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC3220 EMT boards",
"architecture": "cc3220emt",
"version": "5.6.0",
"category": "Energia",
"archiveFileName": "cc3220emt-5.6.0.tar.bz2",
"size": "25970182",
"boards": [
{"name": "CC3220S-LAUNCHXL"},
{"name": "CC3220SF-LAUNCHXL"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"6.3.1-20170620"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.2.0.2096"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC3220 EMT boards",
"architecture": "cc3220emt",
"version": "4.9.0",
"category": "Energia",
"archiveFileName": "cc3220emt-4.9.0.tar.bz2",
"checksum": "SHA-256:e59c6ba609c99c2ec6ee3856e78962c0b3301af2f67a5de42ec50e543c707919",
"size": "19051776",
"boards": [
{"name": "CC3220S-LAUNCHXL"},
{"name": "CC3220SF-LAUNCHXL"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"7.2.0.1988"
},
{
"packager":"energia",
"name":"ino2cpp",
"version":"1.0.2"
}
]
},
{
"name": "Energia CC3200 boards",
"architecture": "cc3200",
"version": "1.0.2",
"category": "Energia",
"archiveFileName": "cc3200-1.0.2.tar.bz2",
"size": "1791123",
"boards": [
{"name": "CC3200-LAUNCHXL"},
{"name": "RedBearLab CC3200"},
{"name": "RedBearLab WiFi Mini"},
{"name": "RedBearLab WiFi Micro"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1594"
},
{
"packager":"energia",
"name":"cc3200prog",
"version":"1.1.4"
}
]
},
{
"name": "Energia CC3200 boards",
"architecture": "cc3200",
"version": "1.0.3",
"category": "Energia",
"archiveFileName": "cc3200-1.0.3.tar.bz2",
"checksum": "SHA-256:69f9ac0980bac4ebb8803a161786215228557eba49051af86e980aa8c422cdca",
"size": "1790853",
"boards": [
{"name": "CC3200-LAUNCHXL"},
{"name": "RedBearLab CC3200"},
{"name": "RedBearLab WiFi Mini"},
{"name": "RedBearLab WiFi Micro"}
],
"toolsDependencies": [
{

"packager":"energia",
"name":"arm-none-eabi-gcc",
"version":"4.8.4-20140725"
},
{
"packager":"energia",
"name":"dslite",
"version":"6.2.1.1594"
},
{
"packager":"energia",
"name":"cc3200prog",
"version":"1.1.4"
}
]
}
],
"tools": [
{
"name":"msp430-gcc",
"version":"4.6.6",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/msp430-gcc-4.6.6-i686-mingw32.tar.bz2",
"archiveFileName":"msp430-gcc-4.6.6-i686-mingw32.tar.bz2",
"checksum":"SHA-256:3dbfe6453f461ae5d7599c3cf1144dc400852b6d788d298f3dd0004283a9202a",
"size":"30818330"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/msp430-gcc-4.6.6-i386-apple-darwin11.tar.bz2",
"archiveFileName":"msp430-gcc-4.6.6-i386-apple-darwin11.tar.bz2",
"checksum":"SHA-256:82d4df153a9d64a507a48ed3b5db9e21eeb069809976c8b69946801252b622bb",
"size":"32574759"
},
{
"host": "x86_64-linux-gnu",
"url": "https://s3.amazonaws.com/energiaUS/tools/linux64/msp430-gcc-4.6.6-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName": "msp430-gcc-4.6.6-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum": "SHA-256:41fbcb3cc73679186989e1fb27cb4578e9164f07d134e650e23089198b87cbfd",
"size": "98503002"
}
]
},
{
"name":"msp430-gcc",
"version":"4.6.5",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/msp430-gcc-4.6.5-i686-mingw32.tar.bz2",
"archiveFileName":"msp430-gcc-4.6.5-i686-mingw32.tar.bz2",
"checksum":"SHA-256:91496ceffdaf63562d28ca0e27d317f4e22048267efc754450f2b3cf37e69a88",
"size":"30758086"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/msp430-gcc-4.6.5-i386-apple-darwin11.tar.bz2",
"archiveFileName":"msp430-gcc-4.6.5-i386-apple-darwin11.tar.bz2",
"checksum":"SHA-256:9a85b83a0015d1219157e503d0515092171c1a49a9bd695fe14a4ddfbde66ffb",
"size":"32399439"
},
{
"host": "x86_64-linux-gnu",
"url": "https://s3.amazonaws.com/energiaUS/tools/linux64/msp430-gcc-4.6.5-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName": "msp430-gcc-4.6.5-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum": "SHA-256:0b5b4ee3e027aa88a8d86b1e5d6bd65f919084f3d3f8678475e4debdbbc930c9",
"size": "98367482"
}
]
},
{
"name":"msp430-gcc",
"version":"4.6.4",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/msp430-gcc-4.6.4-i686-mingw32.tar.bz2",
"archiveFileName":"msp430-gcc-4.6.4-i686-mingw32.tar.bz2",
"checksum":"SHA-256:21efce29cc6a83ddce3dbce241fcd235437ed1717f8268af169a6429d0c3d20d",
"size":"30753419"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/msp430-gcc-4.6.4-i386-apple-darwin11.tar.bz2",
"archiveFileName":"msp430-gcc-4.6.4-i386-apple-darwin11.tar.bz2",
"checksum":"SHA-256:e1628d6ddce2d0ee6f9134d3d1b20560cf98cda0cb09a9c33028b3a1d210603d",
"size":"32431529"
},
{
"host": "x86_64-linux-gnu",
"url": "https://s3.amazonaws.com/energiaUS/tools/linux64/msp430-gcc-4.6.4-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName": "msp430-gcc-4.6.4-i386-x86_64-pc-linux-gnu.tar.bz2",
"size": "98437003",
"checksum": "SHA-256:6595fd1dd4ebfd77aec31939e922fb4791e2c74185e908e1a4c27c50cb3b7440"
}
]
},
{
"name":"msp430-gcc",
"version":"4.6.3",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/msp430-gcc-4.6.3-i686-mingw32.zip",
"archiveFileName":"msp430-gcc-4.6.3-i686-mingw32.zip",
"size":"47733038"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/msp430-gcc-4.6.3-i386-apple-darwin11.tar.bz2",
"archiveFileName":"msp430-gcc-4.6.3-i386-apple-darwin11.tar.bz2",
"checksum":"SHA-256:b919d80880603b55c64b9095eb80d4005e82d7428b0d7ded3864c200cb4f847c",
"size":"32357793"
},
{
"host": "x86_64-linux-gnu",
"url": "https://s3.amazonaws.com/energiaUS/tools/linux64/msp430-gcc-4.6.3-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName": "msp430-gcc-4.6.3-i386-x86_64-pc-linux-gnu.tar.bz2",
"size": "87607164",
"checksum": "SHA-256:453832be5150f45a830ea5b0336a911f22fd7553f668a1e93a5c9e58f65f9f7f"
}
]
},
{
"name": "arm-none-eabi-gcc",
"version": "6.3.1-20170620",
"systems": [
{
"host": "i686-mingw32",
"url": "https://s3.amazonaws.com/energiaUS/tools/windows/gcc-arm-none-eabi-6.3.1-20170620-windows.tar.bz2",
"archiveFileName": "gcc-arm-none-eabi-6.3.1-20170620-windows.tar.bz2",
"checksum": "SHA-256:c28a5c2a5272d09bf396c2dcd4c3188ae0dd8ec04d0ce8f581b1995141fc9044",
"size": "110277553"
},
{
"host": "x86_64-apple-darwin",
"url": "https://s3.amazonaws.com/energiaUS/tools/macosx/gcc-arm-none-eabi-6.3.1-20170620-mac.tar.bz2",
"archiveFileName": "gcc-arm-none-eabi-6.3.1-20170620-mac.tar.bz2",
"size": "104268677"
},
{
"host": "x86_64-pc-linux-gnu",
"url": "https://s3.amazonaws.com/energiaUS/tools/linux64/gcc-arm-none-eabi-6.3.1-20170620-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName": "gcc-arm-none-eabi-6.3.1-20170620-x86_64-pc-linux-gnu.tar.bz2",
"checksum": "SHA-256:0a98e8cf843c41fdfdfb74cfe5b27e7b0c6054ee92ea1277812513334b6ce02a",
"size": "100490382"
}
]
},
{
"name": "arm-none-eabi-gcc",
"version": "4.8.4-20140725",
"systems": [
{
"host": "i686-mingw32",
"archiveFileName": "gcc-arm-none-eabi-4.8.4-20140725-windows.tar.gz",
"url": "https://s3.amazonaws.com/energiaUS/tools/windows/gcc-arm-none-eabi-4.8.4-20140725-windows.tar.gz",
"size": "82014307"
},
{
"host": "x86_64-apple-darwin",
"url": "https://s3.amazonaws.com/energiaUS/tools/macosx/gcc-arm-none-eabi-4.8.4-20140725-mac.tar.bz2",
"archiveFileName": "gcc-arm-none-eabi-4.8.4-20140725-mac.tar.bz2",
"checksum": "SHA-256:66c9261fdd6d646931dfe940e8daf38d3b11cfba8a7e714c7a3811146b6dc9c7",
"size": "52518522"
},
{
"host": "x86_64-pc-linux-gnu",
"url": "https://s3.amazonaws.com/energiaUS/tools/linux64/gcc-arm-none-eabi-4.8.4-20140725-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName": "gcc-arm-none-eabi-4.8.4-20140725-x86_64-pc-linux-gnu.tar.bz2",
"checksum": "SHA-256:00636c299e7a420212cdc1643d5c52d3e82eb66c8ce0e4693327cd1e936b52db",
"size": "68654066"
}
]
},
{
"name":"ino2cpp",
"version":"1.0.4",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.4.tar.bz2",
"archiveFileName":"ino2cpp-1.0.4.tar.bz2",
"checksum":"SHA-256:f1409b404eb650931ab138aea642451d0706deb19210331d3bd62bfe79099f17",
"size":"537535"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.4.tar.bz2",
"archiveFileName":"ino2cpp-1.0.4.tar.bz2",
"checksum":"SHA-256:f1409b404eb650931ab138aea642451d0706deb19210331d3bd62bfe79099f17",
"size":"537535"
},
{
"host": "x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.4.tar.bz2",
"archiveFileName":"ino2cpp-1.0.4.tar.bz2",
"checksum":"SHA-256:f1409b404eb650931ab138aea642451d0706deb19210331d3bd62bfe79099f17",
"size":"537535"
}
]
},
{
"name":"ino2cpp",
"version":"1.0.4",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.4.tar.bz2",
"archiveFileName":"ino2cpp-1.0.4.tar.bz2",
"checksum":"SHA-256:f1409b404eb650931ab138aea642451d0706deb19210331d3bd62bfe79099f17",
"size":"537535"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.4.tar.bz2",
"archiveFileName":"ino2cpp-1.0.4.tar.bz2",
"checksum":"SHA-256:f1409b404eb650931ab138aea642451d0706deb19210331d3bd62bfe79099f17",
"size":"537535"
},
{
"host": "x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.4.tar.bz2",
"archiveFileName":"ino2cpp-1.0.4.tar.bz2",
"checksum":"SHA-256:f1409b404eb650931ab138aea642451d0706deb19210331d3bd62bfe79099f17",
"size":"537535"
}
]
},
{
"name":"ino2cpp",
"version":"1.0.3",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.3.tar.bz2",
"archiveFileName":"ino2cpp-1.0.3.tar.bz2",
"checksum":"SHA-256:562c9364db80affc5a5b51a79b70950680c77d7ee62244e18bc8b6f7c114fdeb",
"size":"485132"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.3.tar.bz2",
"archiveFileName":"ino2cpp-1.0.3.tar.bz2",
"checksum":"SHA-256:562c9364db80affc5a5b51a79b70950680c77d7ee62244e18bc8b6f7c114fdeb",
"size":"485132"
},
{
"host": "x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.3.tar.bz2",
"archiveFileName":"ino2cpp-1.0.3.tar.bz2",
"checksum":"SHA-256:562c9364db80affc5a5b51a79b70950680c77d7ee62244e18bc8b6f7c114fdeb",
"size":"485132"
}
]
},
{
"name":"ino2cpp",
"version":"1.0.2",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.2.tar.bz2",
"archiveFileName":"ino2cpp-1.0.2.tar.bz2",
"checksum":"SHA-256:6f63041767f4f15b1da7b62aa3086e6912f9e05b19bfdf512d573bcc9ac7c9a5",
"size":"484493"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.2.tar.bz2",
"archiveFileName":"ino2cpp-1.0.2.tar.bz2",
"checksum":"SHA-256:6f63041767f4f15b1da7b62aa3086e6912f9e05b19bfdf512d573bcc9ac7c9a5",
"size":"484493"
},
{
"host": "x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/ino2cpp-1.0.2.tar.bz2",
"archiveFileName":"ino2cpp-1.0.2.tar.bz2",
"checksum":"SHA-256:6f63041767f4f15b1da7b62aa3086e6912f9e05b19bfdf512d573bcc9ac7c9a5",
"size":"484493"
}
]
},
{
"name":"dslite",
"version":"8.2.0.1400",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-8.2.0.1400-i686-mingw32.tar.bz2",
"archiveFileName":"dslite-8.2.0.1400-mingw32.tar.bz2",
"checksum":"SHA-256:793a4ea6935fd3436cc7f861b23f353609969b951b62812641635bd467814e05",
"size":"33976575"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-8.2.0.1400-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-8.2.0.140-x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:366b9139052037e480fcba4b3a4fb5783b6336b93bd5e2f3034f479a8d502784",
"size":"17527708"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-8.2.0.1400-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-8.2.0.1400-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:f95b710f36786ba9d28c9cb96e05c812e7eba875afc69753007c8910c3bce7fd",
"size":"19182469"
}
]
},
{
"name":"dslite",
"version":"8.0.0.1202",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-8.0.0.1202-i686-mingw32.tar.bz2",
"archiveFileName":"dslite-8.0.0.1202-mingw32.tar.bz2",
"checksum":"SHA-256:88d45eac72682d35e907cefe101b9b32557d70a5044b872d2ac22594b87ae919",
"size":"33554889"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-8.0.0.1202-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-8.0.0.1202-x86_64-apple-darwin.tar.bz2",
"size":"16963904"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-8.0.0.1202-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-8.0.0.1202-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:8d84a25eab60624fd216d1e8e76948ac6a218ff81cff5118c3942dc67ab78acb",
"size":"18783730"
}
]
},
{
"name":"dslite",
"version":"7.4.0.1099",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-7.4.0.1099-i686-mingw32.tar.bz2",
"archiveFileName":"dslite-7.4.0.1099-i686-mingw32.tar.bz2",
"checksum":"SHA-256:298f2d6df8f1122ce8ea437586dfba9c54d394144fdf7853509437a49b642bb8",
"size":"33486116"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-7.4.0.1099-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-7.4.0.1099-x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:445bfbf65a709e2e031c2670b7b0300d11b25f6a58953037f27b09c341fd7fc4",
"size":"17016539"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-7.4.0.1099-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-7.4.0.1099-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:187aeafd49f76d841f68d5fa9cac0dcdfce9aa401fd2f2b67bd9da5c14833f67",
"size":"18597835"
}
]
},
{
"name":"dslite",
"version":"7.2.0.1988",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-7.2.0.1988-i686-mingw32.tar.bz2",
"archiveFileName":"dslite-7.2.0.1988-i686-mingw32.tar.bz2",
"checksum":"SHA-256:248da7bf2e882587e6e51117b8ab53eb60793aa7362836fdbc0388774367d81c",
"size":"30119837"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-7.2.0.1988-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-7.2.0.1988-x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:aa80e246122096f26df9826c8a889c45abeac96f349234c9baff7e2f27f72c36",
"size":"15546846"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-7.2.0.1988-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-7.2.0.1988-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:f43171fac1c09567d22e070e0652dea43eebaf274467e2110cfb826f983054a0",
"size":"18074747"
}
]
},
{
"name":"dslite",
"version":"7.1.0.1917",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-7.1.0.1917-i686-mingw32.zip",
"archiveFileName":"dslite-7.1.0.1917-mingw32.zip",
"checksum":"SHA-256:e8ef665bfeaa9264a98771ea89d14f977e8e448116372f6883bb74dc703424a8",
"size":"36225191"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-7.1.0.1917-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-7.1.0.1917-x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:629fe0c3c5f066b9dd62e065ac8ba80c5fd260d15d6fe32006e200b9a58343ac",
"size":"15384479"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-7.1.0.1917-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-7.1.0.1917-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:89fa13bec5e5504ccaef25a7d87464cf784c14870e66d7e149b8308839ab83de",
"size":"17793290"
}
]
},
{
"name":"dslite",
"version":"7.2.0.2096",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-7.2.0.2096-i686-mingw32.tar.bz2",
"archiveFileName":"dslite-7.2.0.2096-mingw32.tar.bz2",
"size":"33083804"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-7.2.0.2096-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-7.2.0.2096-x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:2a0282a4aae506edde5999e7cffd7e8d4daf3f98df4a5ee0dccf1bb71798f471",
"size":"16666963"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-7.2.0.2096-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-7.2.0.2096-i386-x86_64-pc-linux-gnu.tar.bz2",
"size":"19132835"
}
]
},
{
"name":"dslite",
"version":"6.2.1.1624",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-6.2.1.1624-i686-mingw32.zip",
"archiveFileName":"dslite-6.2.1.1624-i686-mingw32.zip",
"checksum":"SHA-256:fd673ea66fcd8051d91a0138dcddaf0b3104ca1c6b2e0eab0de8b2080ff70094",
"size":"34948605"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-6.2.1.1624-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-6.2.1.1624-x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:0a89afb99973ec2b4cf23be277ccc66cb2dc53fdd894924aa871b0e9882011e3",
"size":"15312608"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-6.2.1.1624-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-6.2.1.1624-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:401d9edd1956b87a7b89f162456a8444b2ac73d3d972f8f2231a150a7e384503",
"size":"17995725"
}
]
},
{
"name":"dslite",
"version":"6.2.1.1594",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/dslite-6.2.1.1594-i686-mingw32.zip",
"archiveFileName":"dslite-6.2.1.1594-i686-mingw32.zip",
"size":"33819921"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/dslite-6.2.1.1594-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"dslite-6.2.1.1594-x86_64-apple-darwin.tar.bz2",
"size":"14735532"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/dslite-6.2.1.1594-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"dslite-6.2.1.1594-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:dfa17d2c26699e1480a13bd7f2941541417c59276ee38d30848e4606e1fba33b",
"size":"20539172"
}
]
},
{
"name":"mspdebug",
"version":"0.24",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/mspdebug-0.24-i686-mingw32.tar.bz2",
"archiveFileName":"mspdebug-0.24-i686-mingw32.tar.bz2",
"checksum":"SHA-256:7b3dfb269b58f692d03080a641f543dfe01bcfcef43935c2bb31e2839e284e73",
"size":"1058435"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/mspdebug-0.24-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"mspdebug-0.24-x86_64-apple-darwin.tar.bz2",
"size":"171307"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/mspdebug-0.24-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"mspdebug-0.24-i386-x86_64-pc-linux-gnu.tar.bz2",
"checksum":"SHA-256:ec6131053a4ddd35b43d44591732313182e3487ffd77181df02ce23f0860a2e5",
"size":"147947"
}
]
},
{
"name":"mspdebug",
"version":"0.22",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/mspdebug-0.22.zip",
"archiveFileName":"mspdebug-0.22.zip",
"checksum":"SHA-256:e4d061b5cb1de2e17dc7f4fb5c3c6bd8c6f7a3ea013fa16e2332b408440236ec",
"size":"201798"
},
{
"host":"x86_64-apple-darwin",
"url":"http://www.energia.nu/tools/mspdebug-0.22-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"mspdebug-0.22--x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:efc469b4771367bd5e420eb7d6f36551df8da36dd130d2bbf184131b6876111e",
"size":"9891660"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"http://www.energia.nu/tools/mspdebug-0.22-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"mspdebug-0.22--x86_64-apple-darwin.tar.bz2",
"checksum":"SHA-256:efc469b4771367bd5e420eb7d6f36551df8da36dd130d2bbf184131b6876111e",
"size":"9891660"
}
]
},
{
"name":"cc3200prog",
"version":"1.1.4",
"systems":
[
{
"host":"i686-mingw32",
"url":"https://s3.amazonaws.com/energiaUS/tools/windows/cc3200prog-1.1.4-i686-mingw32.zip",
"archiveFileName":"cc3200prog-1.1.4-i686-mingw32.zip",
"checksum":"SHA-256:9701cf08a34c727355261eec502dfa44386b34b2d9cde863eb20c347d7a24f97",
"size":"400542"
},
{
"host":"x86_64-apple-darwin",
"url":"https://s3.amazonaws.com/energiaUS/tools/macosx/cc3200prog-1.1.4-x86_64-apple-darwin.tar.bz2",
"archiveFileName":"cc3200prog-1.1.4-x86_64-apple-darwin.tar.bz2",
"size":"164785"
},
{
"host":"x86_64-pc-linux-gnu",
"url":"https://s3.amazonaws.com/energiaUS/tools/linux64/cc3200prog-1.1.4-i386-x86_64-pc-linux-gnu.tar.bz2",
"archiveFileName":"cc3200prog-1.1.4-i386-x86_64-pc-linux-gnu.tar.bz2",
"size":"134860"
}
]
}
]
}
]
}

http://www.xnumber.com/xnumber/cmhistory.htm

## History of Mechanical Calculators

 A Brief History of Mechanical Calculators James Redin From the Abacus to the electro-mechanical calculators. (Parts I, II and III)

 Part I The Age of the Polymaths Part II Crossing the 19th Century Part III Getting Ready for the 20th Century

http://www.rechenautomat.de/

# Mechanische Rechenmaschinen

#### Bilder und Aufsätze zur Automatisierung der mechanischen Rechentechnik

“Ein Automat (griech.) ist im weitern Sinn jede sich selbst bewegende mechanische Vorrichtung, die durch im Innern verborgene Kraftmittel (Federn, Gewichte etc.) in Bewegung gesetzt wird, z. B. Uhren, Planetarien u. dgl.; im engern Sinn ein mechanisches Kunstwerk, welches vermittelst eines innern Mechanismus die Thätigkeit lebender Wesen, der Menschen (Android) oder Tiere, nachahmt und meist auch an Gestalt diesen nachgebildet ist.” (aus Meyers Konversationslexikon von 1885-1892)

In der Fachliteratur verwendet(e) man den Begriff “Rechenautomat” meist im Zusammenhang mit (elektronischen) programmgesteuerten Rechenanlagen, die im technisch-wissenschaftlichen Bereich zum Einsatz kamen. Betrachtet man jedoch Prospekte von Büromaschinen-Herstellern aus den 1930er bis 1970er Jahren, so findet man auch dort Rechenautomaten im Angebot. Sie waren in unterschiedlichen Ausführungen erhältlich: von Halbautomaten bis hin zu “vollelektrischen Speicher-Superautomaten”. Es handelt sich hierbei um elektrisch angetriebene, aber mechanische Rechenmaschinen für den Einsatz im Büro sowie für Privatleute. Sie konnten teilweise oder vollständig eine Multiplikation oder Division ausführen und oftmals auch Rechenergebnisse zwischenspeichern. Manche von ihnen waren sogar in der Lage, selbsttätig eine Wurzel zu berechnen. In diesem Sinne sind die vollautomatischen Rechenmaschinen die mechanischen Vorläufer unserer heutigen elektronischen Taschenrechner.

Nachfolgende Liste ist eine Sammlung von Aufsätzen und Büchern zu elektrisch-mechanischen Rechenmaschinen, die im Zeitraum von 1900 bis 1970 produziert wurden.

# Využití systémů počítačové algebry (CAS) v matematice

https://www.dos4ever.com/flyback/flyback.html

# Flyback Converters for Dummies

## Ronald Dekker

### Special thanks to Frans Schoofs, who really understands how flyback converters work

 If you are interested in Flyback Converters you might want to keep track of my present project: the µTracer: a miniature radio-tube curve-tracer

## introduction

In the NIXIE clocks that I have built, I did not want to have the big and ugly mains transformer in the actual clock itself. Instead I use an AC adapter that fits into the mains wall plug. This means that I have to use some sort of an up-converter to generate the 180V anode supply for the NIXIEs.

This page describes a simple boost converter and a more efficient flyback converter both of which can be used as a high voltage power supply for a 6 NIXIE tube display. Frans Schoofs beautifully explained to me the working of the flyback converter and much of what he explained to me you find reflected on this page. I additionally explain the essentials of inductors and transformers that you need to know. This is just a practical guide to get you going, it is not a scientific treatise on the topic.

## What you need to know about inductors

Consider the simple circuit consisting of a battery connected to an inductor with inductance L and resistance R (Fig. 1). When the battery is connected to the inductor, the current does not immediately change from zero to its maximum value V/R. The law of electromagnetic induction, Faraday’s law prevents this. What happens instead is the following. As the current increases with time, the magnetic flux through this loop proportional to this current increases. The increasing flux induces an e.m.f. in the circuit that opposes the change in magnetic flux. By Lenz’s law, the induced electric field in the loop must therefore be opposite to the direction of the current. As the magnitude of the current increases, the rate of the increase lessens and hence the induced e.m.f. decreases. This opposing e.m.f. results in a linear increase in current at a rate I=(V/L)*t. The increase in current will finally stop when it becomes limited through the series resistance of the inductor. At that moment the amount of magnetic energy stored in the inductor amounts to E=0.5*L*I*I.

Figure 1

http://www.crisvandevel.de/

## Cris’ site on antique mechanical four-function calculators

http://public.beuth-hochschule.de/~hamann/

 Prof. Dr.-Ing. Christian-M. Hamann ( verantwortlich für den Inhalt dieser HomePage ) Spezialgebiete: ( ehem. Leiter des Labors für Künstliche Intelligenz ) LISP & PROLOG Anwendung Expertensysteme Evolutionsstrategien & Genetische Algorithmen Simulation Neuronaler Netze Positionale Logische Algebra Fuzzy-Logik OVER 777 HISTORICAL/TECHNICAL OBJECTS TO EXPLORE … THE ON-LINE MUSEUM RechenMaschinen, RechenStäbe, … , SchreibMaschinen, Telefone, Uhren

https://www.computerhistory.org/babbage/howitworks/

# How it Works

© Computer History Museum | Credits

http://www.vcalc.net/hp-code.htm

# Microcode: Electronic Building Blocks For Calculators

Last Update: January 22, 2003 — THE HP REFERENCE

Hewlett Packard Personal Calculator Digest
Vol. 3, 1977
pp 4-6

Just as DNA can be called the building blocks of the human organism. Microcode can be called the building blocks of the electronic calculator.

But, while the way the human organism works is determined by heredity, the way an electronic calculator works is determined by the highly personal–and even idiosyncratic–creative impulses of a programming specialist.

The principles of programming can be learned, of course. But anyone who has programmed his own calculator quickly discovers that techniques may vary widely from person to person.

Consider the challenge faced by the professional programmer When you press the key labeled SIN, for example, you expect the calculator to display the sine of the value you have keyed into it–and presto, it does. But in that less-than-a-second interval between keystroke and display, the calculator has executed an internal program of about 3500 steps. And it does this according to the highly individualistic microcode that the programmer has created.

The development of microcode in Hewlett-Packard personal calculators began with the development developments of the microprocessor in the HP-35–and not coincidentally, since both were developed by the same Hewlett-Packard engineer.

It is the microprocessor that determines the “language” of the internal microcode. If you are familiar with computer languages such as BASIC, FORTRAN, and COBOL, you know that these languages structure the way you write your program on the computer. You can only do what the language lets you do.

The microprocessor is similar to the computer. It provides a language that a clever engineer can then build into a function on the keyboard.

The original HP-35 microprocessor has remained essentially unchanged through the years and is the heart of the new HP-19C and HP-29C. Compared with computer processors, the binary-coded decimal microprocessor is very simple it does not handle byte data well, but is, in fact, specially designed for 10-digit floating point numbers (See figure 1.). The resulting microcode language most closely resembles machine language, which is programming at as most basic level.

Most microprocessors use 8-bit instructions and two or three instructions are usually combined to perform one operation. The beauty of HP’s calculator microcode is that 10-bit instructions are used and each usually performs a complete operation by itself.

The language’s strongest point is its robust arithmetic section of 37 instructions combined with eight field-select options. The field-select options allow the program to apply the instruction to any word-select portion of the register (See figure 2.).

The language is also designed to use very little storage; only seven registers were used in the HP-35 of which five were user registers. This is done to reduce costs and to save valuable space. For the design engineer it means that he must accomplish all of his miracles within the program itself.

Based on warranty card analysis and other market research, parameters regarding the desired function set and price are given to the design engineer. It is his job then to determine the specific functions for the calculator and to attempt to fit them in the allotted memory. Price is an important factor to the engineer because it directly influences the amount of memory he has to work with.

Only after several months of hard work writing and compacting microcode will he know if the function set will fit. If it is not possible, the product may be redefined at a higher price with greater performance to increase the available memory. More likely however, the engineer will be forced to pare functions until his program fits.

To give you an idea of how much memory is required, the HP-35 used three pages of 256 instructions each. Each page required a separate ROM read-only memory.

• HP-35—-768 instructions–3/4 quad (3 pages of 256 instructions each)

The HP-45 originally took six pages of instructions. But about that time the quad ROM was developed, which, as its name implies, was the equivalent of four conventional ROM’S. So for the HP-45, two quad ROM’s were used. It was in the leftover two pages that an enterprising designer placed the celebrated HP-45 clock. Later calculators, listed below, continued to use quad ROM’s.

Note: 1 quad = 1024 instructions or 4 pages of 256 instructions each. -Rick-

Writing the microcode is where the designer’s personality is stamped indelibly on the Calculator. While it is true that the fundamental algorithms for commuting the complex mathematical functions found in HP personal calculators have remained essentially the same since the HP-35, the individual code is substantially different.

+---------------------------------------------------------------------+
| NUMBER   REGISTER REPRESENTATION                                    |
|                                                                     |
|          +---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|   23.4   | 0 | 2 | 3 | 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |  |
|          +---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|                                                                     |
|            a                                                        |
|          +---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|  -123.   | 9 | 1 | 2 | 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 2 |  |
|          +---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|                                                                     |
|                                                                   b |
|          +---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|  .002    | 0 | 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 9 | 9 | 7 |  |
|          +---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|                                                                     |
|          a. A "9" in the sign position indicates a negative number. |
|          b. Exponents are kept in 10's complement form.             |
|                                                                     |
+---------------------------------------------------------------------+
|  Figure 1. All numbers in registers are in scientific notation with |
|  the mantissa portion of the number left justified in the mantissa  |
|  portion of the register.                                           |
+---------------------------------------------------------------------+

+---------------------------------------------------------------------+
|          mantissa sign                               exponent sign  |
| pointer    |                                           |            |
| positions+---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|    ----> |13 |12 |11 |10 | 9 | 8 | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |  |
|          +---+---+---+---+---+---+---+---+---+---+---+---+---+---+  |
|          |   |                                       |           |  |
|          |   |                                       |           |  |
|          |   +------------- mantissa ----------------+- exponent +  |
|          |                                           |           |  |
|          +----------- mantissa and sign -------------+           |  |
|          |                                                       |  |
|          +----------------------  word --------------------------+  |
|                                                                     |
+---------------------------------------------------------------------+

+---------------------------------------------------------------------+
|Instructions                                                         |
+--------------+------------------------------------------------------+
|  A = 0       |                                                      |
|  B = 0       | Clears word-select portion.                          |
|  C = 0       |                                                      |
+--------------+------------------------------------------------------+
|  B = A       | Copies word-select portion                           |
|  C = B       |   from specified register                            |
|  A = C       |   to specified register.                             |
+--------------+------------------------------------------------------+
|  AB EX       | Exchanges word-select portion                        |
|  AC EX       |   between specified registers.                       |
|  CB EX       |                                                      |
+--------------+------------------------------------------------------+
|  A = A + B   |                                                      |
|  A = A + C   |                                                      |
|  C = A + C   |                                                      |
|  C = C + C   |                                                      |
|  A = A - B   |                                                      |
|  C = A - C   |                                                      |
|  A = A - C   | Performs stated arithmetic                           |
|  A = A + 1   |   on word-select portion.                            |
|  C = C + 1   |                                                      |
|  A = A - 1   |                                                      |
|  C = C - 1   |                                                      |
|  C = -C      |                                                      |
|  C = -C - 1  |                                                      |
+--------------+------------------------------------------------------+
|  A SR        |                                                      |
|  B SR        | Shifts word-select portion right.                    |
|  C SR        |                                                      |
+--------------+------------------------------------------------------+
|              |                                                      |
|  A SL        | Shifts word-select portion left.                     |
|              |                                                      |
+--------------+------------------------------------------------------+
|              | Circular shifts whole A                              |
|  A SLC       |   register but does not have                         |
|              |   word-select option.                                |
+--------------+------------------------------------------------------+
|  ? B = 0     |                                                      |
|  ? C = 0     |                                                      |
|  ? A => C    | Tests word-select portion of                         |
|  ? A => B    |   given register.                                    |
|  ? A = 0     |                                                      |
|  ? C = 0     |                                                      |
+--------------+------------------------------------------------------+
| Field-Select Options                                                |
|                                                                     |
|  1. Mantissa (M)                                                    |
|  2. Mantissa and Sign (MS)                                          |
|  3. Exponent (X)                                                    |
|  4. Exponent Sign (XS)                                              |
|  5. Sign of Mantissa (S)                                            |
|  6. Pointer (P)                                                     |
|  7. Word (W)                                                        |
|  8. Word thru Pointer (WP)                                          |
|                                                                     |
+---------------------------------------------------------------------+
|  Figure 2. Registers are 14 digits long with each digit being four  |
|  bits. An additional four bit register is used as a pointer. The    |
|  programmer can set the pointer to any digit position, change that  |
|  digit or all digits up to that position.                           |
+---------------------------------------------------------------------+


Some of the major routines such as those for sine, cosine, and tangent are the same from calculator to calculator. But in most cases if the code cannot be borrowed exactly as it exists in another calculator, it must be rewritten.

Some designer begin by strictly flowcharting the entire program Others tackle the code directly and leave all but basic flowcharting till the end for documentation purposes only. The code is written originally on paper just as you would write a program on an HP programming pad. It is then either punched on cards or typed into a handy CRT.

The major task in writing the microcode is not only to have the functions produce the correct answers when a key is pressed, but to fit the code into a given amount of memory and make it execute as fast as possible. Compacting the code, that is, rewriting sections of the program to make them more space-efficient, is easy enough, but sometimes results in a loss of speed. These are tradeoffs to which the designer must be constantly attentive.

The processor executes approximately three instructions per millisecond, with each instruction taking the same amount of time. The designer takes into consideration the type of function and the necessary speed when writing the code. Straight-line code with no branches of any I kind executes the fastest. For the label search function on the HP-67 and the HP-97 the designer duplicated a great deal of code to; make it faster. The print instructions for the new HP-19C, on the other hand, did not need to be as fast to keep up with the printer, mechanism. So the designer compacted these codes, making them very complex.

+---------------------------------------------------------------------+
|     +---------------+    +---------------+    +---------------+     |
|     |   A. Answer   |    |B. Multiplicand|    | C. Multiplier |     |
|     +---------------+    +---------------+    +---------------+     |
|                                                                     |
+--------+-----------+--------+---------------------------------------+
| LABEL  | CODE      |        | Explanation                           |
+--------+-----------+--------+---------------------------------------+
|        | A = 0     | W      | Clearing space for answer.            |
|        | P =       | 3      | Starting at least significant digit.  |
|        | GoTo      | Mpy90  | Starting in middle of loop for speed. |
| Mpy90  | A = A + B | W      | Add Multiplicand to partial product   |
|        |           |        |   the number of times specified by    |
|        |           |        |   digit being worked on.              |
+--------+-----------+--------+---------------------------------------+
| Mpy100 | C = C - 1 | P      |                                       |
|        | GoNC      | Mpy90  | NC stands for no carry, i.e. a GoTo   |
|        |           |        |   is executed unless a digit is       |
|        |           |        |   carried (or borrowed).              |
|        | ? P =     | 12     | Have we reached the end of the world? |
|        | GoYes     | END    |                                       |
|        |           |        |                                       |
+--------+-----------+--------+---------------------------------------+
|        | P = P + 1 |        | Move on the next digit.               |
|        | A SP      | W      | This does a divide by 10 to line up   |
|        |           |        |   for the next decade.                |
|        | GoTo      | Mpy100 | Go reenter loop.                      |
|        |           |        |                                       |
+--------+-----------+--------+---------------------------------------+
|  Figure 3. Multiplying two numbers uses the basic routine shown     |
|  above and involves three registers The starting point of this      |
|  code assumes the sign and exponent of the answer have already      |
|  been calculated. END is a common function return which would       |
|  perform operations such as display formatting, printing, etc.      |
+---------------------------------------------------------------------+


In general, programmable calculators go through more gyrations for each function than do preprogrammed calculators because they must generate an intermediate keycode. Where simple functions such as Change Sign, x exchange y, and ENTER require only 100 steps of code on a preprogrammed calculator, the same functions on a programmable calculator might take 150 steps. And a complex function such as rectangular-to-polar conversion might take over 4000 steps, depending on the argument keyed in.

The engineer uses a computer simulator to write and debug his code. Special programs written for this simulator furnish him with status bit information, register contents, and intermediate answers as an aid in this process.

Once the microcode is completed on the computer, it is transferred to an E-ROM (erasable read only-memory) simulator for further debugging (See photo.). The simulator is ideal for this because it is portable and easily updated as bugs are found and corrected. Simulated calculators are given to application engineers and quality assurance engineers to help locate problems.

After much editing, the microcode is ready to be converted into hardware. This usually takes several weeks. In the meantime, the simulators continue to be used heavily and, in most cases, additional bugs are found.

When the completed integrated circuit chips return, the first working models of the calculator are constructed. Final testing is then initiated. Some problems can only be discovered at this stage because of the peculiarities of simulated operation. For example, this is the first time low battery indicators can be checked since the E-ROM simulator does not work on batteries.

At long last, the revised code is ready to be sent for final chips. Although no problems are anticipated at this stage, testing continues to assure traditional Hewlett-Packard reliability.

The tremendous emphasis on testing of the calculators is for practical reasons as well incorrect programs cannot be easily corrected as they can be on large computers. Once the code is set in hardware, changes are costly and inconvenient.

When the final chips are approved for production, the development cycle is complete. The design engineer has spent anywhere from six months to 13 months perfecting his building block design. And whether the end product is a high-powered financial calculator like the HP-92 or a versatile keystroke programmable like the HP-19C, it is first an expression of his personality and creativity.

The Calculator Reference by Rick Furr (rfurr@vcalc.net)

Back to The HP Page

Back to The Calculator Reference

Division, part 1: Integer division

# DIVISION, PART 1: INTEGER DIVISION

Been a long time since I said anything here, and I and my Nippon HL-21 are parted for a few weeks, so I’ll talk algorithms for a while. Thus far we’ve seen addition, subtraction, and multiplication. The missing operation is division. Now, we’re going to start with “fourth-grade” division: the sort where you divide one whole number by another whole number and get a remainder. Later we’ll talk about decimals.

To start with, we might look at what integer division means, and how we do it by hand; the latter will inform our design of algorithms. Let’s suppose we want to divide, say, 52301 by 13.

## https://www.tutorialspoint.com/execute_python_online.php

https://web.archive.org/web/20180119022941/http://energia.nu/guide/tutorial_energytrace/

https://43oh.com/2015/09/how-to-measure-an-energia-applications-power-usage-with-energytrace

## How to measure Energy profile in Energia with TI Energy Trace

This tutorial is based on material originally posted at 43oh.com by Frank Milburn: http://43oh.com/2015/09/how-to-measure-an-energia-applications-power-usage-with-energytrace/

While experimenting with an nRF24L01 radio and MSP430G2553 microcontroller powered by a super capacitor and solar panel, the need to better understand the energy usage became increasingly apparent. I was aware of EnergyTrace, but didn’t think it could be used because I was developing with the Energia IDE. After some digging though I found out that it can be used on Energia applications and that it has powerful capabilities.

This demonstration will show how to measure the energy and power usage of a MSP-EXP430G2LaunchPad running an application developed entirely within the Energia IDE.

In order to use EnergyTrace, it is necessary to have Code Composer Studio version 6.1 or newer and a LaunchPad with supporting hardware such as the MSP-EXP430FR5969 in addition to the target microcontroller. There is a free version of CCS and the MSP-EXP430FR5969 can be obtained for US \$15.99. The MSP-EXP430FR5969 powers the MSP-EXP430G2 which allows EnergyTrace to sample the supply voltage and provide energy and power data without using the CCS debugger – so the Energia solution is being measured directly.

Code Composer Studio is a full featured professional IDE and it takes time to learn if you are not familiar with it. Fortunately, a detailed understanding of all the features is not necessary to use EnergyTrace. Code Composer Studio can be downloaded here and the second chapter of this workshop gives an introduction on how to use it. These videos provide an understanding of how to use EnergyTrace – pay particular attention to the one on “Using EnergyTrace Technology without a Debug Session” as that is the basic method used here.

EnergyTrace works by continuously measuring the energy supplied to the target as opposed to discrete measurement of voltage over a shunt resistor. This is done with a software controlled dc-dc converter that generates the power for the target. The pulses from the dc-dc converter are counted and the more pulses per unit time, the higher the current flow. Accordingly, even the most rapid events that contribute to current consumption are captured, although the sampling frequency is only on the order of 1 kHz.

## Inefficient Code – Blink Energy 1

As a demonstration, we will use that old standby Blink. The code below gives a pretty standard sketch for Blink although the blink is shortened and the delay time between blinks is lengthened from that which is normally used.

EnergyTrace will be used to estimate how long this will run on two AA batteries.

The sketch was uploaded to a M430G2553 microcontroller on the MSP-EXP430G2 LaunchPad in the normal manner with Energia 16. Then the MSP-EXP430G2 LaunchPad and the MSP-EXP430FR5969 LaunchPad were connected together with female-to-female jumpers as shown in Figure 2.

The connections are described in detail starting at the bottom of page 26 of this reference. Pay attention to which side of J3 and J13 the connections are made. Then connect the MSP-EXP430FR5969 via USB to your computer and open up Code Composer Studio. I chose to start a new CCS Project for the MSP430FR5969 with the blink example but this is not important as EnergyTrace will not use the code in the project or the debugger.

Then, follow the directions for Using EnergyTrace Technology without a Debug Session.

AA batteries were chosen in the preferences tab for EnergyTrace. After selecting 30 seconds for the runtime and pressing start, the simulation began and gave the results in Figure 3.

The summary table at left in Figure 3 reports an estimated battery life of 77 days.The battery life estimates are just that – battery life depends on chemistry, how the battery was manufactured, its age, the temperature, how it is drained, etc.

The power is graphed in the center chart and reports a rather steady 3 mW base with spikes up to about 15.5 mW every second corresponding to the LED blinking. At right is the energy graph showing a total energy usage of 109 mJ over the 30 second test. It may be hard to see, but there are stair steps every second corresponding to the LED spikes.

## More Efficient Code – Blink Energy 2

It looks like the base load is coming from the microcontroller and that it is the primary user of power. Leaving the unused pins floating on the microcontroller can result in incremental power usage. To overcome this, put all pins in OUTPUT mode and then pull them LOW. So, take off the female-to-female jumpers and put the J3 jumpers back in place for the MSP-EXP430G2. The setup() function is then modified as shown in the snippet below.

Upload the revised sketch to the MSP-EXP430G2 and put everything back in place to use Code Composer Studio. Open it up and run EnergyTrace. The results are shown in Figure 4.

The energy used has been reduced to 105 mJ and the battery life of the 2xAA batteries is now 80 days. An improvement, but can we do better?

## Even More Efficient Code – Blink Energy3

The sleep() function was introduced with Energia version 13. Using it instead of delay() puts the microcontroller into Low Power Mode 3 (LPM3) which should reduce the base load. The code below shows a modified loop() function that uses sleep() instead of delay().

The EnergyTrace results are shown in Figure 5.

Impressive. The base has dropped to where it doesn’t show on the scale while in sleep mode and the total energy is reduced to 19.1 mJ. Battery life is up to 441 days now from 77 days in the first example. The energy chart now clearly shows the stair step that occurs when the LED is turned on.

Two additional observations can be made from Figure 7. The first observation is that the spikes appear to be of uneven width and don’t always drop immediately to the base. The User’s Guide for Code Composer Studio contains the answers in the FAQ section of Chapter 3:

Q: My Power graph seems to include noise. Is my board defective?

A: The power values shown in the Power graph are derived (that is, calculated) from the accumulated energy counted by the measurement system. When the target is consuming little energy, a small number of energy packets over time are supplied to the target, and the software needs to accumulate the dc-dc charge pulses over time before a new current value can be calculated. For currents under 1 µA, this can take up to one second, while for currents in the milliamp range, a current can be calculated every millisecond.

Q: My power mode profile sometimes shows short periods of power modes that I haven’t used anywhere in my code. For example, I’m expecting a transition from active mode to LPM3, but I see a LPM2 during the transition.

A: When capturing in EnergyTrace++ mode, digital information is continuously collected from the target device. One piece of this information is the power mode control signals. Activation of low-power modes requires stepping through a number of intermediate states. Usually this happens too quickly to be captured by the trace function, but sometimes intermediate states can be captured and are displayed for a short period of time as valid low-power modes.

The second observation is that the period is longer between blinks with the sleep() function. This can occur because of the way sleep() is implemented and it may give lower timing resolution than delay().

EnergyTrace can also compare the results between two cases as shown in Figure 6.

## More on Energy Savings

Energia users interested in improving the energy efficiency of their applications should also be aware of the sleepSeconds(), suspend(), and wakeup() functions.

Briefly, sleepSeconds() should be used whenever the interval is 1 second or greater. The one second intervals of sleepSeconds () are relatively coarse and are subject to some inaccuracy.

The suspend() function puts the microcontroller into Low Power Mode 4 (LPM4) for very low power usage. It can then be woken with an external interrupt by the wakeup() function.

search on 43oh will turn up a number of threads with information on these functions and there is also a post on github here that demonstrates them. To get the full energy reductions and accuracy that are available on MSP430 microcontrollers though it is necessary to use Code Composer Studio with its full access to timers, lower energy states, and peripherals instead of Energia.

## Summary

EnergyTrace can provide information on the energy usage of MSP430 processors to Energia users. It is necessary to have Code Composer Studio installed along with a LaunchPad having the necessary supporting hardware such as the MSP-EXP430FR5969. In this demonstration the estimated battery life of a simple example was increased from 77 days to 441 days – an increase of a factor of 5.7. The primary benefit came from using the sleep() function instead of delay(). A reduction in power usage from putting all pins in a known state was also demonstrated.

Other means of improving power usage using the sleepSeconds(), suspend(), and wakeup() functions were briefly introduced. Energia users should be aware that sleep () and sleepSeconds () may result in less accurate sleep intervals.

Receiving, identifying and decoding LF/HF radio time signalsReceiving, identifying and decoding time signals is an interesting and sometimes challenging aspect of amateur radio.
Time signals have unique spectral ‘foot print’ which makes them very special!

List of active time signal transmitters, received in Australia (except for MSF, TDF and BBC which were received and decoded in Europe):

———————————-

 ID Frequency Location Website Snapshot Decode QSL RJH77 25 KHz Generalniy Shtab Voenno-morskogo Flota RF (Russian Navy). St.Petersburg, Russia Arkhangelsk, Russia RJH77 Website Recording of RJH77 RAB99 25 KHz Generalniy Shtab Voenno-morskogo Flota RF (Russian Navy). St.Petersburg, Russia Khabarovsk, Russia RAB99 Website

https://joldosh.blogspot.com/

## Sunday, February 3, 2019

### Tiny Calculator: improved CORDIC

Since my last post I have made a lot of changes to the CORDIC routines I was working on. As you can see in the chart above, the new version fits in less than the 4.1k of the last version even after adding in logarithms. The change came after I found an article about how the HP-35 did CORDIC calculations. Unlike the other descriptions of the method I have used, this version uses an atan table of powers of 10 instead of powers of 2. This lets you shift the arguments by whole decimal places, which is much faster with BCD numbers than powers of 2 . Before, I had wondered if this would be more efficient, but I don’t understand the math behind it well enough to modify the routine myself. My implementation of the method the HP-35 uses only takes 90k cycles, compared to the 1.18 million of the last version. The X and Y that the calculation produces, however, cannot be scaled to produce sine and cosine directly. The scale factor depends on the number of rotations, which is easy to precalculate when the angle is halved every iteration, but not possible to know in advance when you use powers of 10 since each iteration requires up to 9 calculations with each affecting the scale factor. As a result, the ratio of X and Y provides the tangent and the HP-35 used identities involving multiplication, division, and square root to generate sine and cosine from tangent. In addition to the 90k cycles for the CORDIC calculation, I would need at least another 140k cycles for these identities. This is 5 times faster than how I was doing it before, although I’m afraid the accuracy would suffer from the added calculations.

http://www.crockford.com/pwl/

# Permanent Weight Loss

My interest in Blissymbolics got me interested in linguistics. That got me interested in the origin of language. That got me interested in the origin of man.

About the same time, the stress of life in an internet startup caused me to gain weight, which led to sleep apnea. It was a long road back, but I came back and I am very happy about that. Along the way, I discovered how to make myself healthy again, and I was surprised to find the connection to our human origins, the Demons from the Ice Age.

Two people who I love very much are struggling with weight loss. I wrote these entries hoping that it could help them. I hope that this can help you too.

## Eat less, exercise more

https://wiki.epfl.ch/polymac/simulators

## Simulateurs des HP Classic, avec émulation complète du microcode original, breakpoints et trace de l’exécution

Remerciements aux auteurs, Jacques Laporte & Eric Smith, pour leur formidable ouvrage didactique et historique.

 HP-35v2 Java HP-35v4 Java HP-45 Java HP-65 Java HP-67 Java Turing Java HP-35 Javascript HP-45 Javascript HP-55 Javascript TI Javascript Sinclair Javascript Curta Flash

https://blogs.msdn.microsoft.com/ashleyf/2010/09/25/microcode-level-hp-35-emulator-in-javascript/

# Microcode-level HP-35 Emulator (in JavaScript!)

★★★★★

★★★★

★★★

★★

Ashley Nathan FenielloSeptember 25, 20105

[Part 1 of the HP Calc
series
]

I recently started a super-geeky side hobby of collecting vintage calculators and got my hands on a pair of HP calcs. The more I learned about the internals of the devices, the more intrigued I was. Jacques Laporte has an absolutely wonderful site going into crazy detail.

In 1972, Hewlett-Packard amazed the engineering world and killed the slide rule with the release of the HP-35 calculator; the very first hand-held electronic scientific calculator. Most astonishing was that apparently even cute girls loved RPN and were impressed by the device’s ability to do transcendental logarithm and trigonometry functions.