Fast, arduino compatible digital pin functions
From Just in Time
| Work in Progress This page describes a work in progress. All specifications may change and the final product may significantly deviate from what we describe here. It is very well possible that there will be no final product at all. |
|
[[Revision timestamp::20141204231530|]]
When reading, or setting pin values on AVRS, there are typically only two options: the readable way or the fast way. The readable way is offered by the Arduino platform and consists of digital pin functions like ‘’digitalRead’’, ‘’shiftOut’’, etc. The fast way is available both on Arduino and on ‘raw’ AVR and consists of bit-wise AND- and OR-operations. In code this looks like this:
<source lang="cpp"> // ************************************************** // The 'readable' way. Use digitalWrite() and friends
int myPin = 12;
void setup() {
pinMode( myPin, OUTPUT);
}
void loop() {
digitalWrite( myPin, HIGH); digitalWrite( myPin, LOW);
}
// ************************************************** // The 'fast' way. Use bitwise operators and defines.
- define MYPINPORT PORTB
- define MYPINMASK _BV(4)
void loop() {
MYPINPORT |= MYPINMASK; MYPINPORT &= ~MYPINMASK;
}
</source> Apart from the obvious differences, there is another, more subtle difference between the two approaches: when giving a name to a pin function, this is typically done by using a variable on Arduino, which is resolved at run-time, while the pins and ports for bitwise operations are normally declared using preprocessor macros, which get resolved at compile time.
It is partly the run-time resolving of pin numbers by Arduino’s digital pin functions that makes them so slow; simply setting or clearing a single output pin will set you back more than 50 clock cycles![1] As a developer, you have to choose between fast, but less readable bitwise operators in combination with macros, or readable but slow Arduino digital pin functions, or so it seems…
At the same time, both ‘raw’ AVR developers and Arduino developers use AVR-GCC, which is a full-flexed, modern C++ compiler. Modern C++ compilers allow techniques like template meta programming (TMP) which in turn allows the compiler to perform almost arbitrarily complex processing before generating the assembler instructions that end up in your AVR’s firmware. Shouldn’t it be possible to use the compiler to solve the readable/fast dilemma?
It should, and it is.
Look at the following code and spot the differences with the digital pin functions as shown earlier
<source lang="cpp">
- include "FastPinDefinitions.h"
using namespace FastPinDefinitions; DigitalPin<12>::type myPin;
void setup() {
pinMode( myPin, OUTPUT);
}
void loop() {
digitalWrite( myPin, HIGH); digitalWrite( myPin, LOW);
} </source>
You see? Almost the same code. One difference that you can’t see is that now the digitalWrite function compiles into 1 assembler instruction, taking 2 clock cycles.
The big difference of course is that the digital pin functions you see called in the code above are not the same ones as the original Arduino ones. These are overloads. The other big difference is that ‘’myPin’’ in the code above is no longer an integer which is read at run-time to determine the port. Instead it is now a variable of some special type, where the pin number is actually a part of the type, not a value. This means that no time needs to be spent at run time to determine which hardware address to use and which bit to set in that hardware.
The generated code is also smaller; in my Arduino environment, the binary size for the code above shrinks from 882 bytes to 472 bytes. If I throw in a shiftOut, code shrinks from 1042 bytes to 508 bytes.
An additional advantage is that now, if you specify a nonsensical pin number (like, say, 42) you will be punished with a compiler error instead of being silently ignored at run time, which is the Arduino treatment.