Replacement for regular GPIO (DigitalIn, DigitalOut, DigitalInOut) classes which has superior speed.

Dependents:   Eavesdropper BitstreamGenerator SimpleDecimationFilter 11U68_MP3Player with TFTLCD ... more


FastIO is a library which is largely compatible with standard mbed GPIO functions, but which provides superior speed. The code is based on Igor's earlier work (, with three main differences: port functions are currently not available (this might change in the future), it is ported to many more targets than the original, and instead of only DigitalOut, all options from DigitalInOut are implemented.

FastIO uses a template for the pin number which is connected to the FastInOut object instead of an argument to the constructor like the regular DigitalInOut uses. The important difference between those two is that the value of a template is known by the compiler at compile time, while the supplied pin for regular DigitalInOut is only known at run-time. This allows the compiler to add more optimizations. The only limitations this introduces is that you cannot at run-time choose which pin is used (which would be an extremely rare use case).

You can start by trying out the test bench program, this should work for every supported target (you might need to update the FastIO lib):

Import programFastIO_TestBench

Testbench for FastIO

Currently the following targets are supported:

  • LPC1768
  • LPC11uXX
  • LPC11XX
  • LPC81X
  • KLXXz
  • K20D50M
  • KSDK (K22F, K64F)
  • NUCLEO F401RE/F411RE
  • NUCLEO F030R8
  • EFM32 (Gecko's)
  • NRF51822

Unsupported targets

This library has the nice feature that it also supports unsupported targets. Obviously these do not get the speed advantage of FastIO, but in case your target is not supported, it will automatically use regular DigitalInOut instead. So if you integrate it in another library it will also work on targets which are not supported by FastIO.

A warning message is printed in the compiler if it reverts back to DigitalInOut.


The main goal is to have a faster, more efficient alternative to regular mbed GPIO functions, so lets compare that. As of library version 86, the mbed library contains extra debug code that is as of yet not possible to be disabled (in the online compiler in a suitable way). This slows DigitalInOut down compared to older versions, but does not affect FastIO. This is, depending on the function, roughly a factor 2 difference: mbed version 86 is twice as slow as version 85.

Five different performance figures are measured:

  • Fixed write(pin.write(1);)
  • Variable write (pin.write(val);)
  • Reading the pin state and comparing it (if ( == 0) break;)
  • Toggling a pin using operators (pin= !pin;)
  • Switching between input and output (pin.output(); pin.input();)

While there are other use cases, these should cover the most used ones. Storing the read value is not included, but should have a fairly similar result. Just comparing it is an easy way to make sure the operation cannot be (partially) optimized away by the compiler, although it results in a longer time than what is actually used by purely the read operation. The main goal of FastIO is to have fast writing, reading, and toggling between input and output (for bidirectional lines), fast construction and mode switching is preferred, but not as important.

The following table shows the time used by fastIO, and also as percentage compared to regular DigitalInOut, this will scale with your clock frequency:

TargetFixed writeVariable writeReadOperator togglingInput/output mode
LPC1768 (96MHz)21ns (29%)78ns (68%)52ns (100%)52ns (28%)52ns (26%)
LPC11uXX (48MHz)83ns (38%)135ns (39%)208ns (60%)219ns (25%)146ns (19%)
LPC11XX (48MHz)104 ns (16%)177ns (22%)125ns (29%)240ns (18%)156ns (12%)
LPC81X (12MHz)229ns (28%)583ns (31%)583ns (100%)708ns (27%)479ns (20%)
KLXXz (48MHz)78ns (54%)146ns (78%)83ns (100%)187ns (38%)78ns (17%)
K20D50M (48MHz)135ns (41%)188ns (47%)104ns (42%)321ns (37%)156ns (17%)
KSDK (120MHz)33ns (4%)62ns (7%)42ns (14%)117ns (10%)33ns (4%)
NUCLEO F4X1RE (84MHz)24ns (27%)83ns (62%)60ns (100%)60ns (27%)60ns (5%)
NUCLEO F030R8 (48MHz)68ns (33%)115ns (36%)125ns (100%)188ns (39%)141ns (5%)
EFM32 (Wonder Gecko) (48MHz)78ns (22%)146ns (40%)188ns (64%)218ns (23%)250ns (10%)
NRF51822 (16MHz)183ns (20%)339ns (25%)372ns (40%)525ns (21%)183ns (7%)

Note that these numbers are from the specific testbench, which highly depends on which optimizations the compiler decides to make. So for your situation it can be different, for example I have seen the write speed change after changes to the read code. Mbed standard write speed also depends on the library version. Since not all targets are supported in older versions I stopped tracking that speed (was also too much effort). If you want to know the comparison for a certain library version, run the testbench on that version.


The library contains three classes you can use:

FastInOut<PinName> your_name;
FastOut<PinName, initial_state> your_name;
FastIn<PinName, initial_mode> your_name;

Initial_state is by default 0 (so output low) and is optional, initial_mode is by default PullDefault, and is optional. Some examples:

FastOut<LED1> led;             //FastOut object for LED1, will default to output low
FastIn<D5, PullUp> input;    //FastIn object for D5, with by default PullUps enabled

Contrary to regular DigitalIn/DigitalOut, FastIn/FastOut can use all functions available to DigitalInOut/FastInOut. The only difference between the three FastIO classes is the initial conditions: FastInOut doesn't set any initial conditions, and the current state of the uC will be maintained. FastOut sets it as output, either high or low, and FastIn as input, with or without pullups/pulldowns enabled. Afterwards you can change your FastIn to an output using simply .output().

For other examples you can look at the test bench code.

Revisions of FastIO.h

Revision Date Message Actions
21:a1dfa6c65400 2016-09-20 Add support to Nucleo L073RZ platform. File  Diff  Annotate
20:ed72895a2402 2016-05-17 Initial version for the NRF51822. I am reasonably sure it works, but with lacking an LED on my board or a logic analyzer it might have issues :). File  Diff  Annotate
19:89d6ae484a35 2016-02-05 Added LPC43XX(4337) File  Diff  Annotate
18:c95920122b2e 2015-07-29 Added LPC11U6x(11U68) File  Diff  Annotate
15:e0c5a5216647 2015-07-09 Initial EFM32 support. FastIn and FastOut child classes seem to be broken yet again. EFM32 has broken mode switching (don't blame me for their GPIO being a pain to use). File  Diff  Annotate
13:0e21ffc6cb84 2015-05-17 Generalized it to all STMF4 platforms. (Holy crap the F407 is fast) File  Diff  Annotate
12:973e253323c9 2015-05-04 FastIn/FastOut didn't properly inherit probably File  Diff  Annotate
11:327ae1d5fecb 2014-12-23 Added F411 (identical to F401) File  Diff  Annotate
10:bb22a3dbedb4 2014-09-20 And this time correct File  Diff  Annotate
8:b0d725519c4f 2014-08-12 FastIn syntax was wrong, now fixed File  Diff  Annotate
7:1e784ae11fba 2014-07-29 Added LPC1114 File  Diff  Annotate
6:da3730030c07 2014-07-17 Added F030 File  Diff  Annotate
4:6ebbf25b9167 2014-07-16 First Nucleo, first version added: F401RE File  Diff  Annotate
3:3dd9466e73fc 2014-07-12 Added K20D50M File  Diff  Annotate
2:1a6ed4b84590 2014-07-04 Added support for unsupported targets :P File  Diff  Annotate
1:85a4a54f15e3 2014-07-02 Added LPC81X File  Diff  Annotate
0:d394ebd01052 2014-07-01 v1.0 File  Diff  Annotate