ETM-Schurig
/
nymea-zigbee
mirror of https://github.com/nymea/nymea-zigbee
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
nymea-zigbee/libqtzigbee/zigbeenode.cpp

543 lines
22 KiB
C++
Raw Blame History

#include "zigbeenode.h"
#include "zigbeeutils.h"
#include "loggingcategory.h"
#include <QDataStream>
quint16 ZigbeeNode::shortAddress() const
{
return m_shortAddress;
}
ZigbeeAddress ZigbeeNode::extendedAddress() const
{
return m_extendedAddress;
}
int ZigbeeNode::endPoint() const
{
return m_endPoint;
}
ZigbeeNode::NodeType ZigbeeNode::nodeType() const
{
return m_nodeType;
}
ZigbeeNode::FrequencyBand ZigbeeNode::frequencyBand() const
{
return m_frequencyBand;
}
ZigbeeNode::Relationship ZigbeeNode::relationShip() const
{
return m_relationShip;
}
Zigbee::ZigbeeProfile ZigbeeNode::profile() const
{
return m_profile;
}
quint16 ZigbeeNode::manufacturerCode() const
{
return m_manufacturerCode;
}
ZigbeeNode::PowerMode ZigbeeNode::powerMode() const
{
return m_powerMode;
}
ZigbeeNode::PowerSource ZigbeeNode::powerSource() const
{
return m_powerSource;
}
QList<ZigbeeNode::PowerSource> ZigbeeNode::availablePowerSources() const
{
return m_availablePowerSources;
}
ZigbeeNode::PowerLevel ZigbeeNode::powerLevel() const
{
return m_powerLevel;
}
void ZigbeeNode::init()
{
requestNodeDescription();
requestSimpleNodeDescription();
requestPowerDescriptor();
}
void ZigbeeNode::identify()
{
// QByteArray data;
// QDataStream stream(&data, QIODevice::WriteOnly);
// stream << m_shortAddress;
// stream << static_cast<quint8>(0);
// ZigbeeInterfaceRequest request(ZigbeeInterfaceMessage(Zigbee::MessageTypeManagementLqiRequest, data));
// request.setExpectedAdditionalMessageType(Zigbee::MessageTypeManagementLqiResponse);
// request.setDescription("Node link quality request for " + ZigbeeUtils::convertUint16ToHexString(m_shortAddress));
// request.setTimoutIntervall(10000);
// ZigbeeInterfaceReply *reply = controller()->sendRequest(request);
// connect(reply, &ZigbeeInterfaceReply::finished, this, &ZigbeeNode::onRequestLinkQuality);
}
void ZigbeeNode::toggle(int addressMode)
{
QByteArray data;
QDataStream stream(&data, QIODevice::WriteOnly);
stream << static_cast<quint8>(addressMode); // adress mode
stream << m_shortAddress;
stream << static_cast<quint8>(1); // source endpoint
stream << static_cast<quint8>(1); // destination endpoint
stream << static_cast<quint8>(2); // command toggle
ZigbeeInterfaceRequest request(ZigbeeInterfaceMessage(Zigbee::MessageTypeCluserOnOff, data));
request.setDescription("Toggle request for " + ZigbeeUtils::convertUint16ToHexString(m_shortAddress));
ZigbeeInterfaceReply *reply = controller()->sendRequest(request);
connect(reply, &ZigbeeInterfaceReply::finished, this, &ZigbeeNode::onToggleFinished);
}
void ZigbeeNode::requestNodeDescription()
{
QByteArray data;
QDataStream stream(&data, QIODevice::WriteOnly);
stream << m_shortAddress;
ZigbeeInterfaceRequest request(ZigbeeInterfaceMessage(Zigbee::MessageTypeNodeDescriptorRequest, data));
request.setExpectedAdditionalMessageType(Zigbee::MessageTypeNodeDescriptorRsponse);
request.setDescription("Node descriptor request for " + ZigbeeUtils::convertUint16ToHexString(m_shortAddress));
request.setTimoutIntervall(5000);
ZigbeeInterfaceReply *reply = controller()->sendRequest(request);
connect(reply, &ZigbeeInterfaceReply::finished, this, &ZigbeeNode::onRequestNodeDescriptionFinished);
}
void ZigbeeNode::requestSimpleNodeDescription()
{
QByteArray data;
QDataStream stream(&data, QIODevice::WriteOnly);
stream << m_shortAddress;
stream << quint8(1);
ZigbeeInterfaceRequest request(ZigbeeInterfaceMessage(Zigbee::MessageTypeSimpleDescriptorRequest, data));
request.setExpectedAdditionalMessageType(Zigbee::MessageTypeSimpleDescriptorResponse);
request.setDescription("Simple node descriptor request for " + ZigbeeUtils::convertUint16ToHexString(m_shortAddress));
request.setTimoutIntervall(5000);
ZigbeeInterfaceReply *reply = controller()->sendRequest(request);
connect(reply, &ZigbeeInterfaceReply::finished, this, &ZigbeeNode::onRequestSimpleNodeDescriptionFinished);
}
void ZigbeeNode::requestPowerDescriptor()
{
QByteArray data;
QDataStream stream(&data, QIODevice::WriteOnly);
stream << m_shortAddress;
ZigbeeInterfaceRequest request(ZigbeeInterfaceMessage(Zigbee::MessageTypePowerDescriptorRequest, data));
request.setExpectedAdditionalMessageType(Zigbee::MessageTypePowerDescriptorResponse);
request.setDescription("Node power descriptor request for " + ZigbeeUtils::convertUint16ToHexString(m_shortAddress));
request.setTimoutIntervall(5000);
ZigbeeInterfaceReply *reply = controller()->sendRequest(request);
connect(reply, &ZigbeeInterfaceReply::finished, this, &ZigbeeNode::onRequestPowerDescriptorFinished);
}
void ZigbeeNode::requestUserDescriptor()
{
QByteArray data;
QDataStream stream(&data, QIODevice::WriteOnly);
stream << m_shortAddress;
stream << static_cast<quint16>(0);
ZigbeeInterfaceRequest request(ZigbeeInterfaceMessage(Zigbee::MessageTypeUserDescriptorRequest, data));
request.setExpectedAdditionalMessageType(Zigbee::MessageTypeUserDescriptorResponse);
request.setDescription("Node user descriptor request for " + ZigbeeUtils::convertUint16ToHexString(m_shortAddress));
request.setTimoutIntervall(5000);
ZigbeeInterfaceReply *reply = controller()->sendRequest(request);
connect(reply, &ZigbeeInterfaceReply::finished, this, &ZigbeeNode::onRequestUserDescriptorFinished);
}
ZigbeeNode::ZigbeeNode(ZigbeeBridgeController *controller, QObject *parent) :
QObject(parent),
m_controller(controller)
{
}
ZigbeeBridgeController *ZigbeeNode::controller()
{
return m_controller;
}
void ZigbeeNode::setShortAddress(const quint16 &shortAddress)
{
m_shortAddress = shortAddress;
}
void ZigbeeNode::setExtendedAddress(const ZigbeeAddress &extendedAddress)
{
m_extendedAddress = extendedAddress;
}
void ZigbeeNode::onRequestNodeDescriptionFinished()
{
ZigbeeInterfaceReply *reply = static_cast<ZigbeeInterfaceReply *>(sender());
reply->deleteLater();
if (reply->status() != ZigbeeInterfaceReply::Success) {
qCWarning(dcZigbeeController()) << "Could not" << reply->request().description() << reply->status() << reply->statusErrorMessage();
return;
}
qCDebug(dcZigbeeController()) << reply->request().description() << "finished successfully";
quint8 sequenceNumber = static_cast<quint8>(reply->additionalMessage().data().at(0));
quint8 status = static_cast<quint8>(reply->additionalMessage().data().at(1));
quint16 shortAddress = reply->additionalMessage().data().at(2);
shortAddress <<= 8;
shortAddress |= reply->additionalMessage().data().at(3);
quint16 manufacturerCode = reply->additionalMessage().data().at(4);
manufacturerCode <<= 8;
manufacturerCode |= reply->additionalMessage().data().at(5);
quint16 maximalRxSize = reply->additionalMessage().data().at(6);
maximalRxSize <<= 8;
maximalRxSize |= reply->additionalMessage().data().at(7);
quint16 maximalTxSize = reply->additionalMessage().data().at(8);
maximalTxSize <<= 8;
maximalTxSize |= reply->additionalMessage().data().at(9);
quint16 serverMask = reply->additionalMessage().data().at(10);
serverMask <<= 8;
serverMask |= reply->additionalMessage().data().at(11);
quint8 descriptorFlag = static_cast<quint8>(reply->additionalMessage().data().at(12));
quint8 macFlags = static_cast<quint8>(reply->additionalMessage().data().at(13));
quint8 maxBufferSize = static_cast<quint8>(reply->additionalMessage().data().at(14));
quint16 bitField = reply->additionalMessage().data().at(15);
bitField <<= 8;
bitField |= reply->additionalMessage().data().at(16);
// Set node data
m_manufacturerCode = manufacturerCode;
m_maximalRxSize = maximalRxSize;
m_maximalTxSize = maximalTxSize;
// Parse server mask
m_isPrimaryTrustCenter = ((serverMask >> 0) & 0x0001);
m_isBackupTrustCenter = ((serverMask >> 1) & 0x0001);
m_isPrimaryBindingCache = ((serverMask >> 2) & 0x0001);
m_isBackupBindingCache = ((serverMask >> 3) & 0x0001);
m_isPrimaryDiscoveryCache = ((serverMask >> 4) & 0x0001);
m_isBackupDiscoveryCache = ((serverMask >> 5) & 0x0001);
m_isNetworkManager = ((serverMask >> 6) & 0x0001);
// Parse desciptor flag
bool extendedActiveEndpointListAvailable = ((descriptorFlag >> 0) & 0x01);
bool extendedSimpleDescriptorListAvailable = ((descriptorFlag >> 1) & 0x01);
// Parse MAC capabilities
m_receiverOnWhenIdle = ((macFlags >> 3) & 0x01);
m_securityCapability = ((macFlags >> 6) & 0x01);
// Parse bit field
bool isCoordinator = ((bitField >> 0) & 0x0001);
bool isRouter = ((bitField >> 1) & 0x0001);
bool isEndDevice = ((bitField >> 2) & 0x0001);
bool complexDescriptorAvailable = ((bitField >> 3) & 0x0001);
bool userDescriptorAvailable = ((bitField >> 4) & 0x0001);
if (isCoordinator && !isRouter && !isEndDevice) {
m_nodeType = NodeTypeCoordinator;
} else if (!isCoordinator && isRouter && !isEndDevice) {
m_nodeType = NodeTypeRouter;
} else if (!isCoordinator && !isRouter && isEndDevice) {
m_nodeType = NodeTypeEndDevice;
} else {
if (m_isNetworkManager) {
m_nodeType = NodeTypeCoordinator;
} else {
m_nodeType = NodeTypeEndDevice;
}
}
// Note: Frequency always 2,4 GHz
qCDebug(dcZigbee()) << "Node descriptor:";
qCDebug(dcZigbee()) << " Node type:" << m_nodeType;
qCDebug(dcZigbee()) << " Sequence number:" << ZigbeeUtils::convertByteToHexString(sequenceNumber);
qCDebug(dcZigbee()) << " Status:" << ZigbeeUtils::convertByteToHexString(status);
qCDebug(dcZigbee()) << " Short address:" << ZigbeeUtils::convertUint16ToHexString(shortAddress);
qCDebug(dcZigbee()) << " Manufacturer code:" << ZigbeeUtils::convertUint16ToHexString(manufacturerCode);
qCDebug(dcZigbee()) << " Maximum Rx size:" << ZigbeeUtils::convertUint16ToHexString(m_maximalRxSize);
qCDebug(dcZigbee()) << " Maximum Tx size:" << ZigbeeUtils::convertUint16ToHexString(m_maximalTxSize);
qCDebug(dcZigbee()) << " Server mask:" << ZigbeeUtils::convertUint16ToHexString(serverMask);
qCDebug(dcZigbee()) << " Primary Trust center:" << m_isPrimaryTrustCenter;
qCDebug(dcZigbee()) << " Backup Trust center:" << m_isBackupTrustCenter;
qCDebug(dcZigbee()) << " Primary Binding cache:" << m_isPrimaryBindingCache;
qCDebug(dcZigbee()) << " Backup Binding cache:" << m_isBackupBindingCache;
qCDebug(dcZigbee()) << " Primary Discovery cache:" << m_isPrimaryDiscoveryCache;
qCDebug(dcZigbee()) << " Backup Discovery cache:" << m_isBackupDiscoveryCache;
qCDebug(dcZigbee()) << " Network Manager:" << m_isNetworkManager;
qCDebug(dcZigbee()) << " Descriptor flag:" << ZigbeeUtils::convertByteToHexString(descriptorFlag);
qCDebug(dcZigbee()) << " Extended active endpoint list available:" << extendedActiveEndpointListAvailable;
qCDebug(dcZigbee()) << " Extended simple descriptor list available:" << extendedSimpleDescriptorListAvailable;
qCDebug(dcZigbee()) << " MAC flags:" << ZigbeeUtils::convertByteToHexString(macFlags);
qCDebug(dcZigbee()) << " Receiver on when idle:" << m_receiverOnWhenIdle;
qCDebug(dcZigbee()) << " Security capability:" << m_securityCapability;
qCDebug(dcZigbee()) << " Maximum buffer size:" << ZigbeeUtils::convertByteToHexString(maxBufferSize);
qCDebug(dcZigbee()) << " Bit field:" << ZigbeeUtils::convertUint16ToHexString(bitField);
qCDebug(dcZigbee()) << " Is coordinator:" << isCoordinator;
qCDebug(dcZigbee()) << " Is router:" << isRouter;
qCDebug(dcZigbee()) << " Is end device:" << isEndDevice;
qCDebug(dcZigbee()) << " Complex desciptor available:" << complexDescriptorAvailable;
qCDebug(dcZigbee()) << " User desciptor available:" << userDescriptorAvailable;
if (userDescriptorAvailable) {
requestUserDescriptor();
}
}
void ZigbeeNode::onRequestSimpleNodeDescriptionFinished()
{
ZigbeeInterfaceReply *reply = static_cast<ZigbeeInterfaceReply *>(sender());
reply->deleteLater();
if (reply->status() != ZigbeeInterfaceReply::Success) {
qCWarning(dcZigbeeController()) << "Could not" << reply->request().description() << reply->status() << reply->statusErrorMessage();
return;
}
qCDebug(dcZigbeeController()) << reply->request().description() << "finished successfully";
qCDebug(dcZigbeeController()) << reply->additionalMessage();
quint8 sequenceNumber = static_cast<quint8>(reply->additionalMessage().data().at(0));
quint8 status = static_cast<quint8>(reply->additionalMessage().data().at(1));
quint16 nwkAddress = reply->additionalMessage().data().at(2);
nwkAddress <<= 8;
nwkAddress |= reply->additionalMessage().data().at(3);
quint8 length = static_cast<quint8>(reply->additionalMessage().data().at(4));
if (length == 0) {
qCWarning(dcZigbee()) << "Length 0";
return;
}
quint8 endPoint = static_cast<quint8>(reply->additionalMessage().data().at(5));
quint16 profileId = reply->additionalMessage().data().at(6);
profileId <<= 8;
profileId |= reply->additionalMessage().data().at(7);
quint16 deviceId = reply->additionalMessage().data().at(8);
deviceId <<= 8;
deviceId |= reply->additionalMessage().data().at(9);
quint8 bitField = static_cast<quint8>(reply->additionalMessage().data().at(10));
qCDebug(dcZigbee()) << "Node simple descriptor:";
qCDebug(dcZigbee()) << " Sequence number:" << ZigbeeUtils::convertByteToHexString(sequenceNumber);
qCDebug(dcZigbee()) << " Status:" << ZigbeeUtils::convertByteToHexString(status);
qCDebug(dcZigbee()) << " Nwk address:" << ZigbeeUtils::convertUint16ToHexString(nwkAddress);
qCDebug(dcZigbee()) << " Lenght:" << ZigbeeUtils::convertByteToHexString(length);
qCDebug(dcZigbee()) << " End Point:" << ZigbeeUtils::convertByteToHexString(endPoint);
qCDebug(dcZigbee()) << " Profile:" << ZigbeeUtils::profileIdToString((Zigbee::ZigbeeProfile)profileId);
if (profileId == Zigbee::ZigbeeProfileLightLink) {
qCDebug(dcZigbee()) << " Device ID:" << ZigbeeUtils::convertUint16ToHexString(deviceId) << static_cast<Zigbee::LightLinkDevice>(deviceId);
} else {
qCDebug(dcZigbee()) << " Device ID:" << ZigbeeUtils::convertUint16ToHexString(deviceId) << static_cast<Zigbee::HomeAutomationDevice>(deviceId);
}
qCDebug(dcZigbee()) << " Bit field:" << ZigbeeUtils::convertByteToHexString(bitField);
quint8 inputClusterCount = static_cast<quint8>(reply->additionalMessage().data().at(10));
qCDebug(dcZigbee()) << " Input clusters:";
QByteArray inputClusterListData = reply->additionalMessage().data().mid(11, inputClusterCount * 2);
for (int i = 0; i < inputClusterListData.count(); i+=2) {
quint16 clusterId = inputClusterListData.at(i);
clusterId <<= 8;
clusterId |= inputClusterListData .at(i+1);
qCDebug(dcZigbee()) << " Cluster ID:" << ZigbeeUtils::convertUint16ToHexString(clusterId) << ZigbeeUtils::clusterIdToString(static_cast<Zigbee::ClusterId>(clusterId));
}
quint8 outputClusterCount = static_cast<quint8>(reply->additionalMessage().data().at(12 + inputClusterCount * 2));
qCDebug(dcZigbee()) << " Output clusters:";
QByteArray outputClusterListData = reply->additionalMessage().data().mid(12 + inputClusterCount * 2, outputClusterCount * 2);
for (int i = 0; i < outputClusterListData.count(); i+=2) {
quint16 clusterId = outputClusterListData.at(i);
clusterId <<= 8;
clusterId |= outputClusterListData .at(i+1);
qCDebug(dcZigbee()) << " Cluster ID:" << ZigbeeUtils::convertUint16ToHexString(clusterId) << ZigbeeUtils::clusterIdToString(static_cast<Zigbee::ClusterId>(clusterId));
}
}
void ZigbeeNode::onRequestPowerDescriptorFinished()
{
ZigbeeInterfaceReply *reply = static_cast<ZigbeeInterfaceReply *>(sender());
reply->deleteLater();
if (reply->status() != ZigbeeInterfaceReply::Success) {
qCWarning(dcZigbeeController()) << "Could not" << reply->request().description() << reply->status() << reply->statusErrorMessage();
return;
}
qCDebug(dcZigbeeController()) << reply->request().description() << "finished successfully";
qCDebug(dcZigbeeController()) << reply->additionalMessage();
quint8 sequenceNumber = static_cast<quint8>(reply->additionalMessage().data().at(0));
quint8 status = static_cast<quint8>(reply->additionalMessage().data().at(1));
quint16 bitField = reply->additionalMessage().data().at(2);
bitField <<= 8;
bitField |= reply->additionalMessage().data().at(3);
// Bit 0 - 3 Power mode
// 0000: Receiver configured according to “Receiver on when idle” MAC flag in the Node Descriptor
// 0001: Receiver switched on periodically
// 0010: Receiver switched on when stimulated, e.g. by pressing a button
if (!ZigbeeUtils::checkBitUint16(bitField, 0) && !ZigbeeUtils::checkBitUint16(bitField, 1)) {
m_powerMode = PowerModeAlwaysOn;
} else if (ZigbeeUtils::checkBitUint16(bitField, 0) && !ZigbeeUtils::checkBitUint16(bitField, 1)) {
m_powerMode = PowerModeOnPeriodically;
} else if (!ZigbeeUtils::checkBitUint16(bitField, 0) && ZigbeeUtils::checkBitUint16(bitField, 1)) {
m_powerMode = PowerModeOnWhenStimulated;
}
// Bit 4 - 7 Available power sources
// Bit 0: Permanent mains supply
// Bit 1: Rechargeable battery
// Bit 2: Disposable battery
// Bit 4: Reserved
if (ZigbeeUtils::checkBitUint16(bitField, 4)) {
m_availablePowerSources.append(PowerSourcePermanentMainSupply);
} else if (ZigbeeUtils::checkBitUint16(bitField, 5)) {
m_availablePowerSources.append(PowerSourceRecharchableBattery);
} else if (ZigbeeUtils::checkBitUint16(bitField, 6)) {
m_availablePowerSources.append(PowerSourceDisposableBattery);
}
// Bit 8 - 11 Active source: according to the same schema as available power sources
if (ZigbeeUtils::checkBitUint16(bitField, 8)) {
m_powerSource = PowerSourcePermanentMainSupply;
} else if (ZigbeeUtils::checkBitUint16(bitField, 9)) {
m_powerSource = PowerSourceRecharchableBattery;
} else if (ZigbeeUtils::checkBitUint16(bitField, 10)) {
m_powerSource = PowerSourceDisposableBattery;
}
// Bit 12 - 15: Battery level if available
// 0000: Critically low
// 0100: Approximately 33%
// 1000: Approximately 66%
// 1100: Approximately 100% (near fully charged)
if (!ZigbeeUtils::checkBitUint16(bitField, 14) && !ZigbeeUtils::checkBitUint16(bitField, 15)) {
m_powerLevel = PowerLevelCriticalLow;
} else if (ZigbeeUtils::checkBitUint16(bitField, 14) && !ZigbeeUtils::checkBitUint16(bitField, 15)) {
m_powerLevel = PowerLevelLow;
} else if (!ZigbeeUtils::checkBitUint16(bitField, 14) && ZigbeeUtils::checkBitUint16(bitField, 15)) {
m_powerLevel = PowerLevelOk;
} else if (ZigbeeUtils::checkBitUint16(bitField, 14) && ZigbeeUtils::checkBitUint16(bitField, 15)) {
m_powerLevel = PowerLevelFull;
}
qCDebug(dcZigbee()) << "Node power descriptor:";
qCDebug(dcZigbee()) << " Sequence number:" << ZigbeeUtils::convertByteToHexString(sequenceNumber);
qCDebug(dcZigbee()) << " Status:" << ZigbeeUtils::convertByteToHexString(status);
qCDebug(dcZigbee()) << " Bitfiled:" << ZigbeeUtils::convertUint16ToHexString(bitField);
qCDebug(dcZigbee()) << " Power mode:" << m_powerMode;
qCDebug(dcZigbee()) << " Available power sources:";
foreach (const PowerSource &source, m_availablePowerSources) {
qCDebug(dcZigbee()) << " " << source;
}
qCDebug(dcZigbee()) << " Power source:" << m_powerSource;
qCDebug(dcZigbee()) << " Power level:" << m_powerLevel;
}
void ZigbeeNode::onRequestUserDescriptorFinished()
{
ZigbeeInterfaceReply *reply = static_cast<ZigbeeInterfaceReply *>(sender());
reply->deleteLater();
if (reply->status() != ZigbeeInterfaceReply::Success) {
qCWarning(dcZigbeeController()) << "Could not" << reply->request().description() << reply->status() << reply->statusErrorMessage();
return;
}
qCDebug(dcZigbeeController()) << reply->request().description() << "finished successfully";
qCDebug(dcZigbeeController()) << reply->additionalMessage();
quint8 sequenceNumber = static_cast<quint8>(reply->additionalMessage().data().at(0));
quint8 status = static_cast<quint8>(reply->additionalMessage().data().at(1));
quint16 nwkAddress = reply->additionalMessage().data().at(2);
nwkAddress <<= 8;
nwkAddress |= reply->additionalMessage().data().at(3);
quint8 length = static_cast<quint8>(reply->additionalMessage().data().at(4));
QByteArray data;
if (length > 0) {
data = reply->additionalMessage().data().mid(5, length);
}
qCDebug(dcZigbee()) << "User descriptor:";
qCDebug(dcZigbee()) << " Sequence number:" << ZigbeeUtils::convertByteToHexString(sequenceNumber);
qCDebug(dcZigbee()) << " Status:" << ZigbeeUtils::convertByteToHexString(status);
qCDebug(dcZigbee()) << " Attribute address:" << ZigbeeUtils::convertUint16ToHexString(nwkAddress);
qCDebug(dcZigbee()) << " Lenght:" << ZigbeeUtils::convertByteToHexString(length);
qCDebug(dcZigbee()) << " Data:" << data;
}
void ZigbeeNode::onToggleFinished()
{
ZigbeeInterfaceReply *reply = static_cast<ZigbeeInterfaceReply *>(sender());
reply->deleteLater();
if (reply->status() != ZigbeeInterfaceReply::Success) {
qCWarning(dcZigbeeController()) << "Could not" << reply->request().description() << reply->status() << reply->statusErrorMessage();
return;
}
qCDebug(dcZigbeeController()) << reply->request().description() << "finished successfully";
}
void ZigbeeNode::onIdentifyFinished()
{
}
QDebug operator<<(QDebug debug, ZigbeeNode *node)
{
debug.nospace().noquote() << "Node(" << ZigbeeUtils::convertUint16ToHexString(node->shortAddress()) << " | " << node->extendedAddress().toString() << ") ";
debug.nospace().noquote() << " " << ZigbeeUtils::convertUint16ToHexString(node->shortAddress()) << " | " << node->extendedAddress().toString() << ") ";
return debug;
}
Reference in New Issue View Git Blame Copy Permalink