Moved all device to seperate directory

Added 'sedu' device based on RS232 device


Former-commit-id: 918cbde65a4a14f532c2e08e104745715c3fdd37

libsrc/hyperion/device/LedDeviceLdp6803.cpp

@@ -0,0 +1,49 @@
+// STL includes
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+
+// Linux includes
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+// hyperion local includes
+#include "LedDeviceLdp6803.h"
+
+LedDeviceLdp6803::LedDeviceLdp6803(const std::string& outputDevice, const unsigned baudrate) :
+	LedSpiDevice(outputDevice, baudrate),
+	_ledBuffer(0)
+{
+	// empty
+}
+
+int LedDeviceLdp6803::write(const std::vector<RgbColor> &ledValues)
+{
+	// Reconfigure if the current connfiguration does not match the required configuration
+	if (4 + 2*ledValues.size() != _ledBuffer.size())
+	{
+		// Initialise the buffer
+		_ledBuffer.resize(4 + 2*ledValues.size(), 0x00);
+	}
+
+	// Copy the colors from the RgbColor vector to the Ldp6803 data vector
+	for (unsigned iLed=0; iLed<ledValues.size(); ++iLed)
+	{
+		const RgbColor& rgb = ledValues[iLed];
+
+		_ledBuffer[4 + 2 * iLed] = 0x80 | ((rgb.red & 0xf8) >> 1) | (rgb.green >> 6);
+		_ledBuffer[5 + 2 * iLed] = ((rgb.green & 0x38) << 2) | (rgb.blue >> 3);
+	}
+
+	// Write the data
+	if (writeBytes(_ledBuffer.size(), _ledBuffer.data()) < 0)
+	{
+		return -1;
+	}
+	return 0;
+}
+
+int LedDeviceLdp6803::switchOff()
+{
+	return write(std::vector<RgbColor>(_ledBuffer.size(), RgbColor::BLACK));
+}

libsrc/hyperion/device/LedDeviceLdp6803.h

@@ -0,0 +1,42 @@
+#pragma once
+
+// Local hyperion incluse
+#include "LedSpiDevice.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 LedDeviceLdp6803 : public LedSpiDevice
+{
+public:
+	///
+	/// Constructs the LedDevice for a string containing leds of the type LDP6803
+	///
+	/// @param[in] outputDevice The name of the output device (eg '/dev/spidev0.0')
+	/// @param[in] baudrate The used baudrate for writing to the output device
+	///
+	LedDeviceLdp6803(const std::string& outputDevice, const unsigned baudrate);
+
+	///
+	/// 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<RgbColor> &ledValues);
+
+	/// Switch the leds off
+	virtual int switchOff();
+
+private:
+	/// The buffer containing the packed RGB values
+	std::vector<uint8_t> _ledBuffer;
+};

libsrc/hyperion/device/LedDeviceSedu.cpp

@@ -0,0 +1,63 @@
+
+// STL includes
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+
+// Linux includes
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+// hyperion local includes
+#include "LedDeviceSedu.h"
+
+struct FrameSpec
+{
+	uint8_t id;
+	size_t size;
+};
+
+LedDeviceSedu::LedDeviceSedu(const std::string& outputDevice, const unsigned baudrate) :
+	LedRs232Device(outputDevice, baudrate),
+	_ledBuffer(0)
+{
+	// empty
+}
+
+int LedDeviceSedu::write(const std::vector<RgbColor> &ledValues)
+{
+	if (_ledBuffer.size() == 0)
+	{
+		std::vector<FrameSpec> frameSpecs{{0xA0, 96}, {0xA1, 256}, {0xA2, 512}, {0xB0, 768}, {0xB1, 1536}, {0xB2, 3072} };
+
+		const unsigned reqColorChannels = ledValues.size() * sizeof(RgbColor);
+
+		for (const FrameSpec& frameSpec : frameSpecs)
+		{
+			if (reqColorChannels <= frameSpec.size)
+			{
+				_ledBuffer.clear();
+				_ledBuffer.resize(frameSpec.size + 3, 0);
+				_ledBuffer[0] = 0x5A;
+				_ledBuffer[1] = frameSpec.id;
+				_ledBuffer.back() = 0xA5;
+				break;
+			}
+		}
+
+		if (_ledBuffer.size() == 0)
+		{
+			std::cout << "More rgb-channels required then available" << std::endl;
+			return -1;
+		}
+	}
+
+	memcpy(_ledBuffer.data()+2, ledValues.data(), ledValues.size() * sizeof(RgbColor));
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}
+
+int LedDeviceSedu::switchOff()
+{
+	memset(_ledBuffer.data()+2, 0, _ledBuffer.size()-3);
+	return writeBytes(_ledBuffer.size(), _ledBuffer.data());
+}

libsrc/hyperion/device/LedDeviceSedu.h

@@ -0,0 +1,37 @@
+#pragma once
+
+// STL includes
+#include <string>
+
+// hyperion incluse
+#include "LedRs232Device.h"
+
+///
+/// Implementation of the LedDevice interface for writing to SEDU led device.
+///
+class LedDeviceSedu : public LedRs232Device
+{
+public:
+	///
+	/// Constructs the LedDevice for attached via SEDU device
+	///
+	/// @param outputDevice The name of the output device (eg '/etc/ttyS0')
+	/// @param baudrate The used baudrate for writing to the output device
+	///
+	LedDeviceSedu(const std::string& outputDevice, const unsigned baudrate);
+
+	///
+	/// 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<RgbColor> &ledValues);
+
+	/// Switch the leds off
+	virtual int switchOff();
+
+private:
+	/// The buffer containing the packed RGB values
+	std::vector<uint8_t> _ledBuffer;
+};

libsrc/hyperion/device/LedDeviceTest.cpp

@@ -0,0 +1,31 @@
+
+// Local-Hyperion includes
+#include "LedDeviceTest.h"
+
+LedDeviceTest::LedDeviceTest(const std::string& output) :
+	_ofs(output.empty()?"/home/pi/LedDevice.out":output.c_str())
+{
+	// empty
+}
+
+LedDeviceTest::~LedDeviceTest()
+{
+	// empty
+}
+
+int LedDeviceTest::write(const std::vector<RgbColor> & ledValues)
+{
+	_ofs << "[";
+	for (const RgbColor& color : ledValues)
+	{
+		_ofs << color;
+	}
+	_ofs << "]" << std::endl;
+
+	return 0;
+}
+
+int LedDeviceTest::switchOff()
+{
+	return 0;
+}

libsrc/hyperion/device/LedDeviceTest.h

@@ -0,0 +1,41 @@
+#pragma once
+
+// STL includes0
+#include <fstream>
+
+// Hyperion includes
+#include <hyperion/LedDevice.h>
+
+///
+/// Implementation of the LedDevice that write the led-colors to an
+/// ASCII-textfile('/home/pi/LedDevice.out')
+///
+class LedDeviceTest : public LedDevice
+{
+public:
+	///
+	/// Constructs the test-device, which opens an output stream to the file
+	///
+	LedDeviceTest(const std::string& output);
+
+	///
+	/// Destructor of this test-device
+	///
+	virtual ~LedDeviceTest();
+
+	///
+	/// Writes the given led-color values to the output stream
+	///
+	/// @param ledValues The color-value per led
+	///
+	/// @return Zero on success else negative
+	///
+	virtual int write(const std::vector<RgbColor> & ledValues);
+
+	/// Switch the leds off
+	virtual int switchOff();
+
+private:
+	/// The outputstream
+	std::ofstream _ofs;
+};

libsrc/hyperion/device/LedDeviceWs2801.cpp

@@ -0,0 +1,34 @@
+
+// STL includes
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+
+// Linux includes
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+// hyperion local includes
+#include "LedDeviceWs2801.h"
+
+LedDeviceWs2801::LedDeviceWs2801(const std::string& outputDevice, const unsigned baudrate) :
+	LedSpiDevice(outputDevice, baudrate, 500000),
+	mLedCount(0)
+{
+	// empty
+}
+
+int LedDeviceWs2801::write(const std::vector<RgbColor> &ledValues)
+{
+	mLedCount = ledValues.size();
+
+	const unsigned dataLen = ledValues.size() * sizeof(RgbColor);
+	const uint8_t * dataPtr = reinterpret_cast<const uint8_t *>(ledValues.data());
+
+	return writeBytes(dataLen, dataPtr);
+}
+
+int LedDeviceWs2801::switchOff()
+{
+	return write(std::vector<RgbColor>(mLedCount, RgbColor::BLACK));
+}

libsrc/hyperion/device/LedDeviceWs2801.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// STL includes
+#include <string>
+
+// hyperion incluse
+#include "LedSpiDevice.h"
+
+///
+/// Implementation of the LedDevice interface for writing to Ws2801 led device.
+///
+class LedDeviceWs2801 : public LedSpiDevice
+{
+public:
+	///
+	/// Constructs the LedDevice for a string containing leds of the type Ws2801
+	///
+	/// @param outputDevice The name of the output device (eg '/etc/SpiDev.0.0')
+	/// @param baudrate The used baudrate for writing to the output device
+	///
+	LedDeviceWs2801(const std::string& outputDevice,
+					const unsigned baudrate);
+
+	///
+	/// 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<RgbColor> &ledValues);
+
+	/// Switch the leds off
+	virtual int switchOff();
+
+private:
+
+	/// the number of leds (needed when switching off)
+	size_t mLedCount;
+};

libsrc/hyperion/device/LedRs232Device.cpp

@@ -0,0 +1,62 @@
+
+// STL includes
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+
+// Local Hyperion includes
+#include "LedRs232Device.h"
+
+
+LedRs232Device::LedRs232Device(const std::string& outputDevice, const unsigned baudrate) :
+	mDeviceName(outputDevice),
+	mBaudRate_Hz(baudrate),
+	_rs232Port()
+{
+	// empty
+}
+
+LedRs232Device::~LedRs232Device()
+{
+	if (_rs232Port.isOpen())
+	{
+		_rs232Port.close();
+	}
+}
+
+int LedRs232Device::open()
+{
+	try
+	{
+		_rs232Port.setPort(mDeviceName);
+		_rs232Port.setBaudrate(mBaudRate_Hz);
+		_rs232Port.open();
+	}
+	catch (const std::exception& e)
+	{
+		std::cerr << "Unable to open RS232 device (" << e.what() << ")" << std::endl;
+		return -1;
+	}
+
+	return 0;
+}
+
+int LedRs232Device::writeBytes(const unsigned size, const uint8_t * data)
+{
+	if (!_rs232Port.isOpen())
+	{
+		return -1;
+	}
+
+	try
+	{
+		_rs232Port.write(data, size);
+	}
+	catch (const std::exception& e)
+	{
+		std::cerr << "Unable to write to RS232 device (" << e.what() << ")" << std::endl;
+		return -1;
+	}
+
+	return 0;
+}

libsrc/hyperion/device/LedRs232Device.h

@@ -0,0 +1,54 @@
+#pragma once
+
+// Serial includes
+#include <serial/serial.h>
+
+// Hyperion includes
+#include <hyperion/LedDevice.h>
+
+///
+/// The LedRs232Device implements an abstract base-class for LedDevices using a RS232-device.
+///
+class LedRs232Device : public LedDevice
+{
+public:
+	///
+	/// Constructs the LedDevice attached to a RS232-device
+	///
+	/// @param[in] outputDevice The name of the output device (eg '/etc/ttyS0')
+	/// @param[in] baudrate The used baudrate for writing to the output device
+	///
+	LedRs232Device(const std::string& outputDevice, const unsigned baudrate);
+
+	///
+	/// Destructor of the LedDevice; closes the output device if it is open
+	///
+	virtual ~LedRs232Device();
+
+	///
+	/// Opens and configures the output device
+	///
+	/// @return Zero on succes else negative
+	///
+	int open();
+
+protected:
+	/**
+	 * Writes the given bytes to the RS232-device and
+	 *
+	 * @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);
+
+private:
+	/// The name of the output device
+	const std::string mDeviceName;
+	/// The used baudrate of the output device
+	const int mBaudRate_Hz;
+
+	/// The RS232 serial-device
+	serial::Serial _rs232Port;
+};

libsrc/hyperion/device/LedSpiDevice.cpp

@@ -0,0 +1,84 @@
+
+// STL includes
+#include <cstring>
+#include <cstdio>
+#include <iostream>
+
+// Linux includes
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+// Local Hyperion includes
+#include "LedSpiDevice.h"
+
+
+LedSpiDevice::LedSpiDevice(const std::string& outputDevice, const unsigned baudrate, const int latchTime_ns) :
+	mDeviceName(outputDevice),
+	mBaudRate_Hz(baudrate),
+	mLatchTime_ns(latchTime_ns),
+	mFid(-1)
+{
+	memset(&spi, 0, sizeof(spi));
+}
+
+LedSpiDevice::~LedSpiDevice()
+{
+//	close(mFid);
+}
+
+int LedSpiDevice::open()
+{
+	const int bitsPerWord = 8;
+
+	mFid = ::open(mDeviceName.c_str(), O_RDWR);
+
+	if (mFid < 0)
+	{
+		std::cerr << "Failed to open device('" << mDeviceName << "') " << std::endl;
+		return -1;
+	}
+
+	int mode = SPI_MODE_0;
+	if (ioctl(mFid, SPI_IOC_WR_MODE, &mode) == -1 || ioctl(mFid, SPI_IOC_RD_MODE, &mode) == -1)
+	{
+		return -2;
+	}
+
+	if (ioctl(mFid, SPI_IOC_WR_BITS_PER_WORD, &bitsPerWord) == -1 || ioctl(mFid, SPI_IOC_RD_BITS_PER_WORD, &bitsPerWord) == -1)
+	{
+		return -4;
+	}
+
+	if (ioctl(mFid, SPI_IOC_WR_MAX_SPEED_HZ, &mBaudRate_Hz) == -1 || ioctl(mFid, SPI_IOC_RD_MAX_SPEED_HZ, &mBaudRate_Hz) == -1)
+	{
+		return -6;
+	}
+
+	return 0;
+}
+
+int LedSpiDevice::writeBytes(const unsigned size, const uint8_t * data)
+{
+	if (mFid < 0)
+	{
+		return -1;
+	}
+
+	spi.tx_buf = __u64(data);
+	spi.len    = __u32(size);
+
+	int retVal = ioctl(mFid, SPI_IOC_MESSAGE(1), &spi);
+
+	if (retVal == 0 && mLatchTime_ns > 0)
+	{
+		// The 'latch' time for latching the shifted-value into the leds
+		timespec latchTime;
+		latchTime.tv_sec  = 0;
+		latchTime.tv_nsec = mLatchTime_ns;
+
+		// Sleep to latch the leds (only if write succesfull)
+		nanosleep(&latchTime, NULL);
+	}
+
+	return retVal;
+}

libsrc/hyperion/device/LedSpiDevice.h

@@ -0,0 +1,61 @@
+#pragma once
+
+// Linux-SPI includes
+#include <linux/spi/spidev.h>
+
+// Hyperion includes
+#include <hyperion/LedDevice.h>
+
+///
+/// The LedSpiDevice implements an abstract base-class for LedDevices using the SPI-device.
+///
+class LedSpiDevice : public LedDevice
+{
+public:
+	///
+	/// Constructs the LedDevice attached to a SPI-device
+	///
+	/// @param[in] outputDevice The name of the output device (eg '/etc/SpiDev.0.0')
+	/// @param[in] baudrate The used baudrate for writing to the output device
+	/// @param[in] latchTime_ns The latch-time to latch in the values across the SPI-device (negative
+	/// means no latch required) [ns]
+	///
+	LedSpiDevice(const std::string& outputDevice, const unsigned baudrate, const int latchTime_ns = -1);
+
+	///
+	/// Destructor of the LedDevice; closes the output device if it is open
+	///
+	virtual ~LedSpiDevice();
+
+	///
+	/// 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);
+
+private:
+	/// The name of the output device
+	const std::string mDeviceName;
+	/// The used baudrate of the output device
+	const int mBaudRate_Hz;
+	/// The time which the device should be untouched after a write
+	const int mLatchTime_ns;
+
+	/// The File Identifier of the opened output device (or -1 if not opened)
+	int mFid;
+	/// The transfer structure for writing to the spi-device
+	spi_ioc_transfer spi;
+};