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

Reformat code

Browse Source
This commit is contained in:
Ainur Timerbaev 2023-04-13 10:33:30 +01:00
parent f28132b458
commit 91713c15b4
1 changed files with 184 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,38 +7,38 @@
#include "ProviderSpi.h" #include "ProviderSpi.h"
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
// Linux includes // Linux includes
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
// qt includes // qt includes
#include <QDir> #include <QDir>
#endif #endif
#ifdef ENABLE_DEV_FTDI #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 #include <ftdi.h>
#define ANY_FTDI_PRODUCT 0x0 #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 namespace Pin {
{ // enumerate the AD bus for convenience.
// enumerate the AD bus for convenience. enum bus_t {
enum bus_t SK = 0x01, // ADBUS0, SPI data clock
{ DO = 0x02, // ADBUS1, SPI data out
SK = 0x01, // ADBUS0, SPI data clock CS = 0x08, // ADBUS3, SPI chip select, active low
DO = 0x02, // ADBUS1, SPI data out };
CS = 0x08, // ADBUS3, SPI chip select, active low }
};
}
const unsigned char pinInitialState = Pin::CS; const unsigned char pinInitialState = Pin::CS;
// Use these pins as outputs // Use these pins as outputs
const unsigned char pinDirection = Pin::SK | Pin::DO | Pin::CS; const unsigned char pinDirection = Pin::SK | Pin::DO | Pin::CS;
#endif #endif
@ -47,11 +47,11 @@
// Constants // Constants
namespace { namespace {
const bool verbose = false; const bool verbose = false;
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
// SPI discovery service // SPI discovery service
const char DISCOVERY_DIRECTORY[] = "/dev/"; const char DISCOVERY_DIRECTORY[] = "/dev/";
const char DISCOVERY_FILEPATTERN[] = "spidev*"; const char DISCOVERY_FILEPATTERN[] = "spidev*";
#endif #endif
const QString ImplementationSPIDEV = QString("spidev"); const QString ImplementationSPIDEV = QString("spidev");
@ -60,144 +60,138 @@ namespace {
} //End of constants } //End of constants
ProviderSpi::ProviderSpi(const QJsonObject &deviceConfig) ProviderSpi::ProviderSpi(const QJsonObject &deviceConfig)
: LedDevice(deviceConfig) : LedDevice(deviceConfig), _deviceName("/dev/spidev0.0"), _baudRate_Hz(1000000)
, _deviceName("/dev/spidev0.0")
, _baudRate_Hz(1000000)
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
, _fid(-1) , _fid(-1)
, _spiMode(SPI_MODE_0) , _spiMode(SPI_MODE_0)
, _spiDataInvert(false) , _spiDataInvert(false)
#endif #endif
, _spiImplementation(SPI_SPIDEV) , _spiImplementation(SPI_SPIDEV) {
{
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
memset(&_spi, 0, sizeof(_spi)); memset(&_spi, 0, sizeof(_spi));
_latchTime_ms = 1; _latchTime_ms = 1;
#endif #endif
} }
ProviderSpi::~ProviderSpi() ProviderSpi::~ProviderSpi() {
{
} }
bool ProviderSpi::init(const QJsonObject &deviceConfig) bool ProviderSpi::init(const QJsonObject &deviceConfig) {
{ bool isInitOK = false;
bool isInitOK = false;
// Initialise sub-class // Initialise sub-class
if ( LedDevice::init(deviceConfig) ) if (LedDevice::init(deviceConfig)) {
{ _deviceName = deviceConfig["output"].toString(_deviceName);
_deviceName = deviceConfig["output"].toString(_deviceName); _baudRate_Hz = deviceConfig["rate"].toInt(_baudRate_Hz);
_baudRate_Hz = deviceConfig["rate"].toInt(_baudRate_Hz);
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
_spiMode = deviceConfig["spimode"].toInt(_spiMode); _spiMode = deviceConfig["spimode"].toInt(_spiMode);
_spiDataInvert = deviceConfig["invert"].toBool(_spiDataInvert); _spiDataInvert = deviceConfig["invert"].toBool(_spiDataInvert);
Debug(_log, "_spiDataInvert [%d], _spiMode [%d]", _spiDataInvert, _spiMode); Debug(_log, "_spiDataInvert [%d], _spiMode [%d]", _spiDataInvert, _spiMode);
#endif #endif
bool isFtdiImplementation = (QString::compare(deviceConfig["implementation"].toString(ImplementationSPIDEV), ImplementationFTDI, Qt::CaseInsensitive) == 0); bool isFtdiImplementation = (
QString::compare(deviceConfig["implementation"].toString(ImplementationSPIDEV), ImplementationFTDI,
Qt::CaseInsensitive) == 0);
_spiImplementation = isFtdiImplementation ? SPI_FTDI : SPI_SPIDEV; _spiImplementation = isFtdiImplementation ? SPI_FTDI : SPI_SPIDEV;
Debug(_log, "_baudRate_Hz [%d], _latchTime_ms [%d]", _baudRate_Hz, _latchTime_ms); Debug(_log, "_baudRate_Hz [%d], _latchTime_ms [%d]", _baudRate_Hz, _latchTime_ms);
isInitOK = true; isInitOK = true;
} }
return isInitOK; return isInitOK;
} }
int ProviderSpi::open() int ProviderSpi::open() {
{ int retVal = -1;
int retVal = -1; QString errortext;
QString errortext; _isDeviceReady = false;
_isDeviceReady = false; if (_spiImplementation == SPI_SPIDEV) {
if (_spiImplementation == SPI_SPIDEV) {
#ifdef ENABLE_DEV_SPI #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) 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; errortext = QString ("Failed to open device (%1). Error message: %2").arg(_deviceName, strerror(errno));
retVal = -1;
} }
else else
{ {
if (ioctl(_fid, SPI_IOC_WR_BITS_PER_WORD, &bitsPerWord) == -1 || ioctl(_fid, SPI_IOC_RD_BITS_PER_WORD, &bitsPerWord) == -1) if (ioctl(_fid, SPI_IOC_WR_MODE, &_spiMode) == -1 || ioctl(_fid, SPI_IOC_RD_MODE, &_spiMode) == -1)
{ {
retVal = -4; retVal = -2;
} }
else else
{ {
if (ioctl(_fid, SPI_IOC_WR_MAX_SPEED_HZ, &_baudRate_Hz) == -1 || ioctl(_fid, SPI_IOC_RD_MAX_SPEED_HZ, &_baudRate_Hz) == -1) if (ioctl(_fid, SPI_IOC_WR_BITS_PER_WORD, &bitsPerWord) == -1 || ioctl(_fid, SPI_IOC_RD_BITS_PER_WORD, &bitsPerWord) == -1)
{ {
retVal = -6; retVal = -4;
} }
else else
{ {
// Everything OK -> enable device if (ioctl(_fid, SPI_IOC_WR_MAX_SPEED_HZ, &_baudRate_Hz) == -1 || ioctl(_fid, SPI_IOC_RD_MAX_SPEED_HZ, &_baudRate_Hz) == -1)
_isDeviceReady = true; {
retVal = 0; 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 ) if ( retVal < 0 )
{ {
errortext = QString ("Failed to open device (%1). Error Code: %2").arg(_deviceName).arg(retVal); this->setInError( errortext );
} }
}
if ( retVal < 0 )
{
this->setInError( errortext );
}
#endif #endif
} else if (_spiImplementation == SPI_FTDI) { } else if (_spiImplementation == SPI_FTDI) {
#ifdef ENABLE_DEV_FTDI #ifdef ENABLE_DEV_FTDI
_ftdic = ftdi_new(); _ftdic = ftdi_new();
Debug(_log, "Opening FTDI device=%s", QSTRING_CSTR(_deviceName)); Debug(_log, "Opening FTDI device=%s", QSTRING_CSTR(_deviceName));
FTDI_CHECK_RESULT((retVal = ftdi_usb_open_string(_ftdic, QSTRING_CSTR(_deviceName))) < 0); 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 */ /* 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_disable_bitbang(_ftdic)) < 0);
FTDI_CHECK_RESULT((retVal = ftdi_setflowctrl(_ftdic, SIO_DISABLE_FLOW_CTRL)) < 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, 0x00, BITMODE_RESET)) < 0);
FTDI_CHECK_RESULT((retVal = ftdi_set_bitmode(_ftdic, 0xff, BITMODE_MPSSE)) < 0); FTDI_CHECK_RESULT((retVal = ftdi_set_bitmode(_ftdic, 0xff, BITMODE_MPSSE)) < 0);
double reference_clock = 60e6; double reference_clock = 60e6;
int divisor = (reference_clock / 2 / _baudRate_Hz) - 1; int divisor = (reference_clock / 2 / _baudRate_Hz) - 1;
std::vector<uint8_t> buf = { std::vector<uint8_t> buf = {
DIS_DIV_5, DIS_DIV_5,
TCK_DIVISOR, TCK_DIVISOR,
static_cast<unsigned char>(divisor), static_cast<unsigned char>(divisor),
static_cast<unsigned char>(divisor >> 8), static_cast<unsigned char>(divisor >> 8),
SET_BITS_LOW, // opcode: set low bits (ADBUS[0-7] SET_BITS_LOW, // opcode: set low bits (ADBUS[0-7]
pinInitialState, // argument: inital pin state pinInitialState, // argument: inital pin state
pinDirection pinDirection
}; };
FTDI_CHECK_RESULT((retVal = ftdi_write_data(_ftdic, buf.data(), buf.size())) != buf.size()); FTDI_CHECK_RESULT((retVal = ftdi_write_data(_ftdic, buf.data(), buf.size())) != buf.size());
_isDeviceReady = true; _isDeviceReady = true;
#endif #endif
} }
return retVal; return retVal;
} }
int ProviderSpi::close() int ProviderSpi::close() {
{ // LedDevice specific closing activities
// LedDevice specific closing activities int retVal = 0;
int retVal = 0; _isDeviceReady = false;
_isDeviceReady = false;
if (_spiImplementation == SPI_SPIDEV) { if (_spiImplementation == SPI_SPIDEV) {
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
// Test, if device requires closing // Test, if device requires closing
@ -213,10 +207,10 @@ int ProviderSpi::close()
#endif #endif
} else if (_spiImplementation == SPI_FTDI) { } else if (_spiImplementation == SPI_FTDI) {
#ifdef ENABLE_DEV_FTDI #ifdef ENABLE_DEV_FTDI
if (_ftdic != nullptr) { if (_ftdic != nullptr) {
Debug(_log, "Closing FTDI device"); Debug(_log, "Closing FTDI device");
// Delay to give time to push color black from writeBlack() into the led, // Delay to give time to push color black from writeBlack() into the led,
// otherwise frame transmission will be terminated half way through // otherwise frame transmission will be terminated half way through
wait(30); wait(30);
ftdi_set_bitmode(_ftdic, 0x00, BITMODE_RESET); ftdi_set_bitmode(_ftdic, 0x00, BITMODE_RESET);
ftdi_usb_close(_ftdic); ftdi_usb_close(_ftdic);
@ -225,11 +219,10 @@ int ProviderSpi::close()
} }
#endif #endif
} }
return retVal; return retVal;
} }
int ProviderSpi::writeBytes(unsigned size, const uint8_t * data) int ProviderSpi::writeBytes(unsigned size, const uint8_t *data) {
{
int retVal = 0; int retVal = 0;
if (_spiImplementation == SPI_SPIDEV) { if (_spiImplementation == SPI_SPIDEV) {
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
@ -279,95 +272,90 @@ int ProviderSpi::writeBytes(unsigned size, const uint8_t * data)
FTDI_CHECK_RESULT((retVal = ftdi_write_data(_ftdic, buf.data(), buf.size())) != buf.size()); FTDI_CHECK_RESULT((retVal = ftdi_write_data(_ftdic, buf.data(), buf.size())) != buf.size());
#endif #endif
} }
return retVal; return retVal;
} }
QJsonObject ProviderSpi::discover(const QJsonObject& /*params*/) QJsonObject ProviderSpi::discover(const QJsonObject & /*params*/) {
{ QJsonObject devicesDiscovered;
QJsonObject devicesDiscovered; devicesDiscovered.insert("ledDeviceType", _activeDeviceType);
devicesDiscovered.insert("ledDeviceType", _activeDeviceType ); QJsonArray deviceList;
QJsonArray deviceList;
#ifdef ENABLE_DEV_SPI #ifdef ENABLE_DEV_SPI
QDir deviceDirectory (DISCOVERY_DIRECTORY); QDir deviceDirectory (DISCOVERY_DIRECTORY);
QStringList deviceFilter(DISCOVERY_FILEPATTERN); QStringList deviceFilter(DISCOVERY_FILEPATTERN);
deviceDirectory.setNameFilters(deviceFilter); deviceDirectory.setNameFilters(deviceFilter);
deviceDirectory.setSorting(QDir::Name); deviceDirectory.setSorting(QDir::Name);
QFileInfoList deviceFiles = deviceDirectory.entryInfoList(QDir::System); QFileInfoList deviceFiles = deviceDirectory.entryInfoList(QDir::System);
QFileInfoList::const_iterator deviceFileIterator; QFileInfoList::const_iterator deviceFileIterator;
for (deviceFileIterator = deviceFiles.constBegin(); deviceFileIterator != deviceFiles.constEnd(); ++deviceFileIterator) for (deviceFileIterator = deviceFiles.constBegin(); deviceFileIterator != deviceFiles.constEnd(); ++deviceFileIterator)
{ {
QJsonObject deviceInfo; QJsonObject deviceInfo;
deviceInfo.insert("deviceName", (*deviceFileIterator).fileName().remove(0,6)); deviceInfo.insert("deviceName", (*deviceFileIterator).fileName().remove(0,6));
deviceInfo.insert("systemLocation", (*deviceFileIterator).absoluteFilePath()); deviceInfo.insert("systemLocation", (*deviceFileIterator).absoluteFilePath());
deviceInfo.insert("implementation", ImplementationSPIDEV); deviceInfo.insert("implementation", ImplementationSPIDEV);
deviceList.append(deviceInfo); deviceList.append(deviceInfo);
} }
#endif #endif
#ifdef ENABLE_DEV_FTDI #ifdef ENABLE_DEV_FTDI
struct ftdi_device_list *devlist; struct ftdi_device_list *devlist;
struct ftdi_context *ftdic; struct ftdi_context *ftdic;
ftdic = ftdi_new(); ftdic = ftdi_new();
if (ftdi_usb_find_all(ftdic, &devlist, ANY_FTDI_VENDOR, ANY_FTDI_PRODUCT) > 0) if (ftdi_usb_find_all(ftdic, &devlist, ANY_FTDI_VENDOR, ANY_FTDI_PRODUCT) > 0) {
{ struct ftdi_device_list *curdev = devlist;
struct ftdi_device_list *curdev = devlist; QMap<QString, uint8_t> deviceIndexes;
QMap<QString, uint8_t> deviceIndexes;
while (curdev) while (curdev) {
{ libusb_device_descriptor desc;
libusb_device_descriptor desc; int rc = libusb_get_device_descriptor(curdev->dev, &desc);
int rc = libusb_get_device_descriptor(curdev->dev, &desc); if (rc == 0) {
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 vendorIdentifier = QString("0x%1").arg(desc.idVendor, 4, 16, QChar{'0'}); QString vendorAndProduct = QString("%1:%2")
QString productIdentifier = QString("0x%1").arg(desc.idProduct, 4, 16, QChar{'0'}); .arg(vendorIdentifier)
QString vendorAndProduct = QString("%1:%2") .arg(productIdentifier);
.arg(vendorIdentifier) uint8_t deviceIndex = deviceIndexes.value(vendorAndProduct, 0);
.arg(productIdentifier);
uint8_t deviceIndex = deviceIndexes.value(vendorAndProduct, 0);
char serial_string[128] = {0}; char serial_string[128] = {0};
char manufacturer_string[128] = {0}; char manufacturer_string[128] = {0};
char description_string[128] = {0}; char description_string[128] = {0};
ftdi_usb_get_strings2(ftdic, curdev->dev, manufacturer_string, 128, description_string, 128, serial_string, 128); ftdi_usb_get_strings2(ftdic, curdev->dev, manufacturer_string, 128, description_string, 128,
serial_string, 128);
QString serialNumber {serial_string}; QString serialNumber{serial_string};
QString ftdiOpenString; QString ftdiOpenString;
if(!serialNumber.isEmpty()) if (!serialNumber.isEmpty()) {
{ ftdiOpenString = QString("s:%1:%2").arg(vendorAndProduct).arg(serialNumber);
ftdiOpenString = QString("s:%1:%2").arg(vendorAndProduct).arg(serialNumber); } else {
} ftdiOpenString = QString("i:%1:%2").arg(vendorAndProduct).arg(deviceIndex);
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},
{"implementation", ImplementationFTDI},
});
deviceIndexes.insert(vendorAndProduct, deviceIndex + 1);
} }
curdev = curdev->next;
}
}
ftdi_list_free(&devlist); deviceList.push_back(QJsonObject{
ftdi_free(ftdic); {"ftdiOpenString", ftdiOpenString},
{"vendorIdentifier", vendorIdentifier},
{"productIdentifier", productIdentifier},
{"deviceIndex", deviceIndex},
{"serialNumber", serialNumber},
{"manufacturer", manufacturer_string},
{"description", description_string},
{"deviceName", description_string},
{"systemLocation", ftdiOpenString},
{"implementation", ImplementationFTDI},
});
deviceIndexes.insert(vendorAndProduct, deviceIndex + 1);
}
curdev = curdev->next;
}
}
ftdi_list_free(&devlist);
ftdi_free(ftdic);
#endif #endif
devicesDiscovered.insert("devices", deviceList); devicesDiscovered.insert("devices", deviceList);
DebugIf(verbose,_log, "devicesDiscovered: [%s]", QString(QJsonDocument(devicesDiscovered).toJson(QJsonDocument::Compact)).toUtf8().constData()); DebugIf(verbose, _log, "devicesDiscovered: [%s]",
QString(QJsonDocument(devicesDiscovered).toJson(QJsonDocument::Compact)).toUtf8().constData());
return devicesDiscovered; return devicesDiscovered;
} }