mirrors
/
Tasmota
mirror of https://github.com/arendst/Tasmota.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #6332 from s-hadinger/zigbee_phase_2 

Add Zigbee support phase 2
This commit is contained in:
Theo Arends 2019-08-31 23:36:44 +02:00 committed by GitHub
parent ae4735af5c 42d3f1f677
commit 7edcb84eab
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 1538 additions and 412 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
sonoff/_changelog.ino
View File

@ -4,6 +4,7 @@
* Add Full support of all protocols in IRremoteESP8266, to be used on dedicated-IR Tasmota version. Warning: +81k Flash when compiling with USE_IR_REMOTE_FULL * Add Full support of all protocols in IRremoteESP8266, to be used on dedicated-IR Tasmota version. Warning: +81k Flash when compiling with USE_IR_REMOTE_FULL
* Add compile time define USE_WS2812_HARDWARE to select hardware type WS2812, WS2812X, WS2813, SK6812, LC8812 or APA106 (DMA mode only) * Add compile time define USE_WS2812_HARDWARE to select hardware type WS2812, WS2812X, WS2813, SK6812, LC8812 or APA106 (DMA mode only)
* Add 'sonoff-ir' pre-packaged IR-dedicated firmware and 'sonoff-ircustom' to customize firmware with IR Full protocol support * Add 'sonoff-ir' pre-packaged IR-dedicated firmware and 'sonoff-ircustom' to customize firmware with IR Full protocol support
* Add Zigbee support phase 2 - cc2530 initialization and basic ZCL decoding
* *
* 6.6.0.8 20190827 * 6.6.0.8 20190827
* Add Tuya Energy monitoring by Shantur Rathore * Add Tuya Energy monitoring by Shantur Rathore

6
sonoff/i18n.h
View File

@ -444,6 +444,12 @@
#define D_CMND_LATITUDE "Latitude" #define D_CMND_LATITUDE "Latitude"
#define D_CMND_LONGITUDE "Longitude" #define D_CMND_LONGITUDE "Longitude"
// Commands xdrv_23_zigbee.ino
#define D_CMND_ZIGBEEZNPSEND "ZigbeeZNPSend"
#define D_JSON_ZIGBEEZNPRECEIVED "ZigbeeZNPReceived"
#define D_JSON_ZIGBEEZNPSENT "ZigbeeZNPSent"
#define D_JSON_ZIGBEEZCLRECEIVED "ZigbeeZCLReceived"
#define D_JSON_ZIGBEEZCLSENT "ZigbeeZCLSent"
/********************************************************************************************/ /********************************************************************************************/
#define D_ASTERISK_PWD "****" #define D_ASTERISK_PWD "****"

6
sonoff/my_user_config.h
View File

@ -491,6 +491,12 @@
// -- Zigbee interface ---------------------------- // -- Zigbee interface ----------------------------
//#define USE_ZIGBEE // Enable serial communication with Zigbee CC2530 flashed with ZNP //#define USE_ZIGBEE // Enable serial communication with Zigbee CC2530 flashed with ZNP
#define USE_ZIGBEE_PANID 0x1A63 // arbitrary PAN ID for Zigbee network, must be unique in the home
#define USE_ZIGBEE_EXTPANID 0xCCCCCCCCCCCCCCCCL // arbitrary extended PAN ID
#define USE_ZIGBEE_CHANNEL 0x00000800 // Zigbee Channel (11)
#define USE_ZIGBEE_PRECFGKEY_L 0x0F0D0B0907050301L // note: changing requires to re-pair all devices
#define USE_ZIGBEE_PRECFGKEY_H 0x0D0C0A0806040200L // note: changing requires to re-pair all devices
#define USE_ZIGBEE_PERMIT_JOIN false // don't allow joining by default
// ------------------------------------------------ // ------------------------------------------------

159
sonoff/support_static_buffer.ino Normal file
View File

@ -0,0 +1,159 @@
/*
support_buffer.ino - Static binary buffer for Zigbee
Copyright (C) 2019 Theo Arends and Stephan Hadinger
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
typedef struct SBuffer_impl {
uint16_t size; // size in bytes of the buffer
uint16_t len; // current size of the data in buffer. Invariant: len <= size
uint8_t buf[]; // the actual data
} SBuffer_impl;
typedef class SBuffer {
protected:
SBuffer(void) {
// unused empty constructor except from subclass
}
public:
SBuffer(const size_t size) {
_buf = (SBuffer_impl*) new char[size+4]; // add 4 bytes for size and len
_buf->size = size;
_buf->len = 0;
//*((uint32_t*)_buf) = size; // writing both size and len=0 in a single 32 bits write
}
inline size_t getSize(void) const { return _buf->size; }
inline size_t size(void) const { return _buf->size; }
inline size_t getLen(void) const { return _buf->len; }
inline size_t len(void) const { return _buf->len; }
inline uint8_t *getBuffer(void) const { return _buf->buf; }
inline uint8_t *buf(void) const { return _buf->buf; }
virtual ~SBuffer(void) {
delete[] _buf;
}
inline void setLen(const size_t len) {
uint16_t old_len = _buf->len;
_buf->len = (len <= _buf->size) ? len : _buf->size;
if (old_len < _buf->len) {
memset((void*) &_buf->buf[old_len], 0, _buf->len - old_len);
}
}
size_t add8(const uint8_t data) { // append 8 bits value
if (_buf->len < _buf->size) { // do we have room for 1 byte
_buf->buf[_buf->len++] = data;
}
return _buf->len;
}
size_t add16(const uint16_t data) { // append 16 bits value
if (_buf->len < _buf->size - 1) { // do we have room for 2 bytes
_buf->buf[_buf->len++] = data;
_buf->buf[_buf->len++] = data >> 8;
}
return _buf->len;
}
size_t add32(const uint32_t data) { // append 32 bits value
if (_buf->len < _buf->size - 3) { // do we have room for 2 bytes
_buf->buf[_buf->len++] = data;
_buf->buf[_buf->len++] = data >> 8;
_buf->buf[_buf->len++] = data >> 16;
_buf->buf[_buf->len++] = data >> 24;
}
return _buf->len;
}
size_t addBuffer(const SBuffer &buf2) {
if (len() + buf2.len() <= size()) {
for (uint32_t i = 0; i < buf2.len(); i++) {
_buf->buf[_buf->len++] = buf2.buf()[i];
}
}
return _buf->len;
}
size_t addBuffer(const char *buf2, size_t len2) {
if (len() + len2 <= size()) {
for (uint32_t i = 0; i < len2; i++) {
_buf->buf[_buf->len++] = pgm_read_byte(&buf2[i]);
}
}
return _buf->len;
}
uint8_t get8(size_t offset) const {
if (offset < _buf->len) {
return _buf->buf[offset];
} else {
return 0;
}
}
uint8_t read8(const size_t offset) const {
if (offset < len()) {
return _buf->buf[offset];
}
return 0;
}
uint16_t get16(const size_t offset) const {
if (offset < len() - 1) {
return _buf->buf[offset] | (_buf->buf[offset+1] << 8);
}
return 0;
}
uint32_t get32(const size_t offset) const {
if (offset < len() - 3) {
return _buf->buf[offset] | (_buf->buf[offset+1] << 8) |
(_buf->buf[offset+2] << 16) | (_buf->buf[offset+3] << 24);
}
return 0;
}
SBuffer subBuffer(const size_t start, size_t len) const {
if (start >= _buf->len) {
len = 0;
} else if (start + len > _buf->len) {
len = _buf->len - start;
}
SBuffer buf2(len);
memcpy(buf2.buf(), buf()+start, len);
buf2._buf->len = len;
return buf2;
}
protected:
SBuffer_impl * _buf;
} SBuffer;
typedef class PreAllocatedSBuffer : public SBuffer {
public:
PreAllocatedSBuffer(const size_t size, void * buffer) {
_buf = (SBuffer_impl*) buffer;
_buf->size = size - 4;
_buf->len = 0;
}
~PreAllocatedSBuffer(void) {
// don't deallocate
_buf = nullptr;
}
} PreAllocatedSBuffer;

412
sonoff/xdrv_23_zigbee.ino
View File

@ -1,412 +0,0 @@
/*
xdrv_23_zigbee.ino - zigbee serial support for Sonoff-Tasmota
Copyright (C) 2019 Theo Arends and Stephan Hadinger
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef USE_ZIGBEE
#define XDRV_23 23
const uint32_t ZIGBEE_BUFFER_SIZE = 256; // Max ZNP frame is SOF+LEN+CMD1+CMD2+250+FCS = 255
const uint8_t ZIGBEE_SOF = 0xFE;
// State machine states
enum class ZnpStates {
S_START = 0,
S_READY
};
// ZNP Constants taken from https://github.com/Frans-Willem/AqaraHub/blob/master/src/znp/znp.h
enum class ZnpCommandType { POLL = 0, SREQ = 2, AREQ = 4, SRSP = 6 };
enum class ZnpSubsystem {
RPC_Error = 0,
SYS = 1,
MAC = 2,
NWK = 3,
AF = 4,
ZDO = 5,
SAPI = 6,
UTIL = 7,
DEBUG = 8,
APP = 9
};
enum class ZnpStatus : uint8_t {
Success = 0x00,
Failure = 0x01,
InvalidParameter = 0x02,
MemError = 0x03,
BufferFull = 0x11
};
typedef uint64_t IEEEAddress;
typedef uint16_t ShortAddress;
enum class AddrMode : uint8_t {
NotPresent = 0,
Group = 1,
ShortAddress = 2,
IEEEAddress = 3,
Broadcast = 0xFF
};
// Commands in the SYS subsystem
enum class SysCommand : uint8_t {
RESET = 0x00,
PING = 0x01,
VERSION = 0x02,
SET_EXTADDR = 0x03,
GET_EXTADDR = 0x04,
RAM_READ = 0x05,
RAM_WRITE = 0x06,
OSAL_NV_ITEM_INIT = 0x07,
OSAL_NV_READ = 0x08,
OSAL_NV_WRITE = 0x09,
OSAL_START_TIMER = 0x0A,
OSAL_STOP_TIMER = 0x0B,
RANDOM = 0x0C,
ADC_READ = 0x0D,
GPIO = 0x0E,
STACK_TUNE = 0x0F,
SET_TIME = 0x10,
GET_TIME = 0x11,
OSAL_NV_DELETE = 0x12,
OSAL_NV_LENGTH = 0x13,
TEST_RF = 0x40,
TEST_LOOPBACK = 0x41,
RESET_IND = 0x80,
OSAL_TIMER_EXPIRED = 0x81,
};
// Commands in the AF subsystem
enum class AfCommand : uint8_t {
REGISTER = 0x00,
DATA_REQUEST = 0x01,
DATA_REQUEST_EXT = 0x02,
DATA_REQUEST_SRC_RTG = 0x03,
INTER_PAN_CTL = 0x10,
DATA_STORE = 0x11,
DATA_RETRIEVE = 0x12,
APSF_CONFIG_SET = 0x13,
DATA_CONFIRM = 0x80,
REFLECT_ERROR = 0x83,
INCOMING_MSG = 0x81,
INCOMING_MSG_EXT = 0x82
};
// Commands in the ZDO subsystem
enum class ZdoCommand : uint8_t {
NWK_ADDR_REQ = 0x00,
IEEE_ADDR_REQ = 0x01,
NODE_DESC_REQ = 0x02,
POWER_DESC_REQ = 0x03,
SIMPLE_DESC_REQ = 0x04,
ACTIVE_EP_REQ = 0x05,
MATCH_DESC_REQ = 0x06,
COMPLEX_DESC_REQ = 0x07,
USER_DESC_REQ = 0x08,
DEVICE_ANNCE = 0x0A,
USER_DESC_SET = 0x0B,
SERVER_DISC_REQ = 0x0C,
END_DEVICE_BIND_REQ = 0x20,
BIND_REQ = 0x21,
UNBIND_REQ = 0x22,
SET_LINK_KEY = 0x23,
REMOVE_LINK_KEY = 0x24,
GET_LINK_KEY = 0x25,
MGMT_NWK_DISC_REQ = 0x30,
MGMT_LQI_REQ = 0x31,
MGMT_RTQ_REQ = 0x32,
MGMT_BIND_REQ = 0x33,
MGMT_LEAVE_REQ = 0x34,
MGMT_DIRECT_JOIN_REQ = 0x35,
MGMT_PERMIT_JOIN_REQ = 0x36,
MGMT_NWK_UPDATE_REQ = 0x37,
MSG_CB_REGISTER = 0x3E,
MGS_CB_REMOVE = 0x3F,
STARTUP_FROM_APP = 0x40,
AUTO_FIND_DESTINATION = 0x41,
EXT_REMOVE_GROUP = 0x47,
EXT_REMOVE_ALL_GROUP = 0x48,
EXT_FIND_ALL_GROUPS_ENDPOINT = 0x49,
EXT_FIND_GROUP = 0x4A,
EXT_ADD_GROUP = 0x4B,
EXT_COUNT_ALL_GROUPS = 0x4C,
NWK_ADDR_RSP = 0x80,
IEEE_ADDR_RSP = 0x81,
NODE_DESC_RSP = 0x82,
POWER_DESC_RSP = 0x83,
SIMPLE_DESC_RSP = 0x84,
ACTIVE_EP_RSP = 0x85,
MATCH_DESC_RSP = 0x86,
COMPLEX_DESC_RSP = 0x87,
USER_DESC_RSP = 0x88,
USER_DESC_CONF = 0x89,
SERVER_DISC_RSP = 0x8A,
END_DEVICE_BIND_RSP = 0xA0,
BIND_RSP = 0xA1,
UNBIND_RSP = 0xA2,
MGMT_NWK_DISC_RSP = 0xB0,
MGMT_LQI_RSP = 0xB1,
MGMT_RTG_RSP = 0xB2,
MGMT_BIND_RSP = 0xB3,
MGMT_LEAVE_RSP = 0xB4,
MGMT_DIRECT_JOIN_RSP = 0xB5,
MGMT_PERMIT_JOIN_RSP = 0xB6,
STATE_CHANGE_IND = 0xC0,
END_DEVICE_ANNCE_IND = 0xC1,
MATCH_DESC_RSP_SENT = 0xC2,
STATUS_ERROR_RSP = 0xC3,
SRC_RTG_IND = 0xC4,
LEAVE_IND = 0xC9,
TC_DEV_IND = 0xCA,
PERMIT_JOIN_IND = 0xCB,
MSG_CB_INCOMING = 0xFF
};
// Commands in the SAPI subsystem
enum class SapiCommand : uint8_t {
START_REQUEST = 0x00,
BIND_DEVICE = 0x01,
ALLOW_BIND = 0x02,
SEND_DATA_REQUEST = 0x03,
READ_CONFIGURATION = 0x04,
WRITE_CONFIGURATION = 0x05,
GET_DEVICE_INFO = 0x06,
FIND_DEVICE_REQUEST = 0x07,
PERMIT_JOINING_REQUEST = 0x08,
SYSTEM_RESET = 0x09,
START_CONFIRM = 0x80,
BIND_CONFIRM = 0x81,
ALLOW_BIND_CONFIRM = 0x82,
SEND_DATA_CONFIRM = 0x83,
FIND_DEVICE_CONFIRM = 0x85,
RECEIVE_DATA_INDICATION = 0x87,
};
// Commands in the UTIL subsystem
enum class UtilCommand : uint8_t {
GET_DEVICE_INFO = 0x00,
GET_NV_INFO = 0x01,
SET_PANID = 0x02,
SET_CHANNELS = 0x03,
SET_SECLEVEL = 0x04,
SET_PRECFGKEY = 0x05,
CALLBACK_SUB_CMD = 0x06,
KEY_EVENT = 0x07,
TIME_ALIVE = 0x09,
LED_CONTROL = 0x0A,
TEST_LOOPBACK = 0x10,
DATA_REQ = 0x11,
SRC_MATCH_ENABLE = 0x20,
SRC_MATCH_ADD_ENTRY = 0x21,
SRC_MATCH_DEL_ENTRY = 0x22,
SRC_MATCH_CHECK_SRC_ADDR = 0x23,
SRC_MATCH_ACK_ALL_PENDING = 0x24,
SRC_MATCH_CHECK_ALL_PENDING = 0x25,
ADDRMGR_EXT_ADDR_LOOKUP = 0x40,
ADDRMGR_NWK_ADDR_LOOKUP = 0x41,
APSME_LINK_KEY_DATA_GET = 0x44,
APSME_LINK_KEY_NV_ID_GET = 0x45,
ASSOC_COUNT = 0x48,
ASSOC_FIND_DEVICE = 0x49,
ASSOC_GET_WITH_ADDRESS = 0x4A,
APSME_REQUEST_KEY_CMD = 0x4B,
ZCL_KEY_EST_INIT_EST = 0x80,
ZCL_KEY_EST_SIGN = 0x81,
UTIL_SYNC_REQ = 0xE0,
ZCL_KEY_ESTABLISH_IND = 0xE1
};
enum class Capability : uint16_t {
SYS = 0x0001,
MAC = 0x0002,
NWK = 0x0004,
AF = 0x0008,
ZDO = 0x0010,
SAPI = 0x0020,
UTIL = 0x0040,
DEBUG = 0x0080,
APP = 0x0100,
ZOAD = 0x1000
};
enum class ConfigurationOption : uint8_t {
STARTUP_OPTION = 0x03,
POLL_RATE = 0x24,
QUEUED_POLL_RATE = 0x25,
RESPONSE_POLL_RATE = 0x26,
POLL_FAILURE_RETRIES = 0x29,
INDIRECT_MSG_TIMEOUT = 0x2B,
ROUTE_EXPIRY_TIME = 0x2C,
EXTENDED_PAN_ID = 0x2D,
BCAST_RETRIES = 0x2E,
PASSIVE_ACK_TIMEOUT = 0x2F,
BCAST_DELIVERY_TIME = 0x30,
APS_FRAME_RETRIES = 0x43,
APS_ACK_WAIT_DURATION = 0x44,
BINDING_TIME = 0x46,
PRECFGKEY = 0x62,
PRECFGKEYS_ENABLE = 0x63,
SECURITY_MODE = 0x64,
USERDESC = 0x81,
PANID = 0x83,
CHANLIST = 0x84,
LOGICAL_TYPE = 0x87,
ZDO_DIRECT_CB = 0x8F
};
#define D_JSON_ZIGBEEZNPRECEIVED "ZigbeeZNPReceived"
#define D_PRFX_ZIGBEE "Zigbee"
#define D_CMND_ZIGBEEZNPSEND "ZNPSend"
const char kZigbeeCommands[] PROGMEM = D_PRFX_ZIGBEE "|" // Prefix
D_CMND_ZIGBEEZNPSEND;
void (* const ZigbeeCommand[])(void) PROGMEM =
{ &CmndZigbeeZNPSend };
#include <TasmotaSerial.h>
TasmotaSerial *ZigbeeSerial = nullptr;
unsigned long zigbee_polling_window = 0;
uint8_t *zigbee_buffer = nullptr;
uint32_t zigbee_in_byte_counter = 0;
uint32_t zigbee_frame_len = 256;
bool zigbee_active = true;
bool zigbee_raw = false;
void ZigbeeInput(void)
{
// Receive only valid ZNP frames:
// 00 - SOF = 0xFE
// 01 - Length of Data Field - 0..250
// 02 - CMD1 - first byte of command
// 03 - CMD2 - second byte of command
// 04..FD - Data Field
// FE (or last) - FCS Checksum
while (ZigbeeSerial->available()) {
yield();
uint8_t zigbee_in_byte = ZigbeeSerial->read();
if ((0 == zigbee_in_byte_counter) && (ZIGBEE_SOF != zigbee_in_byte)) {
// waiting for SOF (Start Of Frame) byte, discard anything else
continue; // discard
}
if (zigbee_in_byte_counter < zigbee_frame_len) {
zigbee_buffer[zigbee_in_byte_counter++] = zigbee_in_byte;
zigbee_polling_window = millis(); // Wait for more data
} else {
zigbee_polling_window = 0; // Publish now
break;
}
// recalculate frame length
if (02 == zigbee_in_byte_counter) {
// We just received the Lenght byte
uint8_t len_byte = zigbee_buffer[1];
if (len_byte > 250) len_byte = 250; // ZNP spec says len is 250 max
zigbee_frame_len = len_byte + 5; // SOF + LEN + CMD1 + CMD2 + FCS = 5 bytes overhead
}
}
if (zigbee_in_byte_counter && (millis() > (zigbee_polling_window + ZIGBEE_POLLING))) {
char hex_char[(zigbee_in_byte_counter * 2) + 2];
Response_P(PSTR("{\"" D_JSON_ZIGBEEZNPRECEIVED "\":\"%s\"}"),
ToHex_P((unsigned char*)zigbee_buffer, zigbee_in_byte_counter, hex_char, sizeof(hex_char)));
MqttPublishPrefixTopic_P(RESULT_OR_TELE, PSTR(D_JSON_ZIGBEEZNPRECEIVED));
XdrvRulesProcess();
zigbee_in_byte_counter = 0;
zigbee_frame_len = 254;
}
}
/********************************************************************************************/
void ZigbeeInit(void)
{
zigbee_active = false;
if ((pin[GPIO_ZIGBEE_RX] < 99) && (pin[GPIO_ZIGBEE_TX] < 99)) {
ZigbeeSerial = new TasmotaSerial(pin[GPIO_ZIGBEE_RX], pin[GPIO_ZIGBEE_TX]);
if (ZigbeeSerial->begin(115200)) { // ZNP is 115200, RTS/CTS (ignored), 8N1
if (ZigbeeSerial->hardwareSerial()) {
ClaimSerial();
zigbee_buffer = (uint8_t*) serial_in_buffer; // Use idle serial buffer to save RAM
} else {
zigbee_buffer = (uint8_t*) malloc(ZIGBEE_BUFFER_SIZE);
}
zigbee_active = true;
ZigbeeSerial->flush();
}
}
}
/*********************************************************************************************\
* Commands
\*********************************************************************************************/
void CmndZigbeeZNPSend(void)
{
if (XdrvMailbox.data_len > 0) {
uint8_t code;
char *codes = RemoveSpace(XdrvMailbox.data);
int32_t size = strlen(XdrvMailbox.data);
while (size > 0) {
char stemp[3];
strlcpy(stemp, codes, sizeof(stemp));
code = strtol(stemp, nullptr, 16);
ZigbeeSerial->write(code);
size -= 2;
codes += 2;
}
}
ResponseCmndDone();
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xdrv23(uint8_t function)
{
bool result = false;
if (zigbee_active) {
switch (function) {
case FUNC_LOOP:
if (ZigbeeSerial) { ZigbeeInput(); }
break;
case FUNC_PRE_INIT:
ZigbeeInit();
break;
case FUNC_COMMAND:
result = DecodeCommand(kZigbeeCommands, ZigbeeCommand);
break;
}
}
return result;
}
#endif // USE_ZIGBEE

407
sonoff/xdrv_23_zigbee_constants.ino Normal file
View File

@ -0,0 +1,407 @@
/*
xdrv_23_zigbee_constants.ino - zigbee support for Sonoff-Tasmota
Copyright (C) 2019 Theo Arends and Stephan Hadinger
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef USE_ZIGBEE
typedef uint64_t Z_IEEEAddress;
typedef uint16_t Z_ShortAddress;
enum ZnpCommandType {
Z_POLL = 0x00,
Z_SREQ = 0x20,
Z_AREQ = 0x40,
Z_SRSP = 0x60
};
enum ZnpSubsystem {
Z_RPC_Error = 0x00,
Z_SYS = 0x01,
Z_MAC = 0x02,
Z_NWK = 0x03,
Z_AF = 0x04,
Z_ZDO = 0x05,
Z_SAPI = 0x06,
Z_UTIL = 0x07,
Z_DEBUG = 0x08,
Z_APP = 0x09
};
// Commands in the SYS subsystem
enum SysCommand {
SYS_RESET = 0x00,
SYS_PING = 0x01,
SYS_VERSION = 0x02,
SYS_SET_EXTADDR = 0x03,
SYS_GET_EXTADDR = 0x04,
SYS_RAM_READ = 0x05,
SYS_RAM_WRITE = 0x06,
SYS_OSAL_NV_ITEM_INIT = 0x07,
SYS_OSAL_NV_READ = 0x08,
SYS_OSAL_NV_WRITE = 0x09,
SYS_OSAL_START_TIMER = 0x0A,
SYS_OSAL_STOP_TIMER = 0x0B,
SYS_RANDOM = 0x0C,
SYS_ADC_READ = 0x0D,
SYS_GPIO = 0x0E,
SYS_STACK_TUNE = 0x0F,
SYS_SET_TIME = 0x10,
SYS_GET_TIME = 0x11,
SYS_OSAL_NV_DELETE = 0x12,
SYS_OSAL_NV_LENGTH = 0x13,
SYS_TEST_RF = 0x40,
SYS_TEST_LOOPBACK = 0x41,
SYS_RESET_IND = 0x80,
SYS_OSAL_TIMER_EXPIRED = 0x81,
};
// Commands in the SAPI subsystem
enum SapiCommand {
SAPI_START_REQUEST = 0x00,
SAPI_BIND_DEVICE = 0x01,
SAPI_ALLOW_BIND = 0x02,
SAPI_SEND_DATA_REQUEST = 0x03,
SAPI_READ_CONFIGURATION = 0x04,
SAPI_WRITE_CONFIGURATION = 0x05,
SAPI_GET_DEVICE_INFO = 0x06,
SAPI_FIND_DEVICE_REQUEST = 0x07,
SAPI_PERMIT_JOINING_REQUEST = 0x08,
SAPI_SYSTEM_RESET = 0x09,
SAPI_START_CONFIRM = 0x80,
SAPI_BIND_CONFIRM = 0x81,
SAPI_ALLOW_BIND_CONFIRM = 0x82,
SAPI_SEND_DATA_CONFIRM = 0x83,
SAPI_FIND_DEVICE_CONFIRM = 0x85,
SAPI_RECEIVE_DATA_INDICATION = 0x87,
};
enum Z_configuration {
CONF_EXTADDR = 0x01,
CONF_BOOTCOUNTER = 0x02,
CONF_STARTUP_OPTION = 0x03,
CONF_START_DELAY = 0x04,
CONF_NIB = 0x21,
CONF_DEVICE_LIST = 0x22,
CONF_ADDRMGR = 0x23,
CONF_POLL_RATE = 0x24,
CONF_QUEUED_POLL_RATE = 0x25,
CONF_RESPONSE_POLL_RATE = 0x26,
CONF_REJOIN_POLL_RATE = 0x27,
CONF_DATA_RETRIES = 0x28,
CONF_POLL_FAILURE_RETRIES = 0x29,
CONF_STACK_PROFILE = 0x2A,
CONF_INDIRECT_MSG_TIMEOUT = 0x2B,
CONF_ROUTE_EXPIRY_TIME = 0x2C,
CONF_EXTENDED_PAN_ID = 0x2D,
CONF_BCAST_RETRIES = 0x2E,
CONF_PASSIVE_ACK_TIMEOUT = 0x2F,
CONF_BCAST_DELIVERY_TIME = 0x30,
CONF_NWK_MODE = 0x31,
CONF_CONCENTRATOR_ENABLE = 0x32,
CONF_CONCENTRATOR_DISCOVERY = 0x33,
CONF_CONCENTRATOR_RADIUS = 0x34,
CONF_CONCENTRATOR_RC = 0x36,
CONF_NWK_MGR_MODE = 0x37,
CONF_SRC_RTG_EXPIRY_TIME = 0x38,
CONF_ROUTE_DISCOVERY_TIME = 0x39,
CONF_NWK_ACTIVE_KEY_INFO = 0x3A,
CONF_NWK_ALTERN_KEY_INFO = 0x3B,
CONF_ROUTER_OFF_ASSOC_CLEANUP = 0x3C,
CONF_NWK_LEAVE_REQ_ALLOWED = 0x3D,
CONF_NWK_CHILD_AGE_ENABLE = 0x3E,
CONF_DEVICE_LIST_KA_TIMEOUT = 0x3F,
CONF_BINDING_TABLE = 0x41,
CONF_GROUP_TABLE = 0x42,
CONF_APS_FRAME_RETRIES = 0x43,
CONF_APS_ACK_WAIT_DURATION = 0x44,
CONF_APS_ACK_WAIT_MULTIPLIER = 0x45,
CONF_BINDING_TIME = 0x46,
CONF_APS_USE_EXT_PANID = 0x47,
CONF_APS_USE_INSECURE_JOIN = 0x48,
CONF_COMMISSIONED_NWK_ADDR = 0x49,
CONF_APS_NONMEMBER_RADIUS = 0x4B,
CONF_APS_LINK_KEY_TABLE = 0x4C,
CONF_APS_DUPREJ_TIMEOUT_INC = 0x4D,
CONF_APS_DUPREJ_TIMEOUT_COUNT = 0x4E,
CONF_APS_DUPREJ_TABLE_SIZE = 0x4F,
CONF_DIAGNOSTIC_STATS = 0x50,
CONF_SECURITY_LEVEL = 0x61,
CONF_PRECFGKEY = 0x62,
CONF_PRECFGKEYS_ENABLE = 0x63,
CONF_SECURITY_MODE = 0x64,
CONF_SECURE_PERMIT_JOIN = 0x65,
CONF_APS_LINK_KEY_TYPE = 0x66,
CONF_APS_ALLOW_R19_SECURITY = 0x67,
CONF_IMPLICIT_CERTIFICATE = 0x69,
CONF_DEVICE_PRIVATE_KEY = 0x6A,
CONF_CA_PUBLIC_KEY = 0x6B,
CONF_KE_MAX_DEVICES = 0x6C,
CONF_USE_DEFAULT_TCLK = 0x6D,
CONF_RNG_COUNTER = 0x6F,
CONF_RANDOM_SEED = 0x70,
CONF_TRUSTCENTER_ADDR = 0x71,
CONF_USERDESC = 0x81,
CONF_NWKKEY = 0x82,
CONF_PANID = 0x83,
CONF_CHANLIST = 0x84,
CONF_LEAVE_CTRL = 0x85,
CONF_SCAN_DURATION = 0x86,
CONF_LOGICAL_TYPE = 0x87,
CONF_NWKMGR_MIN_TX = 0x88,
CONF_NWKMGR_ADDR = 0x89,
CONF_ZDO_DIRECT_CB = 0x8F,
CONF_TCLK_TABLE_START = 0x0101,
ZNP_HAS_CONFIGURED = 0xF00
};
// enum Z_nvItemIds {
// SCENE_TABLE = 145,
// MIN_FREE_NWK_ADDR = 146,
// MAX_FREE_NWK_ADDR = 147,
// MIN_FREE_GRP_ID = 148,
// MAX_FREE_GRP_ID = 149,
// MIN_GRP_IDS = 150,
// MAX_GRP_IDS = 151,
// OTA_BLOCK_REQ_DELAY = 152,
// SAPI_ENDPOINT = 161,
// SAS_SHORT_ADDR = 177,
// SAS_EXT_PANID = 178,
// SAS_PANID = 179,
// SAS_CHANNEL_MASK = 180,
// SAS_PROTOCOL_VER = 181,
// SAS_STACK_PROFILE = 182,
// SAS_STARTUP_CTRL = 183,
// SAS_TC_ADDR = 193,
// SAS_TC_MASTER_KEY = 194,
// SAS_NWK_KEY = 195,
// SAS_USE_INSEC_JOIN = 196,
// SAS_PRECFG_LINK_KEY = 197,
// SAS_NWK_KEY_SEQ_NUM = 198,
// SAS_NWK_KEY_TYPE = 199,
// SAS_NWK_MGR_ADDR = 200,
// SAS_CURR_TC_MASTER_KEY = 209,
// SAS_CURR_NWK_KEY = 210,
// SAS_CURR_PRECFG_LINK_KEY = 211,
// TCLK_TABLE_START = 257,
// TCLK_TABLE_END = 511,
// APS_LINK_KEY_DATA_START = 513,
// APS_LINK_KEY_DATA_END = 767,
// DUPLICATE_BINDING_TABLE = 768,
// DUPLICATE_DEVICE_LIST = 769,
// DUPLICATE_DEVICE_LIST_KA_TIMEOUT = 770,
//};
//
enum Z_Status {
Z_Success = 0x00,
Z_Failure = 0x01,
Z_InvalidParameter = 0x02,
Z_MemError = 0x03,
Z_Created = 0x09,
Z_BufferFull = 0x11
};
enum Z_App_Profiles {
Z_PROF_IPM = 0x0101, // Industrial Plant Monitoring
Z_PROF_HA = 0x0104, // Home Automation -- the only supported right now
Z_PROF_CBA = 0x0105, // Commercial Building Automation
Z_PROF_TA = 0x0107, // Telecom Applications
Z_PROF_PHHC = 0x0108, // Personal Home & Hospital Care
Z_PROF_AMI = 0x0109, // Advanced Metering Initiative
};
enum Z_Device_Ids {
Z_DEVID_CONF_TOOL = 0x0005,
// from https://www.rfwireless-world.com/Terminology/Zigbee-Profile-ID-list.html
// Generic 0x0000 ON/OFF Switch
// 0x0001 Level Control Switch
// 0x0002 ON/OFF Output
// 0x0003 Level Controllable Output
// 0x0004 Scene Selector
// 0x0005 Configuration Tool
// 0x0006 Remote control
// 0x0007 Combined Interface
// 0x0008 Range Extender
// 0x0009 Mains Power Outlet
// Lighting 0x0100 ON/OFF Light
// 0x0101 Dimmable Light
// 0x0102 Color Dimmable Light
// 0x0103 ON/OFF Light Switch
// 0x0104 Dimmer Switch
// 0x0105 Color Dimmer Switch
// 0x0106 Light Sensor
// 0x0107 Occupancy Sensor
// Closures 0x0200 Shade
// 0x0201 Shade Controller
// HVAC 0x0300 Heating/Cooling Unit
// 0x0301 Thermostat
// 0x0302 Temperature Sensor
// 0x0303 Pump
// 0x0304 Pump Controller
// 0x0305 Pressure Sensor
// 0x0306 Flow sensor
// Intruder Alarm Systems 0x0400 IAS Control and Indicating Equipment
// 0x0401 IAS Ancillary Control Equipment
// 0x0402 IAS Zone
// 0x0403 IAS Warning Device
};
// enum class AddrMode : uint8_t {
// NotPresent = 0,
// Group = 1,
// ShortAddress = 2,
// IEEEAddress = 3,
// Broadcast = 0xFF
// };
//
//
//
// Commands in the AF subsystem
enum AfCommand : uint8_t {
AF_REGISTER = 0x00,
AF_DATA_REQUEST = 0x01,
AF_DATA_REQUEST_EXT = 0x02,
AF_DATA_REQUEST_SRC_RTG = 0x03,
AF_INTER_PAN_CTL = 0x10,
AF_DATA_STORE = 0x11,
AF_DATA_RETRIEVE = 0x12,
AF_APSF_CONFIG_SET = 0x13,
AF_DATA_CONFIRM = 0x80,
AF_REFLECT_ERROR = 0x83,
AF_INCOMING_MSG = 0x81,
AF_INCOMING_MSG_EXT = 0x82
};
//
// Commands in the ZDO subsystem
enum : uint8_t {
ZDO_NWK_ADDR_REQ = 0x00,
ZDO_IEEE_ADDR_REQ = 0x01,
ZDO_NODE_DESC_REQ = 0x02,
ZDO_POWER_DESC_REQ = 0x03,
ZDO_SIMPLE_DESC_REQ = 0x04,
ZDO_ACTIVE_EP_REQ = 0x05,
ZDO_MATCH_DESC_REQ = 0x06,
ZDO_COMPLEX_DESC_REQ = 0x07,
ZDO_USER_DESC_REQ = 0x08,
ZDO_DEVICE_ANNCE = 0x0A,
ZDO_USER_DESC_SET = 0x0B,
ZDO_SERVER_DISC_REQ = 0x0C,
ZDO_END_DEVICE_BIND_REQ = 0x20,
ZDO_BIND_REQ = 0x21,
ZDO_UNBIND_REQ = 0x22,
ZDO_SET_LINK_KEY = 0x23,
ZDO_REMOVE_LINK_KEY = 0x24,
ZDO_GET_LINK_KEY = 0x25,
ZDO_MGMT_NWK_DISC_REQ = 0x30,
ZDO_MGMT_LQI_REQ = 0x31,
ZDO_MGMT_RTQ_REQ = 0x32,
ZDO_MGMT_BIND_REQ = 0x33,
ZDO_MGMT_LEAVE_REQ = 0x34,
ZDO_MGMT_DIRECT_JOIN_REQ = 0x35,
ZDO_MGMT_PERMIT_JOIN_REQ = 0x36,
ZDO_MGMT_NWK_UPDATE_REQ = 0x37,
ZDO_MSG_CB_REGISTER = 0x3E,
ZDO_MGS_CB_REMOVE = 0x3F,
ZDO_STARTUP_FROM_APP = 0x40,
ZDO_AUTO_FIND_DESTINATION = 0x41,
ZDO_EXT_REMOVE_GROUP = 0x47,
ZDO_EXT_REMOVE_ALL_GROUP = 0x48,
ZDO_EXT_FIND_ALL_GROUPS_ENDPOINT = 0x49,
ZDO_EXT_FIND_GROUP = 0x4A,
ZDO_EXT_ADD_GROUP = 0x4B,
ZDO_EXT_COUNT_ALL_GROUPS = 0x4C,
ZDO_NWK_ADDR_RSP = 0x80,
ZDO_IEEE_ADDR_RSP = 0x81,
ZDO_NODE_DESC_RSP = 0x82,
ZDO_POWER_DESC_RSP = 0x83,
ZDO_SIMPLE_DESC_RSP = 0x84,
ZDO_ACTIVE_EP_RSP = 0x85,
ZDO_MATCH_DESC_RSP = 0x86,
ZDO_COMPLEX_DESC_RSP = 0x87,
ZDO_USER_DESC_RSP = 0x88,
ZDO_USER_DESC_CONF = 0x89,
ZDO_SERVER_DISC_RSP = 0x8A,
ZDO_END_DEVICE_BIND_RSP = 0xA0,
ZDO_BIND_RSP = 0xA1,
ZDO_UNBIND_RSP = 0xA2,
ZDO_MGMT_NWK_DISC_RSP = 0xB0,
ZDO_MGMT_LQI_RSP = 0xB1,
ZDO_MGMT_RTG_RSP = 0xB2,
ZDO_MGMT_BIND_RSP = 0xB3,
ZDO_MGMT_LEAVE_RSP = 0xB4,
ZDO_MGMT_DIRECT_JOIN_RSP = 0xB5,
ZDO_MGMT_PERMIT_JOIN_RSP = 0xB6,
ZDO_STATE_CHANGE_IND = 0xC0,
ZDO_END_DEVICE_ANNCE_IND = 0xC1,
ZDO_MATCH_DESC_RSP_SENT = 0xC2,
ZDO_STATUS_ERROR_RSP = 0xC3,
ZDO_SRC_RTG_IND = 0xC4,
ZDO_LEAVE_IND = 0xC9,
ZDO_TC_DEV_IND = 0xCA,
ZDO_PERMIT_JOIN_IND = 0xCB,
ZDO_MSG_CB_INCOMING = 0xFF
};
//https://e2e.ti.com/support/wireless-connectivity/zigbee-and-thread/f/158/t/475920
enum ZdoStates {
ZDO_DEV_HOLD = 0x00, // Initialized - not started automatically
ZDO_DEV_INIT = 0x01, // Initialized - not connected to anything
ZDO_DEV_NWK_DISC = 0x02, // Discovering PANIDs to join
ZDO_DEV_NWK_JOINING = 0x03, // Joining a PAN
ZDO_DEV_NWK_REJOIN = 0x04, // ReJoining a PAN, only for end devices
ZDO_DEV_END_DEVICE_UNAUTH = 0x05, // Joined but not yet authenticated by trust center
ZDO_DEV_END_DEVICE = 0x06, // Started as a device after authentication. Note: you'll see this for both Routers or End Devices.
ZDO_DEV_ROUTER = 0x07, // Started as a Zigbee Router
ZDO_DEV_COORD_STARTING = 0x08, // Starting as a Zigbee Coordinator
ZDO_DEV_ZB_COORD = 0x09, // Started as a a Zigbee Coordinator
ZDO_DEV_NWK_ORPHAN = 0x0A, // Device has lost information about its parent.
};
//
// Commands in the UTIL subsystem
enum Z_Util {
Z_UTIL_GET_DEVICE_INFO = 0x00,
Z_UTIL_GET_NV_INFO = 0x01,
Z_UTIL_SET_PANID = 0x02,
Z_UTIL_SET_CHANNELS = 0x03,
Z_UTIL_SET_SECLEVEL = 0x04,
Z_UTIL_SET_PRECFGKEY = 0x05,
Z_UTIL_CALLBACK_SUB_CMD = 0x06,
Z_UTIL_KEY_EVENT = 0x07,
Z_UTIL_TIME_ALIVE = 0x09,
Z_UTIL_LED_CONTROL = 0x0A,
Z_UTIL_TEST_LOOPBACK = 0x10,
Z_UTIL_DATA_REQ = 0x11,
Z_UTIL_SRC_MATCH_ENABLE = 0x20,
Z_UTIL_SRC_MATCH_ADD_ENTRY = 0x21,
Z_UTIL_SRC_MATCH_DEL_ENTRY = 0x22,
Z_UTIL_SRC_MATCH_CHECK_SRC_ADDR = 0x23,
Z_UTIL_SRC_MATCH_ACK_ALL_PENDING = 0x24,
Z_UTIL_SRC_MATCH_CHECK_ALL_PENDING = 0x25,
Z_UTIL_ADDRMGR_EXT_ADDR_LOOKUP = 0x40,
Z_UTIL_ADDRMGR_NWK_ADDR_LOOKUP = 0x41,
Z_UTIL_APSME_LINK_KEY_DATA_GET = 0x44,
Z_UTIL_APSME_LINK_KEY_NV_ID_GET = 0x45,
Z_UTIL_ASSOC_COUNT = 0x48,
Z_UTIL_ASSOC_FIND_DEVICE = 0x49,
Z_UTIL_ASSOC_GET_WITH_ADDRESS = 0x4A,
Z_UTIL_APSME_REQUEST_KEY_CMD = 0x4B,
Z_UTIL_ZCL_KEY_EST_INIT_EST = 0x80,
Z_UTIL_ZCL_KEY_EST_SIGN = 0x81,
Z_UTIL_UTIL_SYNC_REQ = 0xE0,
Z_UTIL_ZCL_KEY_ESTABLISH_IND = 0xE1
};
#endif // USE_ZIGBEE

959
sonoff/xdrv_23_zigbee_impl.ino Normal file
View File

@ -0,0 +1,959 @@
/*
xdrv_23_zigbee.ino - zigbee support for Sonoff-Tasmota
Copyright (C) 2019 Theo Arends and Stephan Hadinger
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef USE_ZIGBEE
#define XDRV_23 23
const uint32_t ZIGBEE_BUFFER_SIZE = 256; // Max ZNP frame is SOF+LEN+CMD1+CMD2+250+FCS = 255
const uint8_t ZIGBEE_SOF = 0xFE;
const uint8_t ZIGBEE_LABEL_ABORT = 99; // goto label 99 in case of fatal error
const uint8_t ZIGBEE_LABEL_READY = 20; // goto label 99 in case of fatal error
#include <TasmotaSerial.h>
TasmotaSerial *ZigbeeSerial = nullptr;
const char kZigbeeCommands[] PROGMEM = "|" D_CMND_ZIGBEEZNPSEND;
void (* const ZigbeeCommand[])(void) PROGMEM = { &CmndZigbeeZNPSend };
typedef int32_t (*ZB_Func)(uint8_t value);
typedef int32_t (*ZB_RecvMsgFunc)(int32_t res, class SBuffer &buf);
typedef union Zigbee_Instruction {
struct {
uint8_t i; // instruction
uint8_t d8; // 8 bits data
uint16_t d16; // 16 bits data
} i;
const void *p; // pointer
// const void *m; // for type checking only, message
// const ZB_Func f;
// const ZB_RecvMsgFunc fr;
} Zigbee_Instruction;
//
// Zigbee_Instruction z1 = { .i = {1,2,3}};
// Zigbee_Instruction z3 = { .p = nullptr };
typedef struct Zigbee_Instruction_Type {
uint8_t instr;
uint8_t data;
} Zigbee_Instruction_Type;
enum Zigbee_StateMachine_Instruction_Set {
// 2 bytes instructions
ZGB_INSTR_4_BYTES = 0,
ZGB_INSTR_NOOP = 0, // do nothing
ZGB_INSTR_LABEL, // define a label
ZGB_INSTR_GOTO, // goto label
ZGB_INSTR_ON_ERROR_GOTO, // goto label if error
ZGB_INSTR_ON_TIMEOUT_GOTO, // goto label if timeout
ZGB_INSTR_WAIT, // wait for x ms (in chunks of 100ms)
ZGB_INSTR_WAIT_FOREVER, // wait forever but state machine still active
ZGB_INSTR_STOP, // stop state machine with optional error code
// 6 bytes instructions
ZGB_INSTR_8_BYTES = 0x80,
ZGB_INSTR_CALL = 0x80, // call a function
ZGB_INSTR_LOG, // log a message, if more detailed logging required, call a function
ZGB_INSTR_SEND, // send a ZNP message
ZGB_INSTR_WAIT_UNTIL, // wait until the specified message is received, ignore all others
ZGB_INSTR_WAIT_RECV, // wait for a message according to the filter
ZGB_ON_RECV_UNEXPECTED, // function to handle unexpected messages, or nullptr
// 10 bytes instructions
ZGB_INSTR_12_BYTES = 0xF0,
ZGB_INSTR_WAIT_RECV_CALL, // wait for a filtered message and call function upon receive
};
#define ZI_NOOP() { .i = { ZGB_INSTR_NOOP, 0x00, 0x0000} },
#define ZI_LABEL(x) { .i = { ZGB_INSTR_LABEL, (x), 0x0000} },
#define ZI_GOTO(x) { .i = { ZGB_INSTR_GOTO, (x), 0x0000} },
#define ZI_ON_ERROR_GOTO(x) { .i = { ZGB_INSTR_ON_ERROR_GOTO, (x), 0x0000} },
#define ZI_ON_TIMEOUT_GOTO(x) { .i = { ZGB_INSTR_ON_TIMEOUT_GOTO, (x), 0x0000} },
#define ZI_WAIT(x) { .i = { ZGB_INSTR_WAIT, 0x00, (x)} },
#define ZI_WAIT_FOREVER() { .i = { ZGB_INSTR_WAIT_FOREVER, 0x00, 0x0000} },
#define ZI_STOP(x) { .i = { ZGB_INSTR_STOP, (x), 0x0000} },
#define ZI_CALL(f, x) { .i = { ZGB_INSTR_CALL, (x), 0x0000} }, { .p = (const void*)(f) },
#define ZI_LOG(x, m) { .i = { ZGB_INSTR_LOG, (x), 0x0000 } }, { .p = ((const void*)(m)) },
#define ZI_ON_RECV_UNEXPECTED(f) { .i = { ZGB_ON_RECV_UNEXPECTED, 0x00, 0x0000} }, { .p = (const void*)(f) },
#define ZI_SEND(m) { .i = { ZGB_INSTR_SEND, sizeof(m), 0x0000} }, { .p = (const void*)(m) },
#define ZI_WAIT_RECV(x, m) { .i = { ZGB_INSTR_WAIT_RECV, sizeof(m), (x)} }, { .p = (const void*)(m) },
#define ZI_WAIT_UNTIL(x, m) { .i = { ZGB_INSTR_WAIT_UNTIL, sizeof(m), (x)} }, { .p = (const void*)(m) },
#define ZI_WAIT_RECV_FUNC(x, m, f) { .i = { ZGB_INSTR_WAIT_RECV_CALL, sizeof(m), (x)} }, { .p = (const void*)(m) }, { .p = (const void*)(f) },
struct ZigbeeStatus {
bool active = true; // is Zigbee active for this device, i.e. GPIOs configured
bool state_machine = false; // the state machine is running
bool state_waiting = false; // the state machine is waiting for external event or timeout
bool state_no_timeout = false; // the current wait loop does not generate a timeout but only continues running
bool ready = false; // cc2530 initialization is complet, ready to operate
uint8_t on_error_goto = ZIGBEE_LABEL_ABORT; // on error goto label, 99 default to abort
uint8_t on_timeout_goto = ZIGBEE_LABEL_ABORT; // on timeout goto label, 99 default to abort
int16_t pc = 0; // program counter, -1 means abort
uint32_t next_timeout = 0; // millis for the next timeout
uint8_t *recv_filter = nullptr; // receive filter message
bool recv_until = false; // ignore all messages until the received frame fully matches
size_t recv_filter_len = 0;
ZB_RecvMsgFunc recv_func = nullptr; // function to call when message is expected
ZB_RecvMsgFunc recv_unexpected = nullptr; // function called when unexpected message is received
bool init_phase = true; // initialization phase, before accepting zigbee traffic
};
struct ZigbeeStatus zigbee;
SBuffer *zigbee_buffer = nullptr;
/*********************************************************************************************\
* ZCL
\*********************************************************************************************/
typedef union ZCLHeaderFrameControl_t {
struct {
uint8_t frame_type : 2; // 00 = across entire profile, 01 = cluster specific
uint8_t manuf_specific : 1; // Manufacturer Specific Sub-field
uint8_t direction : 1; // 0 = tasmota to zigbee, 1 = zigbee to tasmota
uint8_t disable_def_resp : 1; // don't send back default response
uint8_t reserved : 3;
} b;
uint8_t d8; // raw 8 bits field
} ZCLHeaderFrameControl_t;
class ZCLFrame {
public:
ZCLFrame(uint8_t frame_control, uint16_t manuf_code, uint8_t transact_seq, uint8_t cmd_id,
const char *buf, size_t buf_len ):
_cmd_id(cmd_id), _manuf_code(manuf_code), _transact_seq(transact_seq),
_payload(buf_len ? buf_len : 250) // allocate the data frame from source or preallocate big enough
{
_frame_control.d8 = frame_control;
_payload.addBuffer(buf, buf_len);
};
void publishMQTTReceived(void) {
char hex_char[_payload.len()*2+2];
ToHex_P((unsigned char*)_payload.getBuffer(), _payload.len(), hex_char, sizeof(hex_char));
Response_P(PSTR("{\"" D_JSON_ZIGBEEZCLRECEIVED "\":{\"fc\":\"0x%02X\",\"manuf\":\"0x%04X\",\"transact\":%d,"
"\"cmdid\":\"0x%02X\",\"payload\":\"%s\"}}"),
_frame_control, _manuf_code, _transact_seq, _cmd_id,
hex_char);
MqttPublishPrefixTopic_P(RESULT_OR_TELE, PSTR(D_JSON_ZIGBEEZCLSENT));
XdrvRulesProcess();
}
static ZCLFrame parseRawFrame(SBuffer &buf, uint8_t offset, uint8_t len) { // parse a raw frame and build the ZCL frame object
uint32_t i = offset;
ZCLHeaderFrameControl_t frame_control;
uint16_t manuf_code = 0;
uint8_t transact_seq;
uint8_t cmd_id;
frame_control.d8 = buf.get8(i++);
if (frame_control.b.manuf_specific) {
manuf_code = buf.get16(i);
i += 2;
}
transact_seq = buf.get8(i++);
cmd_id = buf.get8(i++);
ZCLFrame zcl_frame(frame_control.d8, manuf_code, transact_seq, cmd_id,
(const char *)(buf.buf() + i), len + offset - i);
return zcl_frame;
}
private:
ZCLHeaderFrameControl_t _frame_control = { .d8 = 0 };
uint16_t _manuf_code = 0; // optional
uint8_t _transact_seq = 0; // transaction sequence number
uint8_t _cmd_id = 0;
SBuffer _payload;
};
/*********************************************************************************************\
* State Machine
\*********************************************************************************************/
#define Z_B0(a) (uint8_t)( ((a) ) & 0xFF )
#define Z_B1(a) (uint8_t)( ((a) >> 8) & 0xFF )
#define Z_B2(a) (uint8_t)( ((a) >> 16) & 0xFF )
#define Z_B3(a) (uint8_t)( ((a) >> 24) & 0xFF )
#define Z_B4(a) (uint8_t)( ((a) >> 32) & 0xFF )
#define Z_B5(a) (uint8_t)( ((a) >> 40) & 0xFF )
#define Z_B6(a) (uint8_t)( ((a) >> 48) & 0xFF )
#define Z_B7(a) (uint8_t)( ((a) >> 56) & 0xFF )
// Macro to define message to send and receive
#define ZBM(n, x...) const uint8_t n[] PROGMEM = { x };
// ZBS_* Zigbee Send
// ZBR_* Zigbee Recv
ZBM(ZBS_RESET, Z_AREQ | Z_SYS, SYS_RESET, 0x01 ) // 410001 SYS_RESET_REQ Software reset
ZBM(ZBR_RESET, Z_AREQ | Z_SYS, SYS_RESET_IND ) // 4180 SYS_RESET_REQ Software reset response
ZBM(ZBS_VERSION, Z_SREQ | Z_SYS, SYS_VERSION ) // 2102 Z_SYS:version
ZBM(ZBR_VERSION, Z_SRSP | Z_SYS, SYS_VERSION ) // 6102 Z_SYS:version
// Check if ZNP_HAS_CONFIGURED is set
ZBM(ZBS_ZNPHC, Z_SREQ | Z_SYS, SYS_OSAL_NV_READ, ZNP_HAS_CONFIGURED & 0xFF, ZNP_HAS_CONFIGURED >> 8, 0x00 /* offset */ ) // 2108000F00 - 6108000155
ZBM(ZBR_ZNPHC, Z_SRSP | Z_SYS, SYS_OSAL_NV_READ, Z_Success, 0x01 /* len */, 0x55) // 6108000155
// If not set, the response is 61-08-02-00 = Z_SRSP | Z_SYS, SYS_OSAL_NV_READ, Z_InvalidParameter, 0x00 /* len */
ZBM(ZBS_PAN, Z_SREQ | Z_SAPI, SAPI_READ_CONFIGURATION, CONF_PANID ) // 260483
ZBM(ZBR_PAN, Z_SRSP | Z_SAPI, SAPI_READ_CONFIGURATION, Z_Success, CONF_PANID, 0x02 /* len */,
Z_B0(USE_ZIGBEE_PANID), Z_B1(USE_ZIGBEE_PANID) ) // 6604008302xxxx
ZBM(ZBS_EXTPAN, Z_SREQ | Z_SAPI, SAPI_READ_CONFIGURATION, CONF_EXTENDED_PAN_ID ) // 26042D
ZBM(ZBR_EXTPAN, Z_SRSP | Z_SAPI, SAPI_READ_CONFIGURATION, Z_Success, CONF_EXTENDED_PAN_ID,
0x08 /* len */,
Z_B0(USE_ZIGBEE_EXTPANID), Z_B1(USE_ZIGBEE_EXTPANID), Z_B2(USE_ZIGBEE_EXTPANID), Z_B3(USE_ZIGBEE_EXTPANID),
Z_B4(USE_ZIGBEE_EXTPANID), Z_B5(USE_ZIGBEE_EXTPANID), Z_B6(USE_ZIGBEE_EXTPANID), Z_B7(USE_ZIGBEE_EXTPANID),
) // 6604002D08xxxxxxxxxxxxxxxx
ZBM(ZBS_CHANN, Z_SREQ | Z_SAPI, SAPI_READ_CONFIGURATION, CONF_CHANLIST ) // 260484
ZBM(ZBR_CHANN, Z_SRSP | Z_SAPI, SAPI_READ_CONFIGURATION, Z_Success, CONF_CHANLIST,
0x04 /* len */,
Z_B0(USE_ZIGBEE_CHANNEL), Z_B1(USE_ZIGBEE_CHANNEL), Z_B2(USE_ZIGBEE_CHANNEL), Z_B3(USE_ZIGBEE_CHANNEL),
) // 6604008404xxxxxxxx
ZBM(ZBS_PFGK, Z_SREQ | Z_SAPI, SAPI_READ_CONFIGURATION, CONF_PRECFGKEY ) // 260462
ZBM(ZBR_PFGK, Z_SRSP | Z_SAPI, SAPI_READ_CONFIGURATION, Z_Success, CONF_PRECFGKEY,
0x10 /* len */,
Z_B0(USE_ZIGBEE_PRECFGKEY_L), Z_B1(USE_ZIGBEE_PRECFGKEY_L), Z_B2(USE_ZIGBEE_PRECFGKEY_L), Z_B3(USE_ZIGBEE_PRECFGKEY_L),
Z_B4(USE_ZIGBEE_PRECFGKEY_L), Z_B5(USE_ZIGBEE_PRECFGKEY_L), Z_B6(USE_ZIGBEE_PRECFGKEY_L), Z_B7(USE_ZIGBEE_PRECFGKEY_L),
Z_B0(USE_ZIGBEE_PRECFGKEY_H), Z_B1(USE_ZIGBEE_PRECFGKEY_H), Z_B2(USE_ZIGBEE_PRECFGKEY_H), Z_B3(USE_ZIGBEE_PRECFGKEY_H),
Z_B4(USE_ZIGBEE_PRECFGKEY_H), Z_B5(USE_ZIGBEE_PRECFGKEY_H), Z_B6(USE_ZIGBEE_PRECFGKEY_H), Z_B7(USE_ZIGBEE_PRECFGKEY_H),
/*0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0D*/ ) // 660400621001030507090B0D0F00020406080A0C0D
ZBM(ZBS_PFGKEN, Z_SREQ | Z_SAPI, SAPI_READ_CONFIGURATION, CONF_PRECFGKEYS_ENABLE ) // 260463
ZBM(ZBR_PFGKEN, Z_SRSP | Z_SAPI, SAPI_READ_CONFIGURATION, Z_Success, CONF_PRECFGKEYS_ENABLE,
0x01 /* len */, 0x00 ) // 660400630100
// commands to "format" the device
// Write configuration - write success
ZBM(ZBR_W_OK, Z_SRSP | Z_SAPI, SAPI_WRITE_CONFIGURATION, Z_Success ) // 660500 - Write Configuration
ZBM(ZBR_WNV_OK, Z_SRSP | Z_SYS, SYS_OSAL_NV_WRITE, Z_Success ) // 610900 - NV Write
// Factory reset
ZBM(ZBS_FACTRES, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_STARTUP_OPTION, 0x01 /* len */, 0x02 ) // 2605030102
// Write PAN ID
ZBM(ZBS_W_PAN, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_PANID, 0x02 /* len */, Z_B0(USE_ZIGBEE_PANID), Z_B1(USE_ZIGBEE_PANID) ) // 26058302xxxx
// Write EXT PAN ID
ZBM(ZBS_W_EXTPAN, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_EXTENDED_PAN_ID, 0x08 /* len */,
Z_B0(USE_ZIGBEE_EXTPANID), Z_B1(USE_ZIGBEE_EXTPANID), Z_B2(USE_ZIGBEE_EXTPANID), Z_B3(USE_ZIGBEE_EXTPANID),
Z_B4(USE_ZIGBEE_EXTPANID), Z_B5(USE_ZIGBEE_EXTPANID), Z_B6(USE_ZIGBEE_EXTPANID), Z_B7(USE_ZIGBEE_EXTPANID)
) // 26052D086263151D004B1200
// Write Channel ID
ZBM(ZBS_W_CHANN, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_CHANLIST, 0x04 /* len */,
Z_B0(USE_ZIGBEE_CHANNEL), Z_B1(USE_ZIGBEE_CHANNEL), Z_B2(USE_ZIGBEE_CHANNEL), Z_B3(USE_ZIGBEE_CHANNEL),
/*0x00, 0x08, 0x00, 0x00*/ ) // 26058404xxxxxxxx
// Write Logical Type = 00 = coordinator
ZBM(ZBS_W_LOGTYP, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_LOGICAL_TYPE, 0x01 /* len */, 0x00 ) // 2605870100
// Write precfgkey
ZBM(ZBS_W_PFGK, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_PRECFGKEY,
0x10 /* len */,
Z_B0(USE_ZIGBEE_PRECFGKEY_L), Z_B1(USE_ZIGBEE_PRECFGKEY_L), Z_B2(USE_ZIGBEE_PRECFGKEY_L), Z_B3(USE_ZIGBEE_PRECFGKEY_L),
Z_B4(USE_ZIGBEE_PRECFGKEY_L), Z_B5(USE_ZIGBEE_PRECFGKEY_L), Z_B6(USE_ZIGBEE_PRECFGKEY_L), Z_B7(USE_ZIGBEE_PRECFGKEY_L),
Z_B0(USE_ZIGBEE_PRECFGKEY_H), Z_B1(USE_ZIGBEE_PRECFGKEY_H), Z_B2(USE_ZIGBEE_PRECFGKEY_H), Z_B3(USE_ZIGBEE_PRECFGKEY_H),
Z_B4(USE_ZIGBEE_PRECFGKEY_H), Z_B5(USE_ZIGBEE_PRECFGKEY_H), Z_B6(USE_ZIGBEE_PRECFGKEY_H), Z_B7(USE_ZIGBEE_PRECFGKEY_H),
/*0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F,
0x00, 0x02, 0x04, 0x06, 0x08, 0x0A, 0x0C, 0x0D*/ ) // 2605621001030507090B0D0F00020406080A0C0D
// Write precfgkey enable
ZBM(ZBS_W_PFGKEN, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_PRECFGKEYS_ENABLE, 0x01 /* len */, 0x00 ) // 2605630100
// Write Security Mode
ZBM(ZBS_WNV_SECMODE, Z_SREQ | Z_SYS, SYS_OSAL_NV_WRITE, Z_B0(CONF_TCLK_TABLE_START), Z_B1(CONF_TCLK_TABLE_START),
0x00 /* offset */, 0x20 /* len */,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x5a, 0x69, 0x67, 0x42, 0x65, 0x65, 0x41, 0x6c,
0x6c, 0x69, 0x61, 0x6e, 0x63, 0x65, 0x30, 0x39,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00) // 2109010100200FFFFFFFFFFFFFFFF5A6967426565416C6C69616E636530390000000000000000
// Write Z_ZDO Direct CB
ZBM(ZBS_W_ZDODCB, Z_SREQ | Z_SAPI, SAPI_WRITE_CONFIGURATION, CONF_ZDO_DIRECT_CB, 0x01 /* len */, 0x01 ) // 26058F0101
// NV Init ZNP Has Configured
ZBM(ZBS_WNV_INITZNPHC, Z_SREQ | Z_SYS, SYS_OSAL_NV_ITEM_INIT, ZNP_HAS_CONFIGURED & 0xFF, ZNP_HAS_CONFIGURED >> 8,
0x01, 0x00 /* InitLen 16 bits */, 0x01 /* len */, 0x00 ) // 2107000F01000100 - 610709
// Init succeeded
ZBM(ZBR_WNV_INIT_OK, Z_SRSP | Z_SYS, SYS_OSAL_NV_WRITE, Z_Created ) // 610709 - NV Write
// Write ZNP Has Configured
ZBM(ZBS_WNV_ZNPHC, Z_SREQ | Z_SYS, SYS_OSAL_NV_WRITE, Z_B0(ZNP_HAS_CONFIGURED), Z_B1(ZNP_HAS_CONFIGURED),
0x00 /* offset */, 0x01 /* len */, 0x55 ) // 2109000F000155 - 610900
// Z_ZDO:startupFromApp
ZBM(ZBS_STARTUPFROMAPP, Z_SREQ | Z_ZDO, ZDO_STARTUP_FROM_APP, 100, 0 /* delay */) // 25406400
ZBM(ZBR_STARTUPFROMAPP, Z_SRSP | Z_ZDO, ZDO_STARTUP_FROM_APP ) // 6540 + 01 for new network, 00 for exisitng network, 02 for error
ZBM(AREQ_STARTUPFROMAPP, Z_AREQ | Z_ZDO, ZDO_STATE_CHANGE_IND, ZDO_DEV_ZB_COORD ) // 45C009 + 08 = starting, 09 = started
// GetDeviceInfo
ZBM(ZBS_GETDEVICEINFO, Z_SREQ | Z_UTIL, Z_UTIL_GET_DEVICE_INFO ) // 2700
ZBM(ZBR_GETDEVICEINFO, Z_SRSP | Z_UTIL, Z_UTIL_GET_DEVICE_INFO, Z_Success ) // Ex= 6700.00.6263151D004B1200.0000.07.09.00
// IEEE Adr (8 bytes) = 6263151D004B1200
// Short Addr (2 bytes) = 0000
// Device Type (1 byte) = 07 (coord?)
// Device State (1 byte) = 09 (coordinator started)
// NumAssocDevices (1 byte) = 00
// Read Pan ID
//ZBM(ZBS_READ_NV_PANID, Z_SREQ | Z_SYS, SYS_OSAL_NV_READ, PANID & 0xFF, PANID >> 8, 0x00 /* offset */ ) // 2108830000
// Z_ZDO:nodeDescReq
ZBM(ZBS_ZDO_NODEDESCREQ, Z_SREQ | Z_ZDO, ZDO_NODE_DESC_REQ, 0x00, 0x00 /* dst addr */, 0x00, 0x00 /* NWKAddrOfInterest */) // 250200000000
ZBM(ZBR_ZDO_NODEDESCREQ, Z_SRSP | Z_ZDO, ZDO_NODE_DESC_REQ, Z_Success ) // 650200
// Async resp ex: 4582.0000.00.0000.00.40.8F.0000.50.A000.0100.A000.00
ZBM(AREQ_ZDO_NODEDESCREQ, Z_AREQ | Z_ZDO, ZDO_NODE_DESC_RSP) // 4582
// SrcAddr (2 bytes) 0000
// Status (1 byte) 00 Success
// NwkAddr (2 bytes) 0000
// LogicalType (1 byte) - 00 Coordinator
// APSFlags (1 byte) - 40 0=APSFlags 4=NodeFreqBands
// MACCapabilityFlags (1 byte) - 8F ALL
// ManufacturerCode (2 bytes) - 0000
// MaxBufferSize (1 byte) - 50 NPDU
// MaxTransferSize (2 bytes) - A000 = 160
// ServerMask (2 bytes) - 0100 - Primary Trust Center
// MaxOutTransferSize (2 bytes) - A000 = 160
// DescriptorCapabilities (1 byte) - 00
// Z_ZDO:activeEpReq
ZBM(ZBS_ZDO_ACTIVEEPREQ, Z_SREQ | Z_ZDO, ZDO_ACTIVE_EP_REQ, 0x00, 0x00, 0x00, 0x00) // 250500000000
ZBM(ZBR_ZDO_ACTIVEEPREQ, Z_SRSP | Z_ZDO, ZDO_ACTIVE_EP_REQ, Z_Success) // 65050000
ZBM(ZBR_ZDO_ACTIVEEPRSP_NONE, Z_AREQ | Z_ZDO, ZDO_ACTIVE_EP_RSP, 0x00, 0x00 /* srcAddr */, Z_Success,
0x00, 0x00 /* nwkaddr */, 0x00 /* activeepcount */) // 45050000 - no Ep running
ZBM(ZBR_ZDO_ACTIVEEPRSP_OK, Z_AREQ | Z_ZDO, ZDO_ACTIVE_EP_RSP, 0x00, 0x00 /* srcAddr */, Z_Success,
0x00, 0x00 /* nwkaddr */, 0x02 /* activeepcount */, 0x0B, 0x01 /* the actual endpoints */) // 25050000 - no Ep running
// Z_AF:register profile:104, ep:01
ZBM(ZBS_AF_REGISTER01, Z_SREQ | Z_AF, AF_REGISTER, 0x01 /* endpoint */, Z_B0(Z_PROF_HA), Z_B1(Z_PROF_HA), // 24000401050000000000
0x05, 0x00 /* AppDeviceId */, 0x00 /* AppDevVer */, 0x00 /* LatencyReq */,
0x00 /* AppNumInClusters */, 0x00 /* AppNumInClusters */)
ZBM(ZBR_AF_REGISTER, Z_SRSP | Z_AF, AF_REGISTER, Z_Success) // 640000
ZBM(ZBS_AF_REGISTER0B, Z_SREQ | Z_AF, AF_REGISTER, 0x0B /* endpoint */, Z_B0(Z_PROF_HA), Z_B1(Z_PROF_HA), // 2400040B050000000000
0x05, 0x00 /* AppDeviceId */, 0x00 /* AppDevVer */, 0x00 /* LatencyReq */,
0x00 /* AppNumInClusters */, 0x00 /* AppNumInClusters */)
// Z_ZDO:mgmtPermitJoinReq
ZBM(ZBS_PERMITJOINREQ_CLOSE, Z_SREQ | Z_ZDO, ZDO_MGMT_PERMIT_JOIN_REQ, 0x02 /* AddrMode */, // 25360200000000
0x00, 0x00 /* DstAddr */, 0x00 /* Duration */, 0x00 /* TCSignificance */)
ZBM(ZBS_PERMITJOINREQ_OPEN, Z_SREQ | Z_ZDO, ZDO_MGMT_PERMIT_JOIN_REQ, 0x0F /* AddrMode */, // 25360FFFFCFF00
0xFC, 0xFF /* DstAddr */, 0xFF /* Duration */, 0x00 /* TCSignificance */)
ZBM(ZBR_PERMITJOINREQ, Z_SRSP | Z_ZDO, ZDO_MGMT_PERMIT_JOIN_REQ, Z_Success) // 653600
ZBM(ZBR_PERMITJOIN_AREQ_CLOSE, Z_AREQ | Z_ZDO, ZDO_PERMIT_JOIN_IND, 0x00 /* Duration */) // 45CB00
ZBM(ZBR_PERMITJOIN_AREQ_OPEN, Z_AREQ | Z_ZDO, ZDO_PERMIT_JOIN_IND, 0xFF /* Duration */) // 45CBFF
ZBM(ZBR_PERMITJOIN_AREQ_RSP, Z_AREQ | Z_ZDO, ZDO_MGMT_PERMIT_JOIN_RSP, 0x00, 0x00 /* srcAddr*/, Z_Success ) // 45B6000000
// Filters for ZCL frames
ZBM(ZBR_AF_INCOMING_MESSAGE, Z_AREQ | Z_AF, AF_INCOMING_MSG) // 4481
static const Zigbee_Instruction zb_prog[] PROGMEM = {
ZI_LABEL(0)
ZI_NOOP()
ZI_ON_ERROR_GOTO(ZIGBEE_LABEL_ABORT)
ZI_ON_TIMEOUT_GOTO(ZIGBEE_LABEL_ABORT)
ZI_ON_RECV_UNEXPECTED(&Z_Recv_Default)
ZI_WAIT(15000) // wait for 15 seconds for Tasmota to stabilize
ZI_ON_ERROR_GOTO(50)
ZI_LOG(LOG_LEVEL_INFO, "ZIG: rebooting device")
ZI_SEND(ZBS_RESET) // reboot cc2530 just in case we rebooted ESP8266 but not cc2530
ZI_WAIT_RECV(5000, ZBR_RESET) // timeout 5s
ZI_LOG(LOG_LEVEL_INFO, "ZIG: checking device configuration")
ZI_SEND(ZBS_ZNPHC) // check value of ZNP Has Configured
ZI_WAIT_RECV(2000, ZBR_ZNPHC)
ZI_SEND(ZBS_VERSION) // check ZNP software version
ZI_WAIT_RECV(500, ZBR_VERSION)
ZI_SEND(ZBS_PAN) // check PAN ID
ZI_WAIT_RECV(500, ZBR_PAN)
ZI_SEND(ZBS_EXTPAN) // check EXT PAN ID
ZI_WAIT_RECV(500, ZBR_EXTPAN)
ZI_SEND(ZBS_CHANN) // check CHANNEL
ZI_WAIT_RECV(500, ZBR_CHANN)
ZI_SEND(ZBS_PFGK) // check PFGK
ZI_WAIT_RECV(500, ZBR_PFGK)
ZI_SEND(ZBS_PFGKEN) // check PFGKEN
ZI_WAIT_RECV(500, ZBR_PFGKEN)
ZI_LOG(LOG_LEVEL_INFO, "ZIG: zigbee configuration ok")
// all is good, we can start
ZI_LABEL(10) // START ZNP App
ZI_CALL(&Z_State_Ready, 1)
ZI_ON_ERROR_GOTO(ZIGBEE_LABEL_ABORT)
// Z_ZDO:startupFromApp
ZI_LOG(LOG_LEVEL_INFO, "ZIG: starting zigbee coordinator")
ZI_SEND(ZBS_STARTUPFROMAPP) // start coordinator
ZI_WAIT_RECV(2000, ZBR_STARTUPFROMAPP) // wait for sync ack of command
ZI_WAIT_UNTIL(5000, AREQ_STARTUPFROMAPP) // wait for async message that coordinator started
ZI_SEND(ZBS_GETDEVICEINFO) // GetDeviceInfo
ZI_WAIT_RECV(500, ZBR_GETDEVICEINFO) // TODO memorize info
ZI_SEND(ZBS_ZDO_NODEDESCREQ) // Z_ZDO:nodeDescReq
ZI_WAIT_RECV(500, ZBR_ZDO_NODEDESCREQ)
ZI_WAIT_UNTIL(5000, AREQ_ZDO_NODEDESCREQ)
ZI_SEND(ZBS_ZDO_ACTIVEEPREQ) // Z_ZDO:activeEpReq
ZI_WAIT_RECV(500, ZBR_ZDO_ACTIVEEPREQ)
ZI_WAIT_UNTIL(500, ZBR_ZDO_ACTIVEEPRSP_NONE)
ZI_SEND(ZBS_AF_REGISTER01) // Z_AF register for endpoint 01, profile 0x0104 Home Automation
ZI_WAIT_RECV(500, ZBR_AF_REGISTER)
ZI_SEND(ZBS_AF_REGISTER0B) // Z_AF register for endpoint 0B, profile 0x0104 Home Automation
ZI_WAIT_RECV(500, ZBR_AF_REGISTER)
// Z_ZDO:nodeDescReq ?? Is is useful to redo it? TODO
// redo Z_ZDO:activeEpReq to check that Ep are available
ZI_SEND(ZBS_ZDO_ACTIVEEPREQ) // Z_ZDO:activeEpReq
ZI_WAIT_RECV(500, ZBR_ZDO_ACTIVEEPREQ)
ZI_WAIT_UNTIL(500, ZBR_ZDO_ACTIVEEPRSP_OK)
ZI_SEND(ZBS_PERMITJOINREQ_CLOSE) // Closing the Permit Join
ZI_WAIT_RECV(500, ZBR_PERMITJOINREQ)
ZI_WAIT_UNTIL(500, ZBR_PERMITJOIN_AREQ_RSP) // not sure it's useful
//ZI_WAIT_UNTIL(500, ZBR_PERMITJOIN_AREQ_CLOSE)
ZI_SEND(ZBS_PERMITJOINREQ_OPEN) // Opening Permit Join, normally through command TODO
ZI_WAIT_RECV(500, ZBR_PERMITJOINREQ)
ZI_WAIT_UNTIL(500, ZBR_PERMITJOIN_AREQ_RSP) // not sure it's useful
//ZI_WAIT_UNTIL(500, ZBR_PERMITJOIN_AREQ_OPEN)
ZI_LABEL(ZIGBEE_LABEL_READY)
ZI_LOG(LOG_LEVEL_INFO, "ZIG: zigbee device ready, listening...")
ZI_CALL(&Z_State_Ready, 1)
ZI_WAIT_FOREVER()
ZI_GOTO(ZIGBEE_LABEL_READY)
ZI_LABEL(50) // reformat device
ZI_LOG(LOG_LEVEL_INFO, "ZIG: zigbee bad configuration of device, doing a factory reset")
ZI_ON_ERROR_GOTO(ZIGBEE_LABEL_ABORT)
ZI_SEND(ZBS_FACTRES) // factory reset
ZI_WAIT_RECV(500, ZBR_W_OK)
ZI_SEND(ZBS_RESET) // reset device
ZI_WAIT_RECV(5000, ZBR_RESET)
ZI_SEND(ZBS_W_PAN) // write PAN ID
ZI_WAIT_RECV(500, ZBR_W_OK)
ZI_SEND(ZBS_W_EXTPAN) // write EXT PAN ID
ZI_WAIT_RECV(500, ZBR_W_OK)
ZI_SEND(ZBS_W_CHANN) // write CHANNEL
ZI_WAIT_RECV(500, ZBR_W_OK)
ZI_SEND(ZBS_W_LOGTYP) // write Logical Type = coordinator
ZI_WAIT_RECV(500, ZBR_W_OK)
ZI_SEND(ZBS_W_PFGK) // write PRECFGKEY
ZI_WAIT_RECV(500, ZBR_W_OK)
ZI_SEND(ZBS_W_PFGKEN) // write PRECFGKEY Enable
ZI_WAIT_RECV(500, ZBR_W_OK)
ZI_SEND(ZBS_WNV_SECMODE) // write Security Mode
ZI_WAIT_RECV(500, ZBR_WNV_OK)
ZI_SEND(ZBS_W_ZDODCB) // write Z_ZDO Direct CB
ZI_WAIT_RECV(500, ZBR_W_OK)
// Now mark the device as ready, writing 0x55 in memory slot 0x0F00
ZI_SEND(ZBS_WNV_INITZNPHC) // Init NV ZNP Has Configured
ZI_WAIT_RECV(500, ZBR_WNV_INIT_OK)
ZI_SEND(ZBS_WNV_ZNPHC) // Write NV ZNP Has Configured
ZI_WAIT_RECV(500, ZBR_WNV_OK)
ZI_LOG(LOG_LEVEL_INFO, "ZIG: zigbee device reconfigured")
ZI_GOTO(10)
ZI_LABEL(ZIGBEE_LABEL_ABORT) // Label 99: abort
ZI_LOG(LOG_LEVEL_ERROR, "ZIG: Abort")
ZI_STOP(ZIGBEE_LABEL_ABORT)
};
int32_t Z_Recv_Vers(int32_t res, class SBuffer &buf) {
// check that the version is supported
// typical version for ZNP 1.2
// 61020200-020603D91434010200000000
// TranportRev = 02
// Product = 00
// MajorRel = 2
// MinorRel = 6
// MaintRel = 3
// Revision = 20190425 d (0x013414D9)
if ((0x02 == buf.get8(4)) && (0x06 == buf.get8(5))) {
return 0; // version 2.6.x is ok
} else {
return -2; // abort
}
}
int32_t Z_Recv_Default(int32_t res, class SBuffer &buf) {
// Default message handler for new messages
AddLog_P2(LOG_LEVEL_DEBUG, PSTR("ZIG: Z_Recv_Default"));
if (zigbee.init_phase) {
// if still during initialization phase, ignore any unexpected message
return -1; // ignore message
} else {
if ( (pgm_read_byte(&ZBR_AF_INCOMING_MESSAGE[0]) == buf.get8(0)) &&
(pgm_read_byte(&ZBR_AF_INCOMING_MESSAGE[1]) == buf.get8(1)) ) {
// AF_INCOMING_MSG, extract ZCL part TODO
// skip first 19 bytes
ZCLFrame zcl_received = ZCLFrame::parseRawFrame(buf, 19, buf.get8(18));
zcl_received.publishMQTTReceived();
}
return -1;
}
}
int32_t Z_State_Ready(uint8_t value) {
zigbee.init_phase = false; // initialization phase complete
return 0; // continue
}
uint8_t ZigbeeGetInstructionSize(uint8_t instr) { // in Zigbee_Instruction lines (words)
if (instr >= ZGB_INSTR_12_BYTES) {
return 3;
} else if (instr >= ZGB_INSTR_8_BYTES) {
return 2;
} else {
return 1;
}
}
void ZigbeeGotoLabel(uint8_t label) {
// look for the label scanning entire code
uint16_t goto_pc = 0xFFFF; // 0xFFFF means not found
uint8_t cur_instr = 0;
uint8_t cur_d8 = 0;
uint8_t cur_instr_len = 1; // size of current instruction in words
for (uint32_t i = 0; i < sizeof(zb_prog)/sizeof(zb_prog[0]); i += cur_instr_len) {
const Zigbee_Instruction *cur_instr_line = &zb_prog[i];
cur_instr = pgm_read_byte(&cur_instr_line->i.i);
cur_d8 = pgm_read_byte(&cur_instr_line->i.d8);
//AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZGB GOTO: pc %d instr %d"), i, cur_instr);
if (ZGB_INSTR_LABEL == cur_instr) {
//AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: found label %d at pc %d"), cur_d8, i);
if (label == cur_d8) {
// label found, goto to this pc
zigbee.pc = i;
zigbee.state_machine = true;
zigbee.state_waiting = false;
return;
}
}
// get instruction length
cur_instr_len = ZigbeeGetInstructionSize(cur_instr);
}
// no label found, abort
AddLog_P2(LOG_LEVEL_ERROR, PSTR("ZIG: Goto label not found, label=%d pc=%d"), label, zigbee.pc);
if (ZIGBEE_LABEL_ABORT != label) {
// if not already looking for ZIGBEE_LABEL_ABORT, goto ZIGBEE_LABEL_ABORT
ZigbeeGotoLabel(ZIGBEE_LABEL_ABORT);
} else {
AddLog_P2(LOG_LEVEL_ERROR, PSTR("ZIG: Label Abort (%d) not present, aborting Zigbee"), ZIGBEE_LABEL_ABORT);
zigbee.state_machine = false;
zigbee.active = false;
}
}
void ZigbeeStateMachine_Run(void) {
uint8_t cur_instr = 0;
uint8_t cur_d8 = 0;
uint16_t cur_d16 = 0;
const void* cur_ptr1 = nullptr;
const void* cur_ptr2 = nullptr;
uint32_t now = millis();
if (zigbee.state_waiting) { // state machine is waiting for external event or timeout
// checking if timeout expired
if ((zigbee.next_timeout) && (now > zigbee.next_timeout)) { // if next_timeout == 0 then wait forever
//AddLog_P2(LOG_LEVEL_INFO, PSTR("ZIG: timeout occured pc=%d"), zigbee.pc);
if (!zigbee.state_no_timeout) {
AddLog_P2(LOG_LEVEL_INFO, PSTR("ZIG: timeout, goto label %d"), zigbee.on_timeout_goto);
ZigbeeGotoLabel(zigbee.on_timeout_goto);
} else {
zigbee.state_waiting = false; // simply stop waiting
}
}
}
while ((zigbee.state_machine) && (!zigbee.state_waiting)) {
// reinit receive filters and functions (they only work for a single instruction)
zigbee.recv_filter = nullptr;
zigbee.recv_func = nullptr;
zigbee.recv_until = false;
zigbee.state_no_timeout = false; // reset the no_timeout for next instruction
if (zigbee.pc > (sizeof(zb_prog)/sizeof(zb_prog[0]))) {
AddLog_P2(LOG_LEVEL_ERROR, PSTR("ZIG: Invalid pc: %d, aborting"), zigbee.pc);
zigbee.pc = -1;
}
if (zigbee.pc < 0) {
zigbee.state_machine = false;
return;
}
// load current instruction details
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZIG: Executing instruction pc=%d"), zigbee.pc);
const Zigbee_Instruction *cur_instr_line = &zb_prog[zigbee.pc];
cur_instr = pgm_read_byte(&cur_instr_line->i.i);
cur_d8 = pgm_read_byte(&cur_instr_line->i.d8);
cur_d16 = pgm_read_word(&cur_instr_line->i.d16);
if (cur_instr >= ZGB_INSTR_8_BYTES) {
cur_instr_line++;
cur_ptr1 = cur_instr_line->p;
}
if (cur_instr >= ZGB_INSTR_12_BYTES) {
cur_instr_line++;
cur_ptr2 = cur_instr_line->p;
}
zigbee.pc += ZigbeeGetInstructionSize(cur_instr); // move pc to next instruction, before any goto
switch (cur_instr) {
case ZGB_INSTR_NOOP:
case ZGB_INSTR_LABEL: // do nothing
break;
case ZGB_INSTR_GOTO:
ZigbeeGotoLabel(cur_d8);
break;
case ZGB_INSTR_ON_ERROR_GOTO:
zigbee.on_error_goto = cur_d8;
break;
case ZGB_INSTR_ON_TIMEOUT_GOTO:
zigbee.on_timeout_goto = cur_d8;
break;
case ZGB_INSTR_WAIT:
zigbee.next_timeout = now + cur_d16;
zigbee.state_waiting = true;
zigbee.state_no_timeout = true; // do not generate a timeout error when waiting is done
break;
case ZGB_INSTR_WAIT_FOREVER:
zigbee.next_timeout = 0;
zigbee.state_waiting = true;
//zigbee.state_no_timeout = true; // do not generate a timeout error when waiting is done
break;
case ZGB_INSTR_STOP:
zigbee.state_machine = false;
if (cur_d8) {
AddLog_P2(LOG_LEVEL_ERROR, PSTR("ZIG: Stopping (%d)"), cur_d8);
}
break;
case ZGB_INSTR_CALL:
if (cur_ptr1) {
uint32_t res;
res = (*((ZB_Func)cur_ptr1))(cur_d8);
if (res > 0) {
ZigbeeGotoLabel(res);
continue; // avoid incrementing PC after goto
} else if (res == 0) {
// do nothing
} else if (res == -1) {
// do nothing
} else {
ZigbeeGotoLabel(zigbee.on_error_goto);
continue;
}
}
// TODO
break;
case ZGB_INSTR_LOG:
AddLog_P(cur_d8, (char*) cur_ptr1);
break;
case ZGB_INSTR_SEND:
ZigbeeZNPSend((uint8_t*) cur_ptr1, cur_d8 /* len */);
break;
case ZGB_INSTR_WAIT_UNTIL:
zigbee.recv_until = true; // and reuse ZGB_INSTR_WAIT_RECV
case ZGB_INSTR_WAIT_RECV:
zigbee.recv_filter = (uint8_t *) cur_ptr1;
zigbee.recv_filter_len = cur_d8; // len
zigbee.next_timeout = now + cur_d16;
zigbee.state_waiting = true;
break;
case ZGB_ON_RECV_UNEXPECTED:
zigbee.recv_unexpected = (ZB_RecvMsgFunc) cur_ptr1;
break;
case ZGB_INSTR_WAIT_RECV_CALL:
zigbee.recv_filter = (uint8_t *) cur_ptr1;
zigbee.recv_filter_len = cur_d8; // len
zigbee.recv_func = (ZB_RecvMsgFunc) cur_ptr2;
zigbee.next_timeout = now + cur_d16;
zigbee.state_waiting = true;
break;
}
}
}
int32_t ZigbeeProcessInput(class SBuffer &buf) {
if (!zigbee.state_machine) { return -1; } // if state machine is stopped, send 'ignore' message
// apply the receive filter, acts as 'startsWith()'
bool recv_filter_match = true;
bool recv_prefix_match = false; // do the first 2 bytes match the response
if ((zigbee.recv_filter) && (zigbee.recv_filter_len > 0)) {
if (zigbee.recv_filter_len >= 2) {
recv_prefix_match = false;
if ( (pgm_read_byte(&zigbee.recv_filter[0]) == buf.get8(0)) &&
(pgm_read_byte(&zigbee.recv_filter[1]) == buf.get8(1)) ) {
recv_prefix_match = true;
}
}
for (uint32_t i = 0; i < zigbee.recv_filter_len; i++) {
if (pgm_read_byte(&zigbee.recv_filter[i]) != buf.get8(i)) {
recv_filter_match = false;
break;
}
}
AddLog_P2(LOG_LEVEL_DEBUG, PSTR("ZIG: ZigbeeProcessInput: recv_prefix_match = %d, recv_filter_match = %d"), recv_prefix_match, recv_filter_match);
}
// if there is a recv_callback, call it now
int32_t res = -1; // default to ok
// res = 0 - proceed to next state
// res > 0 - proceed to the specified state
// res = -1 - silently ignore the message
// res <= -2 - move to error state
// pre-compute the suggested value
if ((zigbee.recv_filter) && (zigbee.recv_filter_len > 0)) {
if (!recv_prefix_match) {
res = -1; // ignore
} else { // recv_prefix_match
if (recv_filter_match) {
res = 0; // ok
} else {
if (zigbee.recv_until) {
res = -1; // ignore until full match
} else {
res = -2; // error, because message is expected but wrong value
}
}
}
} else { // we don't have any filter, ignore message by default
res = -1;
}
if (recv_prefix_match) {
if (zigbee.recv_func) {
res = (*zigbee.recv_func)(res, buf);
}
}
if (-1 == res) {
// if frame was ignored up to now
if (zigbee.recv_unexpected) {
res = (*zigbee.recv_unexpected)(res, buf);
}
}
AddLog_P2(LOG_LEVEL_DEBUG, PSTR("ZIG: ZigbeeProcessInput: res = %d"), res);
// change state accordingly
if (0 == res) {
// if ok, continue execution
zigbee.state_waiting = false;
} else if (res > 0) {
ZigbeeGotoLabel(res); // if >0 then go to specified label
} else if (-1 == res) {
// -1 means ignore message
// just do nothing
} else {
// any other negative value means error
ZigbeeGotoLabel(zigbee.on_error_goto);
}
}
void ZigbeeInput(void)
{
static uint32_t zigbee_polling_window = 0;
static uint8_t fcs = ZIGBEE_SOF;
static uint32_t zigbee_frame_len = 5; // minimal zigbee frame lenght, will be updated when buf[1] is read
// Receive only valid ZNP frames:
// 00 - SOF = 0xFE
// 01 - Length of Data Field - 0..250
// 02 - CMD1 - first byte of command
// 03 - CMD2 - second byte of command
// 04..FD - Data Field
// FE (or last) - FCS Checksum
while (ZigbeeSerial->available()) {
yield();
uint8_t zigbee_in_byte = ZigbeeSerial->read();
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZigbeeInput byte=%d len=%d"), zigbee_in_byte, zigbee_buffer->len());
if (0 == zigbee_buffer->len()) { // make sure all variables are correctly initialized
zigbee_frame_len = 5;
fcs = ZIGBEE_SOF;
}
if ((0 == zigbee_buffer->len()) && (ZIGBEE_SOF != zigbee_in_byte)) {
// waiting for SOF (Start Of Frame) byte, discard anything else
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZigbeeInput discarding byte %02X"), zigbee_in_byte);
continue; // discard
}
if (zigbee_buffer->len() < zigbee_frame_len) {
zigbee_buffer->add8(zigbee_in_byte);
zigbee_polling_window = millis(); // Wait for more data
fcs ^= zigbee_in_byte;
}
if (zigbee_buffer->len() >= zigbee_frame_len) {
zigbee_polling_window = 0; // Publish now
break;
}
// recalculate frame length
if (02 == zigbee_buffer->len()) {
// We just received the Lenght byte
uint8_t len_byte = zigbee_buffer->get8(1);
if (len_byte > 250) len_byte = 250; // ZNP spec says len is 250 max
zigbee_frame_len = len_byte + 5; // SOF + LEN + CMD1 + CMD2 + FCS = 5 bytes overhead
}
}
if (zigbee_buffer->len() && (millis() > (zigbee_polling_window + ZIGBEE_POLLING))) {
char hex_char[(zigbee_buffer->len() * 2) + 2];
ToHex_P((unsigned char*)zigbee_buffer->getBuffer(), zigbee_buffer->len(), hex_char, sizeof(hex_char));
// buffer received, now check integrity
if (zigbee_buffer->len() != zigbee_frame_len) {
// Len is not correct, log and reject frame
AddLog_P2(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received frame of wrong size %s, len %d, expected %d"), hex_char, zigbee_buffer->len(), zigbee_frame_len);
} else if (0x00 != fcs) {
// FCS is wrong, packet is corrupt, log and reject frame
AddLog_P2(LOG_LEVEL_INFO, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received bad FCS frame %s, %d"), hex_char, fcs);
} else {
// frame is correct
AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_JSON_ZIGBEEZNPRECEIVED ": received correct frame %s"), hex_char);
SBuffer znp_buffer = zigbee_buffer->subBuffer(2, zigbee_frame_len - 3); // remove SOF, LEN and FCS
ToHex_P((unsigned char*)znp_buffer.getBuffer(), znp_buffer.len(), hex_char, sizeof(hex_char));
Response_P(PSTR("{\"" D_JSON_ZIGBEEZNPRECEIVED "\":\"%s\"}"), hex_char);
MqttPublishPrefixTopic_P(RESULT_OR_TELE, PSTR(D_JSON_ZIGBEEZNPRECEIVED));
XdrvRulesProcess();
// now process the message
ZigbeeProcessInput(znp_buffer);
}
zigbee_buffer->setLen(0); // empty buffer
}
}
/********************************************************************************************/
void ZigbeeInit(void)
{
zigbee.active = false;
if ((pin[GPIO_ZIGBEE_RX] < 99) && (pin[GPIO_ZIGBEE_TX] < 99)) {
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("Zigbee: GPIOs Rx:%d Tx:%d"), pin[GPIO_ZIGBEE_RX], pin[GPIO_ZIGBEE_TX]);
ZigbeeSerial = new TasmotaSerial(pin[GPIO_ZIGBEE_RX], pin[GPIO_ZIGBEE_TX], 0, 0, 256); // set a receive buffer of 256 bytes
if (ZigbeeSerial->begin(115200)) { // ZNP is 115200, RTS/CTS (ignored), 8N1
if (ZigbeeSerial->hardwareSerial()) {
ClaimSerial();
zigbee_buffer = new PreAllocatedSBuffer(sizeof(serial_in_buffer), serial_in_buffer);
} else {
zigbee_buffer = new SBuffer(ZIGBEE_BUFFER_SIZE);
}
zigbee.active = true;
zigbee.init_phase = true; // start the state machine
zigbee.state_machine = true; // start the state machine
ZigbeeSerial->flush();
}
}
}
/*********************************************************************************************\
* Commands
\*********************************************************************************************/
void CmndZigbeeZNPSend(void)
{
AddLog_P2(LOG_LEVEL_INFO, PSTR("CmndZigbeeZNPSend: entering, data_len = %d"), XdrvMailbox.data_len); // TODO
if (ZigbeeSerial && (XdrvMailbox.data_len > 0)) {
uint8_t code;
char *codes = RemoveSpace(XdrvMailbox.data);
int32_t size = strlen(XdrvMailbox.data);
SBuffer buf((size+1)/2);
while (size > 0) {
char stemp[3];
strlcpy(stemp, codes, sizeof(stemp));
code = strtol(stemp, nullptr, 16);
buf.add8(code);
size -= 2;
codes += 2;
}
ZigbeeZNPSend(buf.getBuffer(), buf.len());
}
ResponseCmndDone();
}
void ZigbeeZNPSend(const uint8_t *msg, size_t len) {
if ((len < 2) || (len > 252)) {
// abort, message cannot be less than 2 bytes for CMD1 and CMD2
AddLog_P2(LOG_LEVEL_DEBUG, PSTR(D_JSON_ZIGBEEZNPSENT ": bad message len %d"), len);
return;
}
uint8_t data_len = len - 2; // removing CMD1 and CMD2
if (ZigbeeSerial) {
uint8_t fcs = data_len;
ZigbeeSerial->write(ZIGBEE_SOF); // 0xFE
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend SOF %02X"), ZIGBEE_SOF);
ZigbeeSerial->write(data_len);
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend LEN %02X"), data_len);
for (uint32_t i = 0; i < len; i++) {
uint8_t b = pgm_read_byte(msg + i);
ZigbeeSerial->write(b);
fcs ^= b;
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend byt %02X"), b);
}
ZigbeeSerial->write(fcs); // finally send fcs checksum byte
AddLog_P2(LOG_LEVEL_DEBUG_MORE, PSTR("ZNPSend FCS %02X"), fcs);
}
// Now send a MQTT message to report the sent message
char hex_char[(len * 2) + 2];
Response_P(PSTR("{\"" D_JSON_ZIGBEEZNPSENT "\":\"%s\"}"),
ToHex_P(msg, len, hex_char, sizeof(hex_char)));
MqttPublishPrefixTopic_P(RESULT_OR_TELE, PSTR(D_JSON_ZIGBEEZNPSENT));
XdrvRulesProcess();
}
/*********************************************************************************************\
* Interface
\*********************************************************************************************/
bool Xdrv23(uint8_t function)
{
bool result = false;
if (zigbee.active) {
switch (function) {
case FUNC_LOOP:
if (ZigbeeSerial) { ZigbeeInput(); }
if (zigbee.state_machine) {
//ZigbeeStateMachine();
ZigbeeStateMachine_Run();
}
break;
case FUNC_PRE_INIT:
ZigbeeInit();
break;
case FUNC_COMMAND:
result = DecodeCommand(kZigbeeCommands, ZigbeeCommand);
break;
}
}
return result;
}
#endif // USE_ZIGBEE