Leddevices source tree refactoring (#461)

* rework structure of leddevice source tree

* fix data type vor v4l sig detection value in webui

* automate leddevicefactory.cpp

libsrc/leddevice/dev_spi/LedDeviceAPA102.cpp

@@ -0,0 +1,42 @@
+#include "LedDeviceAPA102.h"
+
+LedDeviceAPA102::LedDeviceAPA102(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+{
+	_deviceReady = init(deviceConfig);
+}
+
+LedDevice* LedDeviceAPA102::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceAPA102(deviceConfig);
+}
+
+bool LedDeviceAPA102::init(const QJsonObject &deviceConfig)
+{
+	ProviderSpi::init(deviceConfig);
+
+	const unsigned int startFrameSize = 4;
+	const unsigned int endFrameSize = qMax<unsigned int>(((_ledCount + 15) / 16), 4);
+	const unsigned int APAbufferSize = (_ledCount * 4) + startFrameSize + endFrameSize;
+
+	_ledBuffer.resize(APAbufferSize, 0xFF);
+	_ledBuffer[0] = 0x00; 
+	_ledBuffer[1] = 0x00; 
+	_ledBuffer[2] = 0x00; 
+	_ledBuffer[3] = 0x00; 
+	
+	return true;
+}
+
+int LedDeviceAPA102::write(const std::vector<ColorRgb> &ledValues)
+{
+	for (signed iLed=0; iLed < _ledCount; ++iLed) {
+		const ColorRgb& rgb = ledValues[iLed];
+		_ledBuffer[4+iLed*4]   = 0xFF;
+		_ledBuffer[4+iLed*4+1] = rgb.red;
+		_ledBuffer[4+iLed*4+2] = rgb.green;
+		_ledBuffer[4+iLed*4+3] = rgb.blue;
+	}
+
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}

libsrc/leddevice/dev_spi/LedDeviceAPA102.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// hyperion incluse
+#include "ProviderSpi.h"
+
+
+///
+/// Implementation of the LedDevice interface for writing to APA102 led device.
+///
+class LedDeviceAPA102 : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	LedDeviceAPA102(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+	virtual bool init(const QJsonObject &deviceConfig);
+private:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+};

libsrc/leddevice/dev_spi/LedDeviceLpd6803.cpp

@@ -0,0 +1,38 @@
+#include "LedDeviceLpd6803.h"
+
+LedDeviceLpd6803::LedDeviceLpd6803(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+{
+	_deviceReady = init(deviceConfig);
+}
+
+LedDevice* LedDeviceLpd6803::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceLpd6803(deviceConfig);
+}
+
+bool LedDeviceLpd6803::init(const QJsonObject &deviceConfig)
+{
+	ProviderSpi::init(deviceConfig);
+
+	unsigned messageLength = 4 + 2*_ledCount + _ledCount/8 + 1;
+	// Initialise the buffer
+	_ledBuffer.resize(messageLength, 0x00);
+	
+	return true;
+}
+
+int LedDeviceLpd6803::write(const std::vector<ColorRgb> &ledValues)
+{
+	// Copy the colors from the ColorRgb vector to the Ldp6803 data vector
+	for (unsigned iLed=0; iLed<(unsigned)_ledCount; ++iLed)
+	{
+		const ColorRgb& color = ledValues[iLed];
+
+		_ledBuffer[4 + 2 * iLed] = 0x80 | ((color.red & 0xf8) >> 1) | (color.green >> 6);
+		_ledBuffer[5 + 2 * iLed] = ((color.green & 0x38) << 2) | (color.blue >> 3);
+	}
+
+	// Write the data
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}

libsrc/leddevice/dev_spi/LedDeviceLpd6803.h

@@ -0,0 +1,40 @@
+#pragma once
+
+// Local hyperion incluse
+#include "ProviderSpi.h"
+
+///
+/// Implementation of the LedDevice interface for writing to LDP6803 led device.
+///
+/// 00000000 00000000 00000000 00000000 1RRRRRGG GGGBBBBB 1RRRRRGG GGGBBBBB ...
+/// |---------------------------------| |---------------| |---------------|
+/// 32 zeros to start the frame Led1 Led2 ...
+///
+/// For each led, the first bit is always 1, and then you have 5 bits each for red, green and blue
+/// (R, G and B in the above illustration) making 16 bits per led. Total bytes = 4 + (2 x number of
+/// leds)
+///
+class LedDeviceLpd6803 : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	/// @param deviceConfig json device config
+	///
+	LedDeviceLpd6803(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+	virtual bool init(const QJsonObject &deviceConfig);
+
+private:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+};

libsrc/leddevice/dev_spi/LedDeviceLpd8806.cpp

@@ -0,0 +1,41 @@
+#include "LedDeviceLpd8806.h"
+
+LedDeviceLpd8806::LedDeviceLpd8806(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+{
+	_deviceReady = init(deviceConfig);
+}
+
+LedDevice* LedDeviceLpd8806::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceLpd8806(deviceConfig);
+}
+
+bool LedDeviceLpd8806::init(const QJsonObject &deviceConfig)
+{
+	ProviderSpi::init(deviceConfig);
+
+	const unsigned clearSize = _ledCount/32+1;
+	unsigned messageLength = _ledRGBCount + clearSize;
+	// Initialise the buffer
+	_ledBuffer.resize(messageLength, 0x00);
+
+	// Perform an initial reset to start accepting data on the first led
+	return writeBytes(clearSize, _ledBuffer.data());
+}
+
+int LedDeviceLpd8806::write(const std::vector<ColorRgb> &ledValues)
+{
+	// Copy the colors from the ColorRgb vector to the Ldp8806 data vector
+	for (unsigned iLed=0; iLed<(unsigned)_ledCount; ++iLed)
+	{
+		const ColorRgb& color = ledValues[iLed];
+
+		_ledBuffer[iLed*3]   = 0x80 | (color.red   >> 1);
+		_ledBuffer[iLed*3+1] = 0x80 | (color.green >> 1);
+		_ledBuffer[iLed*3+2] = 0x80 | (color.blue  >> 1);
+	}
+
+	// Write the data
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}

libsrc/leddevice/dev_spi/LedDeviceLpd8806.h

@@ -0,0 +1,101 @@
+#pragma once
+
+// Local hyperion incluse
+#include "ProviderSpi.h"
+
+///
+/// Implementation of the LedDevice interface for writing to LPD8806 led device.
+///
+/// The following description is copied from 'adafruit' (github.com/adafruit/LPD8806)
+///
+/// Clearing up some misconceptions about how the LPD8806 drivers work:
+///
+/// The LPD8806 is not a FIFO shift register.  The first data out controls the
+/// LED *closest* to the processor (unlike a typical shift register, where the
+/// first data out winds up at the *furthest* LED).  Each LED driver 'fills up'
+/// with data and then passes through all subsequent bytes until a latch
+/// condition takes place.  This is actually pretty common among LED drivers.
+///
+/// All color data bytes have the high bit (128) set, with the remaining
+/// seven bits containing a brightness value (0-127).  A byte with the high
+/// bit clear has special meaning (explained later).
+///
+/// The rest gets bizarre...
+///
+/// The LPD8806 does not perform an in-unison latch (which would display the
+/// newly-transmitted data all at once).  Rather, each individual byte (even
+/// the separate G, R, B components of each LED) is latched AS IT ARRIVES...
+/// or more accurately, as the first bit of the subsequent byte arrives and
+/// is passed through.  So the strip actually refreshes at the speed the data
+/// is issued, not instantaneously (this can be observed by greatly reducing
+/// the data rate).  This has implications for POV displays and light painting
+/// applications.  The 'subsequent' rule also means that at least one extra
+/// byte must follow the last pixel, in order for the final blue LED to latch.
+///
+/// To reset the pass-through behavior and begin sending new data to the start
+/// of the strip, a number of zero bytes must be issued (remember, all color
+/// data bytes have the high bit set, thus are in the range 128 to 255, so the
+/// zero is 'special').  This should be done before each full payload of color
+/// values to the strip.  Curiously, zero bytes can only travel one meter (32
+/// LEDs) down the line before needing backup; the next meter requires an
+/// extra zero byte, and so forth.  Longer strips will require progressively
+/// more zeros.  *(see note below)
+///
+/// In the interest of efficiency, it's possible to combine the former EOD
+/// extra latch byte and the latter zero reset...the same data can do double
+/// duty, latching the last blue LED while also resetting the strip for the
+/// next payload.
+///
+/// So: reset byte(s) of suitable length are issued once at startup to 'prime'
+/// the strip to a known ready state.  After each subsequent LED color payload,
+/// these reset byte(s) are then issued at the END of each payload, both to
+/// latch the last LED and to prep the strip for the start of the next payload
+/// (even if that data does not arrive immediately).  This avoids a tiny bit
+/// of latency as the new color payload can begin issuing immediately on some
+/// signal, such as a timer or GPIO trigger.
+///
+/// Technically these zero byte(s) are not a latch, as the color data (save
+/// for the last byte) is already latched.  It's a start-of-data marker, or
+/// an indicator to clear the thing-that's-not-a-shift-register.  But for
+/// conversational consistency with other LED drivers, we'll refer to it as
+/// a 'latch' anyway.
+///
+/// This has been validated independently with multiple customers'
+/// hardware.  Please do not report as a bug or issue pull requests for
+/// this.  Fewer zeros sometimes gives the *illusion* of working, the first
+/// payload will correctly load and latch, but subsequent frames will drop
+/// data at the end.  The data shortfall won't always be visually apparent
+/// depending on the color data loaded on the prior and subsequent frames.
+/// Tested.  Confirmed.  Fact.
+///
+///
+/// The summary of the story is that the following needs to be writen on the spi-device:
+/// 1RRRRRRR 1GGGGGGG 1BBBBBBB 1RRRRRRR 1GGGGGGG ... ... 1GGGGGGG 1BBBBBBB 00000000 00000000 ...
+/// |---------led_1----------| |---------led_2--         -led_n----------| |----clear data--
+///
+/// The number of zeroes in the 'clear data' is (#led/32 + 1)bytes (or *8 for bits)
+///
+class LedDeviceLpd8806 : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	/// @param deviceConfig json device config
+	///
+	LedDeviceLpd8806(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+	virtual bool init(const QJsonObject &deviceConfig);
+
+private:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+};

libsrc/leddevice/dev_spi/LedDeviceP9813.cpp

@@ -0,0 +1,47 @@
+#include "LedDeviceP9813.h"
+
+LedDeviceP9813::LedDeviceP9813(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+{
+	_deviceReady = init(deviceConfig);
+}
+
+LedDevice* LedDeviceP9813::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceP9813(deviceConfig);
+}
+
+bool LedDeviceP9813::init(const QJsonObject &deviceConfig)
+{
+	ProviderSpi::init(deviceConfig);
+
+	_ledBuffer.resize(_ledCount * 4 + 8, 0x00);
+	
+	return true;
+}
+
+int LedDeviceP9813::write(const std::vector<ColorRgb> &ledValues)
+{
+	uint8_t * dataPtr = _ledBuffer.data();
+	for (const ColorRgb & color : ledValues)
+	{
+		*dataPtr++ = calculateChecksum(color);
+		*dataPtr++ = color.blue;
+		*dataPtr++ = color.green;
+		*dataPtr++ = color.red;
+	}
+
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}
+
+uint8_t LedDeviceP9813::calculateChecksum(const ColorRgb & color) const
+{
+	uint8_t res = 0;
+
+	res |= (uint8_t)0x03 << 6;
+	res |= (uint8_t)(~(color.blue  >> 6) & 0x03) << 4;
+	res |= (uint8_t)(~(color.green >> 6) & 0x03) << 2;
+	res |= (uint8_t)(~(color.red   >> 6) & 0x03);
+
+	return res;
+}

libsrc/leddevice/dev_spi/LedDeviceP9813.h

@@ -0,0 +1,40 @@
+#pragma once
+
+// hyperion include
+#include "ProviderSpi.h"
+
+///
+/// Implementation of the LedDevice interface for writing to P9813 led device.
+///
+class LedDeviceP9813 : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	/// @param deviceConfig json device config
+	///
+	LedDeviceP9813(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+	virtual bool init(const QJsonObject &deviceConfig);
+
+private:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+
+	///
+	/// Calculates the required checksum for one led
+	///
+	/// @param color The color of the led
+	/// @return The checksum for the led
+	///
+	uint8_t calculateChecksum(const ColorRgb & color) const;
+};

libsrc/leddevice/dev_spi/LedDeviceSk6812SPI.cpp

@@ -0,0 +1,75 @@
+#include "LedDeviceSk6812SPI.h"
+
+LedDeviceSk6812SPI::LedDeviceSk6812SPI(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+	, _whiteAlgorithm(RGBW::INVALID)
+	, SPI_BYTES_PER_COLOUR(4)
+	, bitpair_to_byte {
+		0b10001000,
+		0b10001100,
+		0b11001000,
+		0b11001100,
+	}
+{
+	_deviceReady = init(deviceConfig);
+}
+
+LedDevice* LedDeviceSk6812SPI::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceSk6812SPI(deviceConfig);
+}
+
+bool LedDeviceSk6812SPI::init(const QJsonObject &deviceConfig)
+{
+	QString whiteAlgorithm = deviceConfig["white_algorithm"].toString("white_off");
+	_whiteAlgorithm            = RGBW::stringToWhiteAlgorithm(whiteAlgorithm);
+
+	if (_whiteAlgorithm == RGBW::INVALID)
+	{
+		Error(_log, "unknown whiteAlgorithm %s", QSTRING_CSTR(whiteAlgorithm));
+		return false;
+	}
+	Debug( _log, "whiteAlgorithm : %s", QSTRING_CSTR(whiteAlgorithm));
+
+	_baudRate_Hz = 3000000;
+	if ( !ProviderSpi::init(deviceConfig) )
+	{
+		return false;
+	}
+	WarningIf(( _baudRate_Hz < 2050000 || _baudRate_Hz > 4000000 ), _log, "SPI rate %d outside recommended range (2050000 -> 4000000)", _baudRate_Hz);
+
+	const int SPI_FRAME_END_LATCH_BYTES = 3;
+	_ledBuffer.resize(_ledRGBWCount * SPI_BYTES_PER_COLOUR + SPI_FRAME_END_LATCH_BYTES, 0x00);
+	
+	return true;
+}
+
+int LedDeviceSk6812SPI::write(const std::vector<ColorRgb> &ledValues)
+{
+	unsigned spi_ptr = 0;
+	const int SPI_BYTES_PER_LED = sizeof(ColorRgbw) * SPI_BYTES_PER_COLOUR;
+
+
+	for (const ColorRgb& color : ledValues)
+	{
+		RGBW::Rgb_to_Rgbw(color, &_temp_rgbw, _whiteAlgorithm);
+		uint32_t colorBits = 
+			((uint32_t)_temp_rgbw.red << 24) +
+			((uint32_t)_temp_rgbw.green << 16) +
+			((uint32_t)_temp_rgbw.blue << 8) +
+			_temp_rgbw.white;
+
+		for (int j=SPI_BYTES_PER_LED - 1; j>=0; j--)
+		{
+			_ledBuffer[spi_ptr+j] = bitpair_to_byte[ colorBits & 0x3 ];
+			colorBits >>= 2;
+		}
+		spi_ptr += SPI_BYTES_PER_LED;
+	}
+
+	_ledBuffer[spi_ptr++] = 0;
+	_ledBuffer[spi_ptr++] = 0;
+	_ledBuffer[spi_ptr++] = 0;
+
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}

libsrc/leddevice/dev_spi/LedDeviceSk6812SPI.h

@@ -0,0 +1,45 @@
+#pragma once
+
+// hyperion incluse
+#include "ProviderSpi.h"
+
+///
+/// Implementation of the LedDevice interface for writing to Sk6801 led device via SPI.
+///
+class LedDeviceSk6812SPI : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	/// @param deviceConfig json device config
+	///
+	LedDeviceSk6812SPI(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+	///
+	/// Sets configuration
+	///
+	/// @param deviceConfig the json device config
+	/// @return true if success
+	bool init(const QJsonObject &deviceConfig);
+	
+private:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+
+	RGBW::WhiteAlgorithm _whiteAlgorithm;
+	
+        const int SPI_BYTES_PER_COLOUR;
+
+	uint8_t bitpair_to_byte[4];
+	
+	ColorRgbw _temp_rgbw;
+};

libsrc/leddevice/dev_spi/LedDeviceSk6822SPI.cpp

@@ -0,0 +1,118 @@
+#include "LedDeviceSk6822SPI.h"
+/*
+From the data sheet:
+
+(TH+TL=1.7μs±600ns)
+
+T0H,	 0 code, high level time,	 0.35µs ±0.150ns
+T0L,	 0 code, low level time,	 1.36µs ±0.150ns
+T1H,	 1 code, high level time,	 1.36µs ±0.150ns
+T1L,	 1 code, low level time,	 0.35µs ±0.150ns
+WT,	 Wait for the processing time,	 12µs ±0.150ns
+Trst,	 Reset code,low level time,	 50µs
+
+To normalise the pulse times so they fit in 4 SPI bits:
+
+Use timings at upper end of tolerance:
+1.36 -> 1.50 uS
+0.35 -> 0.50 uS
+
+A SPI bit time of 0.50uS = 2Mbit/sec
+T0 is sent as 1000
+T1 is sent as 1110
+
+With a bit of excel testing, we can work out the maximum and minimum speeds:
+2000000 MIN
+2230000 AVG
+2460000 MAX
+
+Wait time:
+using the min of  2000000, the bit time is 0.500
+Wait time is 12uS = 24 bits = 3 bytes
+
+Reset time:
+using the min of  2000000, the bit time is 0.500
+Reset time is 50uS = 100 bits = 13 bytes
+
+*/
+
+
+LedDeviceSk6822SPI::LedDeviceSk6822SPI(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+	, SPI_BYTES_PER_COLOUR(4)
+	, SPI_BYTES_WAIT_TIME(3)
+	, SPI_FRAME_END_LATCH_BYTES(13)
+	, bitpair_to_byte {
+		0b10001000,
+		0b10001110,
+		0b11101000,
+		0b11101110,
+	}
+{
+	_deviceReady = init(deviceConfig);
+}
+
+LedDevice* LedDeviceSk6822SPI::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceSk6822SPI(deviceConfig);
+}
+
+bool LedDeviceSk6822SPI::init(const QJsonObject &deviceConfig)
+{
+	_baudRate_Hz = 2230000;
+	if ( !ProviderSpi::init(deviceConfig) )
+	{
+		return false;
+	}
+	WarningIf(( _baudRate_Hz < 2000000 || _baudRate_Hz > 2460000 ), _log, "SPI rate %d outside recommended range (2000000 -> 2460000)", _baudRate_Hz);
+
+	_ledBuffer.resize( (_ledRGBCount *  SPI_BYTES_PER_COLOUR) + (_ledCount * SPI_BYTES_WAIT_TIME ) + SPI_FRAME_END_LATCH_BYTES, 0x00);
+//	Debug(_log, "_ledBuffer.resize(_ledRGBCount:%d * SPI_BYTES_PER_COLOUR:%d) + ( _ledCount:%d * SPI_BYTES_WAIT_TIME:%d ) + SPI_FRAME_END_LATCH_BYTES:%d, 0x00)", _ledRGBCount, SPI_BYTES_PER_COLOUR, _ledCount, SPI_BYTES_WAIT_TIME,  SPI_FRAME_END_LATCH_BYTES);
+
+	return true;
+}
+
+int LedDeviceSk6822SPI::write(const std::vector<ColorRgb> &ledValues)
+{
+	unsigned spi_ptr = 0;
+	const int SPI_BYTES_PER_LED = sizeof(ColorRgb) * SPI_BYTES_PER_COLOUR;
+
+	for (const ColorRgb& color : ledValues)
+	{
+		uint32_t colorBits = ((unsigned int)color.red << 16)
+			| ((unsigned int)color.green << 8)
+			| color.blue;
+
+		for (int j=SPI_BYTES_PER_LED - 1; j>=0; j--)
+		{
+			_ledBuffer[spi_ptr+j] = bitpair_to_byte[ colorBits & 0x3 ];
+			colorBits >>= 2;
+		}
+		spi_ptr += SPI_BYTES_PER_LED;
+		spi_ptr += SPI_BYTES_WAIT_TIME;	// the wait between led time is all zeros
+	}
+
+
+/*
+// debug the whole SPI packet
+	char debug_line[2048];
+	int ptr=0;
+	for (unsigned int i=0; i < _ledBuffer.size(); i++)
+	{
+		if (i%16 == 0)
+		{
+			ptr += snprintf (ptr+debug_line, sizeof(debug_line)-ptr, "%03x: ", i);
+		}
+
+		ptr += snprintf (ptr+debug_line, sizeof(debug_line)-ptr, "%02x ", _ledBuffer.data()[i]);
+
+		if ( (i%16 == 15) || ( i == _ledBuffer.size()-1 ) )
+		{
+			Debug(_log, debug_line);
+			ptr = 0;
+		}
+	}
+*/
+
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}

libsrc/leddevice/dev_spi/LedDeviceSk6822SPI.h

@@ -0,0 +1,44 @@
+#pragma once
+
+// hyperion incluse
+#include "ProviderSpi.h"
+
+///
+/// Implementation of the LedDevice interface for writing to Ws2812 led device via spi.
+///
+class LedDeviceSk6822SPI : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	/// @param deviceConfig json device config
+	///
+	LedDeviceSk6822SPI(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+	///
+	/// Sets configuration
+	///
+	/// @param deviceConfig the json device config
+	/// @return true if success
+	virtual bool init(const QJsonObject &deviceConfig);
+
+private:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+
+	const int SPI_BYTES_PER_COLOUR;
+	const int SPI_BYTES_WAIT_TIME;
+	const int SPI_FRAME_END_LATCH_BYTES;
+
+
+	uint8_t bitpair_to_byte[4];
+};

libsrc/leddevice/dev_spi/LedDeviceWs2801.cpp

@@ -0,0 +1,20 @@
+#include "LedDeviceWs2801.h"
+
+LedDeviceWs2801::LedDeviceWs2801(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+{
+	_deviceReady = 	ProviderSpi::init(deviceConfig);
+}
+
+LedDevice* LedDeviceWs2801::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceWs2801(deviceConfig);
+}
+
+int LedDeviceWs2801::write(const std::vector<ColorRgb> &ledValues)
+{
+	const unsigned dataLen = _ledCount * sizeof(ColorRgb);
+	const uint8_t * dataPtr = reinterpret_cast<const uint8_t *>(ledValues.data());
+
+	return writeBytes(dataLen, dataPtr);
+}

libsrc/leddevice/dev_spi/LedDeviceWs2801.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "ProviderSpi.h"
+
+///
+/// Implementation of the LedDevice interface for writing to Ws2801 led device.
+///
+class LedDeviceWs2801 : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	/// @param deviceConfig json device config
+	///
+	LedDeviceWs2801(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+protected:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+};

libsrc/leddevice/dev_spi/LedDeviceWs2812SPI.cpp

@@ -0,0 +1,95 @@
+#include "LedDeviceWs2812SPI.h"
+
+/*
+From the data sheet:
+
+(TH+TL=1.25μs±600ns)
+
+T0H,	 0 code, high level time,	 0.40µs ±0.150ns
+T0L,	 0 code, low level time,	 0.85µs ±0.150ns
+T1H,	 1 code, high level time,	 0.80µs ±0.150ns
+T1L,	 1 code, low level time,	 0.45µs ±0.150ns
+WT,	 Wait for the processing time,	 NA
+Trst,	 Reset code,low level time,	 50µs (not anymore... need 300uS for latest revision)
+
+To normalise the pulse times so they fit in 4 SPI bits:
+
+On the assumption that the "low" time doesnt matter much
+
+A SPI bit time of 0.40uS = 2.5 Mbit/sec
+T0 is sent as 1000
+T1 is sent as 1100
+
+With a bit of excel testing, we can work out the maximum and minimum speeds:
+2106000 MIN
+2590500 AVG
+3075000 MAX
+
+Wait time:
+Not Applicable for WS2812
+
+Reset time:
+using the max of 3075000, the bit time is 0.325
+Reset time is 300uS = 923 bits = 116 bytes
+
+*/
+
+LedDeviceWs2812SPI::LedDeviceWs2812SPI(const QJsonObject &deviceConfig)
+	: ProviderSpi()
+	, SPI_BYTES_PER_COLOUR(4)
+	, SPI_FRAME_END_LATCH_BYTES(116)
+	, bitpair_to_byte {
+		0b10001000,
+		0b10001100,
+		0b11001000,
+		0b11001100,
+	}
+{
+	_deviceReady = init(deviceConfig);
+}
+
+LedDevice* LedDeviceWs2812SPI::construct(const QJsonObject &deviceConfig)
+{
+	return new LedDeviceWs2812SPI(deviceConfig);
+}
+
+bool LedDeviceWs2812SPI::init(const QJsonObject &deviceConfig)
+{
+	_baudRate_Hz = 2600000;
+	if ( !ProviderSpi::init(deviceConfig) )
+	{
+		return false;
+	}
+	WarningIf(( _baudRate_Hz < 2106000 || _baudRate_Hz > 3075000 ), _log, "SPI rate %d outside recommended range (2106000 -> 3075000)", _baudRate_Hz);
+
+	_ledBuffer.resize(_ledRGBCount * SPI_BYTES_PER_COLOUR + SPI_FRAME_END_LATCH_BYTES, 0x00);
+
+	return true;
+}
+
+int LedDeviceWs2812SPI::write(const std::vector<ColorRgb> &ledValues)
+{
+	unsigned spi_ptr = 0;
+	const int SPI_BYTES_PER_LED = sizeof(ColorRgb) * SPI_BYTES_PER_COLOUR;
+
+	for (const ColorRgb& color : ledValues)
+	{
+		uint32_t colorBits = ((unsigned int)color.red << 16)
+			| ((unsigned int)color.green << 8)
+			| color.blue;
+
+		for (int j=SPI_BYTES_PER_LED - 1; j>=0; j--)
+		{
+			_ledBuffer[spi_ptr+j] = bitpair_to_byte[ colorBits & 0x3 ];
+			colorBits >>= 2;
+		}
+		spi_ptr += SPI_BYTES_PER_LED;
+	}
+
+	for (int j=0; j < SPI_FRAME_END_LATCH_BYTES; j++)
+	{
+		_ledBuffer[spi_ptr++] = 0;
+	}
+
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}

libsrc/leddevice/dev_spi/LedDeviceWs2812SPI.h

@@ -0,0 +1,43 @@
+#pragma once
+
+// hyperion incluse
+#include "ProviderSpi.h"
+
+///
+/// Implementation of the LedDevice interface for writing to Ws2812 led device via spi.
+///
+class LedDeviceWs2812SPI : public ProviderSpi
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	/// @param deviceConfig json device config
+	///
+	LedDeviceWs2812SPI(const QJsonObject &deviceConfig);
+
+	/// constructs leddevice
+	static LedDevice* construct(const QJsonObject &deviceConfig);
+
+	///
+	/// Sets configuration
+	///
+	/// @param deviceConfig the json device config
+	/// @return true if success
+	virtual bool init(const QJsonObject &deviceConfig);
+
+private:
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
+	virtual int write(const std::vector<ColorRgb> &ledValues);
+
+        const int SPI_BYTES_PER_COLOUR;
+
+	const int SPI_FRAME_END_LATCH_BYTES;
+
+	uint8_t bitpair_to_byte[4];
+};

libsrc/leddevice/dev_spi/ProviderSpi.cpp

@@ -0,0 +1,102 @@
+
+// STL includes
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+#include <cerrno>
+
+// Linux includes
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+// Local Hyperion includes
+#include "ProviderSpi.h"
+#include <utils/Logger.h>
+
+
+ProviderSpi::ProviderSpi()
+	: LedDevice()
+	, _deviceName("/dev/spidev0.0")
+	, _baudRate_Hz(1000000)
+	, _fid(-1)
+	, _spiMode(SPI_MODE_0)
+	, _spiDataInvert(false)
+{
+	memset(&_spi, 0, sizeof(_spi));
+	_latchTime_ms = 1;
+}
+
+ProviderSpi::~ProviderSpi()
+{
+//	close(_fid);
+}
+
+bool ProviderSpi::init(const QJsonObject &deviceConfig)
+{
+	LedDevice::init(deviceConfig);
+
+	_deviceName    = deviceConfig["output"].toString(_deviceName);
+	_baudRate_Hz   = deviceConfig["rate"].toInt(_baudRate_Hz);
+	_spiMode       = deviceConfig["spimode"].toInt(_spiMode);
+	_spiDataInvert = deviceConfig["invert"].toBool(_spiDataInvert);
+	
+	return true;
+}
+
+int ProviderSpi::open()
+{
+	Debug(_log, "_baudRate_Hz %d,  _latchTime_ns %d", _baudRate_Hz, _latchTime_ms);
+	Debug(_log, "_spiDataInvert %d,  _spiMode %d", _spiDataInvert, _spiMode);
+
+	const int bitsPerWord = 8;
+
+	_fid = ::open(QSTRING_CSTR(_deviceName), O_RDWR);
+
+	if (_fid < 0)
+	{
+		Error( _log, "Failed to open device (%s). Error message: %s", QSTRING_CSTR(_deviceName),  strerror(errno) );
+		return -1;
+	}
+
+	if (ioctl(_fid, SPI_IOC_WR_MODE, &_spiMode) == -1 || ioctl(_fid, SPI_IOC_RD_MODE, &_spiMode) == -1)
+	{
+		return -2;
+	}
+
+	if (ioctl(_fid, SPI_IOC_WR_BITS_PER_WORD, &bitsPerWord) == -1 || ioctl(_fid, SPI_IOC_RD_BITS_PER_WORD, &bitsPerWord) == -1)
+	{
+		return -4;
+	}
+
+	if (ioctl(_fid, SPI_IOC_WR_MAX_SPEED_HZ, &_baudRate_Hz) == -1 || ioctl(_fid, SPI_IOC_RD_MAX_SPEED_HZ, &_baudRate_Hz) == -1)
+	{
+		return -6;
+	}
+
+	return 0;
+}
+
+int ProviderSpi::writeBytes(const unsigned size, const uint8_t * data)
+{
+	if (_fid < 0)
+	{
+		return -1;
+	}
+
+	_spi.tx_buf = __u64(data);
+	_spi.len    = __u32(size);
+
+	if (_spiDataInvert)
+	{
+		uint8_t * newdata = (uint8_t *)malloc(size);
+		for (unsigned i = 0; i<size; i++) {
+			newdata[i] = data[i] ^ 0xff;
+		}
+		_spi.tx_buf = __u64(newdata);
+	}
+
+	int retVal = ioctl(_fid, SPI_IOC_MESSAGE(1), &_spi);
+	ErrorIf((retVal < 0), _log, "SPI failed to write. errno: %d, %s", errno,  strerror(errno) );
+
+	return retVal;
+}

libsrc/leddevice/dev_spi/ProviderSpi.h

@@ -0,0 +1,68 @@
+#pragma once
+
+// Linux-SPI includes
+#include <linux/spi/spidev.h>
+
+// Hyperion includes
+#include <leddevice/LedDevice.h>
+
+///
+/// The ProviderSpi implements an abstract base-class for LedDevices using the SPI-device.
+///
+class ProviderSpi : public LedDevice
+{
+public:
+	///
+	/// Constructs specific LedDevice
+	///
+	ProviderSpi();
+
+	///
+	/// Sets configuration
+	///
+	/// @param deviceConfig the json device config
+	/// @return true if success
+	virtual bool init(const QJsonObject &deviceConfig);
+
+	///
+	/// Destructor of the LedDevice; closes the output device if it is open
+	///
+	virtual ~ProviderSpi();
+
+	///
+	/// Opens and configures the output device
+	///
+	/// @return Zero on succes else negative
+	///
+	int open();
+
+protected:
+	///
+	/// Writes the given bytes/bits to the SPI-device and sleeps the latch time to ensure that the
+	/// values are latched.
+	///
+	/// @param[in[ size The length of the data
+	/// @param[in] data The data
+	///
+	/// @return Zero on succes else negative
+	///
+	int writeBytes(const unsigned size, const uint8_t *data);
+
+	/// The name of the output device
+	QString _deviceName;
+
+	/// The used baudrate of the output device
+	int _baudRate_Hz;
+
+	/// The File Identifier of the opened output device (or -1 if not opened)
+	int _fid;
+
+	/// which spi clock mode do we use? (0..3)
+	int _spiMode;
+
+	/// 1=>invert the data pattern
+	bool _spiDataInvert;
+
+	/// The transfer structure for writing to the spi-device
+	spi_ioc_transfer _spi;
+};