LED Device Features, Fixes and Refactoring (Resubmit PR855) (#875)

* Refactor LedDevices - Initial version * Small renamings * Add WLED as own device * Lpd8806 Remove open() method * remove dependency on Qt 5.10 * Lpd8806 Remove open() method * Update WS281x * Update WS2812SPI * Add writeBlack for WLED powerOff * WLED remove extra bracket * Allow different Nanoleaf panel numbering sequence (Feature req.#827) * build(deps): bump websocket-extensions from 0.1.3 to 0.1.4 in /docs (#826) * Bumps [websocket-extensions](https://github.com/faye/websocket-extensions-node) from 0.1.3 to 0.1.4. - [Release notes](https://github.com/faye/websocket-extensions-node/releases) - [Changelog](https://github.com/faye/websocket-extensions-node/blob/master/CHANGELOG.md) - [Commits](https://github.com/faye/websocket-extensions-node/compare/0.1.3...0.1.4) * Fix typos * Nanoleaf clean-up * Yeelight support, generalize wizard elements * Update Yeelight to handle quota in music mode * Yeelight extend rage for extraTimeDarkness for testing * Clean-up - Add commentary, Remove development debug statements * Fix brightnessSwitchOffOnMinimum typo and default value * Yeelight support restoreOriginalState, additional Fixes * WLED - Remove UDP-Port, as it is not configurable * Fix merging issue * Remove QHostAddress::operator=(const QString&)' is deprecated * Windows compile errors and (Qt 5.15 deprecation) warnings * Fix order includes * LedDeviceFile Support Qt5.7 and greater * Windows compatibility and other Fixes * Fix Qt Version compatability * Rs232 - Resolve portname from unix /dev/ style, fix DMX sub-type support * Disable WLED Wizard Button (until Wizard is available) * Yeelight updates * Add wrong log-type as per #505 * Fixes and Clean-up after clang-tidy report * Fix udpe131 not enabled for generated CID * Change timer into dynamic for Qt Thread-Affinity * Hue clean-up and diyHue workaround * Updates after review feedback by m-seker * Add "chrono" includes
2025-03-01 10:33:28 +00:00 · 2020-07-12 20:27:56 +02:00
parent 3b48d8c9d6
commit 7389068a66
125 changed files with 8864 additions and 3217 deletions
--- a/libsrc/leddevice/LedDevice.cpp
+++ b/libsrc/leddevice/LedDevice.cpp
@@ -1,5 +1,4 @@
 #include <leddevice/LedDevice.h>
-#include <sstream>

 //QT include
 #include <QResource>
@@ -13,102 +12,115 @@
 #include "hyperion/Hyperion.h"
 #include <utils/JsonUtils.h>

-LedDevice::LedDevice(const QJsonObject& config, QObject* parent)
+//std includes
+#include <sstream>
+#include <iomanip>
+
+LedDevice::LedDevice(const QJsonObject& deviceConfig, QObject* parent)
 	: QObject(parent)
-	, _devConfig(config)
-	, _log(Logger::getInstance("LEDDEVICE"))
-	, _ledBuffer(0)
-	, _deviceReady(false)
-	, _deviceInError(false)
-	, _refresh_timer(new QTimer(this))
-	, _refresh_timer_interval(0)
-	, _lastWriteTime(QDateTime::currentDateTime())
-	, _latchTime_ms(0)
-	, _componentRegistered(false)
-	, _enabled(false)
-	, _refresh_enabled(false)
+	  , _devConfig(deviceConfig)
+	  , _log(Logger::getInstance("LEDDEVICE"))
+	  , _ledBuffer(0)
+	  , _refreshTimer(nullptr)
+	  , _refreshTimerInterval_ms(0)
+	  , _latchTime_ms(0)
+	  , _isRestoreOrigState(false)
+	  , _isEnabled(false)
+	  , _isDeviceInitialised(false)
+	  , _isDeviceReady(false)
+	  , _isDeviceInError(false)
+	  , _isInSwitchOff (false)
+	  , _lastWriteTime(QDateTime::currentDateTime())
+	  , _isRefreshEnabled (false)
 {
-	// setup refreshTimer
-	_refresh_timer->setTimerType(Qt::PreciseTimer);
-	_refresh_timer->setInterval( _refresh_timer_interval );
-	connect(_refresh_timer, SIGNAL(timeout()), this, SLOT(rewriteLeds()));
+
 }

 LedDevice::~LedDevice()
 {
-	delete _refresh_timer;
+	delete _refreshTimer;
+}
+
+void LedDevice::start()
+{
+	Info(_log, "Start LedDevice '%s'.", QSTRING_CSTR(_activeDeviceType));
+
+	// setup refreshTimer
+	if ( _refreshTimer == nullptr )
+	{
+		_refreshTimer = new QTimer(this);
+		_refreshTimer->setTimerType(Qt::PreciseTimer);
+		_refreshTimer->setInterval( _refreshTimerInterval_ms );
+		connect(_refreshTimer, &QTimer::timeout, this, &LedDevice::rewriteLEDs );
+	}
+
+	close();
+
+	_isDeviceInitialised = false;
+	// General initialisation and configuration of LedDevice
+	if ( init(_devConfig) )
+	{
+		// Everything is OK -> enable device
+		_isDeviceInitialised = true;
+		setEnable(true);
+	}
+}
+
+void LedDevice::stop()
+{
+	setEnable(false);
+	this->stopRefreshTimer();
 }

 int LedDevice::open()
 {
-	int retval = -1;
-	QString errortext;
-	_deviceReady = false;
+	_isDeviceReady = true;
+	int retval = 0;
+
+	return retval;
+}
+
+int LedDevice::close()
+{
+	_isDeviceReady = false;
+	int retval = 0;

-	// General initialisation and configuration of LedDevice
-	if ( init(_devConfig) )
-	{
-			// Everything is OK -> enable device
-			_deviceReady = true;
-			setEnable(true);
-			retval = 0;
-	}
 	return retval;
 }

 void LedDevice::setInError(const QString& errorMsg)
 {
-	_deviceInError = true;
-	_deviceReady = false;
-	_enabled = false;
+	_isDeviceInError = true;
+	_isDeviceReady = false;
+	_isEnabled = false;
 	this->stopRefreshTimer();

 	Error(_log, "Device disabled, device '%s' signals error: '%s'", QSTRING_CSTR(_activeDeviceType), QSTRING_CSTR(errorMsg));
-	emit enableStateChanged(_enabled);
-}
-
-void LedDevice::close()
-{
-	switchOff();
-	this->stopRefreshTimer();
+	emit enableStateChanged(_isEnabled);
 }

 void LedDevice::setEnable(bool enable)
 {
-	if ( !_deviceReady && enable )
+	bool isSwitched = false;
+	// switch off device when disabled, default: set black to LEDs when they should go off
+	if ( _isEnabled  && !enable)
 	{
-		Debug(_log, "Device '%s' was not ready! Trying to re-open.", QSTRING_CSTR(_activeDeviceType));
-		if ( open() < 0 )
-		{
-			Error(_log, "Device '%s' cannot be enabled, as it is not ready!", QSTRING_CSTR(_activeDeviceType));
-			return;
-		}
-		else
-		{
-			// Open worked
-			_deviceInError = false;
-		}
-	}
-
-	// emit signal when state changed
-	if ( _enabled != enable )
-	{
-		emit enableStateChanged(enable);
-	}
-	// switch off device when disabled, default: set black to leds when they should go off
-	if ( _enabled && !enable )
-	{
-		switchOff();
+		isSwitched = switchOff();
 	}
 	else
 	{
 		// switch on device when enabled
-		if ( !_enabled && enable )
+		if ( !_isEnabled  && enable)
 		{
-			switchOn();
+			isSwitched = switchOn();
 		}
 	}
-	_enabled = enable;
+
+	if ( isSwitched )
+	{
+		_isEnabled = enable;
+		emit enableStateChanged(enable);
+	}
 }

 void LedDevice::setActiveDeviceType(const QString& deviceType)
@@ -118,28 +130,28 @@ void LedDevice::setActiveDeviceType(const QString& deviceType)

 bool LedDevice::init(const QJsonObject &deviceConfig)
 {
-	//Debug(_log, "deviceConfig: [%s]", QString(QJsonDocument(_devConfig).toJson(QJsonDocument::Compact)).toUtf8().constData() );
+	Debug(_log, "deviceConfig: [%s]", QString(QJsonDocument(_devConfig).toJson(QJsonDocument::Compact)).toUtf8().constData() );

 	_colorOrder = deviceConfig["colorOrder"].toString("RGB");
-	_activeDeviceType = deviceConfig["type"].toString("file").toLower();
 	setLedCount(static_cast<unsigned int>( deviceConfig["currentLedCount"].toInt(1) )); // property injected to reflect real led count

-	_latchTime_ms = deviceConfig["latchTime"].toInt( _latchTime_ms );
-	_refresh_timer_interval = deviceConfig["rewriteTime"].toInt( _refresh_timer_interval);
+	_latchTime_ms =deviceConfig["latchTime"].toInt( _latchTime_ms );
+	_refreshTimerInterval_ms =  deviceConfig["rewriteTime"].toInt( _refreshTimerInterval_ms);

-	if ( _refresh_timer_interval > 0 )
+	if ( _refreshTimerInterval_ms > 0 )
 	{
-		_refresh_enabled = true;
+		_isRefreshEnabled = true;

-		if ( _refresh_timer_interval <= _latchTime_ms )
+		if (_refreshTimerInterval_ms <= _latchTime_ms )
 		{
 			int new_refresh_timer_interval = _latchTime_ms + 10;
-			Warning(_log, "latchTime(%d) is bigger/equal rewriteTime(%d), set rewriteTime to %dms", _latchTime_ms, _refresh_timer_interval, new_refresh_timer_interval);
-			_refresh_timer_interval = new_refresh_timer_interval;
+			Warning(_log, "latchTime(%d) is bigger/equal rewriteTime(%d), set rewriteTime to %dms", _latchTime_ms, _refreshTimerInterval_ms, new_refresh_timer_interval);
+			_refreshTimerInterval_ms = new_refresh_timer_interval;
+			_refreshTimer->setInterval( _refreshTimerInterval_ms );
 		}

-		//Debug(_log, "Refresh interval = %dms",_refresh_timer_interval );
-		_refresh_timer->setInterval( _refresh_timer_interval );
+		Debug(_log, "Refresh interval = %dms",_refreshTimerInterval_ms );
+		_refreshTimer->setInterval( _refreshTimerInterval_ms );

 		_lastWriteTime = QDateTime::currentDateTime();

@@ -150,21 +162,21 @@ bool LedDevice::init(const QJsonObject &deviceConfig)

 void LedDevice::startRefreshTimer()
 {
-	if ( _deviceReady )
+	if ( _isDeviceReady && _isEnabled )
 	{
-		_refresh_timer->start();
+		_refreshTimer->start();
 	}
 }

 void LedDevice::stopRefreshTimer()
 {
-	_refresh_timer->stop();
+	_refreshTimer->stop();
 }

 int LedDevice::updateLeds(const std::vector<ColorRgb>& ledValues)
 {
 	int retval = 0;
-	if ( !_deviceReady || _deviceInError )
+	if ( !isEnabled() || !_isDeviceReady || _isDeviceInError )
 	{
 		//std::cout << "LedDevice::updateLeds(), LedDevice NOT ready!" <<  std::endl;
 		return -1;
@@ -179,16 +191,16 @@ int LedDevice::updateLeds(const std::vector<ColorRgb>& ledValues)
 			_lastWriteTime = QDateTime::currentDateTime();

 			// if device requires refreshing, save Led-Values and restart the timer
-			if ( _refresh_enabled )
+			if ( _isRefreshEnabled && _isEnabled )
 			{
 				this->startRefreshTimer();
-				_last_ledValues = ledValues;
+				_lastLedValues = ledValues;
 			}
 		}
 		else
 		{
 			//std::cout << "LedDevice::updateLeds(), Skip write. elapsedTime (" << elapsedTimeMs << ") ms < _latchTime_ms (" << _latchTime_ms << ") ms" << std::endl;
-			if ( _refresh_enabled )
+			if ( _isRefreshEnabled )
 			{
 				//Stop timer to allow for next non-refresh update
 				this->stopRefreshTimer();
@@ -198,30 +210,187 @@ int LedDevice::updateLeds(const std::vector<ColorRgb>& ledValues)
 	return retval;
 }

-int LedDevice::writeBlack()
+int LedDevice::rewriteLEDs()
 {
-	return _deviceReady ? updateLeds(std::vector<ColorRgb>(static_cast<unsigned long>(_ledCount), ColorRgb::BLACK )) : -1;
+	int retval = -1;
+
+	if ( _isDeviceReady && _isEnabled )
+	{
+//				qint64 elapsedTimeMs = _lastWriteTime.msecsTo(QDateTime::currentDateTime());
+//				std::cout << "LedDevice::rewriteLEDs(): Rewrite LEDs now, elapsedTime [" << elapsedTimeMs << "] ms" << std::endl;
+//				//:TESTING: Inject "white" output records to differentiate from normal writes
+//				_lastLedValues.clear();
+//				_lastLedValues.resize(static_cast<unsigned long>(_ledCount), ColorRgb::WHITE);
+//				printLedValues(_lastLedValues);
+//				//:TESTING:
+
+		retval = write(_lastLedValues);
+		_lastWriteTime = QDateTime::currentDateTime();
+	}
+	else
+	{
+		// If Device is not ready stop timer
+		this->stopRefreshTimer();
+	}
+	return retval;
 }

-int LedDevice::switchOff()
+int LedDevice::writeBlack(int numberOfBlack)
 {
-	// Stop refresh timer to ensure that "write Black" is executed
-	this->stopRefreshTimer();
+	int rc = -1;

-	if ( _latchTime_ms > 0 )
+	for (int i = 0; i < numberOfBlack; i++)
 	{
-		// Wait latchtime before writing black
-		QEventLoop loop;
-		QTimer::singleShot( _latchTime_ms, &loop, SLOT( quit() ) );
-		loop.exec();
+		if ( _latchTime_ms > 0 )
+		{
+			// Wait latch time before writing black
+			QEventLoop loop;
+			QTimer::singleShot( _latchTime_ms, &loop, SLOT( quit() ) );
+			loop.exec();
+		}
+		rc = write(std::vector<ColorRgb>(static_cast<unsigned long>(_ledCount), ColorRgb::BLACK ));
 	}
-	int rc = writeBlack();
 	return rc;
 }

-int LedDevice::switchOn()
+bool LedDevice::switchOn()
 {
-	return 0;
+	bool rc = false;
+	if ( _isDeviceInitialised && ! _isDeviceReady && ! _isEnabled )
+	{
+		_isDeviceInError = false;
+		if ( open() < 0 )
+		{
+			rc = false;
+		}
+		else
+		{
+			storeState();
+
+			if ( powerOn() )
+			{
+				_isEnabled = true;
+				rc = true;
+			}
+		}
+	}
+	return rc;
+}
+
+bool LedDevice::switchOff()
+{
+	bool rc = false;
+
+	if ( _isDeviceInitialised )
+	{
+		// Disable device to ensure no standard Led updates are written/processed
+		_isEnabled = false;
+		_isInSwitchOff = true;
+
+		this->stopRefreshTimer();
+
+		rc = true;
+
+		if ( _isDeviceReady )
+		{
+			if ( _isRestoreOrigState )
+			{
+				//Restore devices state
+				restoreState();
+			}
+			else
+			{
+				powerOff();
+			}
+
+		}
+		if ( close() < 0 )
+		{
+			rc = false;
+		}
+	}
+	return rc;
+}
+
+
+bool LedDevice::powerOff()
+{
+	bool rc = false;
+
+	// Simulate power-off by writing a final "Black" to have a defined outcome
+	if ( writeBlack() >= 0 )
+	{
+		rc = true;
+	}
+	return rc;
+}
+
+bool LedDevice::powerOn()
+{
+	bool rc = true;
+	return rc;
+}
+
+bool LedDevice::storeState()
+{
+	bool rc = true;
+
+	if ( _isRestoreOrigState )
+	{
+		// Save device's original state
+		// _originalStateValues = get device's state;
+		// store original power on/off state, if available
+	}
+	return rc;
+}
+
+bool LedDevice::restoreState()
+{
+	bool rc = true;
+
+	if ( _isRestoreOrigState )
+	{
+		// Restore device's original state
+		// update device using _originalStateValues
+		// update original power on/off state, if supported
+	}
+	return rc;
+}
+
+QJsonObject LedDevice::discover()
+{
+	QJsonObject devicesDiscovered;
+
+	devicesDiscovered.insert("ledDeviceType", _activeDeviceType);
+
+	QJsonArray deviceList;
+	devicesDiscovered.insert("devices", deviceList);
+
+	Debug(_log, "devicesDiscovered: [%s]", QString(QJsonDocument(devicesDiscovered).toJson(QJsonDocument::Compact)).toUtf8().constData() );
+	return devicesDiscovered;
+}
+
+QString LedDevice::discoverFirst()
+{
+	QString deviceDiscovered;
+
+	Debug(_log, "deviceDiscovered: [%s]", QSTRING_CSTR(deviceDiscovered) );
+	return deviceDiscovered;
+}
+
+
+QJsonObject LedDevice::getProperties(const QJsonObject& params)
+{
+	Debug(_log, "params: [%s]", QString(QJsonDocument(params).toJson(QJsonDocument::Compact)).toUtf8().constData() );
+
+	QJsonObject properties;
+
+	QJsonObject deviceProperties;
+	properties.insert("properties", deviceProperties);
+
+	Debug(_log, "properties: [%s]", QString(QJsonDocument(properties).toJson(QJsonDocument::Compact)).toUtf8().constData() );
+
+	return properties;
 }

 void LedDevice::setLedCount(unsigned int ledCount)
@@ -237,31 +406,6 @@ void LedDevice::setLatchTime( int latchTime_ms )
 	Debug(_log, "LatchTime updated to %dms", this->getLatchTime());
 }

-int LedDevice::rewriteLeds()
-{
-	int retval = -1;
-
-	if ( _deviceReady )
-	{
-//		qint64 elapsedTimeMs = _lastWriteTime.msecsTo(QDateTime::currentDateTime());
-//		std::cout << "LedDevice::rewriteLEDs(): Rewrite LEDs now, elapsedTime [" << elapsedTimeMs << "] ms" << std::endl;
-//		//:TESTING: Inject "white" output records to differentiate from normal writes
-//		_last_ledValues.clear();
-//		_last_ledValues.resize(static_cast<unsigned long>(_ledCount), ColorRgb::WHITE);
-//		printLedValues(_last_ledValues);
-		//:TESTING:
-
-		retval = write(_last_ledValues);
-		_lastWriteTime = QDateTime::currentDateTime();
-	}
-	else
-	{
-		// If Device is not ready stop timer
-		this->stopRefreshTimer();
-	}
-	return retval;
-}
-
 void LedDevice::printLedValues(const std::vector<ColorRgb>& ledValues)
 {
 	std::cout << "LedValues [" << ledValues.size() <<"] [";
@@ -271,3 +415,18 @@ void LedDevice::printLedValues(const std::vector<ColorRgb>& ledValues)
 	}
 	std::cout << "]" << std::endl;
 }
+
+QString LedDevice::uint8_t_to_hex_string(const uint8_t * data, const qint64 size, qint64 number) const
+{
+	if ( number <= 0 || number > size)
+	{
+		number = size;
+	}
+
+	QByteArray bytes (reinterpret_cast<const char*>(data), number);
+	#if (QT_VERSION >= QT_VERSION_CHECK(5, 9, 0))
+		return bytes.toHex(':');
+	#else
+		return bytes.toHex();
+	#endif
+}