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

Implement basic initialization of NXP network

pull/8/head
Simon Stürz 2020-10-07 14:43:17 +02:00
parent a219fa46ef
commit e00a1ffea0
6 changed files with 156 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
libnymea-zigbee/backends/nxp/interface/nxp.h
View File

@ -10,7 +10,12 @@ public:
enum Command {
CommandGetVersion = 0x00,
CommandGetControllerState = 0x01,
CommandSoftReset = 0x02
CommandSoftReset = 0x02,
CommandFactoryReset = 0x03,
CommandSetPanId = 0x04,
CommandSetChannelMask = 0x05,
CommandSetSecurityKey = 0x06,
CommandStartNetwork = 0x07
};
Q_ENUM(Command)
@ -24,7 +29,8 @@ public:
StatusSuccess = 0x00,
StatusProtocolError = 0x01,
StatusUnknownCommand = 0x02,
StatusInvalidCrc = 0x03
StatusInvalidCrc = 0x03,
StatusStackError = 0x04
};
Q_ENUM(Status)

8
libnymea-zigbee/backends/nxp/interface/zigbeeinterfacenxp.cpp
View File

@ -163,7 +163,7 @@ void ZigbeeInterfaceNxp::onReadyRead()
// Read each byte until we get END byte, then unescape the package
for (int i = 0; i < data.length(); i++) {
quint8 byte = static_cast<quint8>(data.at(i));
qCDebug(dcZigbeeInterfaceTraffic()) << "[in] " << ZigbeeUtils::convertByteToHexString(byte);
//qCDebug(dcZigbeeInterfaceTraffic()) << "[in] " << ZigbeeUtils::convertByteToHexString(byte);
if (byte == ProtocolByteEnd) {
// If there is no data...continue since it might be a starting END byte
if (m_dataBuffer.isEmpty())
@ -235,9 +235,9 @@ void ZigbeeInterfaceNxp::sendPackage(const QByteArray &package)
// Send the data
qCDebug(dcZigbeeInterfaceTraffic()) << "-->" << ZigbeeUtils::convertByteArrayToHexString(data);
for (int i = 0; i < data.length(); i++) {
qCDebug(dcZigbeeInterfaceTraffic()) << "[out]" << ZigbeeUtils::convertByteToHexString(data.at(i));
}
// for (int i = 0; i < data.length(); i++) {
// qCDebug(dcZigbeeInterfaceTraffic()) << "[out]" << ZigbeeUtils::convertByteToHexString(data.at(i));
// }
if (m_serialPort->write(data) < 0) {
qCWarning(dcZigbeeInterface()) << "Could not stream byte" << ZigbeeUtils::convertByteArrayToHexString(data);

103
libnymea-zigbee/backends/nxp/zigbeebridgecontrollernxp.cpp
View File

@ -25,10 +25,11 @@ ZigbeeBridgeControllerNxp::ControllerState ZigbeeBridgeControllerNxp::controller
ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestVersion()
{
QByteArray message;
bumpSequenceNumber();
QDataStream stream(&message, QIODevice::WriteOnly);
stream.setByteOrder(QDataStream::LittleEndian);
stream << static_cast<quint8>(Nxp::CommandGetVersion);
stream << static_cast<quint8>(m_sequenceNumber++);
stream << static_cast<quint8>(m_sequenceNumber);
stream << static_cast<quint16>(0); // Frame length
return createReply(Nxp::CommandGetVersion, m_sequenceNumber, "Request controller version", message, this);
@ -37,10 +38,11 @@ ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestVersion()
ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestControllerState()
{
QByteArray message;
bumpSequenceNumber();
QDataStream stream(&message, QIODevice::WriteOnly);
stream.setByteOrder(QDataStream::LittleEndian);
stream << static_cast<quint8>(Nxp::CommandGetControllerState);
stream << static_cast<quint8>(m_sequenceNumber++);
stream << static_cast<quint8>(m_sequenceNumber);
stream << static_cast<quint16>(0); // Frame length
return createReply(Nxp::CommandGetControllerState, m_sequenceNumber, "Request controller state", message, this);
@ -49,15 +51,57 @@ ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestControllerState()
ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestSoftResetController()
{
QByteArray message;
bumpSequenceNumber();
QDataStream stream(&message, QIODevice::WriteOnly);
stream.setByteOrder(QDataStream::LittleEndian);
stream << static_cast<quint8>(Nxp::CommandSoftReset);
stream << static_cast<quint8>(m_sequenceNumber++);
stream << static_cast<quint8>(m_sequenceNumber);
stream << static_cast<quint16>(0); // Frame length
return createReply(Nxp::CommandSoftReset, m_sequenceNumber, "Request soft reset controller", message, this);
}
ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestFactoryResetController()
{
QByteArray message;
bumpSequenceNumber();
QDataStream stream(&message, QIODevice::WriteOnly);
stream.setByteOrder(QDataStream::LittleEndian);
stream << static_cast<quint8>(Nxp::CommandFactoryReset);
stream << static_cast<quint8>(m_sequenceNumber);
stream << static_cast<quint16>(0); // Frame length
return createReply(Nxp::CommandFactoryReset, m_sequenceNumber, "Request factory reset controller", message, this);
}
ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestSetPanId(quint64 panId)
{
QByteArray message;
bumpSequenceNumber();
QDataStream stream(&message, QIODevice::WriteOnly);
stream.setByteOrder(QDataStream::LittleEndian);
stream << static_cast<quint8>(Nxp::CommandSetPanId);
stream << static_cast<quint8>(m_sequenceNumber);
stream << static_cast<quint16>(8); // Frame length
stream << panId;
return createReply(Nxp::CommandSetPanId, m_sequenceNumber, "Request set PAN ID", message, this);
}
ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::requestSetChannelMask(quint32 channelMask)
{
QByteArray message;
bumpSequenceNumber();
QDataStream stream(&message, QIODevice::WriteOnly);
stream.setByteOrder(QDataStream::LittleEndian);
stream << static_cast<quint8>(Nxp::CommandSetChannelMask);
stream << static_cast<quint8>(m_sequenceNumber);
stream << static_cast<quint16>(4); // Frame length
stream << channelMask;
return createReply(Nxp::CommandSetChannelMask, m_sequenceNumber, "Request set channel mask", message, this);
}
ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::createReply(Nxp::Command command, quint8 sequenceNumber, const QString &requestName, const QByteArray &requestData, QObject *parent)
{
// Create the reply
@ -65,23 +109,32 @@ ZigbeeInterfaceNxpReply *ZigbeeBridgeControllerNxp::createReply(Nxp::Command com
reply->m_requestName = requestName;
reply->m_requestData = requestData;
reply->m_sequenceNumber = sequenceNumber;
// Make sure we clean up on timeout
connect(reply, &ZigbeeInterfaceNxpReply::timeout, this, [reply](){
qCWarning(dcZigbeeController()) << "Reply timeout" << reply;
});
// Auto delete the object on finished
connect(reply, &ZigbeeInterfaceNxpReply::finished, reply, [reply](){
qCDebug(dcZigbeeController()) << "Interface reply finished" << reply->command() << reply->sequenceNumber() << reply->status();
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [this, reply](){
reply->deleteLater();
if (m_currentReply == reply) {
m_currentReply = nullptr;
QMetaObject::invokeMethod(this, "sendNextRequest", Qt::QueuedConnection);
}
});
m_pendingReplies.insert(sequenceNumber, reply);
m_interface->sendPackage(requestData);
qCDebug(dcZigbeeController()) << "Enqueue request" << reply->command() << "SQN:" << reply->sequenceNumber();
m_replyQueue.enqueue(reply);
QMetaObject::invokeMethod(this, "sendNextRequest", Qt::QueuedConnection);
return reply;
}
void ZigbeeBridgeControllerNxp::bumpSequenceNumber()
{
m_sequenceNumber += 1;
}
void ZigbeeBridgeControllerNxp::onInterfaceAvailableChanged(bool available)
{
qCDebug(dcZigbeeController()) << "Interface available changed" << available;
@ -106,14 +159,14 @@ void ZigbeeBridgeControllerNxp::onInterfacePackageReceived(const QByteArray &pac
}
Nxp::Notification notification = static_cast<Nxp::Notification>(commandInt);
//qCDebug(dcZigbeeController()) << "Interface notification received" << notification << "SQN:" << sequenceNumber << ZigbeeUtils::convertByteArrayToHexString(data);
qCDebug(dcZigbeeController()) << "Interface notification received" << notification << "SQN:" << sequenceNumber << ZigbeeUtils::convertByteArrayToHexString(data);
switch (notification) {
case Nxp::NotificationDebugMessage:
if (data.isEmpty()) {
qCWarning(dcZigbeeController()) << "Received empty debug log notification";
return;
}
qCDebug(dcZigbeeController()) << "DEBUG" << static_cast<Nxp::LogLevel>(data.at(0)) << qUtf8Printable(data.right(data.length() - 1));
qCDebug(dcZigbeeController()) << "*****DEBUG*****" << static_cast<Nxp::LogLevel>(data.at(0)) << Qt::endl << qUtf8Printable(data.right(data.length() - 1));
break;
case Nxp::NotificationDeviceStatusChanged:
m_controllerState = static_cast<ControllerState>(data.at(0));
@ -135,21 +188,37 @@ void ZigbeeBridgeControllerNxp::onInterfacePackageReceived(const QByteArray &pac
Nxp::Command command = static_cast<Nxp::Command>(commandInt);
Nxp::Status status = static_cast<Nxp::Status>(statusInt);
qCDebug(dcZigbeeController()) << "Interface response received" << command << "SQN:" << sequenceNumber << status << ZigbeeUtils::convertByteArrayToHexString(data);
if (m_pendingReplies.keys().contains(sequenceNumber)) {
ZigbeeInterfaceNxpReply * reply = m_pendingReplies.take(sequenceNumber);
if (reply->command() == command) {
reply->m_status = status;
reply->m_responseData = data;
if (m_currentReply->sequenceNumber() == sequenceNumber) {
if (m_currentReply->command() == command) {
m_currentReply->m_status = status;
m_currentReply->m_responseData = data;
} else {
qCWarning(dcZigbeeController()) << "Received interface response for a pending sequence number but the command does not match the request." << command << reply->command();
qCWarning(dcZigbeeController()) << "Received interface response for a pending sequence number but the command does not match the request." << command << m_currentReply->command();
}
reply->setFinished();
m_currentReply->setFinished();
} else {
qCWarning(dcZigbeeController()) << "Received a response for a non pending reply. There is no pending reply for command" << command << "SQN:" << sequenceNumber;
}
}
}
void ZigbeeBridgeControllerNxp::sendNextRequest()
{
// Check if there is a reply request to send
if (m_replyQueue.isEmpty())
return;
// Check if there is currently a running reply
if (m_currentReply)
return;
// Send next message
m_currentReply = m_replyQueue.dequeue();
qCDebug(dcZigbeeController()) << "Send request" << m_currentReply;
m_interface->sendPackage(m_currentReply->requestData());
m_currentReply->m_timer->start();
}
bool ZigbeeBridgeControllerNxp::enable(const QString &serialPort, qint32 baudrate)
{
return m_interface->enable(serialPort, baudrate);

13
libnymea-zigbee/backends/nxp/zigbeebridgecontrollernxp.h
View File

@ -17,6 +17,9 @@
class ZigbeeBridgeControllerNxp : public ZigbeeBridgeController
{
Q_OBJECT
friend class ZigbeeNetworkNxp;
public:
explicit ZigbeeBridgeControllerNxp(QObject *parent = nullptr);
~ZigbeeBridgeControllerNxp() override;
@ -36,6 +39,9 @@ public:
ZigbeeInterfaceNxpReply *requestVersion();
ZigbeeInterfaceNxpReply *requestControllerState();
ZigbeeInterfaceNxpReply *requestSoftResetController();
ZigbeeInterfaceNxpReply *requestFactoryResetController();
ZigbeeInterfaceNxpReply *requestSetPanId(quint64 panId);
ZigbeeInterfaceNxpReply *requestSetChannelMask(quint32 channelMask);
signals:
void controllerStateChanged(ControllerState controllerState);
@ -46,13 +52,18 @@ private:
ControllerState m_controllerState = ControllerStateNotRunning;
quint8 m_sequenceNumber = 0;
QHash<quint8, ZigbeeInterfaceNxpReply *> m_pendingReplies;
ZigbeeInterfaceNxpReply *m_currentReply = nullptr;
QQueue<ZigbeeInterfaceNxpReply *> m_replyQueue;
ZigbeeInterfaceNxpReply *createReply(Nxp::Command command, quint8 sequenceNumber, const QString &requestName, const QByteArray &requestData, QObject *parent);
void bumpSequenceNumber();
private slots:
void onInterfaceAvailableChanged(bool available);
void onInterfacePackageReceived(const QByteArray &package);
void sendNextRequest();
public slots:
bool enable(const QString &serialPort, qint32 baudrate);
void disable();

44
libnymea-zigbee/backends/nxp/zigbeenetworknxp.cpp
View File

@ -2,6 +2,8 @@
#include "loggingcategory.h"
#include "zigbeeutils.h"
#include <QDataStream>
ZigbeeNetworkNxp::ZigbeeNetworkNxp(QObject *parent) :
ZigbeeNetwork(parent)
{
@ -49,8 +51,19 @@ void ZigbeeNetworkNxp::onControllerStateChanged(ZigbeeBridgeControllerNxp::Contr
case ZigbeeBridgeControllerNxp::ControllerStateRunning: {
qCDebug(dcZigbeeNetwork()) << "Request controller version";
ZigbeeInterfaceNxpReply *reply = m_controller->requestVersion();
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [reply](){
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [this, reply](){
qCDebug(dcZigbeeNetwork()) << "Version reply finished" << reply->status();
QByteArray payload = reply->responseData();
QDataStream stream(&payload, QIODevice::ReadOnly);
stream.setByteOrder(QDataStream::LittleEndian);
quint8 major = 0; quint8 minor = 0; quint8 patch = 0; quint16 sdkVersion = 0;
stream >> major >> minor >> patch >> sdkVersion;
QString versionString = QString ("%1.%2.%3 - %4").arg(major).arg(minor).arg(patch).arg(sdkVersion);
qCDebug(dcZigbeeNetwork()) << "Controller version" << versionString;
m_controller->setFirmwareVersion(versionString);
// We are done here...
});
break;
@ -62,8 +75,30 @@ void ZigbeeNetworkNxp::onControllerStateChanged(ZigbeeBridgeControllerNxp::Contr
case ZigbeeBridgeControllerNxp::ControllerStateRunningUninitialized: {
qCDebug(dcZigbeeNetwork()) << "Request controller version";
ZigbeeInterfaceNxpReply *reply = m_controller->requestVersion();
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [reply](){
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [this, reply](){
qCDebug(dcZigbeeNetwork()) << "Version reply finished" << reply->status();
QByteArray payload = reply->responseData();
QDataStream stream(&payload, QIODevice::ReadOnly);
stream.setByteOrder(QDataStream::LittleEndian);
quint8 major = 0; quint8 minor = 0; quint8 patch = 0; quint16 sdkVersion = 0;
stream >> major >> minor >> patch >> sdkVersion;
QString versionString = QString ("%1.%2.%3 - %4").arg(major).arg(minor).arg(patch).arg(sdkVersion);
qCDebug(dcZigbeeNetwork()) << "Controller version" << versionString;
m_controller->setFirmwareVersion(versionString);
qCDebug(dcZigbeeNetwork()) << "Set pan id" << ZigbeeUtils::convertUint64ToHexString(extendedPanId()) << extendedPanId();
ZigbeeInterfaceNxpReply *reply = m_controller->requestSetPanId(extendedPanId());
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [this, reply](){
qCDebug(dcZigbeeNetwork()) << "Set PAN ID reply finished" << reply->status();
qCDebug(dcZigbeeNetwork()) << "Set channel mask" << channelMask() << ZigbeeUtils::convertUint32ToHexString(channelMask().toUInt32()) << channelMask().toUInt32();
ZigbeeInterfaceNxpReply *reply = m_controller->requestSetChannelMask(channelMask().toUInt32());
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [reply](){
qCDebug(dcZigbeeNetwork()) << "Set channel mask reply finished" << reply->status();
});
});
});
break;
}
@ -110,5 +145,8 @@ void ZigbeeNetworkNxp::reset()
void ZigbeeNetworkNxp::factoryResetNetwork()
{
ZigbeeInterfaceNxpReply *reply = m_controller->requestFactoryResetController();
connect(reply, &ZigbeeInterfaceNxpReply::finished, this, [](){
qCDebug(dcZigbeeNetwork()) << "Factory reset reply finished";
});
}

4
zigbee-cli/main.cpp
View File

@ -168,6 +168,10 @@ int main(int argc, char *argv[])
network->setSerialPortName(parser.value(serialOption));
network->setSerialBaudrate(baudrate);
network->setSettingsFileName("/tmp/zigbee.conf");
network->setExtendedPanId(5);
ZigbeeChannelMask mask;
mask.setChannel(Zigbee::ZigbeeChannel13);
network->setChannelMask(mask);
network->startNetwork();
//Core core(parser.value(serialOption), baudrate, channel);