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::20150103222139|]]
This page describes a library that offers overloads of Arduino's digital pin functions (digitalWrite(), digitalRead(), shiftOut(), shiftIn()), but with native performance. For example, the digitalWrite() function of this library produces 1 inlined assembler instruction (sbi <port>, <bit>) and runs in two clock cycles (one cycle in reduced core TinyAVRs). This library can be used to include Arduino code in "raw" AVR projects without suffering a memory footprint hit. It is also offered as an Arduino library, providing a much faster implementations of the digital pin functions.
The library is header file only and typically produces code that is as optimal as hand-crafted assembly code. Under certain circumstances, specifically when changing more than one bit at a time, the resulting code is generally faster than the C-style equivalent using #defined macros and bitwise logical operators.
Fast or readable?
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 an integer variable on Arduino, which is resolved at run-time. The pins and ports for bitwise operations are normally declared using preprocessor macros, which get resolved at compile time. There are hybrid cases, such as the Arduino SoftwareSerial library[1], where a pin number is converted once into a bit mask at run time and then that bit mask is used for the remainder of the program in logical AND- and OR operations.
It is partly the run-time resolving of pin numbers that makes Arduino’s digital pin functions so slow[2]; simply setting or clearing a single output pin will set you back more than 50 clock cycles![3] 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.
This choice can be clearly seen when looking at the implementations of several standard Arduino libraries. The strictly timed SoftwareSerial library, as mentioned before, uses bitwise operators[1], while for example the LiquidCrystal library can afford to use the digital pin functions[4].
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.
Fast and readable
Look at the following code and spot the differences with the digital pin functions as shown earlier
<source lang="cpp">
- include "FastPins.h"
using namespace FastPins; 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 is that the digital pin functions are not 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 and interpreted at run-time. Instead, it is now a variable of some special type, where the pin number is part of the type. This means that no time is 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.
Also: 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.
I'll describe some disadvantages later—or rather: consequences, but let me just show you one more advantage: if you want to squeeze the last clock tick from your code, the functions in the FastPins library allow setting or clearing several bits at the same time. The library will generate optimal code, which means that if a call simultaneously sets or resets bits in the same AVR port, the fastest code will be emitted to do that. For example:
<source lang="cpp">
- include "FastPins.h"
using namespace FastPins; DigitalPin<12>::type led1; // this is in port B DigitalPin< 7>::type led2; // port D DigitalPin<11>::type led3; // port B again
void setup()
{
pinMode( led1 | led2 | led3, OUTPUT);
}
void loop() {
// this will combine the output to led1 and led3 // for optimum performance. digitalWrite( led1 | led2 | led3, HIGH);
} </source> In the above code we're asserting pins led1, led2 and led3 at the same time. Because led1 and led3 are in the same AVR port, they offer an optimization opportunity. Instead of creating code that is equivalent to this C-code:
<source lang="cpp">
PORTB |= LED1_MASK; // 2 clocks PORTD |= LED2_MASK; // 2 clocks PORTB |= LED3_MASK; // 2 clocks
</source>
The library generates code that is equivalent to the following C-code:
<source lang="cpp">
PORTB |= (LED1_MASK | LED3_MASK); // 3 clocks PORTD |= LED2_MASK; // 2 clocks
</source>
...which results in slightly faster assembly code[5]. The gain is not enormous compared to the already fast new overloads (1 clock tick in the example above), but adding even more pins is free (will happen in the same 3 clock ticks) and in tight inner loops it feels good to know that there is absolutely no faster way to toggle the pins.
Consequences
FastPins is not completely a drop-in replacement for Arduino pin functions. Because declared pins are not integers anymore, but all have different types, they cannot simply be used in existing Arduino libraries. The following is currently not possible:
<source lang="cpp">
- include "FastPins.h"
using namespace FastPins;
DigitalPin<12>::type rxPin; DigitalPin<11>::type txPin;
SoftwareSerial mySerial(rxPin, txPin); </source>
Although it is certainly possible to create the conversion operators to translate DigitalPins to integers, the SoftwareSerial object would still have the "old" Arduino performance. In fact, any library that would want to use fast pin definitions and that supports configurable pins, should be written as a template that accepts either DigitalPins or pin numbers as template arguments. A fastpin-version of SoftwareSerial would then be instantiated as:
<source lang="cpp"> SoftwareSerial<rxPinType, txPinType> mySerial; </source>
Additionally, the SoftwareSerial becoming a template would mean that most of its implementation would move to a header file and its methods would be instantiated repeatedly for each rx/tx combinatition. Particularly the SoftwareSerial could be problematic, because people often use this class out of a need to have more than one serial port. For most libraries controlling some piece of hardware however, this is not a problem, because these libraries inherently implement singletons.
Download
The Arduino-ified library is available here: FastPins.zip.
References
- ↑ 1.0 1.1 SoftwareSerial source code, take a look at the tx_pin_write()- or rx_pin_read()-methods
- ↑ well, that, and checking whether the pin is maybe used for PWM at the time, see the implementation of the digitalWrite()-function.
- ↑ "To use or not use digitalWrite", a blog by Bill Grundman who, unlike me, is not too lazy to hook up a scope to his AVR and do measurements
- ↑ LiquidCrystal source code
- ↑ The compiler's optimizer will never combine these OR expressions by itself because the ports are declared volatile. Successive writes to a volatile register will never be combined into a single write.