FastShiftOut with Print interface (experimental)

[robtillaart]

Find below an experimental class that implements a FastShiftOut Class which is derived from the Print class.
This means that all print and println interfaces are available to FSO, including printing of strings, floats and ints.
The class does not implement the latch signal (e.g. to be used for one or more 74HC595)

The class is not tested so use at your own risk

as always comments and remarks are welcome.

FastShiftOut.h

//
//    FILE: FastShiftOut.h
//  AUTHOR: Rob Tillaart
// VERSION: 0.1.03
// PURPOSE: shiftout that implements the Print interface
//     URL:
//
// Released to the public domain
//

#ifndef FastShiftOut_h
#define FastShiftOut_h

#if defined(ARDUINO) && ARDUINO >= 100
  #include "Arduino.h"
#else
  #include "WProgram.h"
#endif

#define FASTSHIFTOUT_LIB_VERSION "0.1.03"

#include "Print.h"

class FastShiftOut : public Print
{
  public:
	FastShiftOut(uint8_t, uint8_t, uint8_t);
    size_t write(uint8_t);
    int read(void);

  private:
    uint8_t _bitorder;
    int _value;
    
	uint8_t _databit;
    volatile uint8_t *_dataout;
    
	uint8_t _clockbit;
    volatile uint8_t *_clockout;
};

#endif
// -- END OF FILE --

FastShiftOut.cpp

//
//    FILE: FastShiftOut.cpp
//  AUTHOR: Rob Tillaart
// VERSION: 0.1.03
// PURPOSE: shiftout that implements the Print interface
//     URL:
//
// Released to the public domain
//

#include "FastShiftOut.h"

//
// Constructor
// prepares the digitalWrite()
FastShiftOut::FastShiftOut(uint8_t datapin, uint8_t clockpin, uint8_t bitOrder)
{
    _bitorder = bitOrder;
    _value = -1;
    pinMode(datapin, OUTPUT);
    pinMode(clockpin, OUTPUT);
    
    // uint8_t _datatimer  = digitalPinToTimer(datapin);
    // if (_datatimer != NOT_ON_TIMER) turnOffPWM(_datatimer); TODO
	uint8_t _dataport   = digitalPinToPort(datapin);
    _dataout = portOutputRegister(_dataport);
	_databit = digitalPinToBitMask(datapin);
    
    // uint8_t _clocktimer = digitalPinToTimer(clockpin);
    // if (_clocktimer != NOT_ON_TIMER) turnOffPWM(_clocktimer);
	uint8_t _clockport  = digitalPinToPort(clockpin);
    _clockout = portOutputRegister(_clockport);
	_clockbit   = digitalPinToBitMask(clockpin);
}

//
// write() must implement the virtual write of Print class
//
size_t FastShiftOut::write(uint8_t data)
{
    _value = data;
    for (uint8_t i = 0; i < 8; i++)  
    {
        uint8_t v;
        if (_bitorder == LSBFIRST)   v = !!(_value & (1 << i));
        else                        v = !!(_value & (1 << (7 - i)));
        
        uint8_t oldSREG = SREG;
        cli();
        if (v == LOW)  *_dataout &= ~_databit;
        else           *_dataout |= _databit;
        *_clockout |= _clockbit;
        *_clockout &= ~_clockbit;
        SREG = oldSREG;
    }
    return 1;
}

//
// reads back the last value written.
//
int FastShiftOut::read()
{
    return _value;
}
// -- END OF FILE --

FSO001.ino, tests some performance compared to standard shiftOut()

#include "FastShiftOut.h"

FastShiftOut FSO(12, 13, LSBFIRST);

void setup()
{
  Serial.begin(115200);
  Serial.println("Start FSO");

  unsigned long start = millis();
  for (int i=0; i<10000; i++)
  {
    FSO.write(0x55);
  }
  Serial.println((millis() - start)/10.0, 4);

  start = millis();
  for (int i=0; i<10000; i++)
  {
    FSO.write(0x55);
    FSO.write(0x55);
  }
  Serial.println((millis() - start)/10.0, 4);

  start = millis();
  for (int i=0; i<10000; i++)
  {
    shiftOut(12, 13, 0x55, LSBFIRST);
  }
  Serial.println((millis() - start)/10.0, 4);

  start = millis();
  for (int i=0; i<10000; i++)
  {
    shiftOut(12, 13, 0x55, LSBFIRST);
    shiftOut(12, 13, 0x55, LSBFIRST);
  }
  Serial.println((millis() - start)/10.0, 4);

  Serial.println("test print interface");
  start = millis();
  for (int i=0; i<10000; i++)
  {
    FSO.println("Hello world");
  }
  Serial.println((millis() - start)/10.0, 4);

  start = millis();
  for (int i=0; i<10000; i++)
  {
    FSO.println(1357);
  }
  Serial.println((millis() - start)/10.0, 4);

  start = millis();
  for (int i=0; i<10000; i++)
  {
    FSO.println(3.14159265, 4);
  }
  Serial.println((millis() - start)/10.0, 4);

  Serial.println("done");
}

void loop()
{
}

output:
Start FSO
61.3000
122.4000
114.8000
229.5000
test print interface
812.8000
403.8000
572.5000
done

The FSO Class is almost 2x faster than normal shiftOut() [times in uSec]
Times for strings, ints and floats are approx. as expected. (add newline chars too)

update:
latest version check - Arduino/libraries at master · RobTillaart/Arduino · GitHub -

[robtillaart]

Note: the timings found above might be hard to reproduce as my print.cpp and print.h contains several speed ups (including experimental).
These are discussed in this thread - divmod10() : a fast replacement for /10 and %10 (unsigned) - Libraries - Arduino Forum -

[robtillaart]

speed optimized version of the write, ~twice as fast, but it disables interrupts for the whole byte; and its larger ..
(replace in lib above)

// approx 32 us / byte
size_t FastShiftOut::write(uint8_t data)
{
    _value = data;
    // prep masks
    uint8_t dm1 = *_dataout | _databit;
    uint8_t dm0 = *_dataout & ~_databit;
    uint8_t cm1 = *_clockout | _clockbit;
    uint8_t cm0 = *_clockout & ~_clockbit;
    
    uint8_t oldSREG = SREG;
    cli();
    if (_bitorder == LSBFIRST)
    {
        for (uint8_t m = 0x01; m != 0x80; m <<= 1)  
        {
            if (_value & m) *_dataout = dm1;
            else           *_dataout = dm0;  
            *_clockout = cm1;
            *_clockout = cm0;
        }
    }
    else
    {
        for (uint8_t m = 0x80; m > 0; m >>= 1)  
        {
            if (_value & m) *_dataout = dm1;
            else           *_dataout = dm0;  
            *_clockout = cm1;
            *_clockout = cm0;
        }    
    }
    SREG = oldSREG;
    return 1;
}

use at own risk

[Khalid]

Rob,
Thanks for this new approach in Shiftout. I shall check how can i utilize it in my Graphical waterfall project.
Regards

[robtillaart]

latest version can be found here - Arduino/libraries at master · RobTillaart/Arduino · GitHub -

[Khalid]

Thank you for the generosity and sharing:) I shall come back and report..
Regards

[robtillaart]

latest version 0.1.5 can be found here - Arduino/libraries at master · RobTillaart/Arduino · GitHub -

major improvement in performance by more efficient masking of bits.
Time dropped from 42.72 usec to 28.83 usec per byte.

tests done with IDE 1.8.1

example fastShiftOut: 0.1.5

Performance - time in us
FastShiftOut1: 29.76
FastShiftOut2: 58.59
        Delta: 28.83

Standard shiftOut1: 90.80
Standard shiftOut2: 181.00
             Delta: 90.20


Test print interface
println("Hello world"): 417.08
println(1357): 353.00
println(3.14159265, 4): 766.28

done ...

======================================

example fastShiftOut: 0.1.04

Performance - time in us
FastShiftOut1: 43.66
FastShiftOut2: 86.38
        Delta: 42.72

Standard shiftOut1: 90.79
Standard shiftOut2: 181.00
             Delta: 90.21


Test print interface
println("Hello world"): 597.68
println(1357): 436.44
println(3.14159265, 4): 877.48

done ...

[ice_coffee]

Hi, Thanks for your code.

I am trying to run 4 independent LED Matrix displays from 1 arduino. it's actually working with regular shiftout but I have quite a flicker in the characters. I was hoping to use your library to speed up the writes to the displays, however , I am unsure how to call it more than once, I seem to get a redeclaration error ?

Your help is much appreciated