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/libnymea-zigbee/zigbeenode.cpp

512 lines
14 KiB
C++
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Copyright 2013 - 2020, nymea GmbH
* Contact: contact@nymea.io
*
* This file is part of nymea.
* This project including source code and documentation is protected by copyright law, and
* remains the property of nymea GmbH. All rights, including reproduction, publication,
* editing and translation, are reserved. The use of 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 under https://nymea.io/license
*
* GNU Lesser General Public License Usage
* Alternatively, this project may be redistributed and/or modified under the 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 it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU Lesser General Public License for more details.
*
* 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/>.
*
* For any further details and any questions please contact us under contact@nymea.io
* or see our FAQ/Licensing Information on https://nymea.io/license/faq
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "zigbeenode.h"
#include "zigbeeutils.h"
#include "loggingcategory.h"
#include <QDataStream>
ZigbeeNode::ZigbeeNode(QObject *parent) :
QObject(parent)
{
}
ZigbeeNode::State ZigbeeNode::state() const
{
return m_state;
}
bool ZigbeeNode::connected() const
{
return m_connected;
}
quint16 ZigbeeNode::shortAddress() const
{
return m_shortAddress;
}
ZigbeeAddress ZigbeeNode::extendedAddress() const
{
return m_extendedAddress;
}
quint8 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;
}
quint16 ZigbeeNode::deviceId() const
{
return m_deviceId;
}
bool ZigbeeNode::complexDescriptorAvailable() const
{
return m_complexDescriptorAvailable;
}
bool ZigbeeNode::userDescriptorAvailable() const
{
return m_userDescriptorAvailable;
}
quint16 ZigbeeNode::maximumRxSize() const
{
return m_maximumRxSize;
}
quint16 ZigbeeNode::maximumTxSize() const
{
return m_maximumTxSize;
}
quint8 ZigbeeNode::maximumBufferSize() const
{
return m_maximumBufferSize;
}
QList<ZigbeeCluster *> ZigbeeNode::inputClusters() const
{
return m_inputClusters.values();
}
ZigbeeCluster *ZigbeeNode::getInputCluster(Zigbee::ClusterId clusterId) const
{
return m_inputClusters.value(clusterId);
}
bool ZigbeeNode::hasInputCluster(Zigbee::ClusterId clusterId) const
{
return m_inputClusters.keys().contains(clusterId);
}
QList<ZigbeeCluster *> ZigbeeNode::outputClusters() const
{
return m_outputClusters.values();
}
bool ZigbeeNode::hasOutputCluster(Zigbee::ClusterId clusterId) const
{
return m_outputClusters.keys().contains(clusterId);
}
ZigbeeCluster *ZigbeeNode::getOutputCluster(Zigbee::ClusterId clusterId) const
{
return m_outputClusters.value(clusterId);
}
bool ZigbeeNode::isPrimaryTrustCenter() const
{
return m_isPrimaryTrustCenter;
}
bool ZigbeeNode::isBackupTrustCenter() const
{
return m_isBackupTrustCenter;
}
bool ZigbeeNode::isPrimaryBindingCache() const
{
return m_isPrimaryBindingCache;
}
bool ZigbeeNode::isBackupBindingCache() const
{
return m_isBackupBindingCache;
}
bool ZigbeeNode::isPrimaryDiscoveryCache() const
{
return m_isPrimaryDiscoveryCache;
}
bool ZigbeeNode::isBackupDiscoveryCache() const
{
return m_isBackupDiscoveryCache;
}
bool ZigbeeNode::isNetworkManager() const
{
return m_isNetworkManager;
}
bool ZigbeeNode::extendedActiveEndpointListAvailable() const
{
return m_extendedActiveEndpointListAvailable;
}
bool ZigbeeNode::extendedSimpleDescriptorListAvailable() const
{
return m_extendedSimpleDescriptorListAvailable;
}
bool ZigbeeNode::alternatePanCoordinator() const
{
return m_alternatePanCoordinator;
}
ZigbeeNode::DeviceType ZigbeeNode::deviceType() const
{
return m_deviceType;
}
bool ZigbeeNode::powerSourceFlagMainPower() const
{
return m_powerSourceFlagMainPower;
}
bool ZigbeeNode::receiverOnWhenIdle() const
{
return m_receiverOnWhenIdle;
}
bool ZigbeeNode::securityCapability() const
{
return m_securityCapability;
}
bool ZigbeeNode::allocateAddress() const
{
return m_allocateAddress;
}
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::setState(ZigbeeNode::State state)
{
if (m_state == state)
return;
qCDebug(dcZigbeeNode()) << "State changed" << state;
m_state = state;
emit stateChanged(m_state);
}
void ZigbeeNode::setConnected(bool connected)
{
if (m_connected == connected)
return;
qCDebug(dcZigbeeNode()) << "Connected changed" << connected;
m_connected = connected;
emit connectedChanged(m_connected);
}
//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::setShortAddress(const quint16 &shortAddress)
{
m_shortAddress = shortAddress;
}
void ZigbeeNode::setExtendedAddress(const ZigbeeAddress &extendedAddress)
{
m_extendedAddress = extendedAddress;
}
void ZigbeeNode::setEndPoint(quint8 endPoint)
{
m_endPoint = endPoint;
}
void ZigbeeNode::setNodeType(ZigbeeNode::NodeType nodeType)
{
m_nodeType = nodeType;
}
void ZigbeeNode::setFrequencyBand(ZigbeeNode::FrequencyBand frequencyBand)
{
m_frequencyBand = frequencyBand;
}
void ZigbeeNode::setRelationship(ZigbeeNode::Relationship relationship)
{
m_relationship = relationship;
}
void ZigbeeNode::setZigbeeProfile(Zigbee::ZigbeeProfile profile)
{
m_profile = profile;
}
void ZigbeeNode::setManufacturerCode(quint16 manufacturerCode)
{
m_manufacturerCode = manufacturerCode;
}
void ZigbeeNode::setDeviceId(quint16 deviceId)
{
m_deviceId = deviceId;
}
void ZigbeeNode::setMaximumRxSize(quint16 size)
{
m_maximumRxSize = size;
}
void ZigbeeNode::setMaximumTxSize(quint16 size)
{
m_maximumTxSize = size;
}
void ZigbeeNode::setMaximumBufferSize(quint8 size)
{
m_maximumBufferSize = size;
}
void ZigbeeNode::setServerMask(quint16 serverMask)
{
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);
}
void ZigbeeNode::setComplexDescriptorAvailable(bool complexDescriptorAvailable)
{
m_complexDescriptorAvailable = complexDescriptorAvailable;
}
void ZigbeeNode::setUserDescriptorAvailable(bool userDescriptorAvailable)
{
m_userDescriptorAvailable = userDescriptorAvailable;
}
void ZigbeeNode::setMacCapabilitiesFlag(quint16 macFlag)
{
// Parse MAC capabilities
m_alternatePanCoordinator = ((macFlag >> 0) & 0x01);
if (((macFlag >> 1) & 0x01)) {
m_deviceType = DeviceTypeFullFunction;
} else {
m_deviceType = DeviceTypeReducedFunction;
}
m_powerSourceFlagMainPower = ((macFlag >> 2) & 0x01);
m_receiverOnWhenIdle = ((macFlag >> 3) & 0x01);
m_securityCapability = ((macFlag >> 6) & 0x01);
m_allocateAddress = ((macFlag >> 7) & 0x01);
}
void ZigbeeNode::setDescriptorFlag(quint8 descriptorFlag)
{
m_extendedActiveEndpointListAvailable = ((descriptorFlag >> 0) & 0x01);
m_extendedSimpleDescriptorListAvailable = ((descriptorFlag >> 1) & 0x01);
}
void ZigbeeNode::setPowerMode(ZigbeeNode::PowerMode powerMode)
{
m_powerMode = powerMode;
}
void ZigbeeNode::setPowerSource(ZigbeeNode::PowerSource powerSource)
{
m_powerSource = powerSource;
}
void ZigbeeNode::setAvailablePowerSources(QList<ZigbeeNode::PowerSource> availablePowerSources)
{
m_availablePowerSources = availablePowerSources;
}
void ZigbeeNode::setPowerLevel(ZigbeeNode::PowerLevel powerLevel)
{
m_powerLevel = powerLevel;
}
void ZigbeeNode::setClusterAttribute(Zigbee::ClusterId clusterId, const ZigbeeClusterAttribute &attribute)
{
qCDebug(dcZigbeeNode()) << this << "cluster attribute changed" << clusterId << attribute;
ZigbeeCluster *cluster = m_outputClusters.value(clusterId);
// Note: create the cluster if not there yet
bool clusterCreated = false;
if (!cluster) {
cluster = new ZigbeeCluster(clusterId, this);
qCDebug(dcZigbeeNode()) << "Created cluster" << cluster;
connect(cluster, &ZigbeeCluster::attributeChanged, this, &ZigbeeNode::onClusterAttributeChanged);
m_outputClusters.insert(clusterId, cluster);
clusterCreated = true;
}
// Set the attribute if valid
if (attribute.isValid())
cluster->setAttribute(attribute);
if (clusterCreated)
emit clusterAdded(cluster);
}
void ZigbeeNode::onClusterAttributeChanged(const ZigbeeClusterAttribute &attribute)
{
ZigbeeCluster *cluster = static_cast<ZigbeeCluster *>(sender());
qCDebug(dcZigbeeNode()) << "Cluster" << cluster << "attribute changed" << attribute;
emit clusterAttributeChanged(cluster, attribute);
}
//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 = static_cast<quint16>(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(dcZigbeeNetwork()) << "User descriptor:";
// qCDebug(dcZigbeeNetwork()) << " Sequence number:" << ZigbeeUtils::convertByteToHexString(sequenceNumber);
// qCDebug(dcZigbeeNetwork()) << " Status:" << ZigbeeUtils::convertByteToHexString(status);
// qCDebug(dcZigbeeNetwork()) << " Attribute address:" << ZigbeeUtils::convertUint16ToHexString(nwkAddress);
// qCDebug(dcZigbeeNetwork()) << " Lenght:" << ZigbeeUtils::convertByteToHexString(length);
// qCDebug(dcZigbeeNetwork()) << " 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() << "ZigbeeNode(" << ZigbeeUtils::convertUint16ToHexString(node->shortAddress()) << ", " << node->extendedAddress().toString() << ") ";
return debug;
}
Reference in New Issue View Git Blame Copy Permalink