XBee.h

 
#ifndef XBee_h
#define XBee_h
 
#if defined(ARDUINO) && ARDUINO >= 100
    #include "Arduino.h"
#else
    #include "WProgram.h"
#endif
 
#include <inttypes.h>
#include <BayEOS.h>
 
#define SERIES_1
#define SERIES_2
 
// set to ATAP value of XBee. AP=2 is recommended
#define ATAP 2
 
#define START_BYTE 0x7e
#define ESCAPE 0x7d
#define XON 0x11
#define XOFF 0x13
 
// This value determines the size of the byte array for receiving RX packets
// Most users won't be dealing with packets this large so you can adjust this
// value to reduce memory consumption. But, remember that
// if a RX packet exceeds this size, it cannot be parsed!
 
// This value is determined by the largest packet size (100 byte payload + 64-bit address + option byte and rssi byte) of a series 1 radio
#define MAX_FRAME_DATA_SIZE 110
 
#define BROADCAST_ADDRESS 0xffff
#define ZB_BROADCAST_ADDRESS 0xfffe
 
// the non-variable length of the frame data (not including frame id or api id or variable data size (e.g. payload, at command set value)
#define ZB_TX_API_LENGTH 12
#define TX_16_API_LENGTH 3
#define TX_64_API_LENGTH 9
#define AT_COMMAND_API_LENGTH 2
#define REMOTE_AT_COMMAND_API_LENGTH 13
// start/length(2)/api/frameid/checksum bytes
#define PACKET_OVERHEAD_LENGTH 6
// api is always the third byte in packet
#define API_ID_INDEX 3
 
// frame position of rssi byte
#define RX_16_RSSI_OFFSET 2
#define RX_64_RSSI_OFFSET 8
 
#define DEFAULT_FRAME_ID 1
#define NO_RESPONSE_FRAME_ID 0
 
// TODO put in tx16 class
#define ACK_OPTION 0
#define DISABLE_ACK_OPTION 1
#define BROADCAST_OPTION 4
 
// RX options
#define ZB_PACKET_ACKNOWLEDGED 0x01
#define ZB_BROADCAST_PACKET 0x02
 
// not everything is implemented!
#define TX_64_REQUEST 0x0
#define TX_16_REQUEST 0x1
#define AT_COMMAND_REQUEST 0x08
#define AT_COMMAND_QUEUE_REQUEST 0x09
#define REMOTE_AT_REQUEST 0x17
#define ZB_TX_REQUEST 0x10
#define ZB_EXPLICIT_TX_REQUEST 0x11
#define RX_64_RESPONSE 0x80
#define RX_16_RESPONSE 0x81
#define RX_64_IO_RESPONSE 0x82
#define RX_16_IO_RESPONSE 0x83
#define AT_RESPONSE 0x88
#define TX_STATUS_RESPONSE 0x89
#define MODEM_STATUS_RESPONSE 0x8a
#define ZB_RX_RESPONSE 0x90
#define ZB_EXPLICIT_RX_RESPONSE 0x91
#define ZB_TX_STATUS_RESPONSE 0x8b
#define ZB_IO_SAMPLE_RESPONSE 0x92
#define ZB_IO_NODE_IDENTIFIER_RESPONSE 0x95
#define AT_COMMAND_RESPONSE 0x88
#define REMOTE_AT_COMMAND_RESPONSE 0x97
 
 
#define SUCCESS 0x0
#define CCA_FAILURE 0x2
#define INVALID_DESTINATION_ENDPOINT_SUCCESS 0x15
#define NETWORK_ACK_FAILURE 0x21
#define NOT_JOINED_TO_NETWORK 0x22
#define SELF_ADDRESSED 0x23
#define ADDRESS_NOT_FOUND 0x24
#define ROUTE_NOT_FOUND 0x25
#define PAYLOAD_TOO_LARGE 0x74
 
// modem status
#define HARDWARE_RESET 0
#define WATCHDOG_TIMER_RESET 1
#define ASSOCIATED 2
#define DISASSOCIATED 3
#define SYNCHRONIZATION_LOST 4
#define COORDINATOR_REALIGNMENT 5
#define COORDINATOR_STARTED 6
 
#define ZB_BROADCAST_RADIUS_MAX_HOPS 0
 
#define ZB_TX_UNICAST 0
#define ZB_TX_BROADCAST 8
 
#define AT_OK 0
#define AT_ERROR  1
#define AT_INVALID_COMMAND 2
#define AT_INVALID_PARAMETER 3
#define AT_NO_RESPONSE 4
 
#define NO_ERROR 0
#define CHECKSUM_FAILURE 1
#define PACKET_EXCEEDS_BYTE_ARRAY_LENGTH 2
#define UNEXPECTED_START_BYTE 3
 
class XBeeResponse {
public:
    //static const int MODEM_STATUS = 0x8a;
    XBeeResponse();
    uint8_t getApiId();
    void setApiId(uint8_t apiId);
    uint8_t getMsbLength();
    void setMsbLength(uint8_t msbLength);
    uint8_t getLsbLength();
    void setLsbLength(uint8_t lsbLength);
    uint8_t getChecksum();
    void setChecksum(uint8_t checksum);
    uint8_t getFrameDataLength();
    void setFrameData(uint8_t* frameDataPtr);
    uint8_t* getFrameData();
 
    void setFrameLength(uint8_t frameLength);
    // to support future 65535 byte packets I guess
    uint16_t getPacketLength();
    void reset();
    void init();
#ifdef SERIES_2
    void getZBTxStatusResponse(XBeeResponse &response);
    void getZBRxResponse(XBeeResponse &response);
    void getZBRxIoSampleResponse(XBeeResponse &response);
#endif
#ifdef SERIES_1
    void getTxStatusResponse(XBeeResponse &response);
    void getRx16Response(XBeeResponse &response);
    void getRx64Response(XBeeResponse &response);
    void getRx16IoSampleResponse(XBeeResponse &response);
    void getRx64IoSampleResponse(XBeeResponse &response);
#endif
    void getAtCommandResponse(XBeeResponse &responses);
    void getRemoteAtCommandResponse(XBeeResponse &response);
    void getModemStatusResponse(XBeeResponse &response);
    bool isAvailable();
    void setAvailable(bool complete);
    bool isError();
    uint8_t getErrorCode();
    void setErrorCode(uint8_t errorCode);
protected:
    // pointer to frameData
    uint8_t* _frameDataPtr;
private:
    void setCommon(XBeeResponse &target);
    uint8_t _apiId;
    uint8_t _msbLength;
    uint8_t _lsbLength;
    uint8_t _checksum;
    uint8_t _frameLength;
    bool _complete;
    uint8_t _errorCode;
};
 
class XBeeAddress {
public:
    XBeeAddress();
};
 
class XBeeAddress64 : public XBeeAddress {
public:
    XBeeAddress64(uint32_t msb, uint32_t lsb);
    XBeeAddress64();
    uint32_t getMsb();
    uint32_t getLsb();
    void setMsb(uint32_t msb);
    void setLsb(uint32_t lsb);
private:
    uint32_t _msb;
    uint32_t _lsb;
};
 
//class XBeeAddress16 : public XBeeAddress {
//public:
//  XBeeAddress16(uint16_t addr);
//  XBeeAddress16();
//  uint16_t getAddress();
//  void setAddress(uint16_t addr);
//private:
//  uint16_t _addr;
//};
 
class FrameIdResponse : public XBeeResponse {
public:
    FrameIdResponse();
    uint8_t getFrameId();
private:
    uint8_t _frameId;
};
 
class RxDataResponse : public XBeeResponse {
public:
    RxDataResponse();
    uint8_t getData(int index);
    uint8_t* getData();
    virtual uint8_t getDataLength() = 0;
    virtual uint8_t getDataOffset() = 0;
};
 
// getResponse to return the proper subclass:
// we maintain a pointer to each type of response, when a response is parsed, it is allocated only if NULL
// can we allocate an object in a function?
 
#ifdef SERIES_2
class ZBTxStatusResponse : public FrameIdResponse {
    public:
        ZBTxStatusResponse();
        uint16_t getRemoteAddress();
        uint8_t getTxRetryCount();
        uint8_t getDeliveryStatus();
        uint8_t getDiscoveryStatus();
        bool isSuccess();
};
 
class ZBRxResponse : public RxDataResponse {
public:
    ZBRxResponse();
    XBeeAddress64& getRemoteAddress64();
    uint16_t getRemoteAddress16();
    uint8_t getOption();
    uint8_t getDataLength();
    // frame position where data starts
    uint8_t getDataOffset();
private:
    XBeeAddress64 _remoteAddress64;
};
 
class ZBRxIoSampleResponse : public ZBRxResponse {
public:
    ZBRxIoSampleResponse();
    bool containsAnalog();
    bool containsDigital();
    bool isAnalogEnabled(uint8_t pin);
    bool isDigitalEnabled(uint8_t pin);
    uint16_t getAnalog(uint8_t pin);
    bool isDigitalOn(uint8_t pin);
    uint8_t getDigitalMaskMsb();
    uint8_t getDigitalMaskLsb();
    uint8_t getAnalogMask();
};
 
#endif
 
#ifdef SERIES_1
class TxStatusResponse : public FrameIdResponse {
    public:
        TxStatusResponse();
        uint8_t getStatus();
        bool isSuccess();
};
 
class RxResponse : public RxDataResponse {
public:
    RxResponse();
    // remember rssi is negative but this is unsigned byte so it's up to you to convert
    uint8_t getRssi();
    uint8_t getOption();
    bool isAddressBroadcast();
    bool isPanBroadcast();
    uint8_t getDataLength();
    uint8_t getDataOffset();
    virtual uint8_t getRssiOffset() = 0;
};
 
class Rx16Response : public RxResponse {
public:
    Rx16Response();
    uint8_t getRssiOffset();
    uint16_t getRemoteAddress16();
protected:
    uint16_t _remoteAddress;
};
 
class Rx64Response : public RxResponse {
public:
    Rx64Response();
    uint8_t getRssiOffset();
    XBeeAddress64& getRemoteAddress64();
private:
    XBeeAddress64 _remoteAddress;
};
 
class RxIoSampleBaseResponse : public RxResponse {
    public:
        RxIoSampleBaseResponse();
        uint8_t getSampleSize();
        bool containsAnalog();
        bool containsDigital();
        bool isAnalogEnabled(uint8_t pin);
        bool isDigitalEnabled(uint8_t pin);
        uint16_t getAnalog(uint8_t pin, uint8_t sample);
        bool isDigitalOn(uint8_t pin, uint8_t sample);
        uint8_t getSampleOffset();
    private:
};
 
class Rx16IoSampleResponse : public RxIoSampleBaseResponse {
public:
    Rx16IoSampleResponse();
    uint16_t getRemoteAddress16();
    uint8_t getRssiOffset();
 
};
 
class Rx64IoSampleResponse : public RxIoSampleBaseResponse {
public:
    Rx64IoSampleResponse();
    XBeeAddress64& getRemoteAddress64();
    uint8_t getRssiOffset();
private:
    XBeeAddress64 _remoteAddress;
};
 
#endif
 
class ModemStatusResponse : public XBeeResponse {
public:
    ModemStatusResponse();
    uint8_t getStatus();
};
 
class AtCommandResponse : public FrameIdResponse {
    public:
        AtCommandResponse();
        uint8_t* getCommand();
        uint8_t getStatus();
        uint8_t* getValue();
        uint8_t getValueLength();
        bool isOk();
};
 
class RemoteAtCommandResponse : public AtCommandResponse {
    public:
        RemoteAtCommandResponse();
        uint8_t* getCommand();
        uint8_t getStatus();
        uint8_t* getValue();
        uint8_t getValueLength();
        uint16_t getRemoteAddress16();
        XBeeAddress64& getRemoteAddress64();
        bool isOk();
    private:
        XBeeAddress64 _remoteAddress64;
};
 
 
class XBeeRequest {
public:
    XBeeRequest(uint8_t apiId, uint8_t frameId);
    void setFrameId(uint8_t frameId);
    uint8_t getFrameId();
    uint8_t getApiId();
    // setting = 0 makes this a pure virtual function, meaning the subclass must implement, like abstract in java
    virtual uint8_t getFrameData(uint8_t pos) = 0;
    virtual uint8_t getFrameDataLength() = 0;
    //void reset();
protected:
    void setApiId(uint8_t apiId);
private:
    uint8_t _apiId;
    uint8_t _frameId;
};
 
 
 
// TODO add reset/clear method since responses are often reused
class XBeeInterface {
public:
    XBeeInterface();
 
 
    void readPacket();
    bool readPacket(int timeout);
    void readPacketUntilAvailable();
    void getResponse(XBeeResponse &response);
    XBeeResponse& getResponse();
    void send(XBeeRequest &request);
    //uint8_t sendAndWaitForResponse(XBeeRequest &request, int timeout);
    uint16_t getPANID(void);
 
    uint8_t parseRX16(BayEOS &client, int rx_panid);
 
 
    uint8_t getNextFrameId();
    virtual void i_begin(long baud) = 0;
    virtual int i_available() = 0;
    virtual int read() = 0;
    virtual void flush() = 0;
    virtual size_t write(uint8_t val) = 0;
protected:
    void sendByte(uint8_t b, bool escape);
    void resetResponse();
    XBeeResponse _response;
    bool _escape;
    // current packet position for response.  just a state variable for packet parsing and has no relevance for the response otherwise
    uint8_t _pos;
    // last byte read
    uint8_t b;
    uint8_t _checksumTotal;
    uint8_t _nextFrameId;
    // buffer for incoming RX packets.  holds only the api specific frame data, starting after the api id byte and prior to checksum
    uint8_t _responseFrameData[MAX_FRAME_DATA_SIZE];
};
 
class XBee : public XBeeInterface {
private:
    HardwareSerial* _serial;
 
public:
    XBee():XBeeInterface()
    {
        _serial = &Serial;
    }
 
    void setSerial(HardwareSerial &serial){
        _serial = &serial;
    }
 
    int i_available(void){
        return _serial->available();
    }
    void begin(long baud){
        _serial->begin(baud);
    }
    void i_begin(long baud){
        _serial->begin(baud);
    }
    void flush(void){
        _serial->flush();
    }
    int read(void){
        return _serial->read();
    }
    size_t write(uint8_t c){
        return _serial->write(c);
    }
 
 
};
class PayloadRequest : public XBeeRequest {
public:
    PayloadRequest(uint8_t apiId, uint8_t frameId, uint8_t *payload, uint8_t payloadLength);
    uint8_t* getPayload();
    void setPayload(uint8_t* payloadPtr);
    uint8_t getPayloadLength();
    void setPayloadLength(uint8_t payloadLength);
private:
    uint8_t* _payloadPtr;
    uint8_t _payloadLength;
};
 
#ifdef SERIES_1
 
class Tx16Request : public PayloadRequest {
public:
    Tx16Request(uint16_t addr16, uint8_t option, uint8_t *payload, uint8_t payloadLength, uint8_t frameId);
    Tx16Request(uint16_t addr16, uint8_t *payload, uint8_t payloadLength);
    Tx16Request();
    uint16_t getAddress16();
    void setAddress16(uint16_t addr16);
    uint8_t getOption();
    void setOption(uint8_t option);
    uint8_t getFrameData(uint8_t pos);
    uint8_t getFrameDataLength();
protected:
private:
    uint16_t _addr16;
    uint8_t _option;
};
 
class Tx64Request : public PayloadRequest {
public:
    Tx64Request(XBeeAddress64 &addr64, uint8_t option, uint8_t *payload, uint8_t payloadLength, uint8_t frameId);
    Tx64Request(XBeeAddress64 &addr64, uint8_t *payload, uint8_t payloadLength);
    Tx64Request();
    XBeeAddress64& getAddress64();
    void setAddress64(XBeeAddress64& addr64);
    // TODO move option to superclass
    uint8_t getOption();
    void setOption(uint8_t option);
    uint8_t getFrameData(uint8_t pos);
    uint8_t getFrameDataLength();
private:
    XBeeAddress64 _addr64;
    uint8_t _option;
};
 
#endif
 
 
#ifdef SERIES_2
 
class ZBTxRequest : public PayloadRequest {
public:
    ZBTxRequest(XBeeAddress64 &addr64, uint8_t *payload, uint8_t payloadLength);
    ZBTxRequest(XBeeAddress64 &addr64, uint16_t addr16, uint8_t broadcastRadius, uint8_t option, uint8_t *payload, uint8_t payloadLength, uint8_t frameId);
    ZBTxRequest();
    XBeeAddress64& getAddress64();
    uint16_t getAddress16();
    uint8_t getBroadcastRadius();
    uint8_t getOption();
    void setAddress64(XBeeAddress64& addr64);
    void setAddress16(uint16_t addr16);
    void setBroadcastRadius(uint8_t broadcastRadius);
    void setOption(uint8_t option);
protected:
    // declare virtual functions
    uint8_t getFrameData(uint8_t pos);
    uint8_t getFrameDataLength();
private:
    XBeeAddress64 _addr64;
    uint16_t _addr16;
    uint8_t _broadcastRadius;
    uint8_t _option;
};
 
#endif
 
class AtCommandRequest : public XBeeRequest {
public:
    AtCommandRequest();
    AtCommandRequest(uint8_t *command);
    AtCommandRequest(uint8_t *command, uint8_t *commandValue, uint8_t commandValueLength);
    uint8_t getFrameData(uint8_t pos);
    uint8_t getFrameDataLength();
    uint8_t* getCommand();
    void setCommand(uint8_t* command);
    uint8_t* getCommandValue();
    void setCommandValue(uint8_t* command);
    uint8_t getCommandValueLength();
    void setCommandValueLength(uint8_t length);
    void clearCommandValue();
    //void reset();
private:
    uint8_t *_command;
    uint8_t *_commandValue;
    uint8_t _commandValueLength;
};
 
class RemoteAtCommandRequest : public AtCommandRequest {
public:
    RemoteAtCommandRequest();
    RemoteAtCommandRequest(uint16_t remoteAddress16, uint8_t *command, uint8_t *commandValue, uint8_t commandValueLength);
    RemoteAtCommandRequest(uint16_t remoteAddress16, uint8_t *command);
    RemoteAtCommandRequest(XBeeAddress64 &remoteAddress64, uint8_t *command, uint8_t *commandValue, uint8_t commandValueLength);
    RemoteAtCommandRequest(XBeeAddress64 &remoteAddress64, uint8_t *command);
    uint16_t getRemoteAddress16();
    void setRemoteAddress16(uint16_t remoteAddress16);
    XBeeAddress64& getRemoteAddress64();
    void setRemoteAddress64(XBeeAddress64 &remoteAddress64);
    bool getApplyChanges();
    void setApplyChanges(bool applyChanges);
    uint8_t getFrameData(uint8_t pos);
    uint8_t getFrameDataLength();
    static XBeeAddress64 broadcastAddress64;
//  static uint16_t broadcast16Address;
private:
    XBeeAddress64 _remoteAddress64;
    uint16_t _remoteAddress16;
    bool _applyChanges;
};
 
 
 
#endif //XBee_h