As the final tutorial in this series, we present four example inline assembly functions for the arduino. Specifically, these cover the conversion of a byte to a hexadecimal string, SPI Mode 0 hardware transfer, SPI Mode 0 Bit-banging, and the C library atoi function. Do not take these functions as archetypical examples of high-quality coding practice or brilliantly efficient inline code. They are just simple examples.
Most of the previous examples in this series were simple “snippets of code”, and as such gave a myopic view of inline assembly. The goal here is to show complete and working demonstrations of how to include inline assembly into the typical arduino program. Each example includes explanatory comments covering the key portions of code.
In addition to these examples, have a look at the Arduino Inline Assembly Blink Program.
Stringing Hexadecimals
The following code converts a byte value into a hexadecimal string. Notice at the start of the code, that the constraint #0 value (val) is temporarily saved in the r25 register. The function then converts the first nibble. When the conversion process is complete, the function loops back and converts the second nibble. Note how the code uses the SREG T-bit to flag the first vs. second nibble.
void ByteToHexStr(uint8_t val, char *str) {
asm (
"set \n" //flag first nibble
"mov r25, %0 \n" //save val
"swap %0 \n" //swap for correct nibble order
"1: \n"
"andi %0, 0xf \n" //mask a nibble
"cpi %0, 0xa \n" //>10?
"brcc 2f \n" //yes
"subi %0, 0xd0 \n" //convert numeral (0-9)
"rjmp 3f \n" //skip next
"2: \n"
"subi %0, 0xc9 \n" //convert letter (A-F)
"3: \n"
"st Z+, %0 \n" //put into string
"brtc 4f \n" //upper nibble?
"clt \n" //clear nibble flag
"mov %0, r25 \n" //get upper nibble
"rjmp 1b \n" //repeat conversion
"4: \n" //exit
: : "r" (val), "z" (str) : "memory"
);
}
I SPI With My Little Eye…
Serial Peripheral Interface (SPI) is a synchronous serial data protocol used by microcontrollers for communicating with one or more peripheral devices, or for communication between two microcontrollers. The SPI standard is loose and each device implements it a little differently, which means you must pay close attention to the device’s datasheet when implementing the protocol. Generally speaking, there are four modes of transmission, defined by the clock phase and polarity.
Here are two versions of the SPI transfer function. The first of these programs incorporates the arduino hardware SPI. The second is a bit-bang version using different pins. More information on SPI can be found here and here.
SPI Mode 0 Hardware Transfer
static __attribute__ ((noinline)) uint8_t SpiXfer(uint8_t data) {
asm (
"out %1, %0 \n" //put data out SPDR register
"nop \n" //pause
"1: \n"
“in __tmp_reg__, %2 \n" //check xmit complete
"sbrs __tmp_reg__, %3 \n"
"rjmp 1b \n"
"in %0, %1 \n" //get incoming data
: "+r" (data) : "M" (_SFR_IO_ADDR(SPDR)),
"M" (_SFR_IO_ADDR(SPSR)), "I" (SPIF)
);
return data;
}
SPI Bit-Bang
#define MOSI_PORT PORTD
#define MOSI_BIT PORTD5
#define MISO_PORT PIND
#define MISO_BIT PIND6
#define CLOCK_PORT PORTD
#define CLOCK_BIT PORTD7
static __attribute__ ((noinline)) uint8_t SpiBitBang(uint8_t data) {
register uint8_t tmp, i=8;
//save and restore sreg because t-bit is utilized
asm (
"in __tmp_reg__, __SREG__ \n"
"1: \n"
"sbrs %0, 0x07 \n" //is output data bit high?
"rjmp 2f \n" //no
"sbi %3, %4 \n" //output a high bit
"rjmp 3f \n"
"2: \n"
"cbi %3, %4 \n" //output a low bit
"3: \n"
"lsl %0 \n" //shift to next bit
"in %1, %5 \n" //get input
"tst %1 \n" //anything here?
"breq 4f \n" //nope
"bst %1, %6 \n" //set t-bit if input bit is high
"clr %1 \n" //zeroize register
"bld %1, 0 \n" //set bit 0
"or %0, %1 \n" //or low bit with data for return value
"4: \n"
"sbi %7, %8 \n" //toggle clock bit high
"nop \n" //pause
"cbi %7, %8 \n" //toggle clock bit low
"subi %2, 1 \n" //more bits?
"brne 1b \n" //do next bit
"out __SREG__, __tmp_reg__ \n"
: "+r" (data), "=&r" (tmp): "a" (i),
"M" (_SFR_IO_ADDR(MOSI_PORT)), "I" (MOSI_BIT),
"M" (_SFR_IO_ADDR(MISO_PORT)), "I" (MISO_BIT),
"M" (_SFR_IO_ADDR(CLOCK_PORT)), "I" (CLOCK_BIT)
);
return data;
}
A Toy
Atoi is a function in the that converts a string into an integer numerical representation (atoi stands for ASCII to integer). It is included in the C standard library header file stdlib.h. It is prototyped as follows:
int atoi(const char *str);
The str argument is a string, represented by an array of characters, containing the characters of a signed integer number. The string must be null-terminated.
Here is the basic idea of the atoi function implemented in C language:
int16_t atoi(char s[]) {
uint8_t i, sign;
int16_t n;
//skip white space
for (i=0; s[i]<=' '; i++);
//sign
sign = 0;
if (s[i] == '-') {
sign = 1;
i++;
}
//convert
for (n=0; s[i]>='0' && s[i]<='9'; i++)
n = 10*n + s[i] - '0';
if (sign)
return (-1*n);
else
return n;
}
Atoi Inline
Here is our implementation, which is only 64 bytes in length. By comparison, the arduino AVR libc atoi() function is 76 bytes long. This version is basically functionally equivalent, however there are a few detail differences (this function steps over all leading ASCII characters 0x2F and below, not just whitespace):
int16_t _atoi(const char *s) {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
//sign & c are initialized inside inline asm code
register uint8_t sign, c;
#pragma GCC diagnostic pop
//force result into return registers
register int16_t result asm("r24");
asm (
"ldi %A0, 0x00 \n" //result = 0
"ldi %B0, 0x00 \n"
"1: \n"
"ld %2, Z+ \n" //fetch char
"cpi %2, '-' \n" //negative sign?
"brne 2f \n"
"ldi %3, 0x01 \n" //sign = TRUE
"2: \n"
"cpi %2, '/' + 1 \n" //step over whitespace/garbage
"brcc 3f \n"
"rjmp 1b \n"
"3: \n"
"rjmp 5f \n"
"4: \n"
"ldi r23, 10 \n" //result *= 10
"mul %B0, r23 \n"
"mov %B0, r0 \n"
"mul %A0, r23 \n"
"mov %A0, r0 \n"
"add %B0, r1 \n"
"clr __zero_reg__ \n" //r1 trashed by mul
"add %A0, %2 \n" //result += new digit
"adc %B0, __zero_reg__ \n"
"ld %2, Z+ \n" //fetch next digit char
"5: \n"
"subi %2, '0' \n" //convert char to 0-9
"cpi %2, 10 \n" //end of string?
"brlo 4b \n"
"cpi %3, 0 \n" //negative?
"breq 6f \n"
"com %B0 \n" //negate result
"neg %A0 \n"
"sbci %B0, -1 \n"
"6: \n"
: "+r" (result) : "z" (s), "a" (c), "a" (sign) : "memory"
);
return result;
}
Conclusion
While there are countless more topics to cover, and many more rabbit-holes to dive down, I believe I have covered enough of the basics in this series. I sure enjoyed researching and writing these tutorials. And, hopefully you gained a few insights into the funky world of arduino (AVR) inline assembly programming. Now, get inline with your programming!
[updated: 4.11.16]
Also available as a book, with greatly expanded coverage!
[click on the image]
µC eXperiment 