ETM-Schurig/powersync-core
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Continue node api development

Browse Source
This commit is contained in:
Simon Stürz 2021-04-26 13:29:27 +02:00 committed by Michael Zanetti
parent a0169b179d
commit eef44c78c6
4 changed files with 541 additions and 476 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

977
libnymea-core/jsonrpc/zigbeehandler.cpp
View File

@ -1,463 +1,514 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright 2013 - 2020, nymea GmbH * Copyright 2013 - 2020, nymea GmbH
* Contact: contact@nymea.io * Contact: contact@nymea.io
* *
* This file is part of nymea. * This file is part of nymea.
* This project including source code and documentation is protected by * This project including source code and documentation is protected by
* copyright law, and remains the property of nymea GmbH. All rights, including * copyright law, and remains the property of nymea GmbH. All rights, including
* reproduction, publication, editing and translation, are reserved. The use of * reproduction, publication, editing and translation, are reserved. The use of
* this project is subject to the terms of a license agreement to be concluded * this project is subject to the terms of a license agreement to be concluded
* with nymea GmbH in accordance with the terms of use of nymea GmbH, available * with nymea GmbH in accordance with the terms of use of nymea GmbH, available
* under https://nymea.io/license * under https://nymea.io/license
* *
* GNU Lesser General Public License Usage * GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the * Alternatively, this project may be redistributed and/or modified under the
* terms of the GNU Lesser General Public License as published by the Free * terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; version 3. This project is distributed in the hope that * Software Foundation; version 3. This project is distributed in the hope that
* it will be useful, but WITHOUT ANY WARRANTY; without even the implied * it will be useful, but WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public License * You should have received a copy of the GNU Lesser General Public License
* along with this project. If not, see <https://www.gnu.org/licenses/>. * along with this project. If not, see <https://www.gnu.org/licenses/>.
* *
* For any further details and any questions please contact us under * For any further details and any questions please contact us under
* contact@nymea.io or see our FAQ/Licensing Information on * contact@nymea.io or see our FAQ/Licensing Information on
* https://nymea.io/license/faq * https://nymea.io/license/faq
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "zigbeehandler.h" #include "zigbeehandler.h"
#include "zigbee/zigbeemanager.h" #include "zigbee/zigbeemanager.h"
#include "zigbee/zigbeeadapters.h" #include "zigbee/zigbeeadapters.h"
#include "loggingcategories.h" #include "loggingcategories.h"
#include <zigbeeuartadapter.h> #include <zigbeeuartadapter.h>
namespace nymeaserver { namespace nymeaserver {
ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) : ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) :
JsonHandler(parent), JsonHandler(parent),
m_zigbeeManager(zigbeeManager) m_zigbeeManager(zigbeeManager)
{ {
qRegisterMetaType<nymeaserver::ZigbeeAdapter>(); qRegisterMetaType<nymeaserver::ZigbeeAdapter>();
registerEnum<ZigbeeManager::ZigbeeNetworkState>(); registerEnum<ZigbeeManager::ZigbeeNetworkState>();
registerEnum<ZigbeeManager::ZigbeeError>(); registerEnum<ZigbeeManager::ZigbeeError>();
registerEnum<ZigbeeManager::ZigbeeNodeType>(); registerEnum<ZigbeeManager::ZigbeeNodeType>();
registerEnum<ZigbeeManager::ZigbeeNodeState>(); registerEnum<ZigbeeManager::ZigbeeNodeState>();
registerObject<ZigbeeAdapter, ZigbeeAdapters>(); registerObject<ZigbeeAdapter, ZigbeeAdapters>();
// Network object describing a network instance // Network object describing a network instance
QVariantMap zigbeeNetworkDescription; QVariantMap zigbeeNetworkDescription;
zigbeeNetworkDescription.insert("networkUuid", enumValueName(Uuid)); zigbeeNetworkDescription.insert("networkUuid", enumValueName(Uuid));
zigbeeNetworkDescription.insert("enabled", enumValueName(Bool)); zigbeeNetworkDescription.insert("enabled", enumValueName(Bool));
zigbeeNetworkDescription.insert("serialPort", enumValueName(String)); zigbeeNetworkDescription.insert("serialPort", enumValueName(String));
zigbeeNetworkDescription.insert("baudRate", enumValueName(Uint)); zigbeeNetworkDescription.insert("baudRate", enumValueName(Uint));
zigbeeNetworkDescription.insert("macAddress", enumValueName(String)); zigbeeNetworkDescription.insert("macAddress", enumValueName(String));
zigbeeNetworkDescription.insert("firmwareVersion", enumValueName(String)); zigbeeNetworkDescription.insert("firmwareVersion", enumValueName(String));
zigbeeNetworkDescription.insert("panId", enumValueName(Uint)); zigbeeNetworkDescription.insert("panId", enumValueName(Uint));
zigbeeNetworkDescription.insert("channel", enumValueName(Uint)); zigbeeNetworkDescription.insert("channel", enumValueName(Uint));
zigbeeNetworkDescription.insert("channelMask", enumValueName(Uint)); zigbeeNetworkDescription.insert("channelMask", enumValueName(Uint));
zigbeeNetworkDescription.insert("permitJoiningEnabled", enumValueName(Bool)); zigbeeNetworkDescription.insert("permitJoiningEnabled", enumValueName(Bool));
zigbeeNetworkDescription.insert("permitJoiningDuration", enumValueName(Uint)); zigbeeNetworkDescription.insert("permitJoiningDuration", enumValueName(Uint));
zigbeeNetworkDescription.insert("permitJoiningRemaining", enumValueName(Uint)); zigbeeNetworkDescription.insert("permitJoiningRemaining", enumValueName(Uint));
zigbeeNetworkDescription.insert("backend", enumValueName(String)); zigbeeNetworkDescription.insert("backend", enumValueName(String));
zigbeeNetworkDescription.insert("networkState", enumRef<ZigbeeManager::ZigbeeNetworkState>()); zigbeeNetworkDescription.insert("networkState", enumRef<ZigbeeManager::ZigbeeNetworkState>());
registerObject("ZigbeeNetwork", zigbeeNetworkDescription); registerObject("ZigbeeNetwork", zigbeeNetworkDescription);
// Zigbee node description // Zigbee node description
QVariantMap zigbeeNodeDescription; QVariantMap zigbeeNodeDescription;
zigbeeNodeDescription.insert("networkUuid", enumValueName(Uuid)); zigbeeNodeDescription.insert("networkUuid", enumValueName(Uuid));
zigbeeNodeDescription.insert("ieeeAddress", enumValueName(String)); zigbeeNodeDescription.insert("ieeeAddress", enumValueName(String));
zigbeeNodeDescription.insert("networkAddress", enumValueName(Uint)); zigbeeNodeDescription.insert("networkAddress", enumValueName(Uint));
zigbeeNodeDescription.insert("type", enumRef<ZigbeeManager::ZigbeeNodeType>()); zigbeeNodeDescription.insert("type", enumRef<ZigbeeManager::ZigbeeNodeType>());
zigbeeNodeDescription.insert("state", enumRef<ZigbeeManager::ZigbeeNodeState>()); zigbeeNodeDescription.insert("state", enumRef<ZigbeeManager::ZigbeeNodeState>());
zigbeeNodeDescription.insert("manufacturer", enumValueName(String)); zigbeeNodeDescription.insert("manufacturer", enumValueName(String));
zigbeeNodeDescription.insert("model", enumValueName(String)); zigbeeNodeDescription.insert("model", enumValueName(String));
zigbeeNodeDescription.insert("version", enumValueName(String)); zigbeeNodeDescription.insert("version", enumValueName(String));
zigbeeNodeDescription.insert("receiverOnWhileIdle", enumValueName(Bool)); zigbeeNodeDescription.insert("receiverOnWhileIdle", enumValueName(Bool));
zigbeeNodeDescription.insert("reachable", enumValueName(Bool)); zigbeeNodeDescription.insert("reachable", enumValueName(Bool));
zigbeeNodeDescription.insert("lqi", enumValueName(Uint)); zigbeeNodeDescription.insert("lqi", enumValueName(Uint));
zigbeeNodeDescription.insert("lastSeen", enumValueName(Uint)); zigbeeNodeDescription.insert("lastSeen", enumValueName(Uint));
registerObject("ZigbeeNode", zigbeeNodeDescription); registerObject("ZigbeeNode", zigbeeNodeDescription);
QVariantMap params, returns; QVariantMap params, returns;
QString description; QString description;
// GetAvailableBackends // GetAvailableBackends
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Get the list of available ZigBee backends."; description = "Get the list of available ZigBee backends.";
returns.insert("backends", QVariantList() << enumValueName(String)); returns.insert("backends", QVariantList() << enumValueName(String));
registerMethod("GetAvailableBackends", description, params, returns); registerMethod("GetAvailableBackends", description, params, returns);
// GetAdapters // GetAdapters
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Get the list of available ZigBee adapters and serial ports in order to set up the ZigBee network " description = "Get the list of available ZigBee adapters and serial ports in order to set up the ZigBee network "
"on the desired interface. The \'serialPort\' property can be used as unique identifier for an adapter. " "on the desired interface. The \'serialPort\' property can be used as unique identifier for an adapter. "
"If an adapter hardware has been recognized as a well known ZigBee adapter, " "If an adapter hardware has been recognized as a well known ZigBee adapter, "
"the \'hardwareRecognized\' property will be true and the \'baudRate\' and \'backend\' " "the \'hardwareRecognized\' property will be true and the \'baudRate\' and \'backend\' "
"configurations can be used as they where given, otherwise the user might set the backend " "configurations can be used as they where given, otherwise the user might set the backend "
"and baud rate manually. The available backends can be fetched using the GetAvailableBackends method."; "and baud rate manually. The available backends can be fetched using the GetAvailableBackends method.";
returns.insert("adapters", objectRef<ZigbeeAdapters>()); returns.insert("adapters", objectRef<ZigbeeAdapters>());
registerMethod("GetAdapters", description, params, returns); registerMethod("GetAdapters", description, params, returns);
// AdapterAdded notification // AdapterAdded notification
params.clear(); params.clear();
description = "Emitted whenever a new ZigBee adapter or serial port has been detected in the system."; description = "Emitted whenever a new ZigBee adapter or serial port has been detected in the system.";
params.insert("adapter", objectRef<ZigbeeAdapter>()); params.insert("adapter", objectRef<ZigbeeAdapter>());
registerNotification("AdapterAdded", description, params); registerNotification("AdapterAdded", description, params);
// AdapterRemoved notification // AdapterRemoved notification
params.clear(); params.clear();
description = "Emitted whenever a ZigBee adapter or serial port has been removed from the system (i.e. unplugged)."; description = "Emitted whenever a ZigBee adapter or serial port has been removed from the system (i.e. unplugged).";
params.insert("adapter", objectRef<ZigbeeAdapter>()); params.insert("adapter", objectRef<ZigbeeAdapter>());
registerNotification("AdapterRemoved", description, params); registerNotification("AdapterRemoved", description, params);
// GetNetworks // GetNetworks
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Returns the list of configured ZigBee networks in the system."; description = "Returns the list of configured ZigBee networks in the system.";
returns.insert("zigbeeNetworks", QVariantList() << objectRef("ZigbeeNetwork")); returns.insert("zigbeeNetworks", QVariantList() << objectRef("ZigbeeNetwork"));
registerMethod("GetNetworks", description, params, returns); registerMethod("GetNetworks", description, params, returns);
// AddNetwork // AddNetwork
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Create a new ZigBee network for the given \'serialPort\', \'baudRate\' and \'backend\'. " description = "Create a new ZigBee network for the given \'serialPort\', \'baudRate\' and \'backend\'. "
"The serial ports can be fetched from the available adapters. See \'GetAdapters\' for more information. " "The serial ports can be fetched from the available adapters. See \'GetAdapters\' for more information. "
"The available backends can be fetched using the \'GetAvailableBackends\' method."; "The available backends can be fetched using the \'GetAvailableBackends\' method.";
params.insert("serialPort", enumValueName(String)); params.insert("serialPort", enumValueName(String));
params.insert("baudRate", enumValueName(Uint)); params.insert("baudRate", enumValueName(Uint));
params.insert("backend", enumValueName(String)); params.insert("backend", enumValueName(String));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
returns.insert("o:networkUuid", enumValueName(Uuid)); returns.insert("o:networkUuid", enumValueName(Uuid));
registerMethod("AddNetwork", description, params, returns); registerMethod("AddNetwork", description, params, returns);
// RemoveNetwork // RemoveNetwork
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Remove the ZigBee network with the given network uuid."; description = "Remove the ZigBee network with the given network uuid.";
params.insert("networkUuid", enumValueName(Uuid)); params.insert("networkUuid", enumValueName(Uuid));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("RemoveNetwork", description, params, returns); registerMethod("RemoveNetwork", description, params, returns);
// NetworkAdded notification // NetworkAdded notification
params.clear(); params.clear();
description = "Emitted whenever a new ZigBee network has been added."; description = "Emitted whenever a new ZigBee network has been added.";
params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork")); params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork"));
registerNotification("NetworkAdded", description, params); registerNotification("NetworkAdded", description, params);
// NetworkRemoved notification // NetworkRemoved notification
params.clear(); params.clear();
description = "Emitted whenever a new ZigBee network has been removed."; description = "Emitted whenever a new ZigBee network has been removed.";
params.insert("networkUuid", enumValueName(Uuid)); params.insert("networkUuid", enumValueName(Uuid));
registerNotification("NetworkRemoved", description, params); registerNotification("NetworkRemoved", description, params);
// NetworkChanged notification // NetworkChanged notification
params.clear(); params.clear();
description = "Emitted whenever a new ZigBee network has changed."; description = "Emitted whenever a new ZigBee network has changed.";
params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork")); params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork"));
registerNotification("NetworkChanged", description, params); registerNotification("NetworkChanged", description, params);
// FactoryResetNetwork // FactoryResetNetwork
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Factory reset the network with the given \'networkUuid\'. The network does not have " description = "Factory reset the network with the given \'networkUuid\'. The network does not have "
"to be online for this procedure, and all associated nodes and things will be removed permanently."; "to be online for this procedure, and all associated nodes and things will be removed permanently.";
params.insert("networkUuid", enumValueName(Uuid)); params.insert("networkUuid", enumValueName(Uuid));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("FactoryResetNetwork", description, params, returns); registerMethod("FactoryResetNetwork", description, params, returns);
// SetPermitJoin // SetPermitJoin
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Allow or deny nodes to join the network with the given \'networkUuid\' for a specific \'duration\' in seconds. " description = "Allow or deny nodes to join the network with the given \'networkUuid\' for a specific \'duration\' in seconds. "
"The duration value has to be between 0 and 255 seconds. The \'permitJoinDuration\' property of ZigBee network " "The duration value has to be between 0 and 255 seconds. The \'permitJoinDuration\' property of ZigBee network "
"object indicates how long permit has been enabled and the \'permitJoiningRemaining\' indicates the rest of the time. " "object indicates how long permit has been enabled and the \'permitJoiningRemaining\' indicates the rest of the time. "
"Those values can be used to show a countdown or progressbar. This method can be recalled for resetting the timeout. " "Those values can be used to show a countdown or progressbar. This method can be recalled for resetting the timeout. "
"If the duration is set to 0 seconds, joining will be disabled immediatly for the entire network. " "If the duration is set to 0 seconds, joining will be disabled immediatly for the entire network. "
"The \'shortAddress\' is optional and defaults to the broadcast address 0xfffc for all routers in the network. " "The \'shortAddress\' is optional and defaults to the broadcast address 0xfffc for all routers in the network. "
"If the short address matches the address of a router node in the network, only that specific router will " "If the short address matches the address of a router node in the network, only that specific router will "
"be able to allow new nodes to join the network. A new node will join to the router with the best link quality index (LQI)."; "be able to allow new nodes to join the network. A new node will join to the router with the best link quality index (LQI).";
params.insert("networkUuid", enumValueName(Uuid)); params.insert("networkUuid", enumValueName(Uuid));
params.insert("duration", enumValueName(Uint)); params.insert("duration", enumValueName(Uint));
params.insert("o:shortAddress", enumValueName(Uint)); params.insert("o:shortAddress", enumValueName(Uint));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("SetPermitJoin", description, params, returns); registerMethod("SetPermitJoin", description, params, returns);
// GetNodes // GetNodes
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Returns the list of ZigBee nodes from the network the given \'networkUuid\' in the system."; description = "Returns the list of ZigBee nodes from the network the given \'networkUuid\' in the system.";
params.insert("networkUuid", enumValueName(Uuid)); params.insert("networkUuid", enumValueName(Uuid));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
returns.insert("o:zigbeeNodes", QVariantList() << objectRef("ZigbeeNode")); returns.insert("o:zigbeeNodes", QVariantList() << objectRef("ZigbeeNode"));
registerMethod("GetNodes", description, params, returns); registerMethod("GetNodes", description, params, returns);
// RemoveNode // RemoveNode
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Remove a ZigBee node with the given \'ieeeAddress\' from the network with the given \'networkUuid\'. " description = "Remove a ZigBee node with the given \'ieeeAddress\' from the network with the given \'networkUuid\'. "
"If there is a thing configured for this node, also the thing will be removed from the system. " "If there is a thing configured for this node, also the thing will be removed from the system. "
"The coordinator node cannot be removed."; "The coordinator node cannot be removed.";
params.insert("networkUuid", enumValueName(Uuid)); params.insert("networkUuid", enumValueName(Uuid));
params.insert("ieeeAddress", enumValueName(String)); params.insert("ieeeAddress", enumValueName(String));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("RemoveNode", description, params, returns); registerMethod("RemoveNode", description, params, returns);
connect(m_zigbeeManager, &ZigbeeManager::availableAdapterAdded, this, [this](const ZigbeeAdapter &adapter){ // NodeAdded
QVariantMap params; params.clear();
params.insert("adapter", pack(adapter)); description = "Emitted whenever a new ZigBee node has joined the network with the given \'networkUuid\'.";
emit AdapterAdded(params); params.insert("networkUuid", enumValueName(Uuid));
}); params.insert("zigbeeNode", objectRef("ZigbeeNode"));
registerNotification("NodeAdded", description, params);
connect(m_zigbeeManager, &ZigbeeManager::availableAdapterRemoved, this, [this](const ZigbeeAdapter &adapter){
QVariantMap params; // NodeRemoved
params.insert("adapter", pack(adapter)); params.clear();
emit AdapterRemoved(params); description = "Emitted whenever a ZigBee node has removed from the network with the given \'networkUuid\'.";
}); params.insert("networkUuid", enumValueName(Uuid));
params.insert("zigbeeNode", objectRef("ZigbeeNode"));
connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkAdded, this, [this](ZigbeeNetwork *network){ registerNotification("NodeRemoved", description, params);
QVariantMap params;
params.insert("zigbeeNetwork", packNetwork(network)); // NodeChanged
emit NetworkAdded(params); params.clear();
}); description = "Emitted whenever a ZigBee node has changed.";
params.insert("networkUuid", enumValueName(Uuid));
connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkChanged, this, [this](ZigbeeNetwork *network){ params.insert("zigbeeNode", objectRef("ZigbeeNode"));
QVariantMap params; registerNotification("NodeChanged", description, params);
params.insert("zigbeeNetwork", packNetwork(network));
emit NetworkChanged(params); connect(m_zigbeeManager, &ZigbeeManager::availableAdapterAdded, this, [this](const ZigbeeAdapter &adapter){
}); QVariantMap params;
params.insert("adapter", pack(adapter));
connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkRemoved, this, [this](const QUuid &networkUuid){ emit AdapterAdded(params);
QVariantMap params; });
params.insert("networkUuid", networkUuid);
emit NetworkRemoved(params); connect(m_zigbeeManager, &ZigbeeManager::availableAdapterRemoved, this, [this](const ZigbeeAdapter &adapter){
}); QVariantMap params;
} params.insert("adapter", pack(adapter));
emit AdapterRemoved(params);
QString ZigbeeHandler::name() const });
{
return "Zigbee"; connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkAdded, this, [this](ZigbeeNetwork *network){
} QVariantMap params;
params.insert("zigbeeNetwork", packNetwork(network));
JsonReply *ZigbeeHandler::GetAvailableBackends(const QVariantMap &params) emit NetworkAdded(params);
{ });
Q_UNUSED(params)
connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkChanged, this, [this](ZigbeeNetwork *network){
QVariantMap returnMap; QVariantMap params;
QVariantList backendsList; params.insert("zigbeeNetwork", packNetwork(network));
foreach (const QString &backendName, ZigbeeAdapter::backendNames().values()) emit NetworkChanged(params);
backendsList << backendName; });
returnMap.insert("backends", backendsList); connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkRemoved, this, [this](const QUuid &networkUuid){
return createReply(returnMap); QVariantMap params;
} params.insert("networkUuid", networkUuid);
emit NetworkRemoved(params);
JsonReply *ZigbeeHandler::GetAdapters(const QVariantMap &params) });
{
Q_UNUSED(params) connect(m_zigbeeManager, &ZigbeeManager::nodeJoined, this, &ZigbeeHandler::onNodeJoined);
connect(m_zigbeeManager, &ZigbeeManager::nodeAdded, this, &ZigbeeHandler::onNodeAdded);
QVariantMap returnMap; connect(m_zigbeeManager, &ZigbeeManager::nodeRemoved, this, &ZigbeeHandler::onNodeRemoved);
QVariantList adapterList;
foreach (const ZigbeeAdapter &adapter, m_zigbeeManager->availableAdapters()) { }
adapterList << pack(adapter);
} QString ZigbeeHandler::name() const
returnMap.insert("adapters", adapterList); {
return createReply(returnMap); return "Zigbee";
} }
JsonReply *ZigbeeHandler::AddNetwork(const QVariantMap &params) JsonReply *ZigbeeHandler::GetAvailableBackends(const QVariantMap &params)
{ {
QVariantMap returnMap; Q_UNUSED(params)
QString serialPort = params.value("serialPort").toString(); QVariantMap returnMap;
uint baudRate = params.value("baudRate").toUInt(); QVariantList backendsList;
QString backendString = params.value("backend").toString(); foreach (const QString &backendName, ZigbeeAdapter::backendNames().values()) {
if (!ZigbeeAdapter::backendNames().values().contains(backendString)) { backendsList << backendName;
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorUnknownBackend)); }
return createReply(returnMap); returnMap.insert("backends", backendsList);
} return createReply(returnMap);
}
QPair<ZigbeeManager::ZigbeeError, QUuid> result = m_zigbeeManager->createZigbeeNetwork(serialPort, baudRate, ZigbeeAdapter::backendNames().key(backendString));
if (result.first == ZigbeeManager::ZigbeeErrorNoError) { JsonReply *ZigbeeHandler::GetAdapters(const QVariantMap &params)
returnMap.insert("networkUuid", result.second); {
} Q_UNUSED(params)
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(result.first));
return createReply(returnMap); QVariantMap returnMap;
} QVariantList adapterList;
foreach (const ZigbeeAdapter &adapter, m_zigbeeManager->availableAdapters()) {
JsonReply *ZigbeeHandler::RemoveNetwork(const QVariantMap &params) adapterList << pack(adapter);
{ }
QUuid networkUuid = params.value("networkUuid").toUuid(); returnMap.insert("adapters", adapterList);
ZigbeeManager::ZigbeeError error = m_zigbeeManager->removeZigbeeNetwork(networkUuid); return createReply(returnMap);
QVariantMap returnMap; }
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
return createReply(returnMap); JsonReply *ZigbeeHandler::AddNetwork(const QVariantMap &params)
} {
QVariantMap returnMap;
JsonReply *ZigbeeHandler::FactoryResetNetwork(const QVariantMap &params)
{ QString serialPort = params.value("serialPort").toString();
QUuid networkUuid = params.value("networkUuid").toUuid(); uint baudRate = params.value("baudRate").toUInt();
ZigbeeManager::ZigbeeError error = m_zigbeeManager->factoryResetNetwork(networkUuid); QString backendString = params.value("backend").toString();
QVariantMap returnMap; if (!ZigbeeAdapter::backendNames().values().contains(backendString)) {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error)); returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorUnknownBackend));
return createReply(returnMap); return createReply(returnMap);
} }
JsonReply *ZigbeeHandler::SetPermitJoin(const QVariantMap &params) QPair<ZigbeeManager::ZigbeeError, QUuid> result = m_zigbeeManager->createZigbeeNetwork(serialPort, baudRate, ZigbeeAdapter::backendNames().key(backendString));
{ if (result.first == ZigbeeManager::ZigbeeErrorNoError) {
QUuid networkUuid = params.value("networkUuid").toUuid(); returnMap.insert("networkUuid", result.second);
uint duration = params.value("duration").toUInt(); }
quint16 shortAddress = static_cast<quint16>(Zigbee::BroadcastAddressAllRouters); returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(result.first));
if (params.contains("shortAddress")) { return createReply(returnMap);
shortAddress = static_cast<quint16>(params.value("shortAddress").toUInt()); }
}
ZigbeeManager::ZigbeeError error = m_zigbeeManager->setZigbeeNetworkPermitJoin(networkUuid, shortAddress, duration); JsonReply *ZigbeeHandler::RemoveNetwork(const QVariantMap &params)
QVariantMap returnMap; {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error)); QUuid networkUuid = params.value("networkUuid").toUuid();
return createReply(returnMap); ZigbeeManager::ZigbeeError error = m_zigbeeManager->removeZigbeeNetwork(networkUuid);
} QVariantMap returnMap;
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
JsonReply *ZigbeeHandler::GetNodes(const QVariantMap &params) return createReply(returnMap);
{ }
QVariantMap returnMap;
QUuid networkUuid = params.value("networkUuid").toUuid(); JsonReply *ZigbeeHandler::FactoryResetNetwork(const QVariantMap &params)
ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid); {
if (!network) { QUuid networkUuid = params.value("networkUuid").toUuid();
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound)); ZigbeeManager::ZigbeeError error = m_zigbeeManager->factoryResetNetwork(networkUuid);
return createReply(returnMap); QVariantMap returnMap;
} returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
return createReply(returnMap);
QVariantList nodeList; }
foreach (ZigbeeNode *node, network->nodes()) {
nodeList << packNode(node); JsonReply *ZigbeeHandler::SetPermitJoin(const QVariantMap &params)
} {
QUuid networkUuid = params.value("networkUuid").toUuid();
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError)); uint duration = params.value("duration").toUInt();
returnMap.insert("zigbeeNodes", nodeList); quint16 shortAddress = static_cast<quint16>(Zigbee::BroadcastAddressAllRouters);
return createReply(returnMap); if (params.contains("shortAddress")) {
} shortAddress = static_cast<quint16>(params.value("shortAddress").toUInt());
}
JsonReply *ZigbeeHandler::RemoveNode(const QVariantMap &params) ZigbeeManager::ZigbeeError error = m_zigbeeManager->setZigbeeNetworkPermitJoin(networkUuid, shortAddress, duration);
{ QVariantMap returnMap;
QVariantMap returnMap; returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
QUuid networkUuid = params.value("networkUuid").toUuid(); return createReply(returnMap);
ZigbeeAddress nodeAddress(params.value("ieeeAddress").toString()); }
ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid);
if (!network) { JsonReply *ZigbeeHandler::GetNodes(const QVariantMap &params)
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound)); {
return createReply(returnMap); QVariantMap returnMap;
} QUuid networkUuid = params.value("networkUuid").toUuid();
ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid);
if (!network->hasNode(nodeAddress)) { if (!network) {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNodeNotFound)); returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound));
return createReply(returnMap); return createReply(returnMap);
} }
ZigbeeNode *node = network->getZigbeeNode(nodeAddress); QVariantList nodeList;
if (node->shortAddress() == 0x0000) { foreach (ZigbeeNode *node, network->nodes()) {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorForbidden)); nodeList << packNode(node);
return createReply(returnMap); }
}
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError));
network->removeZigbeeNode(nodeAddress); returnMap.insert("zigbeeNodes", nodeList);
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError)); return createReply(returnMap);
return createReply(returnMap); }
}
JsonReply *ZigbeeHandler::RemoveNode(const QVariantMap &params)
JsonReply *ZigbeeHandler::GetNetworks(const QVariantMap &params) {
{ QVariantMap returnMap;
Q_UNUSED(params) QUuid networkUuid = params.value("networkUuid").toUuid();
ZigbeeAddress nodeAddress(params.value("ieeeAddress").toString());
QVariantMap returnMap; ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid);
QVariantList networkList; if (!network) {
foreach (ZigbeeNetwork *network, m_zigbeeManager->zigbeeNetworks().values()) { returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound));
networkList.append(packNetwork(network)); return createReply(returnMap);
} }
returnMap.insert("zigbeeNetworks", networkList);
return createReply(returnMap); if (!network->hasNode(nodeAddress)) {
} returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNodeNotFound));
return createReply(returnMap);
QVariantMap ZigbeeHandler::packNetwork(ZigbeeNetwork *network) }
{
QVariantMap networkMap; ZigbeeNode *node = network->getZigbeeNode(nodeAddress);
networkMap.insert("networkUuid", network->networkUuid()); if (node->shortAddress() == 0x0000) {
networkMap.insert("enabled", true); // FIXME: set actual value once supported returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorForbidden));
networkMap.insert("serialPort", network->serialPortName()); return createReply(returnMap);
networkMap.insert("baudRate", network->serialBaudrate()); }
networkMap.insert("macAddress", network->macAddress().toString());
networkMap.insert("firmwareVersion", network->firmwareVersion()); network->removeZigbeeNode(nodeAddress);
networkMap.insert("panId", network->panId()); returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError));
networkMap.insert("channel", network->channel()); return createReply(returnMap);
networkMap.insert("channelMask", network->channelMask().toUInt32()); }
networkMap.insert("permitJoiningEnabled", network->permitJoiningEnabled());
networkMap.insert("permitJoiningDuration", network->permitJoiningDuration()); JsonReply *ZigbeeHandler::GetNetworks(const QVariantMap &params)
networkMap.insert("permitJoiningRemaining", network->permitJoiningRemaining()); {
Q_UNUSED(params)
switch (network->backendType()) {
case Zigbee::ZigbeeBackendTypeDeconz: QVariantMap returnMap;
networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeDeconz)); QVariantList networkList;
break; foreach (ZigbeeNetwork *network, m_zigbeeManager->zigbeeNetworks().values()) {
case Zigbee::ZigbeeBackendTypeNxp: networkList.append(packNetwork(network));
networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeNxp)); }
break; returnMap.insert("zigbeeNetworks", networkList);
} return createReply(returnMap);
}
switch (network->state()) {
case ZigbeeNetwork::StateOffline: QVariantMap ZigbeeHandler::packNetwork(ZigbeeNetwork *network)
case ZigbeeNetwork::StateStopping: {
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOffline)); QVariantMap networkMap;
break; networkMap.insert("networkUuid", network->networkUuid());
case ZigbeeNetwork::StateStarting: networkMap.insert("enabled", true); // FIXME: set actual value once supported
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateStarting)); networkMap.insert("serialPort", network->serialPortName());
break; networkMap.insert("baudRate", network->serialBaudrate());
case ZigbeeNetwork::StateRunning: networkMap.insert("macAddress", network->macAddress().toString());
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOnline)); networkMap.insert("firmwareVersion", network->firmwareVersion());
break; networkMap.insert("panId", network->panId());
case ZigbeeNetwork::StateUpdating: networkMap.insert("channel", network->channel());
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateUpdating)); networkMap.insert("channelMask", network->channelMask().toUInt32());
break; networkMap.insert("permitJoiningEnabled", network->permitJoiningEnabled());
case ZigbeeNetwork::StateUninitialized: networkMap.insert("permitJoiningDuration", network->permitJoiningDuration());
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateError)); networkMap.insert("permitJoiningRemaining", network->permitJoiningRemaining());
break;
} switch (network->backendType()) {
case Zigbee::ZigbeeBackendTypeDeconz:
return networkMap; networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeDeconz));
} break;
case Zigbee::ZigbeeBackendTypeNxp:
QVariantMap ZigbeeHandler::packNode(ZigbeeNode *node) networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeNxp));
{ break;
QVariantMap nodeMap; }
nodeMap.insert("networkUuid", node->networkUuid());
nodeMap.insert("ieeeAddress", node->extendedAddress().toString()); switch (network->state()) {
nodeMap.insert("networkAddress", node->shortAddress()); case ZigbeeNetwork::StateOffline:
switch (node->nodeDescriptor().nodeType) { case ZigbeeNetwork::StateStopping:
case ZigbeeDeviceProfile::NodeTypeCoordinator: networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOffline));
nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeCoordinator)); break;
break; case ZigbeeNetwork::StateStarting:
case ZigbeeDeviceProfile::NodeTypeRouter: networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateStarting));
nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeRouter)); break;
break; case ZigbeeNetwork::StateRunning:
default: networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOnline));
nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeEndDevice)); break;
break; case ZigbeeNetwork::StateUpdating:
} networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateUpdating));
break;
switch (node->state()) { case ZigbeeNetwork::StateUninitialized:
case ZigbeeNode::StateUninitialized: networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateError));
nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateUninitialized)); break;
break; }
case ZigbeeNode::StateInitializing:
nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateInitializing)); return networkMap;
break; }
case ZigbeeNode::StateInitialized:
nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateInitialized)); QVariantMap ZigbeeHandler::packNode(ZigbeeNode *node)
break; {
} QVariantMap nodeMap;
nodeMap.insert("networkUuid", node->networkUuid());
nodeMap.insert("manufacturer", node->manufacturerName()); nodeMap.insert("ieeeAddress", node->extendedAddress().toString());
nodeMap.insert("model", node->modelName()); nodeMap.insert("networkAddress", node->shortAddress());
nodeMap.insert("version", node->version()); switch (node->nodeDescriptor().nodeType) {
nodeMap.insert("receiverOnWhileIdle", node->macCapabilities().receiverOnWhenIdle); case ZigbeeDeviceProfile::NodeTypeCoordinator:
nodeMap.insert("reachable", node->reachable()); nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeCoordinator));
nodeMap.insert("lqi", node->lqi()); break;
nodeMap.insert("lastSeen", node->lastSeen().toMSecsSinceEpoch() / 1000); case ZigbeeDeviceProfile::NodeTypeRouter:
return nodeMap; nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeRouter));
} break;
default:
} nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeEndDevice));
break;
}
switch (node->state()) {
case ZigbeeNode::StateUninitialized:
nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateUninitialized));
break;
case ZigbeeNode::StateInitializing:
nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateInitializing));
break;
case ZigbeeNode::StateInitialized:
nodeMap.insert("state", enumValueName<ZigbeeManager::ZigbeeNodeState>(ZigbeeManager::ZigbeeNodeStateInitialized));
break;
}
nodeMap.insert("manufacturer", node->manufacturerName());
nodeMap.insert("model", node->modelName());
nodeMap.insert("version", node->version());
nodeMap.insert("receiverOnWhileIdle", node->macCapabilities().receiverOnWhenIdle);
nodeMap.insert("reachable", node->reachable());
nodeMap.insert("lqi", node->lqi());
nodeMap.insert("lastSeen", node->lastSeen().toMSecsSinceEpoch() / 1000);
return nodeMap;
}
void ZigbeeHandler::onNodeJoined(const QUuid &networkUuid, ZigbeeNode *node)
{
QVariantMap params;
params.insert("networkUuid", networkUuid);
params.insert("zigbeeNode", packNode(node));
emit NodeAdded(params);
}
void ZigbeeHandler::onNodeAdded(const QUuid &networkUuid, ZigbeeNode *node)
{
// Note: we emit the node changed signal here, since the node has been added internally after initialization.
QVariantMap params;
params.insert("networkUuid", networkUuid);
params.insert("zigbeeNode", packNode(node));
emit NodeChanged(params);
}
void ZigbeeHandler::onNodeRemoved(const QUuid &networkUuid, ZigbeeNode *node)
{
QVariantMap params;
params.insert("networkUuid", networkUuid);
params.insert("zigbeeNode", packNode(node));
emit NodeRemoved(params);
}
}

7
libnymea-core/jsonrpc/zigbeehandler.h
View File

@ -67,12 +67,19 @@ public:
private: private:
ZigbeeManager *m_zigbeeManager = nullptr; ZigbeeManager *m_zigbeeManager = nullptr;
private slots:
void onNodeJoined(const QUuid &networkUuid, ZigbeeNode *node);
void onNodeAdded(const QUuid &networkUuid, ZigbeeNode *node);
void onNodeRemoved(const QUuid &networkUuid, ZigbeeNode *node);
signals: signals:
void AdapterAdded(const QVariantMap &params); void AdapterAdded(const QVariantMap &params);
void AdapterRemoved(const QVariantMap &params); void AdapterRemoved(const QVariantMap &params);
void NetworkAdded(const QVariantMap &params); void NetworkAdded(const QVariantMap &params);
void NetworkRemoved(const QVariantMap &params); void NetworkRemoved(const QVariantMap &params);
void NetworkChanged(const QVariantMap &params); void NetworkChanged(const QVariantMap &params);
void NodeAdded(const QVariantMap &params); void NodeAdded(const QVariantMap &params);
void NodeRemoved(const QVariantMap &params); void NodeRemoved(const QVariantMap &params);
void NodeChanged(const QVariantMap &params); void NodeChanged(const QVariantMap &params);

32
libnymea-core/zigbee/zigbeemanager.cpp
View File

@ -343,19 +343,19 @@ void ZigbeeManager::loadZigbeeNetworks()
void ZigbeeManager::checkPlatformConfiguration() void ZigbeeManager::checkPlatformConfiguration()
{ {
/* Example platform configurations /* Example platform configurations
* *
* serialPort=/dev/ttymxc2 * serialPort=/dev/ttymxc2
* baudRate=115200 * baudRate=115200
* backend=nxp * backend=nxp
* autoSetup=false * autoSetup=false
* *
* serialPort=/dev/ttyS0 * serialPort=/dev/ttyS0
* baudRate=38400 * baudRate=38400
* backend=deconz * backend=deconz
* autoSetup=false * autoSetup=false
* *
* autoSetup=true * autoSetup=true
*/ */
QFileInfo platformConfigurationFileInfo(NymeaSettings::settingsPath() + QDir::separator() + "zigbee-platform.conf"); QFileInfo platformConfigurationFileInfo(NymeaSettings::settingsPath() + QDir::separator() + "zigbee-platform.conf");
if (platformConfigurationFileInfo.exists()) { if (platformConfigurationFileInfo.exists()) {
@ -544,6 +544,12 @@ void ZigbeeManager::addNetwork(ZigbeeNetwork *network)
emit nodeRemoved(network->networkUuid(), node); emit nodeRemoved(network->networkUuid(), node);
}); });
connect(network, &ZigbeeNetwork::nodeJoined, this, [this, network](ZigbeeNode *node){
// The node has joined but is still initializing. Once the node has been initialized by the stack, the node added signal will be emitted.
qCDebug(dcZigbee()) << "Node joined the network" << network->networkUuid().toString() << node;
emit nodeJoined(network->networkUuid(), node);
});
connect(network, &ZigbeeNetwork::firmwareVersionChanged, this, [this, network](const QString &firmwareVersion){ connect(network, &ZigbeeNetwork::firmwareVersionChanged, this, [this, network](const QString &firmwareVersion){
qCDebug(dcZigbee()) << "Network adapter firmware version changed for" << network << firmwareVersion; qCDebug(dcZigbee()) << "Network adapter firmware version changed for" << network << firmwareVersion;
emit zigbeeNetworkChanged(network); emit zigbeeNetworkChanged(network);

1
libnymea-core/zigbee/zigbeemanager.h
View File

@ -125,6 +125,7 @@ signals:
void zigbeeNetworkRemoved(const QUuid networkUuid); void zigbeeNetworkRemoved(const QUuid networkUuid);
void zigbeeNetworkChanged(ZigbeeNetwork *zigbeeNetwork); void zigbeeNetworkChanged(ZigbeeNetwork *zigbeeNetwork);
void nodeJoined(const QUuid &networkUuid, ZigbeeNode *node);
void nodeAdded(const QUuid &networkUuid, ZigbeeNode *node); void nodeAdded(const QUuid &networkUuid, ZigbeeNode *node);
void nodeRemoved(const QUuid &networkUuid, ZigbeeNode *node); void nodeRemoved(const QUuid &networkUuid, ZigbeeNode *node);
}; };