frodovdr/hyperion.ng
1
0
Fork 0
mirror of https://github.com/hyperion-project/hyperion.ng.git synced 2025-03-01 10:33:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement ftdi led device

Browse Source
This commit is contained in:
Ainur Timerbaev
2023-04-13 12:32:04 +01:00
parent 2f09f9a0b8
commit 913d636542
12 changed files with 457 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
libsrc/leddevice/CMakeLists.txt
View File

@@ -42,7 +42,7 @@ if ( ENABLE_DEV_SERIAL )
FILE ( GLOB Leddevice_SERIAL_SOURCES "${CURRENT_SOURCE_DIR}/dev_serial/*.h" "${CURRENT_SOURCE_DIR}/dev_serial/*.cpp")
endif()
if ( ENABLE_DEV_SPI )
if ( ENABLE_DEV_SPI OR ENABLE_DEV_FTDI )
FILE ( GLOB Leddevice_SPI_SOURCES "${CURRENT_SOURCE_DIR}/dev_spi/*.h" "${CURRENT_SOURCE_DIR}/dev_spi/*.cpp")
endif()
@@ -164,3 +164,10 @@ if(ENABLE_MDNS)
target_link_libraries(leddevice mdns)
endif()
if( ENABLE_DEV_FTDI )
find_package(PkgConfig REQUIRED)
pkg_check_modules(LIB_FTDI REQUIRED IMPORTED_TARGET libftdi1 )
target_include_directories(leddevice PRIVATE PkgConfig::LIB_FTDI)
target_link_libraries(leddevice PkgConfig::LIB_FTDI)
endif()

452
libsrc/leddevice/dev_spi/ProviderSpi.cpp
View File

@@ -1,195 +1,359 @@

// Local Hyperion includes
#include "ProviderSpi.h"
#ifdef ENABLE_DEV_SPI
// STL includes
#include <cstring>
#include <cstdio>
#include <iostream>
#include <cerrno>
// Linux includes
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
// Local Hyperion includes
#include "ProviderSpi.h"
#include <utils/Logger.h>
// qt includes
#include <QDir>
#endif
#ifdef ENABLE_DEV_FTDI
#include <ftdi.h>
#include <libusb.h>
#include <utils/WaitTime.h>
#define FTDI_CHECK_RESULT(statement) if (statement) {setInError(ftdi_get_error_string(_ftdic)); return retVal;}
#define ANY_FTDI_VENDOR 0x0
#define ANY_FTDI_PRODUCT 0x0
namespace Pin {
// enumerate the AD bus for convenience.
enum bus_t {
SK = 0x01, // ADBUS0, SPI data clock
DO = 0x02, // ADBUS1, SPI data out
CS = 0x08, // ADBUS3, SPI chip select, active low
};
}
const unsigned char pinInitialState = Pin::CS;
// Use these pins as outputs
const unsigned char pinDirection = Pin::SK | Pin::DO | Pin::CS;
#endif
#include <utils/Logger.h>
// Constants
namespace {
const bool verbose = false;
const bool verbose = false;
#ifdef ENABLE_DEV_SPI
// SPI discovery service
const char DISCOVERY_DIRECTORY[] = "/dev/";
const char DISCOVERY_FILEPATTERN[] = "spidev*";
#endif
// SPI discovery service
const char DISCOVERY_DIRECTORY[] = "/dev/";
const char DISCOVERY_FILEPATTERN[] = "spidev*";
const QString ImplementationSPIDEV = QString("spidev");
const QString ImplementationFTDI = QString("ftdi");
} //End of constants
ProviderSpi::ProviderSpi(const QJsonObject &deviceConfig)
: LedDevice(deviceConfig)
, _deviceName("/dev/spidev0.0")
, _baudRate_Hz(1000000)
, _fid(-1)
, _spiMode(SPI_MODE_0)
, _spiDataInvert(false)
{
memset(&_spi, 0, sizeof(_spi));
_latchTime_ms = 1;
: LedDevice(deviceConfig), _deviceName("/dev/spidev0.0"), _baudRate_Hz(1000000)
#ifdef ENABLE_DEV_SPI
, _fid(-1)
, _spiMode(SPI_MODE_0)
, _spiDataInvert(false)
#endif
, _spiImplementation(SPIDEV) {
#ifdef ENABLE_DEV_SPI
memset(&_spi, 0, sizeof(_spi));
_latchTime_ms = 1;
#endif
}
ProviderSpi::~ProviderSpi()
{
ProviderSpi::~ProviderSpi() {
}
bool ProviderSpi::init(const QJsonObject &deviceConfig)
{
bool isInitOK = false;
bool ProviderSpi::init(const QJsonObject &deviceConfig) {
bool isInitOK = false;
// Initialise sub-class
if ( 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);
// Initialise sub-class
if (LedDevice::init(deviceConfig)) {
_deviceName = deviceConfig["output"].toString(_deviceName);
_baudRate_Hz = deviceConfig["rate"].toInt(_baudRate_Hz);
#ifdef ENABLE_DEV_SPI
_spiMode = deviceConfig["spimode"].toInt(_spiMode);
_spiDataInvert = deviceConfig["invert"].toBool(_spiDataInvert);
Debug(_log, "_spiDataInvert [%d], _spiMode [%d]", _spiDataInvert, _spiMode);
#endif
bool isFtdiImplementation = _deviceName.startsWith("d:")
or _deviceName.startsWith("i:")
or _deviceName.startsWith("s:");
_spiImplementation = isFtdiImplementation ? FTDI : SPIDEV;
Debug(_log, "_baudRate_Hz [%d], _latchTime_ms [%d]", _baudRate_Hz, _latchTime_ms);
Debug(_log, "_spiDataInvert [%d], _spiMode [%d]", _spiDataInvert, _spiMode);
Debug(_log, "_baudRate_Hz [%d], _latchTime_ms [%d]", _baudRate_Hz, _latchTime_ms);
isInitOK = true;
}
return isInitOK;
isInitOK = true;
}
return isInitOK;
}
int ProviderSpi::open()
{
int retval = -1;
QString errortext;
_isDeviceReady = false;
int ProviderSpi::open() {
int retVal = -1;
QString errortext;
_isDeviceReady = false;
if (_spiImplementation == SPIDEV) {
#ifdef ENABLE_DEV_SPI
const int bitsPerWord = 8;
const int bitsPerWord = 8;
_fid = ::open(QSTRING_CSTR(_deviceName), O_RDWR);
_fid = ::open(QSTRING_CSTR(_deviceName), O_RDWR);
if (_fid < 0)
{
errortext = QString ("Failed to open device (%1). Error message: %2").arg(_deviceName, strerror(errno));
retVal = -1;
}
else
{
if (ioctl(_fid, SPI_IOC_WR_MODE, &_spiMode) == -1 || ioctl(_fid, SPI_IOC_RD_MODE, &_spiMode) == -1)
{
retVal = -2;
}
else
{
if (ioctl(_fid, SPI_IOC_WR_BITS_PER_WORD, &bitsPerWord) == -1 || ioctl(_fid, SPI_IOC_RD_BITS_PER_WORD, &bitsPerWord) == -1)
{
retVal = -4;
}
else
{
if (ioctl(_fid, SPI_IOC_WR_MAX_SPEED_HZ, &_baudRate_Hz) == -1 || ioctl(_fid, SPI_IOC_RD_MAX_SPEED_HZ, &_baudRate_Hz) == -1)
{
retVal = -6;
}
else
{
// Everything OK -> enable device
_isDeviceReady = true;
retVal = 0;
}
}
}
if ( retVal < 0 )
{
errortext = QString ("Failed to open device (%1). Error Code: %2").arg(_deviceName).arg(retVal);
}
}
if (_fid < 0)
{
errortext = QString ("Failed to open device (%1). Error message: %2").arg(_deviceName, strerror(errno));
retval = -1;
}
else
{
if (ioctl(_fid, SPI_IOC_WR_MODE, &_spiMode) == -1 || ioctl(_fid, SPI_IOC_RD_MODE, &_spiMode) == -1)
{
retval = -2;
}
else
{
if (ioctl(_fid, SPI_IOC_WR_BITS_PER_WORD, &bitsPerWord) == -1 || ioctl(_fid, SPI_IOC_RD_BITS_PER_WORD, &bitsPerWord) == -1)
{
retval = -4;
}
else
{
if (ioctl(_fid, SPI_IOC_WR_MAX_SPEED_HZ, &_baudRate_Hz) == -1 || ioctl(_fid, SPI_IOC_RD_MAX_SPEED_HZ, &_baudRate_Hz) == -1)
{
retval = -6;
}
else
{
// Everything OK -> enable device
_isDeviceReady = true;
retval = 0;
}
}
}
if ( retval < 0 )
{
errortext = QString ("Failed to open device (%1). Error Code: %2").arg(_deviceName).arg(retval);
}
}
if ( retVal < 0 )
{
this->setInError( errortext );
}
#endif
} else if (_spiImplementation == FTDI) {
#ifdef ENABLE_DEV_FTDI
if ( retval < 0 )
{
this->setInError( errortext );
}
_ftdic = ftdi_new();
return retval;
Debug(_log, "Opening FTDI device=%s", QSTRING_CSTR(_deviceName));
FTDI_CHECK_RESULT((retVal = ftdi_usb_open_string(_ftdic, QSTRING_CSTR(_deviceName))) < 0);
/* doing this disable resets things if they were in a bad state */
FTDI_CHECK_RESULT((retVal = ftdi_disable_bitbang(_ftdic)) < 0);
FTDI_CHECK_RESULT((retVal = ftdi_setflowctrl(_ftdic, SIO_DISABLE_FLOW_CTRL)) < 0);
FTDI_CHECK_RESULT((retVal = ftdi_set_bitmode(_ftdic, 0x00, BITMODE_RESET)) < 0);
FTDI_CHECK_RESULT((retVal = ftdi_set_bitmode(_ftdic, 0xff, BITMODE_MPSSE)) < 0);
double reference_clock = 60e6;
int divisor = (reference_clock / 2 / _baudRate_Hz) - 1;
std::vector<uint8_t> buf = {
DIS_DIV_5,
TCK_DIVISOR,
static_cast<unsigned char>(divisor),
static_cast<unsigned char>(divisor >> 8),
SET_BITS_LOW, // opcode: set low bits (ADBUS[0-7]
pinInitialState, // argument: inital pin state
pinDirection
};
FTDI_CHECK_RESULT((retVal = ftdi_write_data(_ftdic, buf.data(), buf.size())) != buf.size());
_isDeviceReady = true;
#endif
}
return retVal;
}
int ProviderSpi::close()
{
// LedDevice specific closing activities
int retval = 0;
_isDeviceReady = false;
// Test, if device requires closing
if ( _fid > -1 )
{
// Close device
if ( ::close(_fid) != 0 )
{
Error( _log, "Failed to close device (%s). Error message: %s", QSTRING_CSTR(_deviceName), strerror(errno) );
retval = -1;
}
}
return retval;
int ProviderSpi::close() {
// LedDevice specific closing activities
int retVal = 0;
_isDeviceReady = false;
if (_spiImplementation == SPIDEV) {
#ifdef ENABLE_DEV_SPI
// Test, if device requires closing
if ( _fid > -1 )
{
// Close device
if ( ::close(_fid) != 0 )
{
Error( _log, "Failed to close device (%s). Error message: %s", QSTRING_CSTR(_deviceName), strerror(errno) );
retVal = -1;
}
}
#endif
} else if (_spiImplementation == FTDI) {
#ifdef ENABLE_DEV_FTDI
if (_ftdic != nullptr) {
Debug(_log, "Closing FTDI device");
// Delay to give time to push color black from writeBlack() into the led,
// otherwise frame transmission will be terminated half way through
wait(30);
ftdi_set_bitmode(_ftdic, 0x00, BITMODE_RESET);
ftdi_usb_close(_ftdic);
ftdi_free(_ftdic);
_ftdic = nullptr;
}
#endif
}
return retVal;
}
int ProviderSpi::writeBytes(unsigned size, const uint8_t * data)
{
if (_fid < 0)
{
return -1;
}
int ProviderSpi::writeBytes(unsigned size, const uint8_t *data) {
int retVal = 0;
if (_spiImplementation == SPIDEV) {
#ifdef ENABLE_DEV_SPI
if (_fid < 0)
{
return -1;
}
uint8_t * newdata {nullptr};
uint8_t * newdata {nullptr};
_spi.tx_buf = __u64(data);
_spi.len = __u32(size);
_spi.tx_buf = __u64(data);
_spi.len = __u32(size);
if (_spiDataInvert)
{
newdata = static_cast<uint8_t *>(malloc(size));
for (unsigned i = 0; i<size; i++) {
newdata[i] = data[i] ^ 0xff;
}
_spi.tx_buf = __u64(newdata);
}
if (_spiDataInvert)
{
newdata = static_cast<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) );
retVal = ioctl(_fid, SPI_IOC_MESSAGE(1), &_spi);
ErrorIf((retVal < 0), _log, "SPI failed to write. errno: %d, %s", errno, strerror(errno) );
free (newdata);
free (newdata);
#endif
} else if (_spiImplementation == FTDI) {
#ifdef ENABLE_DEV_FTDI
int count_arg = size - 1;
std::vector<uint8_t> buf = {
SET_BITS_LOW,
pinInitialState & ~Pin::CS,
pinDirection,
MPSSE_DO_WRITE | MPSSE_WRITE_NEG,
static_cast<unsigned char>(count_arg),
static_cast<unsigned char>(count_arg >> 8),
// LED's data will be inserted here
SET_BITS_LOW,
pinInitialState | Pin::CS,
pinDirection
};
// insert before last SET_BITS_LOW command
// SET_BITS_LOW takes 2 arguments, so we're inserting data in -3 position from the end
buf.insert(buf.end() - 3, &data[0], &data[size]);
return retVal;
FTDI_CHECK_RESULT((retVal = ftdi_write_data(_ftdic, buf.data(), buf.size())) != buf.size());
#endif
}
return retVal;
}
QJsonObject ProviderSpi::discover(const QJsonObject& /*params*/)
{
QJsonObject devicesDiscovered;
devicesDiscovered.insert("ledDeviceType", _activeDeviceType );
QJsonObject ProviderSpi::discover(const QJsonObject & /*params*/) {
QJsonObject devicesDiscovered;
devicesDiscovered.insert("ledDeviceType", _activeDeviceType);
QJsonArray deviceList;
QJsonArray deviceList;
#ifdef ENABLE_DEV_SPI
QDir deviceDirectory (DISCOVERY_DIRECTORY);
QStringList deviceFilter(DISCOVERY_FILEPATTERN);
deviceDirectory.setNameFilters(deviceFilter);
deviceDirectory.setSorting(QDir::Name);
QFileInfoList deviceFiles = deviceDirectory.entryInfoList(QDir::System);
QDir deviceDirectory (DISCOVERY_DIRECTORY);
QStringList deviceFilter(DISCOVERY_FILEPATTERN);
deviceDirectory.setNameFilters(deviceFilter);
deviceDirectory.setSorting(QDir::Name);
QFileInfoList deviceFiles = deviceDirectory.entryInfoList(QDir::System);
QFileInfoList::const_iterator deviceFileIterator;
for (deviceFileIterator = deviceFiles.constBegin(); deviceFileIterator != deviceFiles.constEnd(); ++deviceFileIterator)
{
QJsonObject deviceInfo;
deviceInfo.insert("deviceName", (*deviceFileIterator).fileName().remove(0,6));
deviceInfo.insert("systemLocation", (*deviceFileIterator).absoluteFilePath());
deviceList.append(deviceInfo);
}
#endif
#ifdef ENABLE_DEV_FTDI
struct ftdi_device_list *devlist;
struct ftdi_context *ftdic;
QFileInfoList::const_iterator deviceFileIterator;
for (deviceFileIterator = deviceFiles.constBegin(); deviceFileIterator != deviceFiles.constEnd(); ++deviceFileIterator)
{
QJsonObject deviceInfo;
deviceInfo.insert("deviceName", (*deviceFileIterator).fileName().remove(0,6));
deviceInfo.insert("systemLocation", (*deviceFileIterator).absoluteFilePath());
deviceList.append(deviceInfo);
}
devicesDiscovered.insert("devices", deviceList);
ftdic = ftdi_new();
DebugIf(verbose,_log, "devicesDiscovered: [%s]", QString(QJsonDocument(devicesDiscovered).toJson(QJsonDocument::Compact)).toUtf8().constData());
if (ftdi_usb_find_all(ftdic, &devlist, ANY_FTDI_VENDOR, ANY_FTDI_PRODUCT) > 0) {
struct ftdi_device_list *curdev = devlist;
QMap<QString, uint8_t> deviceIndexes;
return devicesDiscovered;
while (curdev) {
libusb_device_descriptor desc;
int rc = libusb_get_device_descriptor(curdev->dev, &desc);
if (rc == 0) {
QString vendorIdentifier = QString("0x%1").arg(desc.idVendor, 4, 16, QChar{'0'});
QString productIdentifier = QString("0x%1").arg(desc.idProduct, 4, 16, QChar{'0'});
QString vendorAndProduct = QString("%1:%2")
.arg(vendorIdentifier)
.arg(productIdentifier);
uint8_t deviceIndex = deviceIndexes.value(vendorAndProduct, 0);
char serial_string[128] = {0};
char manufacturer_string[128] = {0};
char description_string[128] = {0};
ftdi_usb_get_strings2(ftdic, curdev->dev, manufacturer_string, 128, description_string, 128,
serial_string, 128);
QString serialNumber{serial_string};
QString ftdiOpenString;
if (!serialNumber.isEmpty()) {
ftdiOpenString = QString("s:%1:%2").arg(vendorAndProduct).arg(serialNumber);
} else {
ftdiOpenString = QString("i:%1:%2").arg(vendorAndProduct).arg(deviceIndex);
}
deviceList.push_back(QJsonObject{
{"ftdiOpenString", ftdiOpenString},
{"vendorIdentifier", vendorIdentifier},
{"productIdentifier", productIdentifier},
{"deviceIndex", deviceIndex},
{"serialNumber", serialNumber},
{"manufacturer", manufacturer_string},
{"description", description_string},
{"deviceName", description_string},
{"systemLocation", ftdiOpenString}
});
deviceIndexes.insert(vendorAndProduct, deviceIndex + 1);
}
curdev = curdev->next;
}
}
ftdi_list_free(&devlist);
ftdi_free(ftdic);
#endif
devicesDiscovered.insert("devices", deviceList);
DebugIf(verbose, _log, "devicesDiscovered: [%s]",
QString(QJsonDocument(devicesDiscovered).toJson(QJsonDocument::Compact)).toUtf8().constData());
return devicesDiscovered;
}

25
libsrc/leddevice/dev_spi/ProviderSpi.h
View File

@@ -1,11 +1,22 @@
#pragma once
#include "HyperionConfig.h"
// Linux-SPI includes
#include <linux/spi/spidev.h>
#ifdef ENABLE_DEV_SPI
// Linux-SPI includes
#include <linux/spi/spidev.h>
#endif
#ifdef ENABLE_DEV_FTDI
#include <ftdi.h>
#endif
// Hyperion includes
#include <leddevice/LedDevice.h>
enum SpiImplementation { SPIDEV, FTDI };
///
/// The ProviderSpi implements an abstract base-class for LedDevices using the SPI-device.
///
@@ -66,7 +77,7 @@ protected:
/// The used baudrate of the output device
int _baudRate_Hz;
#ifdef ENABLE_DEV_SPI
/// The File Identifier of the opened output device (or -1 if not opened)
int _fid;
@@ -78,4 +89,12 @@ protected:
/// The transfer structure for writing to the spi-device
spi_ioc_transfer _spi;
#endif
#ifdef ENABLE_DEV_FTDI
/// The Ftdi serial-device
struct ftdi_context *_ftdic;
#endif
SpiImplementation _spiImplementation;
};

81
libsrc/utils/RgbToRgbw.cpp
View File

@@ -3,6 +3,8 @@
#include <utils/RgbToRgbw.h>
#include <utils/Logger.h>
#define ROUND_DIVIDE(number, denom) (((number) + (denom) / 2) / (denom))
namespace RGBW {
WhiteAlgorithm stringToWhiteAlgorithm(const QString& str)
@@ -19,7 +21,27 @@ WhiteAlgorithm stringToWhiteAlgorithm(const QString& str)
{
return WhiteAlgorithm::SUB_MIN_COOL_ADJUST;
}
if (str.isEmpty() || str == "white_off")
if (str == "cold_white")
{
return WhiteAlgorithm::COLD_WHITE;
}
if (str == "neutral_white")
{
return WhiteAlgorithm::NEUTRAL_WHITE;
}
if (str == "auto")
{
return WhiteAlgorithm::AUTO;
}
if (str == "auto_max")
{
return WhiteAlgorithm::AUTO_MAX;
}
if (str == "auto_accurate")
{
return WhiteAlgorithm::AUTO_ACCURATE;
}
if (str.isEmpty() || str == "white_off")
{
return WhiteAlgorithm::WHITE_OFF;
}
@@ -77,6 +99,63 @@ void Rgb_to_Rgbw(ColorRgb input, ColorRgbw * output, WhiteAlgorithm algorithm)
output->white = 0;
break;
}
case WhiteAlgorithm::AUTO_MAX:
{
output->red = input.red;
output->green = input.green;
output->blue = input.blue;
output->white = input.red > input.green ? (input.red > input.blue ? input.red : input.blue) : (input.green > input.blue ? input.green : input.blue);
break;
}
case WhiteAlgorithm::AUTO_ACCURATE:
{
output->white = input.red < input.green ? (input.red < input.blue ? input.red : input.blue) : (input.green < input.blue ? input.green : input.blue);
output->red = input.red - output->white;
output->green = input.green - output->white;
output->blue = input.blue - output->white;
break;
}
case WhiteAlgorithm::AUTO:
{
output->red = input.red;
output->green = input.green;
output->blue = input.blue;
output->white = input.red < input.green ? (input.red < input.blue ? input.red : input.blue) : (input.green < input.blue ? input.green : input.blue);
break;
}
case WhiteAlgorithm::NEUTRAL_WHITE:
case WhiteAlgorithm::COLD_WHITE:
{
//cold white config
uint8_t gain = 0xFF;
uint8_t red = 0xA0;
uint8_t green = 0xA0;
uint8_t blue = 0xA0;
if (algorithm == WhiteAlgorithm::NEUTRAL_WHITE) {
gain = 0xFF;
red = 0xB0;
green = 0xB0;
blue = 0x70;
}
uint8_t _r = qMin((uint32_t)(ROUND_DIVIDE(red * input.red, 0xFF)), (uint32_t)0xFF);
uint8_t _g = qMin((uint32_t)(ROUND_DIVIDE(green * input.green, 0xFF)), (uint32_t)0xFF);
uint8_t _b = qMin((uint32_t)(ROUND_DIVIDE(blue * input.blue, 0xFF)), (uint32_t)0xFF);
output->white = qMin(_r, qMin(_g, _b));
output->red = input.red - _r;
output->green = input.green - _g;
output->blue = input.blue - _b;
uint8_t _w = qMin((uint32_t)(ROUND_DIVIDE(gain * output->white, 0xFF)), (uint32_t)0xFF);
output->white = _w;
break;
}
default:
break;
}