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

Merge PR #365: Zigbee node JSON RPC API

Browse Source
This commit is contained in:
Jenkins nymea 2021-07-06 17:18:14 +02:00
commit 152255d45c
6 changed files with 694 additions and 360 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,341 +1,520 @@
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* 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>();
registerObject<ZigbeeAdapter, ZigbeeAdapters>(); registerEnum<ZigbeeManager::ZigbeeNodeType>();
registerEnum<ZigbeeManager::ZigbeeNodeState>();
// Network object describing a network instance registerObject<ZigbeeAdapter, ZigbeeAdapters>();
QVariantMap zigbeeNetworkDescription;
zigbeeNetworkDescription.insert("networkUuid", enumValueName(Uuid)); // Network object describing a network instance
zigbeeNetworkDescription.insert("enabled", enumValueName(Bool)); QVariantMap zigbeeNetworkDescription;
zigbeeNetworkDescription.insert("serialPort", enumValueName(String)); zigbeeNetworkDescription.insert("networkUuid", enumValueName(Uuid));
zigbeeNetworkDescription.insert("baudRate", enumValueName(Uint)); zigbeeNetworkDescription.insert("enabled", enumValueName(Bool));
zigbeeNetworkDescription.insert("macAddress", enumValueName(String)); zigbeeNetworkDescription.insert("serialPort", enumValueName(String));
zigbeeNetworkDescription.insert("firmwareVersion", enumValueName(String)); zigbeeNetworkDescription.insert("baudRate", enumValueName(Uint));
zigbeeNetworkDescription.insert("panId", enumValueName(Uint)); zigbeeNetworkDescription.insert("macAddress", enumValueName(String));
zigbeeNetworkDescription.insert("channel", enumValueName(Uint)); zigbeeNetworkDescription.insert("firmwareVersion", enumValueName(String));
zigbeeNetworkDescription.insert("channelMask", enumValueName(Uint)); zigbeeNetworkDescription.insert("panId", enumValueName(Uint));
zigbeeNetworkDescription.insert("permitJoiningEnabled", enumValueName(Bool)); zigbeeNetworkDescription.insert("channel", enumValueName(Uint));
zigbeeNetworkDescription.insert("permitJoiningDuration", enumValueName(Uint)); zigbeeNetworkDescription.insert("channelMask", enumValueName(Uint));
zigbeeNetworkDescription.insert("permitJoiningRemaining", enumValueName(Uint)); zigbeeNetworkDescription.insert("permitJoiningEnabled", enumValueName(Bool));
zigbeeNetworkDescription.insert("backend", enumValueName(String)); zigbeeNetworkDescription.insert("permitJoiningDuration", enumValueName(Uint));
zigbeeNetworkDescription.insert("networkState", enumRef<ZigbeeManager::ZigbeeNetworkState>()); zigbeeNetworkDescription.insert("permitJoiningRemaining", enumValueName(Uint));
registerObject("ZigbeeNetwork", zigbeeNetworkDescription); zigbeeNetworkDescription.insert("backend", enumValueName(String));
zigbeeNetworkDescription.insert("networkState", enumRef<ZigbeeManager::ZigbeeNetworkState>());
QVariantMap params, returns; registerObject("ZigbeeNetwork", zigbeeNetworkDescription);
QString description;
// Zigbee node description
// GetAvailableBackends QVariantMap zigbeeNodeDescription;
params.clear(); returns.clear(); zigbeeNodeDescription.insert("networkUuid", enumValueName(Uuid));
description = "Get the list of available ZigBee backends."; zigbeeNodeDescription.insert("ieeeAddress", enumValueName(String));
returns.insert("backends", QVariantList() << enumValueName(String)); zigbeeNodeDescription.insert("networkAddress", enumValueName(Uint));
registerMethod("GetAvailableBackends", description, params, returns); zigbeeNodeDescription.insert("type", enumRef<ZigbeeManager::ZigbeeNodeType>());
zigbeeNodeDescription.insert("state", enumRef<ZigbeeManager::ZigbeeNodeState>());
// GetAdapters zigbeeNodeDescription.insert("manufacturer", enumValueName(String));
params.clear(); returns.clear(); zigbeeNodeDescription.insert("model", enumValueName(String));
description = "Get the list of available ZigBee adapters and serial ports in order to set up the ZigBee network " zigbeeNodeDescription.insert("version", enumValueName(String));
"on the desired interface. The \'serialPort\' property can be used as unique identifier for an adapter. " zigbeeNodeDescription.insert("receiverOnWhileIdle", enumValueName(Bool));
"If an adapter hardware has been recognized as a well known ZigBee adapter, " zigbeeNodeDescription.insert("reachable", enumValueName(Bool));
"the \'hardwareRecognized\' property will be true and the \'baudRate\' and \'backend\' " zigbeeNodeDescription.insert("lqi", enumValueName(Uint));
"configurations can be used as they where given, otherwise the user might set the backend " zigbeeNodeDescription.insert("lastSeen", enumValueName(Uint));
"and baud rate manually. The available backends can be fetched using the GetAvailableBackends method."; registerObject("ZigbeeNode", zigbeeNodeDescription);
returns.insert("adapters", objectRef<ZigbeeAdapters>());
registerMethod("GetAdapters", description, params, returns); QVariantMap params, returns;
QString description;
// AdapterAdded notification
params.clear(); // GetAvailableBackends
description = "Emitted whenever a new ZigBee adapter or serial port has been detected in the system."; params.clear(); returns.clear();
params.insert("adapter", objectRef<ZigbeeAdapter>()); description = "Get the list of available ZigBee backends.";
registerNotification("AdapterAdded", description, params); returns.insert("backends", QVariantList() << enumValueName(String));
registerMethod("GetAvailableBackends", description, params, returns);
// AdapterRemoved notification
params.clear(); // GetAdapters
description = "Emitted whenever a ZigBee adapter or serial port has been removed from the system (i.e. unplugged)."; params.clear(); returns.clear();
params.insert("adapter", objectRef<ZigbeeAdapter>()); description = "Get the list of available ZigBee adapters and serial ports in order to set up the ZigBee network "
registerNotification("AdapterRemoved", description, params); "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, "
// GetNetworks "the \'hardwareRecognized\' property will be true and the \'baudRate\' and \'backend\' "
params.clear(); returns.clear(); "configurations can be used as they where given, otherwise the user might set the backend "
description = "Returns the list of configured ZigBee networks in the system."; "and baud rate manually. The available backends can be fetched using the GetAvailableBackends method.";
returns.insert("zigbeeNetworks", QVariantList() << objectRef("ZigbeeNetwork")); returns.insert("adapters", objectRef<ZigbeeAdapters>());
registerMethod("GetNetworks", description, params, returns); registerMethod("GetAdapters", description, params, returns);
// AddNetwork // AdapterAdded notification
params.clear(); returns.clear(); params.clear();
description = "Create a new ZigBee network for the given \'serialPort\', \'baudRate\' and \'backend\'. " description = "Emitted whenever a new ZigBee adapter or serial port has been detected in the system.";
"The serial ports can be fetched from the available adapters. See \'GetAdapters\' for more information. " params.insert("adapter", objectRef<ZigbeeAdapter>());
"The available backends can be fetched using the \'GetAvailableBackends\' method."; registerNotification("AdapterAdded", description, params);
params.insert("serialPort", enumValueName(String));
params.insert("baudRate", enumValueName(Uint)); // AdapterRemoved notification
params.insert("backend", enumValueName(String)); params.clear();
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); description = "Emitted whenever a ZigBee adapter or serial port has been removed from the system (i.e. unplugged).";
returns.insert("o:networkUuid", enumValueName(Uuid)); params.insert("adapter", objectRef<ZigbeeAdapter>());
registerMethod("AddNetwork", description, params, returns); registerNotification("AdapterRemoved", description, params);
// RemoveNetwork // GetNetworks
params.clear(); returns.clear(); params.clear(); returns.clear();
description = "Remove the ZigBee network with the given network uuid."; description = "Returns the list of configured ZigBee networks in the system.";
params.insert("networkUuid", enumValueName(Uuid)); returns.insert("zigbeeNetworks", QVariantList() << objectRef("ZigbeeNetwork"));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); registerMethod("GetNetworks", description, params, returns);
registerMethod("RemoveNetwork", description, params, returns);
// AddNetwork
// NetworkAdded notification params.clear(); returns.clear();
params.clear(); description = "Create a new ZigBee network for the given \'serialPort\', \'baudRate\' and \'backend\'. "
description = "Emitted whenever a new ZigBee network has been added."; "The serial ports can be fetched from the available adapters. See \'GetAdapters\' for more information. "
params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork")); "The available backends can be fetched using the \'GetAvailableBackends\' method.";
registerNotification("NetworkAdded", description, params); params.insert("serialPort", enumValueName(String));
params.insert("baudRate", enumValueName(Uint));
// NetworkRemoved notification params.insert("backend", enumValueName(String));
params.clear(); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
description = "Emitted whenever a new ZigBee network has been removed."; returns.insert("o:networkUuid", enumValueName(Uuid));
params.insert("networkUuid", enumValueName(Uuid)); registerMethod("AddNetwork", description, params, returns);
registerNotification("NetworkRemoved", description, params);
// RemoveNetwork
// NetworkChanged notification params.clear(); returns.clear();
params.clear(); description = "Remove the ZigBee network with the given network uuid.";
description = "Emitted whenever a new ZigBee network has changed."; params.insert("networkUuid", enumValueName(Uuid));
params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork")); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerNotification("NetworkChanged", description, params); registerMethod("RemoveNetwork", description, params, returns);
// FactoryResetNetwork // NetworkAdded notification
params.clear(); returns.clear(); params.clear();
description = "Factory reset the network with the given \'networkUuid\'. The network does not have " description = "Emitted whenever a new ZigBee network has been added.";
"to be online for this procedure, and all associated nodes and things will be removed permanently."; params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork"));
params.insert("networkUuid", enumValueName(Uuid)); registerNotification("NetworkAdded", description, params);
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("FactoryResetNetwork", description, params, returns); // NetworkRemoved notification
params.clear();
// SetPermitJoin description = "Emitted whenever a new ZigBee network has been removed.";
params.clear(); returns.clear(); params.insert("networkUuid", enumValueName(Uuid));
description = "Allow or deny nodes to join the network with the given \'networkUuid\' for a specific \'duration\' in seconds. " registerNotification("NetworkRemoved", description, params);
"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. " // NetworkChanged notification
"Those values can be used to show a countdown or progressbar. This method can be recalled for resetting the timeout. " params.clear();
"If the duration is set to 0 seconds, joining will be disabled immediatly for the entire network. " description = "Emitted whenever a new ZigBee network has changed.";
"The \'shortAddress\' is optional and defaults to the broadcast address 0xfffc for all routers in the network. " params.insert("zigbeeNetwork", objectRef("ZigbeeNetwork"));
"If the short address matches the address of a router node in the network, only that specific router will " registerNotification("NetworkChanged", description, params);
"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)); // FactoryResetNetwork
params.insert("duration", enumValueName(Uint)); params.clear(); returns.clear();
params.insert("o:shortAddress", enumValueName(Uint)); description = "Factory reset the network with the given \'networkUuid\'. The network does not have "
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>()); "to be online for this procedure, and all associated nodes and things will be removed permanently.";
registerMethod("SetPermitJoin", description, params, returns); params.insert("networkUuid", enumValueName(Uuid));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("FactoryResetNetwork", description, params, returns);
connect(m_zigbeeManager, &ZigbeeManager::availableAdapterAdded, this, [this](const ZigbeeAdapter &adapter){
QVariantMap params; // SetPermitJoin
params.insert("adapter", pack(adapter)); params.clear(); returns.clear();
emit AdapterAdded(params); 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 "
"object indicates how long permit has been enabled and the \'permitJoiningRemaining\' indicates the rest of the time. "
connect(m_zigbeeManager, &ZigbeeManager::availableAdapterRemoved, this, [this](const ZigbeeAdapter &adapter){ "Those values can be used to show a countdown or progressbar. This method can be recalled for resetting the timeout. "
QVariantMap params; "If the duration is set to 0 seconds, joining will be disabled immediatly for the entire network. "
params.insert("adapter", pack(adapter)); "The \'shortAddress\' is optional and defaults to the broadcast address 0xfffc for all routers in the network. "
emit AdapterRemoved(params); "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).";
params.insert("networkUuid", enumValueName(Uuid));
connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkAdded, this, [this](ZigbeeNetwork *network){ params.insert("duration", enumValueName(Uint));
QVariantMap params; params.insert("o:shortAddress", enumValueName(Uint));
params.insert("zigbeeNetwork", packNetwork(network)); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
emit NetworkAdded(params); registerMethod("SetPermitJoin", description, params, returns);
});
// GetNodes
connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkChanged, this, [this](ZigbeeNetwork *network){ params.clear(); returns.clear();
QVariantMap params; description = "Returns the list of ZigBee nodes from the network the given \'networkUuid\' in the system.";
params.insert("zigbeeNetwork", packNetwork(network)); params.insert("networkUuid", enumValueName(Uuid));
emit NetworkChanged(params); returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
}); returns.insert("o:zigbeeNodes", QVariantList() << objectRef("ZigbeeNode"));
registerMethod("GetNodes", description, params, returns);
connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkRemoved, this, [this](const QUuid &networkUuid){
QVariantMap params; // RemoveNode
params.insert("networkUuid", networkUuid); params.clear(); returns.clear();
emit NetworkRemoved(params); 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. "
} "The coordinator node cannot be removed.";
params.insert("networkUuid", enumValueName(Uuid));
QString ZigbeeHandler::name() const params.insert("ieeeAddress", enumValueName(String));
{ returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
return "Zigbee"; registerMethod("RemoveNode", description, params, returns);
}
// NodeAdded
JsonReply *ZigbeeHandler::GetAvailableBackends(const QVariantMap &params) params.clear();
{ description = "Emitted whenever a new ZigBee node has joined the network with the given \'networkUuid\'.";
Q_UNUSED(params) params.insert("networkUuid", enumValueName(Uuid));
params.insert("zigbeeNode", objectRef("ZigbeeNode"));
QVariantMap returnMap; registerNotification("NodeAdded", description, params);
QVariantList backendsList;
foreach (const QString &backendName, ZigbeeAdapter::backendNames().values()) // NodeRemoved
backendsList << backendName; params.clear();
description = "Emitted whenever a ZigBee node has removed from the network with the given \'networkUuid\'.";
returnMap.insert("backends", backendsList); params.insert("networkUuid", enumValueName(Uuid));
return createReply(returnMap); params.insert("zigbeeNode", objectRef("ZigbeeNode"));
} registerNotification("NodeRemoved", description, params);
JsonReply *ZigbeeHandler::GetAdapters(const QVariantMap &params) // NodeChanged
{ params.clear();
Q_UNUSED(params) description = "Emitted whenever a ZigBee node has changed.";
params.insert("networkUuid", enumValueName(Uuid));
QVariantMap returnMap; params.insert("zigbeeNode", objectRef("ZigbeeNode"));
QVariantList adapterList; registerNotification("NodeChanged", description, params);
foreach (const ZigbeeAdapter &adapter, m_zigbeeManager->availableAdapters()) {
adapterList << pack(adapter); connect(m_zigbeeManager, &ZigbeeManager::availableAdapterAdded, this, [this](const ZigbeeAdapter &adapter){
} QVariantMap params;
returnMap.insert("adapters", adapterList); params.insert("adapter", pack(adapter));
return createReply(returnMap); emit AdapterAdded(params);
} });
JsonReply *ZigbeeHandler::AddNetwork(const QVariantMap &params) connect(m_zigbeeManager, &ZigbeeManager::availableAdapterRemoved, this, [this](const ZigbeeAdapter &adapter){
{ QVariantMap params;
QVariantMap returnMap; params.insert("adapter", pack(adapter));
emit AdapterRemoved(params);
QString serialPort = params.value("serialPort").toString(); });
uint baudRate = params.value("baudRate").toUInt();
QString backendString = params.value("backend").toString(); connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkAdded, this, [this](ZigbeeNetwork *network){
if (!ZigbeeAdapter::backendNames().values().contains(backendString)) { QVariantMap params;
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorUnknownBackend)); params.insert("zigbeeNetwork", packNetwork(network));
return createReply(returnMap); emit NetworkAdded(params);
} });
QPair<ZigbeeManager::ZigbeeError, QUuid> result = m_zigbeeManager->createZigbeeNetwork(serialPort, baudRate, ZigbeeAdapter::backendNames().key(backendString)); connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkChanged, this, [this](ZigbeeNetwork *network){
if (result.first == ZigbeeManager::ZigbeeErrorNoError) { QVariantMap params;
returnMap.insert("networkUuid", result.second); params.insert("zigbeeNetwork", packNetwork(network));
} emit NetworkChanged(params);
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(result.first)); });
return createReply(returnMap);
} connect(m_zigbeeManager, &ZigbeeManager::zigbeeNetworkRemoved, this, [this](const QUuid &networkUuid){
QVariantMap params;
JsonReply *ZigbeeHandler::RemoveNetwork(const QVariantMap &params) params.insert("networkUuid", networkUuid);
{ emit NetworkRemoved(params);
QUuid networkUuid = params.value("networkUuid").toUuid(); });
ZigbeeManager::ZigbeeError error = m_zigbeeManager->removeZigbeeNetwork(networkUuid);
QVariantMap returnMap; connect(m_zigbeeManager, &ZigbeeManager::nodeJoined, this, &ZigbeeHandler::onNodeJoined);
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error)); connect(m_zigbeeManager, &ZigbeeManager::nodeAdded, this, &ZigbeeHandler::onNodeAdded);
return createReply(returnMap); connect(m_zigbeeManager, &ZigbeeManager::nodeChanged, this, &ZigbeeHandler::onNodeChanged);
} connect(m_zigbeeManager, &ZigbeeManager::nodeRemoved, this, &ZigbeeHandler::onNodeRemoved);
JsonReply *ZigbeeHandler::FactoryResetNetwork(const QVariantMap &params) }
{
QUuid networkUuid = params.value("networkUuid").toUuid(); QString ZigbeeHandler::name() const
ZigbeeManager::ZigbeeError error = m_zigbeeManager->factoryResetNetwork(networkUuid); {
QVariantMap returnMap; return "Zigbee";
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error)); }
return createReply(returnMap);
} JsonReply *ZigbeeHandler::GetAvailableBackends(const QVariantMap &params)
{
JsonReply *ZigbeeHandler::SetPermitJoin(const QVariantMap &params) Q_UNUSED(params)
{
QUuid networkUuid = params.value("networkUuid").toUuid(); QVariantMap returnMap;
uint duration = params.value("duration").toUInt(); QVariantList backendsList;
quint16 shortAddress = static_cast<quint16>(Zigbee::BroadcastAddressAllRouters); foreach (const QString &backendName, ZigbeeAdapter::backendNames().values()) {
if (params.contains("shortAddress")) { backendsList << backendName;
shortAddress = static_cast<quint16>(params.value("shortAddress").toUInt()); }
} returnMap.insert("backends", backendsList);
ZigbeeManager::ZigbeeError error = m_zigbeeManager->setZigbeeNetworkPermitJoin(networkUuid, shortAddress, duration); return createReply(returnMap);
QVariantMap returnMap; }
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
return createReply(returnMap); JsonReply *ZigbeeHandler::GetAdapters(const QVariantMap &params)
} {
Q_UNUSED(params)
JsonReply *ZigbeeHandler::GetNetworks(const QVariantMap &params)
{ QVariantMap returnMap;
Q_UNUSED(params) QVariantList adapterList;
foreach (const ZigbeeAdapter &adapter, m_zigbeeManager->availableAdapters()) {
QVariantMap returnMap; adapterList << pack(adapter);
QVariantList networkList; }
foreach (ZigbeeNetwork *network, m_zigbeeManager->zigbeeNetworks().values()) { returnMap.insert("adapters", adapterList);
networkList.append(packNetwork(network)); return createReply(returnMap);
} }
returnMap.insert("zigbeeNetworks", networkList);
return createReply(returnMap); JsonReply *ZigbeeHandler::AddNetwork(const QVariantMap &params)
} {
QVariantMap returnMap;
QVariantMap ZigbeeHandler::packNetwork(ZigbeeNetwork *network)
{ QString serialPort = params.value("serialPort").toString();
QVariantMap networkMap; uint baudRate = params.value("baudRate").toUInt();
networkMap.insert("networkUuid", network->networkUuid()); QString backendString = params.value("backend").toString();
networkMap.insert("enabled", true); // FIXME: set actual value once supported if (!ZigbeeAdapter::backendNames().values().contains(backendString)) {
networkMap.insert("serialPort", network->serialPortName()); returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorUnknownBackend));
networkMap.insert("baudRate", network->serialBaudrate()); return createReply(returnMap);
networkMap.insert("macAddress", network->macAddress().toString()); }
networkMap.insert("firmwareVersion", network->firmwareVersion());
networkMap.insert("panId", network->panId()); QPair<ZigbeeManager::ZigbeeError, QUuid> result = m_zigbeeManager->createZigbeeNetwork(serialPort, baudRate, ZigbeeAdapter::backendNames().key(backendString));
networkMap.insert("channel", network->channel()); if (result.first == ZigbeeManager::ZigbeeErrorNoError) {
networkMap.insert("channelMask", network->channelMask().toUInt32()); returnMap.insert("networkUuid", result.second);
networkMap.insert("permitJoiningEnabled", network->permitJoiningEnabled()); }
networkMap.insert("permitJoiningDuration", network->permitJoiningDuration()); returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(result.first));
networkMap.insert("permitJoiningRemaining", network->permitJoiningRemaining()); return createReply(returnMap);
}
switch (network->backendType()) {
case Zigbee::ZigbeeBackendTypeDeconz: JsonReply *ZigbeeHandler::RemoveNetwork(const QVariantMap &params)
networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeDeconz)); {
break; QUuid networkUuid = params.value("networkUuid").toUuid();
case Zigbee::ZigbeeBackendTypeNxp: ZigbeeManager::ZigbeeError error = m_zigbeeManager->removeZigbeeNetwork(networkUuid);
networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeNxp)); QVariantMap returnMap;
break; returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
} return createReply(returnMap);
}
switch (network->state()) {
case ZigbeeNetwork::StateOffline: JsonReply *ZigbeeHandler::FactoryResetNetwork(const QVariantMap &params)
case ZigbeeNetwork::StateStopping: {
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOffline)); QUuid networkUuid = params.value("networkUuid").toUuid();
break; ZigbeeManager::ZigbeeError error = m_zigbeeManager->factoryResetNetwork(networkUuid);
case ZigbeeNetwork::StateStarting: QVariantMap returnMap;
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateStarting)); returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
break; return createReply(returnMap);
case ZigbeeNetwork::StateRunning: }
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOnline));
break; JsonReply *ZigbeeHandler::SetPermitJoin(const QVariantMap &params)
case ZigbeeNetwork::StateUpdating: {
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateUpdating)); QUuid networkUuid = params.value("networkUuid").toUuid();
break; uint duration = params.value("duration").toUInt();
case ZigbeeNetwork::StateUninitialized: quint16 shortAddress = static_cast<quint16>(Zigbee::BroadcastAddressAllRouters);
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateError)); if (params.contains("shortAddress")) {
break; shortAddress = static_cast<quint16>(params.value("shortAddress").toUInt());
} }
ZigbeeManager::ZigbeeError error = m_zigbeeManager->setZigbeeNetworkPermitJoin(networkUuid, shortAddress, duration);
return networkMap; QVariantMap returnMap;
} returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(error));
return createReply(returnMap);
} }
JsonReply *ZigbeeHandler::GetNodes(const QVariantMap &params)
{
QVariantMap returnMap;
QUuid networkUuid = params.value("networkUuid").toUuid();
ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid);
if (!network) {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound));
return createReply(returnMap);
}
QVariantList nodeList;
foreach (ZigbeeNode *node, network->nodes()) {
nodeList << packNode(node);
}
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError));
returnMap.insert("zigbeeNodes", nodeList);
return createReply(returnMap);
}
JsonReply *ZigbeeHandler::RemoveNode(const QVariantMap &params)
{
QVariantMap returnMap;
QUuid networkUuid = params.value("networkUuid").toUuid();
ZigbeeAddress nodeAddress(params.value("ieeeAddress").toString());
ZigbeeNetwork *network = m_zigbeeManager->zigbeeNetworks().value(networkUuid);
if (!network) {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNetworkUuidNotFound));
return createReply(returnMap);
}
if (!network->hasNode(nodeAddress)) {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNodeNotFound));
return createReply(returnMap);
}
ZigbeeNode *node = network->getZigbeeNode(nodeAddress);
if (node->shortAddress() == 0x0000) {
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorForbidden));
return createReply(returnMap);
}
network->removeZigbeeNode(nodeAddress);
returnMap.insert("zigbeeError", enumValueName<ZigbeeManager::ZigbeeError>(ZigbeeManager::ZigbeeErrorNoError));
return createReply(returnMap);
}
JsonReply *ZigbeeHandler::GetNetworks(const QVariantMap &params)
{
Q_UNUSED(params)
QVariantMap returnMap;
QVariantList networkList;
foreach (ZigbeeNetwork *network, m_zigbeeManager->zigbeeNetworks().values()) {
networkList.append(packNetwork(network));
}
returnMap.insert("zigbeeNetworks", networkList);
return createReply(returnMap);
}
QVariantMap ZigbeeHandler::packNetwork(ZigbeeNetwork *network)
{
QVariantMap networkMap;
networkMap.insert("networkUuid", network->networkUuid());
networkMap.insert("enabled", true); // FIXME: set actual value once supported
networkMap.insert("serialPort", network->serialPortName());
networkMap.insert("baudRate", network->serialBaudrate());
networkMap.insert("macAddress", network->macAddress().toString());
networkMap.insert("firmwareVersion", network->firmwareVersion());
networkMap.insert("panId", network->panId());
networkMap.insert("channel", network->channel());
networkMap.insert("channelMask", network->channelMask().toUInt32());
networkMap.insert("permitJoiningEnabled", network->permitJoiningEnabled());
networkMap.insert("permitJoiningDuration", network->permitJoiningDuration());
networkMap.insert("permitJoiningRemaining", network->permitJoiningRemaining());
switch (network->backendType()) {
case Zigbee::ZigbeeBackendTypeDeconz:
networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeDeconz));
break;
case Zigbee::ZigbeeBackendTypeNxp:
networkMap.insert("backend", ZigbeeAdapter::backendNames().value(ZigbeeAdapter::ZigbeeBackendTypeNxp));
break;
}
switch (network->state()) {
case ZigbeeNetwork::StateOffline:
case ZigbeeNetwork::StateStopping:
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOffline));
break;
case ZigbeeNetwork::StateStarting:
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateStarting));
break;
case ZigbeeNetwork::StateRunning:
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateOnline));
break;
case ZigbeeNetwork::StateUpdating:
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateUpdating));
break;
case ZigbeeNetwork::StateUninitialized:
networkMap.insert("networkState", enumValueName<ZigbeeManager::ZigbeeNetworkState>(ZigbeeManager::ZigbeeNetworkStateError));
break;
}
return networkMap;
}
QVariantMap ZigbeeHandler::packNode(ZigbeeNode *node)
{
QVariantMap nodeMap;
nodeMap.insert("networkUuid", node->networkUuid());
nodeMap.insert("ieeeAddress", node->extendedAddress().toString());
nodeMap.insert("networkAddress", node->shortAddress());
switch (node->nodeDescriptor().nodeType) {
case ZigbeeDeviceProfile::NodeTypeCoordinator:
nodeMap.insert("type", enumValueName<ZigbeeManager::ZigbeeNodeType>(ZigbeeManager::ZigbeeNodeTypeCoordinator));
break;
case ZigbeeDeviceProfile::NodeTypeRouter:
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.
onNodeChanged(networkUuid, node);
}
void ZigbeeHandler::onNodeChanged(const QUuid &networkUuid, ZigbeeNode *node)
{
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);
}
}

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

@ -51,24 +51,39 @@ public:
Q_INVOKABLE JsonReply *GetAvailableBackends(const QVariantMap &params); Q_INVOKABLE JsonReply *GetAvailableBackends(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetAdapters(const QVariantMap &params); Q_INVOKABLE JsonReply *GetAdapters(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetNetworks(const QVariantMap &params); Q_INVOKABLE JsonReply *GetNetworks(const QVariantMap &params);
Q_INVOKABLE JsonReply *AddNetwork(const QVariantMap &params); Q_INVOKABLE JsonReply *AddNetwork(const QVariantMap &params);
Q_INVOKABLE JsonReply *RemoveNetwork(const QVariantMap &params); Q_INVOKABLE JsonReply *RemoveNetwork(const QVariantMap &params);
Q_INVOKABLE JsonReply *FactoryResetNetwork(const QVariantMap &params); Q_INVOKABLE JsonReply *FactoryResetNetwork(const QVariantMap &params);
Q_INVOKABLE JsonReply *SetPermitJoin(const QVariantMap &params); Q_INVOKABLE JsonReply *SetPermitJoin(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetNodes(const QVariantMap &params);
Q_INVOKABLE JsonReply *RemoveNode(const QVariantMap &params);
QVariantMap packNetwork(ZigbeeNetwork *network); QVariantMap packNetwork(ZigbeeNetwork *network);
QVariantMap packNode(ZigbeeNode *node);
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 onNodeChanged(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 NodeRemoved(const QVariantMap &params);
void NodeChanged(const QVariantMap &params);
}; };
} }

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

@ -205,8 +205,8 @@ ZigbeeManager::ZigbeeError ZigbeeManager::removeZigbeeNetwork(const QUuid &netwo
settings.beginGroup("ZigbeeNetworks"); settings.beginGroup("ZigbeeNetworks");
settings.beginGroup(network->networkUuid().toString()); settings.beginGroup(network->networkUuid().toString());
settings.remove(""); settings.remove("");
settings.endGroup(); settings.endGroup(); // networkUuid
settings.endGroup(); settings.endGroup(); // ZigbeeNetworks
qCDebug(dcZigbee()) << "Network removed successfully"; qCDebug(dcZigbee()) << "Network removed successfully";
return ZigbeeManager::ZigbeeErrorNoError; return ZigbeeManager::ZigbeeErrorNoError;
@ -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,14 @@ 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);
setupNodeSignals(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);
@ -583,6 +591,10 @@ void ZigbeeManager::addNetwork(ZigbeeNetwork *network)
} }
} }
} }
foreach (ZigbeeNode *node, network->nodes()) {
setupNodeSignals(node);
}
} }
ZigbeeAdapter ZigbeeManager::convertUartAdapterToAdapter(const ZigbeeUartAdapter &uartAdapter) ZigbeeAdapter ZigbeeManager::convertUartAdapterToAdapter(const ZigbeeUartAdapter &uartAdapter)
@ -628,5 +640,42 @@ void ZigbeeManager::evaluateZigbeeAvailable()
emit availableChanged(m_available); emit availableChanged(m_available);
} }
void ZigbeeManager::setupNodeSignals(ZigbeeNode *node)
{
// Connect signals while joining for initializing
connect(node, &ZigbeeNode::shortAddressChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
connect(node, &ZigbeeNode::stateChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
connect(node, &ZigbeeNode::manufacturerNameChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
connect(node, &ZigbeeNode::modelNameChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
connect(node, &ZigbeeNode::versionChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
connect(node, &ZigbeeNode::lqiChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
connect(node, &ZigbeeNode::lastSeenChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
connect(node, &ZigbeeNode::reachableChanged, this, [=](){
emit nodeChanged(node->networkUuid(), node);
});
}
} }

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

@ -60,10 +60,28 @@ public:
ZigbeeErrorNetworkUuidNotFound, ZigbeeErrorNetworkUuidNotFound,
ZigbeeErrorDurationOutOfRange, ZigbeeErrorDurationOutOfRange,
ZigbeeErrorNetworkOffline, ZigbeeErrorNetworkOffline,
ZigbeeErrorUnknownBackend ZigbeeErrorUnknownBackend,
ZigbeeErrorNodeNotFound,
ZigbeeErrorForbidden
}; };
Q_ENUM(ZigbeeError) Q_ENUM(ZigbeeError)
// Node information
enum ZigbeeNodeType {
ZigbeeNodeTypeCoordinator,
ZigbeeNodeTypeRouter,
ZigbeeNodeTypeEndDevice
};
Q_ENUM(ZigbeeNodeType)
enum ZigbeeNodeState {
ZigbeeNodeStateUninitialized,
ZigbeeNodeStateInitializing,
ZigbeeNodeStateInitialized,
ZigbeeNodeStateHandled
};
Q_ENUM(ZigbeeNodeState)
explicit ZigbeeManager(QObject *parent = nullptr); explicit ZigbeeManager(QObject *parent = nullptr);
bool available() const; bool available() const;
@ -96,6 +114,7 @@ private:
ZigbeeAdapter convertUartAdapterToAdapter(const ZigbeeUartAdapter &uartAdapter); ZigbeeAdapter convertUartAdapterToAdapter(const ZigbeeUartAdapter &uartAdapter);
void evaluateZigbeeAvailable(); void evaluateZigbeeAvailable();
void setupNodeSignals(ZigbeeNode *node);
signals: signals:
void availableChanged(bool available); void availableChanged(bool available);
@ -107,7 +126,9 @@ 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 nodeChanged(const QUuid &networkUuid, ZigbeeNode *node);
void nodeRemoved(const QUuid &networkUuid, ZigbeeNode *node); void nodeRemoved(const QUuid &networkUuid, ZigbeeNode *node);
}; };

2
nymea.pro
View File

@ -5,7 +5,7 @@ NYMEA_VERSION_STRING=$$system('dpkg-parsechangelog | sed -n -e "s/^Version: //p"
# define protocol versions # define protocol versions
JSON_PROTOCOL_VERSION_MAJOR=5 JSON_PROTOCOL_VERSION_MAJOR=5
JSON_PROTOCOL_VERSION_MINOR=5 JSON_PROTOCOL_VERSION_MINOR=6
JSON_PROTOCOL_VERSION="$${JSON_PROTOCOL_VERSION_MAJOR}.$${JSON_PROTOCOL_VERSION_MINOR}" JSON_PROTOCOL_VERSION="$${JSON_PROTOCOL_VERSION_MAJOR}.$${JSON_PROTOCOL_VERSION_MINOR}"
LIBNYMEA_API_VERSION_MAJOR=7 LIBNYMEA_API_VERSION_MAJOR=7
LIBNYMEA_API_VERSION_MINOR=0 LIBNYMEA_API_VERSION_MINOR=0

74
tests/auto/api.json
View File

@ -1,4 +1,4 @@
5.5 5.6
{ {
"enums": { "enums": {
"BasicType": [ "BasicType": [
@ -377,7 +377,9 @@
"ZigbeeErrorNetworkUuidNotFound", "ZigbeeErrorNetworkUuidNotFound",
"ZigbeeErrorDurationOutOfRange", "ZigbeeErrorDurationOutOfRange",
"ZigbeeErrorNetworkOffline", "ZigbeeErrorNetworkOffline",
"ZigbeeErrorUnknownBackend" "ZigbeeErrorUnknownBackend",
"ZigbeeErrorNodeNotFound",
"ZigbeeErrorForbidden"
], ],
"ZigbeeNetworkState": [ "ZigbeeNetworkState": [
"ZigbeeNetworkStateOffline", "ZigbeeNetworkStateOffline",
@ -385,6 +387,17 @@
"ZigbeeNetworkStateUpdating", "ZigbeeNetworkStateUpdating",
"ZigbeeNetworkStateOnline", "ZigbeeNetworkStateOnline",
"ZigbeeNetworkStateError" "ZigbeeNetworkStateError"
],
"ZigbeeNodeState": [
"ZigbeeNodeStateUninitialized",
"ZigbeeNodeStateInitializing",
"ZigbeeNodeStateInitialized",
"ZigbeeNodeStateHandled"
],
"ZigbeeNodeType": [
"ZigbeeNodeTypeCoordinator",
"ZigbeeNodeTypeRouter",
"ZigbeeNodeTypeEndDevice"
] ]
}, },
"flags": { "flags": {
@ -2058,6 +2071,18 @@
] ]
} }
}, },
"Zigbee.GetNodes": {
"description": "Returns the list of ZigBee nodes from the network the given 'networkUuid' in the system.",
"params": {
"networkUuid": "Uuid"
},
"returns": {
"o:zigbeeNodes": [
"$ref:ZigbeeNode"
],
"zigbeeError": "$ref:ZigbeeError"
}
},
"Zigbee.RemoveNetwork": { "Zigbee.RemoveNetwork": {
"description": "Remove the ZigBee network with the given network uuid.", "description": "Remove the ZigBee network with the given network uuid.",
"params": { "params": {
@ -2067,6 +2092,16 @@
"zigbeeError": "$ref:ZigbeeError" "zigbeeError": "$ref:ZigbeeError"
} }
}, },
"Zigbee.RemoveNode": {
"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. The coordinator node cannot be removed.",
"params": {
"ieeeAddress": "String",
"networkUuid": "Uuid"
},
"returns": {
"zigbeeError": "$ref:ZigbeeError"
}
},
"Zigbee.SetPermitJoin": { "Zigbee.SetPermitJoin": {
"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 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. 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. 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).", "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 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. 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. 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).",
"params": { "params": {
@ -2534,6 +2569,27 @@
"params": { "params": {
"networkUuid": "Uuid" "networkUuid": "Uuid"
} }
},
"Zigbee.NodeAdded": {
"description": "Emitted whenever a new ZigBee node has joined the network with the given 'networkUuid'.",
"params": {
"networkUuid": "Uuid",
"zigbeeNode": "$ref:ZigbeeNode"
}
},
"Zigbee.NodeChanged": {
"description": "Emitted whenever a ZigBee node has changed.",
"params": {
"networkUuid": "Uuid",
"zigbeeNode": "$ref:ZigbeeNode"
}
},
"Zigbee.NodeRemoved": {
"description": "Emitted whenever a ZigBee node has removed from the network with the given 'networkUuid'.",
"params": {
"networkUuid": "Uuid",
"zigbeeNode": "$ref:ZigbeeNode"
}
} }
}, },
"types": { "types": {
@ -3043,6 +3099,20 @@
"permitJoiningEnabled": "Bool", "permitJoiningEnabled": "Bool",
"permitJoiningRemaining": "Uint", "permitJoiningRemaining": "Uint",
"serialPort": "String" "serialPort": "String"
},
"ZigbeeNode": {
"ieeeAddress": "String",
"lastSeen": "Uint",
"lqi": "Uint",
"manufacturer": "String",
"model": "String",
"networkAddress": "Uint",
"networkUuid": "Uuid",
"reachable": "Bool",
"receiverOnWhileIdle": "Bool",
"state": "$ref:ZigbeeNodeState",
"type": "$ref:ZigbeeNodeType",
"version": "String"
} }
} }
} }