Diff: Utility/XBeeApiCmdAt.cpp

Revision:

13:302e7c1ea0b3

Parent:

11:bfcf1356027b

Child:

14:edec6cd78ffb

--- a/Utility/XBeeApiCmdAt.cpp	Sat Feb 01 00:04:42 2014 +0000
+++ b/Utility/XBeeApiCmdAt.cpp	Mon Feb 03 23:26:27 2014 +0000
@@ -1,7 +1,7 @@
 /**
 
 Copyright 2014 John Bailey
-   
+
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
@@ -20,61 +20,174 @@
 
 /* Set of Frame ID codes for the various commands (see XBEE_CMD_POSN_FRAME_ID) */
 
-#define CMD_RESPONSE_GET_VR '1'
-#define CMD_RESPONSE_GET_HV '2'
-#define CMD_RESPONSE_GET_CH '3'
-#define CMD_RESPONSE_SET_CH '4'
+#define CMD_RESPONSE_GET_VR  '1'
+#define CMD_RESPONSE_GET_HV  '2'
+#define CMD_RESPONSE_GET_CH  '3'
+#define CMD_RESPONSE_SET_CH  '4'
+#define CMD_RESPONSE_SET_CE  '5'
+#define CMD_RESPONSE_GET_CE  '6'
+#define CMD_RESPONSE_SET_EDA '7'
+#define CMD_RESPONSE_GET_EDA '8'
+#define CMD_RESPONSE_SET_PID '9'
+#define CMD_RESPONSE_GET_PID '0'
+
+extern Serial pc;
+
 
 /* Content for the various commands - value of 0 indicates a value to be populated (i.e. variable) */
 
-const uint8_t cmd_vr[] = { CMD_RESPONSE_GET_VR, 'V', 'R' }; 
-const uint8_t cmd_hv[] = { CMD_RESPONSE_GET_HV, 'H', 'V' }; 
-const uint8_t cmd_ch[] = { CMD_RESPONSE_GET_CH, 'C', 'H' }; 
-const uint8_t cmd_set_ch[] = { CMD_RESPONSE_SET_CH, 'C', 'H', 0 }; 
+const uint8_t cmd_vr[] =      { CMD_RESPONSE_GET_VR, 'V', 'R' };
+const uint8_t cmd_hv[] =      { CMD_RESPONSE_GET_HV, 'H', 'V' };
+
+const uint8_t cmd_ch[] =      { CMD_RESPONSE_GET_CH, 'C', 'H' };
+const uint8_t cmd_set_ch[] =  { CMD_RESPONSE_SET_CH, 'C', 'H', 0 };
+
+const uint8_t cmd_ce[] =      { CMD_RESPONSE_GET_CE, 'C', 'E' };
+const uint8_t cmd_set_ce[] =  { CMD_RESPONSE_SET_CE, 'C', 'E', 0 };
+
+const uint8_t cmd_eda[] =     { CMD_RESPONSE_GET_EDA, 'A', '1' };
+const uint8_t cmd_set_eda[] = { CMD_RESPONSE_SET_EDA, 'A', '1', 0 };
+
+const uint8_t cmd_pid[] =     { CMD_RESPONSE_GET_PID, 'I', 'D' };
+const uint8_t cmd_set_pid[] = { CMD_RESPONSE_SET_PID, 'I', 'D', 0, 0 };
 
 #define XBEE_CMD_POSN_FRAME_ID (4U)
+#define XBEE_CMD_POSN_STATUS (7U)
 #define XBEE_CMD_POSN_PARAM_START (8U)
 
+#define XBEE_CMD_RESPONS_HAS_DATA( _p_len ) ((_p_len > ( XBEE_CMD_POSN_PARAM_START + 1 ))
+
 XBeeApiCmdAt::XBeeApiCmdAt() : XBeeApiFrameDecoder( ) , m_haveHwVer( false ),
-                                                                m_haveFwVer( false ),
-                                                                m_haveChan( false )
+    m_haveFwVer( false ),
+    m_haveChan( false ),
+    m_havePANId( false ),
+    m_haveEDA( false ),
+    m_haveCE( false )
 {
 }
 
 bool XBeeApiCmdAt::decodeCallback( const uint8_t* const p_data, size_t p_len )
 {
     bool ret_val = false;
-    
-    if( XBEE_CMD_AT_RESPONSE == p_data[ XBEE_CMD_POSN_API_ID ] )
-    {
-    
-        switch( p_data[ XBEE_CMD_POSN_FRAME_ID ] )
-        {
+
+    if( XBEE_CMD_AT_RESPONSE == p_data[ XBEE_CMD_POSN_API_ID ] ) {
+
+        switch( p_data[ XBEE_CMD_POSN_FRAME_ID ] ) {
             case CMD_RESPONSE_GET_HV:
-                m_haveHwVer = true;
-                // TODO: Is this right?
-                m_hwVer = ((uint16_t)p_data[ XBEE_CMD_POSN_PARAM_START ] << 8) + p_data[ XBEE_CMD_POSN_PARAM_START + 1 ];
+                if( p_data[ XBEE_CMD_POSN_STATUS ] == 0 ) 
+                {
+                    m_hwVer = ((uint16_t)p_data[ XBEE_CMD_POSN_PARAM_START ] << 8) + p_data[ XBEE_CMD_POSN_PARAM_START + 1 ];
+                    m_haveHwVer = true;
+                } 
+                else 
+                {
+                    pc.printf("\r\nERROR1\r\n");    
+                }
+                ret_val = true;
+                break;
+
+            case CMD_RESPONSE_GET_VR:
+                if( p_data[ XBEE_CMD_POSN_STATUS ] == 0 ) 
+                {
+                    m_fwVer = ((uint16_t)p_data[ XBEE_CMD_POSN_PARAM_START ] << 8) + p_data[ XBEE_CMD_POSN_PARAM_START + 1 ];
+                    m_haveFwVer = true;
+                } 
+                else 
+                {
+                    pc.printf("\r\nERROR2\r\n");    
+                }
+                ret_val = true;
+                break;
+
+            case CMD_RESPONSE_GET_CH:
+            case CMD_RESPONSE_SET_CH:
+                if( p_data[ XBEE_CMD_POSN_STATUS ] == 0 ) 
+                {
+                    if( CMD_RESPONSE_GET_CH == p_data[ XBEE_CMD_POSN_API_ID ] )
+                    {
+                        m_chan = p_data[ XBEE_CMD_POSN_PARAM_START ];
+                    } 
+                    else
+                    {  
+                        m_chan = m_chanPend;
+                    }
+                    #if 0
+                    printf("\r\n%02x (%2d) - %02x %02x %02x %02x %02x %02x %02x %02x %02x\r\n",p_data[ XBEE_CMD_POSN_API_ID ],p_len,
+                        p_data[0],p_data[1],p_data[2],p_data[3],p_data[4],p_data[5],p_data[6],p_data[7],p_data[8]);
+                    #endif
+                    m_haveChan = true;
+                } 
+                else 
+                {
+                    /* TODO */
+                    pc.printf("\r\nERROR3\r\n");    
+                }
                 ret_val = true;
                 break;
-    
-            case CMD_RESPONSE_GET_VR:
-                m_haveFwVer = true;
-                // TODO: Is this right?
-                m_fwVer = ((uint16_t)p_data[ XBEE_CMD_POSN_PARAM_START ] << 8) + p_data[ XBEE_CMD_POSN_PARAM_START + 1 ];
+
+            case CMD_RESPONSE_SET_CE:
+            case CMD_RESPONSE_GET_CE:
+                if( p_data[ XBEE_CMD_POSN_STATUS ] == 0 ) 
+                {
+                    if( CMD_RESPONSE_GET_CE == p_data[ XBEE_CMD_POSN_API_ID ] )
+                    {
+                        m_CE = p_data[ XBEE_CMD_POSN_PARAM_START ];
+                    }
+                    else
+                    {
+                        m_CE = m_CEPend;
+                    }
+                    m_haveCE = true;
+                } 
+                else 
+                {
+                    pc.printf("\r\nERROR3\r\n");    
+                }
                 ret_val = true;
                 break;
-                
-            case CMD_RESPONSE_GET_CH:
-                m_haveChan = true;
-                m_chan = p_data[ XBEE_CMD_POSN_PARAM_START ];
+
+            case CMD_RESPONSE_SET_PID:
+            case CMD_RESPONSE_GET_PID:
+                if( p_data[ XBEE_CMD_POSN_STATUS ] == 0 ) 
+                {
+                    if( CMD_RESPONSE_GET_PID == p_data[ XBEE_CMD_POSN_API_ID ] )
+                    {
+                        m_PANId = p_data[ XBEE_CMD_POSN_PARAM_START ];
+                    } 
+                    else
+                    {
+                        m_PANId = m_PANIdPend;
+                    }
+                    m_havePANId = true;
+                } 
+                else 
+                {
+                    pc.printf("\r\nERROR3\r\n");    
+                }
                 ret_val = true;
                 break;
-    
-            case CMD_RESPONSE_SET_CH:
-                m_chan = m_chanPend;
-                m_haveChan = true;
-                ret_val = true;    
+
+            case CMD_RESPONSE_SET_EDA:
+            case CMD_RESPONSE_GET_EDA:
+                if( p_data[ XBEE_CMD_POSN_STATUS ] == 0 ) 
+                {
+                    if( CMD_RESPONSE_GET_EDA == p_data[ XBEE_CMD_POSN_API_ID ] )
+                    {
+                        m_EDA = p_data[ XBEE_CMD_POSN_PARAM_START ];
+                    }
+                    else
+                    {
+                        m_EDA = m_EDAPend;
+                    }
+                    m_haveEDA = true;
+                } 
+                else 
+                {
+                    pc.printf("\r\nERROR3\r\n");    
+                }
+                ret_val = true;
                 break;
+
         }
     }
     return ret_val;
@@ -85,23 +198,22 @@
     XBeeApiCmdAt::XBeeApiCmdAtChannelSet req( p_chan );
     m_chanPend = p_chan;
     m_device->SendFrame( &req );
-    
     return true;
 }
 
 bool XBeeApiCmdAt::requestHardwareVersion( void )
 {
     XBeeApiCmdAt::XBeeApiCmdAtHardwareVersionRequest req;
-    m_haveHwVer = false;    
+    m_haveHwVer = false;
     m_device->SendFrame( &req );
     return true;
 }
-    
+
 bool XBeeApiCmdAt::requestFirmwareVersion( void )
 {
     XBeeApiCmdAt::XBeeApiCmdAtFirmwareVersionRequest req;
     m_haveFwVer = false;
-    m_device->SendFrame( &req );       
+    m_device->SendFrame( &req );
     return true;
 }
 
@@ -113,20 +225,42 @@
     return true;
 }
 
+bool XBeeApiCmdAt::requestPanId( void )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtPANIdRequest req;
+    m_havePANId = false;
+    m_device->SendFrame( &req );
+    return true;
+}
+
+bool XBeeApiCmdAt::requestCoordinatorEnabled( void )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtCERequest req;
+    m_haveCE = false;
+    m_device->SendFrame( &req );
+    return true;
+}
+
+bool XBeeApiCmdAt::requestEndDeviceAssociationEnabled( void )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtEDARequest req;
+    m_haveEDA = false;
+    m_device->SendFrame( &req );
+    return true;
+}
+
 bool XBeeApiCmdAt::getFirmwareVersion( uint16_t* const p_ver )
 {
-    if( m_haveFwVer )
-    {
+    if( m_haveFwVer ) {
         *p_ver = m_fwVer;
     }
     return m_haveFwVer;
-    
+
 }
 
 bool XBeeApiCmdAt::getHardwareVersion( uint16_t* const p_ver )
 {
-    if( m_haveHwVer )
-    {
+    if( m_haveHwVer ) {
         *p_ver = m_hwVer;
     }
     return m_haveHwVer;
@@ -134,31 +268,79 @@
 
 bool XBeeApiCmdAt::getChannel( uint8_t* const p_chan )
 {
-    if( m_haveChan )
-    {
+    if( m_haveChan ) {
         *p_chan = m_chan;
     }
     return m_haveChan;
 }
 
-XBeeApiCmdAtBlocking::XBeeApiCmdAtBlocking( const uint16_t p_timeout, const uint16_t p_slice ) : 
-                                                                                     XBeeApiCmdAt( ), 
-                                                                                     m_timeout( p_timeout ), 
-                                                                                     m_slice( p_slice )
+bool XBeeApiCmdAt::getCoordinatorEnabled( bool* const p_en )
+{
+    if( m_haveCE ) {
+        *p_en = m_CE;
+    }
+    return m_haveCE;
+}
+
+bool XBeeApiCmdAt::setCoordinatorEnabled( const bool p_en )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtCESet ce( p_en );
+    m_haveCE = false;
+    m_CEPend = p_en;
+    m_device->SendFrame( &ce );
+    return true;
+}
+
+bool XBeeApiCmdAt::getEndDeviceAssociationEnabled( bool* const p_en )
+{
+    if( m_haveEDA ) {
+        *p_en = m_EDA;
+    }
+    return m_haveEDA;
+}
+bool XBeeApiCmdAt::setEndDeviceAssociationEnabled( const bool p_en  )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtEDASet req( p_en );
+    m_haveEDA = false;
+    m_EDAPend = p_en;
+    m_device->SendFrame( &req );
+    return true;
+}
+
+bool XBeeApiCmdAt::getPanId( panId_t* const p_chan )
+{
+    if( m_havePANId ) {
+        *p_chan = m_PANId;
+    }
+    return m_havePANId;
+
+}
+bool XBeeApiCmdAt::setPanId( const panId_t p_chan )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtPANIdSet panid( p_chan );
+    m_havePANId = false;
+    m_PANIdPend = p_chan;
+    m_device->SendFrame( &panid );
+    return true;
+}
+
+
+XBeeApiCmdAtBlocking::XBeeApiCmdAtBlocking( const uint16_t p_timeout, const uint16_t p_slice ) :
+    XBeeApiCmdAt( ),
+    m_timeout( p_timeout ),
+    m_slice( p_slice )
 {
 }
 
-extern Serial pc;
-
-/** 
+/**
    Macro to wrap around the "requestXXX" & "getXXX" methods and implement a blocking call.
    This macro is used as the basis for getXXX functions in XBeeApiCmdAtBlocking.
 
-   Originally looked to achieve this using a template function passing method pointers, however 
-   there's no way to get a method pointer to the parent class implementation as opposed to the 
-   implementation in this class, meaning that the result was a recursive method call.  The joys of 
+   Originally looked to achieve this using a template function passing method pointers, however
+   there's no way to get a method pointer to the parent class implementation as opposed to the
+   implementation in this class, meaning that the result was a recursive method call.  The joys of
    polymorphism.
-          
+
    e.g. We pass a pointer to method getHardwareVersion().  The function receiving the pointer
         uses it to make a function call.  The actual function that's called is (correctly)
         the one implemented in this class, however what we actually wanted in this case
@@ -192,7 +374,7 @@
     \
     return( ret_val );
 
-/** 
+/**
    Macro to wrap around the "setXXX" & "getXXX" methods and implement a blocking call.
    This macro is used as the basis for setXXX functions in XBeeApiCmdAtBlocking.
 */
@@ -208,7 +390,7 @@
         do{\
             wait_ms( m_slice );\
             if( _GET_FN( &readback ) &&\
-               ( readback == p_chan ))\
+               ( readback == _VAR ))\
             {\
                 ret_val = true;\
             }\
@@ -221,11 +403,11 @@
     \
     return( ret_val );
 
-    
+
 bool XBeeApiCmdAtBlocking::getHardwareVersion( uint16_t* const p_ver )
 {
-    BLOCKING_GET( XBeeApiCmdAt::requestHardwareVersion, 
-                  XBeeApiCmdAt::getHardwareVersion,  
+    BLOCKING_GET( XBeeApiCmdAt::requestHardwareVersion,
+                  XBeeApiCmdAt::getHardwareVersion,
                   p_ver );
 }
 
@@ -242,43 +424,145 @@
                   XBeeApiCmdAtBlocking::getChannel,
                   p_chan );
 }
-       
+
 bool XBeeApiCmdAtBlocking::setChannel( uint8_t const p_chan )
 {
     BLOCKING_SET( XBeeApiCmdAtBlocking::setChannel,
                   XBeeApiCmdAtBlocking::getChannel,
                   p_chan,
-                  uint8_t );    
+                  uint8_t );
+}
+
+bool XBeeApiCmdAtBlocking::getCoordinatorEnabled( bool* const p_en )
+{
+    BLOCKING_GET( XBeeApiCmdAt::requestCoordinatorEnabled,
+                  XBeeApiCmdAt::getCoordinatorEnabled,
+                  p_en );
+}
+
+bool XBeeApiCmdAtBlocking::setCoordinatorEnabled( const bool p_en )
+{
+    BLOCKING_SET( XBeeApiCmdAtBlocking::setCoordinatorEnabled,
+                  XBeeApiCmdAtBlocking::getCoordinatorEnabled,
+                  p_en,
+                  bool );
+}
+
+bool XBeeApiCmdAtBlocking::getEndDeviceAssociationEnabled( bool* const p_en )
+{
+    BLOCKING_GET( XBeeApiCmdAt::requestEndDeviceAssociationEnabled,
+                  XBeeApiCmdAt::getEndDeviceAssociationEnabled,
+                  p_en );
 }
 
+bool XBeeApiCmdAtBlocking::setEndDeviceAssociationEnabled( const bool p_en )
+{
+    BLOCKING_SET( XBeeApiCmdAtBlocking::setEndDeviceAssociationEnabled,
+                  XBeeApiCmdAtBlocking::getEndDeviceAssociationEnabled,
+                  p_en,
+                  bool );
+}
+
+bool XBeeApiCmdAtBlocking::getPanId( panId_t* const p_chan )
+{
+    BLOCKING_GET( XBeeApiCmdAt::requestPanId,
+                  XBeeApiCmdAt::getPanId,
+                  p_chan );
+}
+
+bool XBeeApiCmdAtBlocking::setPanId( const panId_t p_chan )
+{
+    BLOCKING_SET( XBeeApiCmdAtBlocking::setPanId,
+                  XBeeApiCmdAtBlocking::getPanId,
+                  p_chan,
+                  panId_t );
+}
+
+
 XBeeApiCmdAt::XBeeApiCmdAtFirmwareVersionRequest::XBeeApiCmdAtFirmwareVersionRequest( void ) : XBeeApiFrame( )
 {
-     m_apiId = XBEE_CMD_AT_CMD;
-     m_data = cmd_vr;
-     m_dataLen = sizeof( cmd_vr );
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_data = cmd_vr;
+    m_dataLen = sizeof( cmd_vr );
 }
 
 XBeeApiCmdAt::XBeeApiCmdAtHardwareVersionRequest::XBeeApiCmdAtHardwareVersionRequest( void ) : XBeeApiFrame( )
 {
-     m_apiId = XBEE_CMD_AT_CMD;
-     m_data = cmd_hv;
-     m_dataLen = sizeof( cmd_hv );
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_data = cmd_hv;
+    m_dataLen = sizeof( cmd_hv );
 }
 
 XBeeApiCmdAt::XBeeApiCmdAtChannelRequest::XBeeApiCmdAtChannelRequest( void ) : XBeeApiFrame( )
 {
-     m_apiId = XBEE_CMD_AT_CMD;
-     m_data = cmd_ch;
-     m_dataLen = sizeof( cmd_ch );
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_data = cmd_ch;
+    m_dataLen = sizeof( cmd_ch );
+}
+
+XBeeApiCmdAt::XBeeApiCmdAtCERequest::XBeeApiCmdAtCERequest( void ) : XBeeApiFrame( )
+{
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_data = cmd_ce;
+    m_dataLen = sizeof( cmd_ce );
+}
+
+XBeeApiCmdAt::XBeeApiCmdAtPANIdRequest::XBeeApiCmdAtPANIdRequest( void ) : XBeeApiFrame( )
+{
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_data = cmd_pid;
+    m_dataLen = sizeof( cmd_pid );
+}
+
+
+XBeeApiCmdAt::XBeeApiCmdAtEDARequest::XBeeApiCmdAtEDARequest( void ) : XBeeApiFrame( )
+{
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_data = cmd_eda;
+    m_dataLen = sizeof( cmd_eda );
 }
 
 XBeeApiCmdAt::XBeeApiCmdAtChannelSet::XBeeApiCmdAtChannelSet( const uint8_t p_chan ) : XBeeApiFrame( )
 {
-     m_apiId = XBEE_CMD_AT_CMD;
-     m_buffer[0] = cmd_set_ch[0];
-     m_buffer[1] = cmd_set_ch[1];
-     m_buffer[2] = cmd_set_ch[2];
-     m_buffer[3] = p_chan;
-     m_data = m_buffer;
-     m_dataLen = sizeof( cmd_set_ch );
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_buffer[0] = cmd_set_ch[0];
+    m_buffer[1] = cmd_set_ch[1];
+    m_buffer[2] = cmd_set_ch[2];
+    m_buffer[3] = p_chan;
+    m_data = m_buffer;
+    m_dataLen = sizeof( cmd_set_ch );
+}
+
+XBeeApiCmdAt::XBeeApiCmdAtCESet::XBeeApiCmdAtCESet( const bool p_en ) : XBeeApiFrame( )
+{
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_buffer[0] = cmd_set_ce[0];
+    m_buffer[1] = cmd_set_ce[1];
+    m_buffer[2] = cmd_set_ce[2];
+    m_buffer[3] = p_en;
+    m_data = m_buffer;
+    m_dataLen = sizeof( cmd_set_ce );
 }
+
+XBeeApiCmdAt::XBeeApiCmdAtEDASet::XBeeApiCmdAtEDASet( const bool p_en ) : XBeeApiFrame( )
+{
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_buffer[0] = cmd_set_eda[0];
+    m_buffer[1] = cmd_set_eda[1];
+    m_buffer[2] = cmd_set_eda[2];
+    m_buffer[3] = p_en;
+    m_data = m_buffer;
+    m_dataLen = sizeof( cmd_set_eda );
+}
+
+XBeeApiCmdAt::XBeeApiCmdAtPANIdSet::XBeeApiCmdAtPANIdSet( const panId_t p_id ) : XBeeApiFrame( )
+{
+    m_apiId = XBEE_CMD_AT_CMD;
+    m_buffer[0] = cmd_set_pid[0];
+    m_buffer[1] = cmd_set_pid[1];
+    m_buffer[2] = cmd_set_pid[2];
+    m_buffer[3] = p_id >> 8U;
+    m_buffer[4] = p_id;
+    m_data = m_buffer;
+    m_dataLen = sizeof( cmd_set_pid );
+}