Vergil Cola
/
MQTTGatewayK64
Fork of my MQTTGateway
Diff: XbeeMonitor/XBeeLib/XBee802/XBee802.cpp
- Revision:
- 0:f1d3878b8dd9
diff -r 000000000000 -r f1d3878b8dd9 XbeeMonitor/XBeeLib/XBee802/XBee802.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/XbeeMonitor/XBeeLib/XBee802/XBee802.cpp Sat Apr 08 14:45:51 2017 +0000 @@ -0,0 +1,615 @@ +/** + * Copyright (c) 2015 Digi International Inc., + * All rights not expressly granted are reserved. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Digi International Inc. 11001 Bren Road East, Minnetonka, MN 55343 + * ======================================================================= + */ +#include "XBee802.h" +#include "IO/IOSample802.h" +#include "Frames/802_Frames.h" +#include "FrameHandlers/FH_ModemStatus.h" + +using namespace XBeeLib; + +/* Class constructor */ +XBee802::XBee802(PinName tx, PinName rx, PinName reset, PinName rts, PinName cts, int baud) : + XBee(tx, rx, reset, rts, cts, baud), + _nd_handler(NULL), _rx_64b_handler(NULL), _rx_16b_handler(NULL), + _io_data_64b_handler(NULL), _io_data_16b_handler(NULL) +{ + +} + +/* Class destructor */ +XBee802::~XBee802() +{ + unregister_node_discovery_cb(); + unregister_receive_cb(); + unregister_io_sample_cb(); +} + +RadioStatus XBee802::init() +{ + RadioStatus retval = XBee::init(); + uint16_t addr16; + RadioStatus error = get_network_address(&addr16); + if (error == Success) { + digi_log(LogLevelInfo, "ADDR16: %04x\r\n", addr16); + } else { + digi_log(LogLevelInfo, "ADDR16: UNKNOWN\r\n"); + } + + const RadioProtocol radioProtocol = get_radio_protocol(); + if (radioProtocol != Raw_802_15_4) { + digi_log(LogLevelError, "Radio protocol does not match, needed a %d got a %d\r\n", Raw_802_15_4, radioProtocol); + retval = Failure; + } + assert(radioProtocol == Raw_802_15_4); + + return retval; +} + +RadioStatus XBee802::set_channel(uint8_t channel) +{ + AtCmdFrame::AtCmdResp cmdresp; + + /* Pro and Non-Pro modules have different channels available. The at + command will return an error if the selected channel is not available */ + cmdresp = set_param("CH", channel); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + return Success; +} + +RadioStatus XBee802::get_channel(uint8_t * const channel) +{ + if (channel == NULL) { + return Failure; + } + AtCmdFrame::AtCmdResp cmdresp; + + uint32_t var32; + cmdresp = get_param("CH", &var32); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + *channel = var32; + return Success; +} + +RadioStatus XBee802::set_panid(uint16_t panid) +{ + AtCmdFrame::AtCmdResp cmdresp; + + cmdresp = set_param("ID", panid); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + return Success; +} + +RadioStatus XBee802::get_panid(uint16_t * const panid) +{ + if (panid == NULL) { + return Failure; + } + AtCmdFrame::AtCmdResp cmdresp; + + uint32_t var32; + cmdresp = get_param("ID", &var32); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + *panid = var32; + return Success; +} + +RadioStatus XBee802::get_network_address(uint16_t * const addr16) +{ + if (addr16 == NULL) { + return Failure; + } + AtCmdFrame::AtCmdResp cmdresp; + + uint32_t var32; + cmdresp = get_param("MY", &var32); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + *addr16 = var32; + return Success; +} + +RadioStatus XBee802::set_network_address(uint16_t addr16) +{ + AtCmdFrame::AtCmdResp cmdresp; + + cmdresp = set_param("MY", addr16); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + return Success; +} + +RadioStatus XBee802::get_node_discovery_timeout(uint16_t * const timeout_ms) +{ + AtCmdFrame::AtCmdResp cmdresp; + uint32_t var32; + + cmdresp = get_param("NT", &var32); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + *timeout_ms = (uint16_t)var32; + + /* No N? command available for this protocol. Add a fix 1s guard time */ + *timeout_ms += 1000; + + return Success; +} + +RadioStatus XBee802::get_node_discovery_timeout(uint16_t * const timeout_ms, bool * const wait_for_complete_timeout) +{ + const RadioStatus status = get_node_discovery_timeout(timeout_ms); + + /* This protocol requires to wait for the complete timeout before attempting + to execute other commands */ + *wait_for_complete_timeout = true; + + return status; +} + +void XBee802::radio_status_update(AtCmdFrame::ModemStatus modem_status) +{ + /* Update the radio status variables */ + if (modem_status == AtCmdFrame::HwReset) { + _hw_reset_cnt++; + } else if (modem_status == AtCmdFrame::WdReset) { + _wd_reset_cnt++; + } + + _modem_status = modem_status; + + digi_log(LogLevelDebug, "\r\nUpdating radio status: %02x\r\n", modem_status); +} + +TxStatus XBee802::send_data(const RemoteXBee& remote, const uint8_t *const data, uint16_t len, bool syncr) +{ + if (remote.is_valid_addr64b()) { + const uint64_t remote64 = remote.get_addr64(); + + digi_log(LogLevelDebug, "send_data ADDR64: %08x:%08x\r\n", UINT64_HI32(remote64), UINT64_LO32(remote64)); + + TxFrame802 frame = TxFrame802(remote64, _tx_options, data, len); + + if (syncr) { + return send_data(&frame); + } else { + frame.set_data(0, 0); /* Set frame id to 0 so there is no answer */ + send_api_frame(&frame); + return TxStatusSuccess; + } + } + + if (remote.is_valid_addr16b()) { + const uint16_t remote16 = remote.get_addr16(); + + digi_log(LogLevelDebug, "send_data ADDR16: %04x\r\n", remote16); + + TxFrame802 frame = TxFrame802(remote16, _tx_options, data, len); + + if (syncr) { + return send_data(&frame); + } else { + frame.set_data(0, 0); /* Set frame id to 0 so there is no answer */ + send_api_frame(&frame); + return TxStatusSuccess; + } + } + + return TxStatusInvalidAddr; +} + +XBee802::AssocStatus XBee802::get_assoc_status(void) +{ + return (AssocStatus)get_AI(); +} + +RemoteXBee802 XBee802::get_remote_node_by_id(const char * const node_id) +{ + uint64_t addr64; + uint16_t addr16; + + _get_remote_node_by_id(node_id, &addr64, &addr16); + return RemoteXBee802(addr64, addr16); +} + +void XBee802::register_node_discovery_cb(node_discovery_802_cb_t function) +{ + if (_nd_handler == NULL) { + _nd_handler = new FH_NodeDiscovery802(); + register_frame_handler(_nd_handler); + } + _nd_handler->register_node_discovery_cb(function); +} + +void XBee802::unregister_node_discovery_cb() +{ + if (_nd_handler != NULL) { + _nd_handler->unregister_node_discovery_cb(); + unregister_frame_handler(_nd_handler); + delete _nd_handler; + _nd_handler = NULL; /* as delete does not set to NULL */ + } +} + +void XBee802::register_receive_cb(receive_802_cb_t function) +{ + if (_rx_64b_handler == NULL) { + _rx_64b_handler = new FH_RxPacket64b802(); + register_frame_handler(_rx_64b_handler); + } + _rx_64b_handler->register_receive_cb(function); + + if (_rx_16b_handler == NULL) { + _rx_16b_handler = new FH_RxPacket16b802(); + register_frame_handler(_rx_16b_handler); + } + _rx_16b_handler->register_receive_cb(function); +} + +void XBee802::unregister_receive_cb() +{ + if (_rx_64b_handler != NULL) { + _rx_64b_handler->unregister_receive_cb(); + unregister_frame_handler(_rx_64b_handler); + delete _rx_64b_handler; + _rx_64b_handler = NULL; /* as delete does not set to NULL */ + } + + if (_rx_16b_handler != NULL) { + _rx_16b_handler->unregister_receive_cb(); + unregister_frame_handler(_rx_16b_handler); + delete _rx_16b_handler; + _rx_16b_handler = NULL; /* as delete does not set to NULL */ + } +} + +void XBee802::register_io_sample_cb(io_data_cb_802_t function) +{ + if (_io_data_64b_handler == NULL) { + _io_data_64b_handler = new FH_IoDataSampe64b802(); + register_frame_handler(_io_data_64b_handler); + } + _io_data_64b_handler->register_io_data_cb(function); + + if (_io_data_16b_handler == NULL) { + _io_data_16b_handler = new FH_IoDataSampe16b802(); + register_frame_handler(_io_data_16b_handler); + } + _io_data_16b_handler->register_io_data_cb(function); +} + +void XBee802::unregister_io_sample_cb() +{ + if (_io_data_64b_handler != NULL) { + _io_data_64b_handler->unregister_io_data_cb(); + unregister_frame_handler(_io_data_64b_handler); + delete _io_data_64b_handler; + _io_data_64b_handler = NULL; /* as delete does not set to NULL */ + } + + if (_io_data_16b_handler != NULL) { + _io_data_16b_handler->unregister_io_data_cb(); + unregister_frame_handler(_io_data_16b_handler); + delete _io_data_16b_handler; + _io_data_16b_handler = NULL; /* as delete does not set to NULL */ + } +} + +AtCmdFrame::AtCmdResp XBee802::get_param(const RemoteXBee& remote, const char * const param, uint32_t * const data) +{ + uint16_t len = sizeof *data; + AtCmdFrame::AtCmdResp atCmdResponse; + + if (remote.is_valid_addr64b()) { + const uint64_t dev_addr64 = remote.get_addr64(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr64, param); + atCmdResponse = send_at_cmd(&cmd_frame, (uint8_t *)data, &len, RadioRemote); + } else if (remote.is_valid_addr16b()) { + const uint16_t dev_addr16 = remote.get_addr16(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr16, param); + atCmdResponse = send_at_cmd(&cmd_frame, (uint8_t *)data, &len, RadioRemote); + } else { + return AtCmdFrame::AtCmdRespInvalidAddr; + } + + if (atCmdResponse == AtCmdFrame::AtCmdRespOk && len > sizeof *data) { + atCmdResponse = AtCmdFrame::AtCmdRespLenMismatch; + } + + return atCmdResponse; +} + +AtCmdFrame::AtCmdResp XBee802::set_param(const RemoteXBee& remote, const char * const param, uint32_t data) +{ + if (remote.is_valid_addr64b()) { + const uint64_t dev_addr64 = remote.get_addr64(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr64, param, data); + return send_at_cmd(&cmd_frame, NULL, NULL, RadioRemote); + } + + if (remote.is_valid_addr16b()) { + const uint16_t dev_addr16 = remote.get_addr16(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr16, param, data); + return send_at_cmd(&cmd_frame, NULL, NULL, RadioRemote); + } + + return AtCmdFrame::AtCmdRespInvalidAddr; +} + +AtCmdFrame::AtCmdResp XBee802::set_param(const RemoteXBee& remote, const char * const param, const uint8_t * data, uint16_t len) +{ + if (remote.is_valid_addr64b()) { + const uint64_t dev_addr64 = remote.get_addr64(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr64, param, data, len); + return send_at_cmd(&cmd_frame, NULL, NULL, RadioRemote); + } + + if (remote.is_valid_addr16b()) { + const uint16_t dev_addr16 = remote.get_addr16(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr16, param, data, len); + return send_at_cmd(&cmd_frame, NULL, NULL, RadioRemote); + } + + return AtCmdFrame::AtCmdRespInvalidAddr; +} + +AtCmdFrame::AtCmdResp XBee802::get_param(const RemoteXBee& remote, const char * const param, uint8_t * const data, uint16_t * const len) +{ + if (remote.is_valid_addr64b()) { + uint64_t dev_addr64 = remote.get_addr64(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr64, param); + return send_at_cmd(&cmd_frame, data, len, RadioRemote, false); + } + + if (remote.is_valid_addr16b()) { + uint16_t dev_addr16 = remote.get_addr16(); + + AtCmdFrame cmd_frame = AtCmdFrame(dev_addr16, param); + return send_at_cmd(&cmd_frame, data, len, RadioRemote, false); + } + + return AtCmdFrame::AtCmdRespInvalidAddr; +} + +static void get_dio_cmd(XBee802::IoLine line, char * const iocmd) +{ + if (line >= XBee802::PWM0) { + iocmd[0] = 'P'; + iocmd[1] = '0' + line - XBee802::PWM0; + } else { + iocmd[0] = 'D'; + iocmd[1] = '0' + line; + } + iocmd[2] = '\0'; +} + +RadioStatus XBee802::set_pin_config(const RemoteXBee& remote, IoLine line, IoMode mode) +{ + AtCmdFrame::AtCmdResp cmdresp; + char iocmd[3]; + + get_dio_cmd(line, iocmd); + + cmdresp = set_param(remote, iocmd, (uint8_t)mode); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + digi_log(LogLevelError, "set_pin_config: set_param returned %d\r\n", cmdresp); + return Failure; + } + + return Success; +} + +RadioStatus XBee802::get_pin_config(const RemoteXBee& remote, IoLine line, IoMode * const mode) +{ + AtCmdFrame::AtCmdResp cmdresp; + char iocmd[3]; + + get_dio_cmd(line, iocmd); + + uint32_t var32; + cmdresp = get_param(remote, iocmd, &var32); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + *mode = (IoMode)var32; + + return Success; +} + +RadioStatus XBee802::set_dio(const RemoteXBee& remote, IoLine line, DioVal val) +{ + if (line > DI8) { + digi_log(LogLevelError, "set_dio: Pin %d not supported as IO\r\n", line); + return Failure; + } + + if (val == Low) { + return set_pin_config(remote, line, DigitalOutLow); + } else { + return set_pin_config(remote, line, DigitalOutHigh); + } +} + +RadioStatus XBee802::get_dio(const RemoteXBee& remote, IoLine line, DioVal * const val) +{ + return get_iosample(remote).get_dio(line, val); +} + +RadioStatus XBee802::get_adc(const RemoteXBee& remote, IoLine line, uint16_t * const val) +{ + return get_iosample(remote).get_adc(line, val); +} + +RadioStatus XBee802::set_pwm(const RemoteXBee& remote, IoLine line, float duty_cycle) +{ + AtCmdFrame::AtCmdResp cmdresp; + char iocmd[3] = { 'M', '0', '\0' }; + + if (line != PWM0 && line != PWM1) { + return Failure; + } + if (line == PWM1) { + iocmd[1] = '1'; + } + + uint16_t pwm_val = (uint16_t)(duty_cycle * DR_PWM_MAX_VAL / 100); + + cmdresp = set_param(remote, iocmd, pwm_val); + return cmdresp == AtCmdFrame::AtCmdRespOk ? Success : Failure; +} + +IOSample802 XBee802::get_iosample(const RemoteXBee& remote) +{ + uint8_t io_sample[MAX_IO_SAMPLE_802_LEN]; + uint16_t len = sizeof io_sample; + + RadioStatus resp = _get_iosample(remote, io_sample, &len); + if (resp != Success) { + digi_log(LogLevelError, "XBee802::get_iosample failed to get an IOSample\r\n"); + len = 0; + } + return IOSample802(io_sample, len); +} + +static uint8_t get_dio_mask(XBee802::IoLine line) +{ + switch (line) { + case XBee802::DIO4_AD4: + return (1 << 0); + case XBee802::DIO3_AD3: + return (1 << 1); + case XBee802::DIO2_AD2: + return (1 << 2); + case XBee802::DIO1_AD1: + return (1 << 3); + case XBee802::DIO0_AD0: + return (1 << 4); + case XBee802::DIO6: + return (1 << 5); + case XBee802::DI8: + return (1 << 6); + default: + return 0; + } +} + +RadioStatus XBee802::set_pin_pull_up(const RemoteXBee& remote, IoLine line, bool enable) +{ + AtCmdFrame::AtCmdResp cmdresp; + uint32_t var32; + uint8_t pr; + + cmdresp = get_param(remote, "PR", &var32); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + pr = var32; + + const uint8_t dio_mask = get_dio_mask(line); + if (dio_mask == 0) { + digi_log(LogLevelError, "XBee802::set_pin_pull_up: invalid pin %d\r\n", line); + return Failure; + } + + if (enable) { + pr |= dio_mask; + } else { + pr &= ~dio_mask; + } + + cmdresp = set_param(remote, "PR", pr); + return cmdresp == AtCmdFrame::AtCmdRespOk ? Success : Failure; +} + +static uint8_t get_dio_ic_mask(XBee802::IoLine line) +{ + if (line < XBee802::DI8) { + return (1 << line); + } + return 0; +} + +RadioStatus XBee802::enable_dio_change_detection(const RemoteXBee& remote, IoLine line, bool enable) +{ + if (line > DIO7) { + digi_log(LogLevelError, "XBee802::enable_dio_change_detection: pin not supported (%d)\r\n", line); + return Failure; + } + + AtCmdFrame::AtCmdResp cmdresp; + uint32_t var32; + uint8_t ic; + + cmdresp = get_param(remote, "IC", &var32); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + ic = var32; + + const uint8_t dio_mask = get_dio_ic_mask(line); + if (dio_mask == 0) { + digi_log(LogLevelError, "XBeeZB::enable_dio_change_detection: invalid pin %d\r\n", line); + return Failure; + } + + if (enable) { + ic |= dio_mask; + } else { + ic &= ~dio_mask; + } + + cmdresp = set_param(remote, "IC", ic); + return cmdresp == AtCmdFrame::AtCmdRespOk ? Success : Failure; +} + +#ifdef GET_PWM_AVAILABLE +RadioStatus XBee802::get_pwm(const RemoteXBee& remote, IoLine line, float * const duty_cycle) +{ + AtCmdFrame::AtCmdResp cmdresp; + char iocmd[3] = { 'M', '0', '\0' }; + + if (line != PWM0 && line != PWM1) { + return Failure; + } + + if (line == PWM1) { + iocmd[1] = '1'; + } + + uint16_t pwm_val; + + cmdresp = get_param(remote, iocmd, &pwm_val); + if (cmdresp != AtCmdFrame::AtCmdRespOk) { + return Failure; + } + + *duty_cycle = (float)(pwm_val * 100 / DR_PWM_MAX_VAL); + + return Success; +} +#endif