Diff: xbee.cpp

Revision:

1:13c7d6237a53

Parent:

0:2a59dd59ee5e

Child:

2:406da750f115

--- a/xbee.cpp	Mon Mar 27 15:09:52 2017 +0000
+++ b/xbee.cpp	Mon Mar 27 15:49:25 2017 +0000
@@ -2,45 +2,50 @@
 #include "rtos.h"
 #include "xbee.h"
 
-DigitalOut _xbeeConnection(LED4);
-
-Serial _xbee(p9, p10);
-DigitalOut _xbeeRst(p8);
+/*******************************************************/
+/*****************PRIVATE FUNCTIONS*********************/
+/*******************************************************/
+namespace {
+    DigitalOut _xbeeConnection(LED4);
 
-// Hidden functions
-namespace {
-    char destination64bit[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-    char destination16bit[2] = {0xff, 0xfe};
+    Serial _xbee(p9, p10);
+    DigitalOut _xbeeRst(p8);
+
+    char _destination64bit[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+    char _destination16bit[2] = {0xff, 0xfe};
     
     const int HARDWARE_RESET_SIGNAL = 0x10;
     const int CONNECTED_SIGNAL = 0x20;
     const int TICKER_SIGNAL = 0x40;
     const int RESPONSE_SIGNAL = 0x80;
     
-    int responseStatus;
+    int _responseStatus;
     
-    int panID = 0xB00B;
-    char frameID = 0;
+    int _panID = 0xB00B;
+    char _frameID = 0;
     
     Thread _xbeeReceiver;
     Thread * _xbeeTransmitter;
     
-    void(*_callback)(char*, int) = 0;
-
-    inline char GetFrameID(){
-        ++frameID;
-        if (frameID == 0){
-            frameID = 1;
+    void(*_packetReceivedCallback)(char*, int) = 0;
+    
+    /*******************************************************/
+    /*******************XBEE UTILITIES**********************/
+    /*******************************************************/
+    inline char _GetFrameID(){
+        ++_frameID;
+        if (_frameID == 0){
+            _frameID = 1;
         }
-        return frameID;
+        return _frameID;
     }
     
-    inline uint16_t GetFrameLength(char * buffer){
+    inline uint16_t _GetFrameLength(char * buffer){
         return (((uint16_t)buffer[LENGTH_MSB_IDX]) << 8) + buffer[LENGTH_LSB_IDX];
     }
     
-    bool ValidateCheckSum(char * buffer){
-        uint16_t length = GetFrameLength(buffer);
+    bool _ValidateCheckSum(char * buffer){
+        uint16_t length = _GetFrameLength(buffer);
         
         char sum = 0;
         for (int i = 0; i <= length; ++i){
@@ -50,46 +55,28 @@
         return sum == 0xff;
     }
     
-    inline uint16_t GetAtParamLength(char * buffer){
-        return GetFrameLength(buffer) - AT_MIN_SIZE;
-    }
-    
-    inline uint16_t GetAtQueueParamLength(char * buffer){
-        return GetFrameLength(buffer) - AT_QUEUE_MIN_SIZE;
+    inline uint16_t _GetAtParamLength(char * buffer){
+        return _GetFrameLength(buffer) - AT_MIN_SIZE;
     }
     
-    inline uint16_t GetTransmitDataLength(char * buffer){
-        return GetFrameLength(buffer) - TRANSMIT_MIN_SIZE;
-    }
-    
-    inline uint16_t GetRemoteAtRequestParamLength(char * buffer){
-        return GetFrameLength(buffer) - REMOTE_AT_RQST_MIN_SIZE;
-    }
-    
-    inline uint16_t GetAtResponseParamLength(char * buffer){
-        return GetFrameLength(buffer) - AT_CMD_RSP_MIN_SIZE;
+    inline uint16_t _GetAtQueueParamLength(char * buffer){
+        return _GetFrameLength(buffer) - AT_QUEUE_MIN_SIZE;
     }
     
-    inline uint16_t GetReceivedPacketDataLength(char * buffer){
-        return GetFrameLength(buffer) - RECEIVED_PACKET_MIN_SIZE;
+    inline uint16_t _GetTransmitDataLength(char * buffer){
+        return _GetFrameLength(buffer) - TRANSMIT_MIN_SIZE;
     }
     
-    inline long long int Get64Addr(char * buffer, int start){
-        long long int addr = 0;
-        memcpy(&addr, &buffer[start], ADDR_64BIT_SIZE);
-        
-        return addr;
+    inline uint16_t _GetAtResponseParamLength(char * buffer){
+        return _GetFrameLength(buffer) - AT_CMD_RSP_MIN_SIZE;
     }
     
-    inline short Get16Addr(char * buffer, int start){
-        short addr = 0;
-        memcpy(&addr, &buffer[start], ADDR_16BIT_SIZE);
-        
-        return addr;
+    inline uint16_t _GetReceivedPacketDataLength(char * buffer){
+        return _GetFrameLength(buffer) - RECEIVED_PACKET_MIN_SIZE;
     }
     
-    void SetCheckSum(char * buffer){
-        uint16_t length = GetFrameLength(buffer);
+    void _SetCheckSum(char * buffer){
+        uint16_t length = _GetFrameLength(buffer);
         
         char sum = 0;
         
@@ -102,31 +89,34 @@
         buffer[max] = 0xff - sum;
     }
     
-    void XBeeSend(char * buffer, int count){
+    /*******************************************************/
+    /**********************XBEE SEND************************/
+    /*******************************************************/
+    void _XbeeSend(char * buffer, int count){
         for ( int i = 0; i < count; ++i ){
             _xbee.putc(buffer[i]);
             wait_us(25);
         }
     }
     
-    void XBeeSendATCommand(bool queue, char * type, char * data, int dataLength){
+    void _XbeeSendATCommand(bool queue, char * type, char * data, int dataLength){
         char buffer[64];
         buffer[START_IDX] = START;
         buffer[LENGTH_MSB_IDX] = (dataLength + AT_MIN_SIZE) >> 8;
         buffer[LENGTH_LSB_IDX] = (dataLength + AT_MIN_SIZE) & 0xff;
         buffer[API_ID_IDX] = queue ? API_ID_AT_CMD_QUEUE : API_ID_AT_CMD;
-        buffer[FRAME_ID_IDX] = GetFrameID();
+        buffer[FRAME_ID_IDX] = _GetFrameID();
         memcpy(&buffer[AT_CMD_ID_IDX], type, AT_CMD_ID_SIZE);
         memcpy(&buffer[AT_PARAM_IDX], data, dataLength);
         
-        SetCheckSum(buffer);
+        _SetCheckSum(buffer);
         
         while(true){
-            XBeeSend(buffer, dataLength + AT_MIN_SIZE + FRAME_MIN_SIZE);
+            _XbeeSend(buffer, dataLength + AT_MIN_SIZE + FRAME_MIN_SIZE);
         
             Thread::signal_wait(RESPONSE_SIGNAL);
             
-            switch (responseStatus){
+            switch (_responseStatus){
             case AT_CMD_RSP_STATUS_OK:
                 return;
             case AT_CMD_RSP_STATUS_ERROR:
@@ -140,33 +130,36 @@
         }
     }
     
-    inline void XBeeSendATID(){
+    inline void _XbeeSendATID(){
         char idBuf[8];
         for (int i = 0; i < 8; ++i){
-            idBuf[i] = (panID >> (56 - 8 * i)) & 0xff;
+            idBuf[i] = (_panID >> (56 - 8 * i)) & 0xff;
         }
-        XBeeSendATCommand(true, "ID", idBuf, 8);
+        _XbeeSendATCommand(true, "ID", idBuf, 8);
     }
     
-    inline void XBeeSendATWR(){
-        XBeeSendATCommand(true, "WR", 0, 0);
+    inline void _XbeeSendATWR(){
+        _XbeeSendATCommand(true, "WR", 0, 0);
     }
     
-    inline void XBeeSendATAC(){
-        XBeeSendATCommand(true, "AC", 0, 0);
+    inline void _XbeeSendATAC(){
+        _XbeeSendATCommand(true, "AC", 0, 0);
     }
 
-    inline char XbeeReadChar(){
+    /*******************************************************/
+    /********************XBEE RECEIVE***********************/
+    /*******************************************************/
+    inline char _XbeeReadChar(){
         while(!_xbee.readable()){
         }
         return _xbee.getc();
     }
     
-    void HandleXbeeReceivedPacket(char * cmd){
-        _callback(&cmd[RECEIVED_PACKET_DATA_IDX], GetReceivedPacketDataLength(cmd));
+    void _HandleXbeeReceivedPacket(char * cmd){
+        _packetReceivedCallback(&cmd[RECEIVED_PACKET_DATA_IDX], _GetReceivedPacketDataLength(cmd));
     }
     
-    void HandleXbeeModemStatus(char * cmd){
+    void _HandleXbeeModemStatus(char * cmd){
         switch(cmd[MODEM_STATUS_STATUS_IDX]){
         case MODEM_STATUS_HARDWARE_RST:
             _xbeeTransmitter->signal_set(HARDWARE_RESET_SIGNAL);
@@ -181,15 +174,15 @@
         }
     }
     
-    void HandleXBeeATCommandResponse(char * cmd){
-        responseStatus = cmd[AT_CMD_RSP_STATUS_IDX];
+    void _HandleXbeeATCommandResponse(char * cmd){
+        _responseStatus = cmd[AT_CMD_RSP_STATUS_IDX];
         _xbeeTransmitter->signal_set(RESPONSE_SIGNAL);
     }
     
-    void HandleXbeeTransmitStatus(char * cmd){
+    void _HandleXbeeTransmitStatus(char * cmd){
         switch(cmd[TRANSMIT_STATUS_DELIVERY_STATUS_IDX]){
         case TRANSMIT_STATUS_OK:
-            responseStatus = cmd[TRANSMIT_STATUS_DELIVERY_STATUS_IDX];
+            _responseStatus = cmd[TRANSMIT_STATUS_DELIVERY_STATUS_IDX];
             _xbeeTransmitter->signal_set(RESPONSE_SIGNAL);
             break;
         default:
@@ -197,19 +190,19 @@
         }
     }
     
-    void HandleXbeeReceivedCommand(char * cmd){
+    void _HandleXbeeReceivedCommand(char * cmd){
         switch(cmd[API_ID_IDX]){
         case API_ID_AT_CMD_RSP:
-            HandleXBeeATCommandResponse(cmd);
+            _HandleXbeeATCommandResponse(cmd);
             break;
         case API_ID_MODEM_STATUS:
-            HandleXbeeModemStatus(cmd);
+            _HandleXbeeModemStatus(cmd);
             break;
         case API_ID_RECEIVED_PACKET:
-            HandleXbeeReceivedPacket(cmd);
+            _HandleXbeeReceivedPacket(cmd);
             break;
         case API_ID_TRANSMIT_STATUS:
-            HandleXbeeTransmitStatus(cmd);
+            _HandleXbeeTransmitStatus(cmd);
             break;
         default:
             _xbeeConnection = 0;
@@ -217,57 +210,59 @@
         }
     }
     
+    /*******************************************************/
+    /*********************THREAD MAIN***********************/
+    /*******************************************************/
     void _XbeeReceiver(){
         char buffer[64];
         while(true){
-            buffer[START_IDX] = XbeeReadChar();
+            buffer[START_IDX] = _XbeeReadChar();
             if (buffer[START_IDX] != START){
                 _xbeeConnection = 0;
                 continue;
             }
-            buffer[LENGTH_MSB_IDX] = XbeeReadChar();
-            buffer[LENGTH_LSB_IDX] = XbeeReadChar();
-            int length = GetFrameLength(buffer);
+            buffer[LENGTH_MSB_IDX] = _XbeeReadChar();
+            buffer[LENGTH_LSB_IDX] = _XbeeReadChar();
+            int length = _GetFrameLength(buffer);
             
             for (int i = 0; i <= length; ++i){
-                buffer[i + API_ID_IDX] = XbeeReadChar();
+                buffer[i + API_ID_IDX] = _XbeeReadChar();
             }
-            if (!ValidateCheckSum(buffer)){
+            if (!_ValidateCheckSum(buffer)){
                 _xbeeConnection = 0;
                 continue;
             }
             
-            HandleXbeeReceivedCommand(buffer);
+            _HandleXbeeReceivedCommand(buffer);
         }
     }
 
 };
 
 /*******************************************************/
-/**********************XBEE SEND************************/
+/******************PUBLIC FUNCTIONS*********************/
 /*******************************************************/
-
-void XBeeSendData(char * data, int dataLength){
+void XbeeSendData(char * data, int dataLength){
     char buffer[64];
     buffer[START_IDX] = START;
     buffer[LENGTH_MSB_IDX] = (dataLength + TRANSMIT_MIN_SIZE) >> 8;
     buffer[LENGTH_LSB_IDX] = (dataLength + TRANSMIT_MIN_SIZE) & 0xff;
     buffer[API_ID_IDX] = API_ID_TRANSMIT;
-    buffer[FRAME_ID_IDX] = GetFrameID();
-    memcpy(&buffer[TRANSMIT_64BIT_MSB_IDX], destination64bit, ADDR_64BIT_SIZE);
-    memcpy(&buffer[TRANSMIT_16BIT_MSB_IDX], destination16bit, ADDR_16BIT_SIZE);
+    buffer[FRAME_ID_IDX] = _GetFrameID();
+    memcpy(&buffer[TRANSMIT_64BIT_MSB_IDX], _destination64bit, ADDR_64BIT_SIZE);
+    memcpy(&buffer[TRANSMIT_16BIT_MSB_IDX], _destination16bit, ADDR_16BIT_SIZE);
     buffer[TRANSMIT_BROADCAST_IDX] = TRANSMIT_DEFAULT_BROADCAST;
     buffer[TRANSMIT_OPT_IDX] = TRANSMIT_DEFAULT_OPT;
     memcpy(&buffer[TRANSMIT_DATA_IDX], data, dataLength);
     
-    SetCheckSum(buffer);
+    _SetCheckSum(buffer);
     
     while(true) {
-        XBeeSend(buffer, dataLength + TRANSMIT_MIN_SIZE + FRAME_MIN_SIZE);
+        _XbeeSend(buffer, dataLength + TRANSMIT_MIN_SIZE + FRAME_MIN_SIZE);
     
         Thread::signal_wait(RESPONSE_SIGNAL);
         
-        switch (responseStatus){
+        switch (_responseStatus){
         case TRANSMIT_STATUS_OK:
             return;
         default:
@@ -277,14 +272,14 @@
     }
 }
 
-bool InitXBee(bool coordinator, void(*packetReceivedCallback)(char*, int), Thread * xbeeTransmitter){
-    _callback = packetReceivedCallback;
+bool InitXbee(bool coordinator, void(*packetReceivedCallback)(char*, int), Thread * xbeeTransmitter){
+    _packetReceivedCallback = packetReceivedCallback;
     _xbeeTransmitter = xbeeTransmitter;
     
     if (coordinator)
     {
         uint8_t temp[8] = {0x00, 0x13, 0xA2, 0x00, 0x40, 0x33, 0x19, 0x8D};
-        memcpy(destination64bit, temp, 8);
+        memcpy(_destination64bit, temp, 8);
     }
     
     _xbeeReceiver.start(callback(_XbeeReceiver));
@@ -295,9 +290,9 @@
     
     Thread::signal_wait(HARDWARE_RESET_SIGNAL);
     
-    XBeeSendATID();
-    XBeeSendATWR();
-    XBeeSendATAC();
+    _XbeeSendATID();
+    _XbeeSendATWR();
+    _XbeeSendATAC();
     
     Thread::signal_wait(CONNECTED_SIGNAL);