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

Add basic structure for zigbee nodes on jsonrpc api

Browse Source
This commit is contained in:
Simon Stürz 2020-12-09 13:47:46 +01:00 committed by Michael Zanetti
parent 1acd8ca808
commit a0169b179d
3 changed files with 149 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -44,6 +44,8 @@ ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) :
qRegisterMetaType<nymeaserver::ZigbeeAdapter>();
registerEnum<ZigbeeManager::ZigbeeNetworkState>();
registerEnum<ZigbeeManager::ZigbeeError>();
registerEnum<ZigbeeManager::ZigbeeNodeType>();
registerEnum<ZigbeeManager::ZigbeeNodeState>();
registerObject<ZigbeeAdapter, ZigbeeAdapters>();
// Network object describing a network instance
@ -64,6 +66,22 @@ ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) :
zigbeeNetworkDescription.insert("networkState", enumRef<ZigbeeManager::ZigbeeNetworkState>());
registerObject("ZigbeeNetwork", zigbeeNetworkDescription);
// Zigbee node description
QVariantMap zigbeeNodeDescription;
zigbeeNodeDescription.insert("networkUuid", enumValueName(Uuid));
zigbeeNodeDescription.insert("ieeeAddress", enumValueName(String));
zigbeeNodeDescription.insert("networkAddress", enumValueName(Uint));
zigbeeNodeDescription.insert("type", enumRef<ZigbeeManager::ZigbeeNodeType>());
zigbeeNodeDescription.insert("state", enumRef<ZigbeeManager::ZigbeeNodeState>());
zigbeeNodeDescription.insert("manufacturer", enumValueName(String));
zigbeeNodeDescription.insert("model", enumValueName(String));
zigbeeNodeDescription.insert("version", enumValueName(String));
zigbeeNodeDescription.insert("receiverOnWhileIdle", enumValueName(Bool));
zigbeeNodeDescription.insert("reachable", enumValueName(Bool));
zigbeeNodeDescription.insert("lqi", enumValueName(Uint));
zigbeeNodeDescription.insert("lastSeen", enumValueName(Uint));
registerObject("ZigbeeNode", zigbeeNodeDescription);
QVariantMap params, returns;
QString description;
@ -163,6 +181,23 @@ ZigbeeHandler::ZigbeeHandler(ZigbeeManager *zigbeeManager, QObject *parent) :
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("SetPermitJoin", description, params, returns);
// GetNodes
params.clear(); returns.clear();
description = "Returns the list of ZigBee nodes from the network the given \'networkUuid\' in the system.";
params.insert("networkUuid", enumValueName(Uuid));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
returns.insert("o:zigbeeNodes", QVariantList() << objectRef("ZigbeeNode"));
registerMethod("GetNodes", description, params, returns);
// RemoveNode
params.clear(); returns.clear();
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));
params.insert("ieeeAddress", enumValueName(String));
returns.insert("zigbeeError", enumRef<ZigbeeManager::ZigbeeError>());
registerMethod("RemoveNode", description, params, returns);
connect(m_zigbeeManager, &ZigbeeManager::availableAdapterAdded, this, [this](const ZigbeeAdapter &adapter){
QVariantMap params;
@ -278,6 +313,53 @@ JsonReply *ZigbeeHandler::SetPermitJoin(const QVariantMap &params)
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)
@ -338,4 +420,44 @@ QVariantMap ZigbeeHandler::packNetwork(ZigbeeNetwork *network)
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;
}
}

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

@ -51,13 +51,18 @@ public:
Q_INVOKABLE JsonReply *GetAvailableBackends(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetAdapters(const QVariantMap &params);
Q_INVOKABLE JsonReply *GetNetworks(const QVariantMap &params);
Q_INVOKABLE JsonReply *AddNetwork(const QVariantMap &params);
Q_INVOKABLE JsonReply *RemoveNetwork(const QVariantMap &params);
Q_INVOKABLE JsonReply *FactoryResetNetwork(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 packNode(ZigbeeNode *node);
private:
ZigbeeManager *m_zigbeeManager = nullptr;
@ -68,7 +73,9 @@ signals:
void NetworkAdded(const QVariantMap &params);
void NetworkRemoved(const QVariantMap &params);
void NetworkChanged(const QVariantMap &params);
void NodeAdded(const QVariantMap &params);
void NodeRemoved(const QVariantMap &params);
void NodeChanged(const QVariantMap &params);
};
}

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

@ -60,10 +60,28 @@ public:
ZigbeeErrorNetworkUuidNotFound,
ZigbeeErrorDurationOutOfRange,
ZigbeeErrorNetworkOffline,
ZigbeeErrorUnknownBackend
ZigbeeErrorUnknownBackend,
ZigbeeErrorNodeNotFound,
ZigbeeErrorForbidden
};
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);
bool available() const;