GitHub-Mirror/qt-openzwave
2
0
Fork 0
mirror of https://github.com/Fishwaldo/qt-openzwave.git synced 2025-03-16 12:01:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

updates and bugfixes

Browse source
This commit is contained in:
Justin Hammond 2019-10-30 19:35:52 +08:00
parent 0d09037006
commit 1489ccee39
13 changed files with 286 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

81
qt-openzwave/include/qt-openzwave/qtozw_pods.h
View file

@ -180,6 +180,87 @@ inline QDataStream &operator>>(QDataStream &ds, NodeStatistics &obj) {
/** \endcond
*/
/** \brief Statistics Relating to Communications with the Network
*/
struct DriverStatistics {
quint32 m_SOFCnt;
quint32 m_ACKWaiting;
quint32 m_readAborts;
quint32 m_badChecksum;
quint32 m_readCnt;
quint32 m_writeCnt;
quint32 m_CANCnt;
quint32 m_NAKCnt;
quint32 m_ACKCnt;
quint32 m_OOFCnt;
quint32 m_dropped;
quint32 m_retries;
quint32 m_callbacks;
quint32 m_badroutes;
quint32 m_noack;
quint32 m_netbusy;
quint32 m_notidle;
quint32 m_txverified;
quint32 m_nondelivery;
quint32 m_routedbusy;
quint32 m_broadcastReadCnt;
quint32 m_broadcastWriteCnt;
};
Q_DECLARE_METATYPE(DriverStatistics)
inline QDataStream &operator<<(QDataStream &ds, const DriverStatistics &obj) {
ds << static_cast<quint32>(obj.m_SOFCnt);
ds << static_cast<quint32>(obj.m_ACKWaiting);
ds << static_cast<quint32>(obj.m_readAborts);
ds << static_cast<quint32>(obj.m_badChecksum);
ds << static_cast<quint32>(obj.m_readCnt);
ds << static_cast<quint32>(obj.m_writeCnt);
ds << static_cast<quint32>(obj.m_CANCnt);
ds << static_cast<quint32>(obj.m_NAKCnt);
ds << static_cast<quint32>(obj.m_ACKCnt);
ds << static_cast<quint32>(obj.m_OOFCnt);
ds << static_cast<quint32>(obj.m_dropped);
ds << static_cast<quint32>(obj.m_retries);
ds << static_cast<quint32>(obj.m_callbacks);
ds << static_cast<quint32>(obj.m_badroutes);
ds << static_cast<quint32>(obj.m_noack);
ds << static_cast<quint32>(obj.m_netbusy);
ds << static_cast<quint32>(obj.m_notidle);
ds << static_cast<quint32>(obj.m_txverified);
ds << static_cast<quint32>(obj.m_nondelivery);
ds << static_cast<quint32>(obj.m_routedbusy);
ds << static_cast<quint32>(obj.m_broadcastReadCnt);
ds << static_cast<quint32>(obj.m_broadcastWriteCnt);
return ds;
}
inline QDataStream &operator>>(QDataStream &ds, DriverStatistics &obj) {
ds >> obj.m_SOFCnt;
ds >> obj.m_ACKWaiting;
ds >> obj.m_readAborts;
ds >> obj.m_badChecksum;
ds >> obj.m_readCnt;
ds >> obj.m_writeCnt;
ds >> obj.m_CANCnt;
ds >> obj.m_NAKCnt;
ds >> obj.m_ACKCnt;
ds >> obj.m_OOFCnt;
ds >> obj.m_dropped;
ds >> obj.m_retries;
ds >> obj.m_callbacks;
ds >> obj.m_badroutes;
ds >> obj.m_noack;
ds >> obj.m_netbusy;
ds >> obj.m_notidle;
ds >> obj.m_txverified;
ds >> obj.m_nondelivery;
ds >> obj.m_routedbusy;
ds >> obj.m_broadcastReadCnt;
ds >> obj.m_broadcastWriteCnt;
return ds;
}
/** \brief Represents a ENUM list for a Single Option
*
* Some of the Options available in the QTOZW_Options class are

4
qt-openzwave/include/qt-openzwave/qtozwmanager.h
View file

@ -108,6 +108,8 @@ public:
QString GetNodeQueryStage(quint8 const _node);
NodeStatistics GetNodeStatistics(quint8 const node);
DriverStatistics GetDriverStatistics();
QVector<quint8> GetNodeNeighbors(quint8 const node);
bool IsNodeFailed(const quint8 _node);
bool checkLatestConfigFileRevision(quint8 const _node);
@ -115,6 +117,8 @@ public:
bool downloadLatestConfigFileRevision(quint8 const _node);
bool downloadLatestMFSRevision();
QString getCommandClassString(quint8 const _cc);
/* Property Methods */
QDir OZWDatabasePath() { return this->m_ozwdatabasepath; }
QDir OZWUserPath() { return this->m_ozwuserpath; }

6
qt-openzwave/include/qt-openzwave/qtozwmanager.rep
View file

@ -124,10 +124,12 @@ class QTOZWManager {
SLOT(QString GetNodeQueryStage(quint8 _node))
SLOT(NodeStatistics GetNodeStatistics(quint8 _node))
SLOT(DriverStatistics GetDriverStatistics())
SLOT(QVector<quint8> GetNodeNeighbors(quint8 const _node))
SLOT(bool IsNodeFailed(quint8 _node))
SLOT(bool checkLatestConfigFileRevision(quint8 const _node))
SLOT(bool checkLatestMFSRevision())
SLOT(bool downloadLatestConfigFileRevision(quint8 const _node))
SLOT(bool downloadLatestMFSRevision())
}
SLOT(QString getCommandClassString(quint8 const _cc))
}

7
qt-openzwave/include/qtozwmanager_p.h
View file

@ -49,6 +49,8 @@
#include "Notification.h"
#include "platform/Log.h"
#include "OZWException.h"
#include "command_classes/CommandClasses.h"
class QTOZWManager_Internal : public QTOZWManagerSimpleSource
@ -99,7 +101,10 @@ public Q_SLOTS:
QString GetNodeQueryStage(quint8 const node);
NodeStatistics GetNodeStatistics(quint8 const node);
DriverStatistics GetDriverStatistics();
QVector<quint8> GetNodeNeighbors(quint8 const node);
bool IsNodeFailed(quint8 const _node);
bool checkLatestConfigFileRevision(quint8 const _node);
@ -107,6 +112,8 @@ public Q_SLOTS:
bool downloadLatestConfigFileRevision(quint8 const _node);
bool downloadLatestMFSRevision();
QString getCommandClassString(quint8 const _cc);
/* these slots are called from our OZWNotification Class. Applications should not call them */
void pvt_valueAdded(quint64 vidKey);

15
qt-openzwave/source/qtozwmanager.cpp
View file

@ -373,6 +373,15 @@ QString QTOZWManager::GetNodeQueryStage(const quint8 _node) {
NodeStatistics QTOZWManager::GetNodeStatistics(const quint8 _node) {
CALL_DPTR_RTN(GetNodeStatistics(_node), NodeStatistics);
}
DriverStatistics QTOZWManager::GetDriverStatistics() {
CALL_DPTR_RTN(GetDriverStatistics(), DriverStatistics);
}
QVector<quint8> QTOZWManager::GetNodeNeighbors(quint8 const _node) {
CALL_DPTR_RTN(GetNodeNeighbors(_node), QVector<quint8>);
}
bool QTOZWManager::IsNodeFailed(const quint8 _node) {
CALL_DPTR_RTN(IsNodeFailed(_node), bool);
}
@ -389,6 +398,12 @@ bool QTOZWManager::downloadLatestMFSRevision() {
CALL_DPTR_RTN(downloadLatestMFSRevision(), bool);
}
QString QTOZWManager::getCommandClassString(quint8 const _cc) {
CALL_DPTR_RTN(getCommandClassString(_cc), QString);
}
void QTOZWManager::setOZWDatabasePath(QDir path) {
if (path.exists())
this->m_ozwdatabasepath = path;

74
qt-openzwave/source/qtozwmanager_p.cpp
View file

@ -510,6 +510,65 @@ NodeStatistics QTOZWManager_Internal::GetNodeStatistics(quint8 const _node) {
}
DriverStatistics QTOZWManager_Internal::GetDriverStatistics() {
if (!this->checkHomeId())
return DriverStatistics();
try {
OpenZWave::Driver::DriverData dd;
DriverStatistics ds;
this->m_manager->GetDriverStatistics(this->homeId(), &dd);
/* copy */
ds.m_SOFCnt = dd.m_SOFCnt;
ds.m_ACKWaiting = dd.m_ACKWaiting;
ds.m_readAborts = dd.m_readAborts;
ds.m_badChecksum = dd.m_badChecksum;
ds.m_readCnt = dd.m_readCnt;
ds.m_writeCnt = dd.m_writeCnt;
ds.m_CANCnt = dd.m_CANCnt;
ds.m_NAKCnt = dd.m_NAKCnt;
ds.m_ACKCnt = dd.m_ACKCnt;
ds.m_OOFCnt = dd.m_OOFCnt;
ds.m_dropped = dd.m_dropped;
ds.m_retries = dd.m_retries;
ds.m_callbacks = dd.m_callbacks;
ds.m_badroutes = dd.m_badroutes;
ds.m_noack = dd.m_noack;
ds.m_netbusy = dd.m_netbusy;
ds.m_notidle = dd.m_notidle;
ds.m_txverified = dd.m_txverified;
ds.m_nondelivery = dd.m_nondelivery;
ds.m_routedbusy = dd.m_routedbusy;
ds.m_broadcastReadCnt = dd.m_broadcastReadCnt;
ds.m_broadcastWriteCnt = dd.m_broadcastWriteCnt;
return ds;
} catch (OpenZWave::OZWException &e) {
emit this->error(QTOZWManagerErrorCodes::OZWException);
this->setErrorString(e.GetMsg().c_str());
}
return DriverStatistics();
}
QVector<quint8> QTOZWManager_Internal::GetNodeNeighbors(quint8 const _node) {
if (!this->checkHomeId() || !this->checkNodeId(_node))
return QVector<quint8>();
try {
uint8 *neighbours;
int size = this->m_manager->GetNodeNeighbors(this->homeId(), _node, &neighbours);
QVector<quint8> data;
for (int i = 0; i < size; i++) {
data.append(neighbours[i]);
}
delete[] neighbours;
return data;
} catch (OpenZWave::OZWException &e) {
emit this->error(QTOZWManagerErrorCodes::OZWException);
this->setErrorString(e.GetMsg().c_str());
}
return QVector<quint8>();
}
bool QTOZWManager_Internal::IsNodeFailed(quint8 const _node) {
if (!this->checkHomeId() || !this->checkNodeId(_node))
return false;
@ -571,6 +630,21 @@ bool QTOZWManager_Internal::downloadLatestMFSRevision() {
return false;
}
QString QTOZWManager_Internal::getCommandClassString(quint8 const _cc) {
if (!this->checkHomeId())
return QString();
try {
/* TODO: This should be a public method on the Manager Class of OZW */
return OpenZWave::Internal::CC::CommandClasses::GetName(_cc).c_str();
} catch (OpenZWave::OZWException &e) {
emit this->error(QTOZWManagerErrorCodes::OZWException);
this->setErrorString(e.GetMsg().c_str());
}
return QString();
}
QTOZW_Nodes *QTOZWManager_Internal::getNodeModel() {
return static_cast<QTOZW_Nodes *>(this->m_nodeModel);
}

2
qt-openzwave/source/qtozwnodemodel.cpp
View file

@ -203,6 +203,6 @@ int32_t QTOZW_Nodes::getNodeRow(quint8 _node) {
return it.key();
}
}
qCWarning(nodeModel) << "Can't Find NodeID " << _node << " in NodeData";
//qCWarning(nodeModel) << "Can't Find NodeID " << _node << " in NodeData";
return -1;
}

3
qt-openzwave/source/qtozwnodemodel_p.cpp
View file

@ -50,6 +50,7 @@ void QTOZW_Nodes_internal::addNode(quint8 _nodeID)
this->beginInsertRows(QModelIndex(), this->rowCount(QModelIndex()), this->rowCount(QModelIndex()));
this->m_nodeData[this->rowCount(QModelIndex())] = newNode;
this->endInsertRows();
qCInfo(nodeModel) << "Adding Node " << _nodeID << "At Row " << this->getNodeRow(_nodeID);
}
void QTOZW_Nodes_internal::setNodeData(quint8 _nodeID, QTOZW_Nodes::NodeColumns column, QVariant data, bool transaction)
@ -64,6 +65,8 @@ void QTOZW_Nodes_internal::setNodeData(quint8 _nodeID, QTOZW_Nodes::NodeColumns
QVector<int> roles;
roles << Qt::DisplayRole;
if (!transaction) this->dataChanged(this->createIndex(row, column), this->createIndex(row, column), roles);
qCDebug(nodeModel) << "setNodeData " << _nodeID << ": " << column << ":" << data << " Transaction:" << transaction;
}
}

2
qt-openzwave/source/qtozwvalueidmodel.cpp
View file

@ -207,6 +207,6 @@ int32_t QTOZW_ValueIds::getValueRow(quint64 _vidKey) {
return it.key();
}
}
qCWarning(valueModel) << "Can't Find ValueID " << _vidKey << " in valueData";
//qCWarning(valueModel) << "Can't Find ValueID " << _vidKey << " in valueData";
return -1;
}

2
qt-ozwdaemon/main.cpp
View file

@ -69,7 +69,7 @@ int main(int argc, char *argv[])
settings.setValue("MQTTPort", parser.value(MQTTPort).toInt());
}
#if 1
#if 0
QLoggingCategory::setFilterRules("qt.remoteobjects.debug=true\n"
"qt.remoteobjects.warning=true\n"
"qt.remoteobjects.models.debug=true\n"

95
qt-ozwdaemon/mqttpublisher.cpp
View file

@ -15,6 +15,9 @@ QVariant mqttNodeModel::getNodeData(quint8 node, NodeColumns col) {
bool mqttNodeModel::populateJsonObject(QJsonObject *jsonobject, quint8 node, QTOZWManager *mgr) {
for (int i = 0; i < this->columnCount(QModelIndex()); i++) {
QVariant data = this->getNodeData(node, static_cast<NodeColumns>(i));
if (data.type() == QVariant::Invalid) {
continue;
}
switch (static_cast<NodeColumns>(i)) {
case NodeColumns::NodeFlags: {
QBitArray flag = data.toBitArray();
@ -52,7 +55,15 @@ bool mqttNodeModel::populateJsonObject(QJsonObject *jsonobject, quint8 node, QTO
metadata.insert("ProductPicBase64", QString(mgr->GetMetaDataProductPic(node).toBase64()));
jsonobject->insert("MetaData", metadata);
}
qDebug() << jsonobject;
/* Neihbors */
QVector<quint8> neighbors = mgr->GetNodeNeighbors(node);
if (neighbors.size() > 0) {
QJsonArray N;
for (int i = 0; i < neighbors.count(); i++) {
N.append(neighbors[i]);
}
jsonobject->insert("Neighbors", N);
}
return true;
}
@ -81,6 +92,21 @@ bool mqttValueIDModel::populateJsonObject(QJsonObject *jsonobject, quint64 vidKe
jsonobject->insert("Value", this->encodeValue(vidKey));
break;
}
case Genre: {
QMetaEnum metaEnum = QMetaEnum::fromType<ValueIdGenres>();
jsonobject->insert("Genre", metaEnum.valueToKey(data.toInt()));
break;
}
case Type: {
QMetaEnum metaEnum = QMetaEnum::fromType<ValueIdTypes>();
jsonobject->insert("Type", metaEnum.valueToKey(data.toInt()));
break;
}
case CommandClass: {
jsonobject->insert("CommandClass", mgr->getCommandClassString(data.toInt()));
break;
}
default: {
QMetaEnum metaEnum = QMetaEnum::fromType<ValueIdColumns>();
if (data.type() == QMetaType::QString) {
@ -105,7 +131,6 @@ bool mqttValueIDModel::populateJsonObject(QJsonObject *jsonobject, quint64 vidKe
}
qDebug() << jsonobject;
return true;
}
@ -124,8 +149,10 @@ QJsonValue mqttValueIDModel::encodeValue(quint64 vidKey) {
value = data.toDouble();
} else if (data.type() == QMetaType::ULongLong) {
value = static_cast<qint64>(data.toULongLong());
} else if (data.type() == QMetaType::Short) {
value = static_cast<qint16>(data.toInt());
} else {
qWarning() << "Can't Convert " << data.type() << " to store in JsonObject: " << vidKey;
qWarning() << "Can't Convert " << data.type() << " to store in JsonObject: " << vidKey << this->getValueData(vidKey, mqttValueIDModel::ValueIdColumns::Label).toString() << this->getValueData(vidKey, mqttValueIDModel::ValueIdColumns::Type);
}
return value;
}
@ -155,6 +182,43 @@ mqttpublisher::mqttpublisher(QObject *parent) : QObject(parent)
willMsg["Status"] = "Offline";
this->m_client->setWillMessage(QJsonDocument(willMsg).toJson());
this->m_client->setWillRetain(true);
connect(&this->m_statsTimer, &QTimer::timeout, this, &mqttpublisher::doStats);
}
void mqttpublisher::doStats() {
QJsonObject stats;
if (!this->m_qtozwdeamon) {
return;
}
QTOZWManager *manager = this->m_qtozwdeamon->getManager();
DriverStatistics ds = manager->GetDriverStatistics();
QJsonObject dsjson;
dsjson["SOFCnt"] = static_cast<int>(ds.m_SOFCnt);
dsjson["ACKWaiting"] = static_cast<int>(ds.m_ACKWaiting);
dsjson["readAborts"] = static_cast<int>(ds.m_readAborts);
dsjson["badChecksum"] = static_cast<int>(ds.m_badChecksum);
dsjson["readCnt"] = static_cast<int>(ds.m_readCnt);
dsjson["writeCnt"] = static_cast<int>(ds.m_writeCnt);
dsjson["CANCnt"] = static_cast<int>(ds.m_CANCnt);
dsjson["NAKCnt"] = static_cast<int>(ds.m_NAKCnt);
dsjson["ACKCnt"] = static_cast<int>(ds.m_ACKCnt);
dsjson["OOFCnt"] = static_cast<int>(ds.m_OOFCnt);
dsjson["dropped"] = static_cast<int>(ds.m_dropped);
dsjson["retries"] = static_cast<int>(ds.m_retries);
dsjson["callbacks"] = static_cast<int>(ds.m_callbacks);
dsjson["badroutes"] = static_cast<int>(ds.m_badroutes);
dsjson["noack"] = static_cast<int>(ds.m_noack);
dsjson["netbusy"] = static_cast<int>(ds.m_netbusy);
dsjson["notidle"] = static_cast<int>(ds.m_notidle);
dsjson["txverified"] = static_cast<int>(ds.m_txverified);
dsjson["nondelivery"] = static_cast<int>(ds.m_nondelivery);
dsjson["routedbusy"] = static_cast<int>(ds.m_routedbusy);
dsjson["broadcastReadCnt"] = static_cast<int>(ds.m_broadcastReadCnt);
dsjson["broadcastWriteCnt"] = static_cast<int>(ds.m_broadcastWriteCnt);
stats["Network"] = dsjson;
this->m_client->publish(QMqttTopicName(getTopic(MQTT_OZW_STATS_TOPIC)), QJsonDocument(stats).toJson(), 0, false);
}
@ -212,6 +276,8 @@ void mqttpublisher::setOZWDaemon(qtozwdaemon *ozwdaemon) {
connect(manager, &QTOZWManager::stopped, this, &mqttpublisher::stopped);
this->m_client->connectToHost();
this->m_statsTimer.start(10000);
}
void mqttpublisher::updateLogStateChange()
@ -237,13 +303,11 @@ void mqttpublisher::handleMessage(const QByteArray &message, const QMqttTopicNam
bool mqttpublisher::sendStatusUpdate() {
qDebug() << QJsonDocument(this->m_ozwstatus).toJson();
this->m_client->publish(QMqttTopicName(getTopic(MQTT_OZW_STATUS_TOPIC)), QJsonDocument(this->m_ozwstatus).toJson(), 0, true);
return true;
}
bool mqttpublisher::sendNodeUpdate(quint8 node) {
qDebug() << this->m_nodeModel->getNodeData(node, QTOZW_Nodes::NodeProductName);
this->m_client->publish(QMqttTopicName(getNodeTopic(MQTT_OZW_NODE_TOPIC, node)), QJsonDocument(this->m_nodes[node]).toJson(), 0, true);
return true;
}
@ -258,100 +322,121 @@ bool mqttpublisher::sendValueUpdate(quint64 vidKey) {
void mqttpublisher::ready() {
qDebug() << "Publishing Event ready:";
this->m_ozwstatus["Status"] = "Ready";
this->sendStatusUpdate();
}
void mqttpublisher::valueAdded(quint64 vidKey) {
qDebug() << "Publishing Event valueAdded:" << vidKey;
this->m_valueModel->populateJsonObject(&this->m_values[vidKey], vidKey, this->m_qtozwdeamon->getManager());
this->m_values[vidKey]["Event"] = "valueAdded";
this->sendValueUpdate(vidKey);
}
void mqttpublisher::valueRemoved(quint64 vidKey) {
qDebug() << "Publishing Event valueRemoved:" << vidKey;
this->m_values[vidKey]["Event"] = "valueRemoved";
this->sendValueUpdate(vidKey);
}
void mqttpublisher::valueChanged(quint64 vidKey) {
qDebug() << "Publishing Event valueChanged:" << vidKey;
this->m_values[vidKey]["Event"] = "valueChanged";
this->m_values[vidKey]["Value"] = this->m_valueModel->encodeValue(vidKey);
this->sendValueUpdate(vidKey);
}
void mqttpublisher::valueRefreshed(quint64 vidKey) {
qDebug() << "Publishing Event valueRefreshed:" << vidKey;
this->m_values[vidKey]["Event"] = "valueRefreshed";
this->m_values[vidKey]["Value"] = this->m_valueModel->encodeValue(vidKey);
this->sendValueUpdate(vidKey);
}
void mqttpublisher::nodeNew(quint8 node) {
qDebug() << "Publishing Event NodeNew:" << node;
this->m_nodeModel->populateJsonObject(&this->m_nodes[node], node, this->m_qtozwdeamon->getManager());
this->m_nodes[node]["Event"] = "nodeNew";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeAdded(quint8 node) {
qDebug() << "Publishing Event NodeAdded:" << node;
this->m_nodeModel->populateJsonObject(&this->m_nodes[node], node, this->m_qtozwdeamon->getManager());
this->m_nodes[node]["Event"] = "nodeAdded";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeRemoved(quint8 node) {
qDebug() << "Publishing Event nodeRemoved:" << node;
this->m_nodes[node]["Event"] = "nodeRemoved";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeReset(quint8 node) {
qDebug() << "Publishing Event nodeReset:" << node;
this->m_nodes[node]["Event"] = "nodeReset";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeNaming(quint8 node) {
qDebug() << "Publishing Event nodeNaming:" << node;
this->m_nodes[node]["Event"] = "nodeNaming";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeEvent(quint8 node, quint8 event) {
qDebug() << "Publishing Event nodeEvent:" << node;
this->m_nodes[node]["Event"] = "nodeEvent";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeProtocolInfo(quint8 node) {
qDebug() << "Publishing Event nodeProtocolInfo:" << node;
this->m_nodeModel->populateJsonObject(&this->m_nodes[node], node, this->m_qtozwdeamon->getManager());
this->m_nodes[node]["Event"] = "nodeProtocolInfo";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeEssentialNodeQueriesComplete(quint8 node) {
qDebug() << "Publishing Event nodeEssentialNodeQueriesComplete:" << node;
this->m_nodeModel->populateJsonObject(&this->m_nodes[node], node, this->m_qtozwdeamon->getManager());
this->m_nodes[node]["Event"] = "nodeEssentialNodeQueriesComplete";
this->sendNodeUpdate(node);
}
void mqttpublisher::nodeQueriesComplete(quint8 node) {
qDebug() << "Publishing Event nodeQueriesComplete:" << node;
this->m_nodeModel->populateJsonObject(&this->m_nodes[node], node, this->m_qtozwdeamon->getManager());
this->m_nodes[node]["Event"] = "nodeQueriesComplete";
this->sendNodeUpdate(node);
}
void mqttpublisher::driverReady(quint32 homeID) {
qDebug() << "Publishing Event driverReady:" << homeID;
this->m_ozwstatus["Status"] = "driverReady";
this->m_ozwstatus["homeID"] = QJsonValue(static_cast<int>(homeID));
this->sendStatusUpdate();
}
void mqttpublisher::driverFailed(quint32 homeID) {
qDebug() << "Publishing Event driverFailed:" << homeID;
this->m_ozwstatus["Status"] = "driverFailed";
this->m_ozwstatus["homeID"] = QJsonValue(static_cast<int>(homeID));
this->sendStatusUpdate();
}
void mqttpublisher::driverReset(quint32 homeID) {
qDebug() << "Publishing Event driverReset:" << homeID;
this->m_ozwstatus["Status"] = "driverReset";
this->m_ozwstatus["homeID"] = QJsonValue(static_cast<int>(homeID));
this->sendStatusUpdate();
}
void mqttpublisher::driverRemoved(quint32 homeID) {
qDebug() << "Publishing Event driverRemoved:" << homeID;
this->m_ozwstatus["Status"] = "driverRemoved";
this->m_ozwstatus["homeID"] = QJsonValue(static_cast<int>(homeID));
this->sendStatusUpdate();
}
void mqttpublisher::driverAllNodesQueriedSomeDead() {
qDebug() << "Publishing Event driverAllNodesQueriedSomeDead:" ;
this->m_ozwstatus["Status"] = "driverAllNodesQueriedSomeDead";
this->sendStatusUpdate();
}
void mqttpublisher::driverAllNodesQueried() {
qDebug() << "Publishing Event driverAllNodesQueried:" ;
this->m_ozwstatus["Status"] = "driverAllNodesQueried";
this->sendStatusUpdate();
}
void mqttpublisher::driverAwakeNodesQueried() {
qDebug() << "Publishing Event driverAwakeNodesQueried:" ;
this->m_ozwstatus["Status"] = "driverAwakeNodesQueried";
this->sendStatusUpdate();
}

4
qt-ozwdaemon/mqttpublisher.h
View file

@ -6,11 +6,13 @@
#include <QtMqtt/QMqttClient>
#include <QJsonDocument>
#include <QJsonObject>
#include <QTimer>
#include "qtozwdaemon.h"
#define MQTT_OZW_TOP_TOPIC "/OpenZWave/%1/"
#define MQTT_OZW_STATS_TOPIC "statistics"
#define MQTT_OZW_STATUS_TOPIC "status/"
#define MQTT_OZW_NODE_TOPIC "node/%1/"
#define MQTT_OZW_VID_TOPIC "node/%1/%2/"
@ -80,6 +82,7 @@ private slots:
void updateLogStateChange();
void brokerDisconnected();
void handleMessage(const QByteArray &message, const QMqttTopicName &topic = QMqttTopicName());
void doStats();
private:
@ -99,6 +102,7 @@ private:
QMqttClient *m_client;
qtozwdaemon *m_qtozwdeamon;
QSettings settings;
QTimer m_statsTimer;
};
#endif // MQTTPUBLISHER_H

1
setenv.sh
View file

@ -1 +1,2 @@
export DYLD_LIBRARY_PATH="$DYLD_LIBRARY_PATH:`pwd`/qt-openzwave"
export LD_LIBRARY_PATH="/home/fish/workspace/open-zwave/:/home/fish/workspace/qt-openzwave/qt-openzwave/:/home/fish/workspace/qt-openzwave/qt-openzwavedatabase/"