John Bailey / XBeeApi

Dependencies:   CircularBuffer FixedLengthList

Dependents:   XBeeApiTest XBeeApiSimpleATCmdsExample XBeeApiBroadcastExample XBeeApiBroadcastExampleRTOS ... more

Revision:
8:1b48b619d7f6
Child:
11:bfcf1356027b
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Utility/XBeeApiCmdAt.cpp	Fri Jan 31 01:16:56 2014 +0000
@@ -0,0 +1,266 @@
+/**
+
+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
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+*/
+
+#include "XBeeApiCmdAt.hpp"
+
+/* 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'
+
+/* 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 }; 
+
+#define XBEE_CMD_POSN_FRAME_ID (4U)
+#define XBEE_CMD_POSN_PARAM_START (8U)
+
+XBeeApiCmdAt::XBeeApiCmdAt() : XBeeApiFrameDecoder( ) , m_haveHwVer( false ),
+                                                                m_haveFwVer( false ),
+                                                                m_haveChan( 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 ] )
+        {
+            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 ];
+                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 ];
+                ret_val = true;
+                break;
+                
+            case CMD_RESPONSE_GET_CH:
+                m_haveChan = true;
+                m_chan = p_data[ XBEE_CMD_POSN_PARAM_START ];
+                ret_val = true;
+                break;
+    
+            case CMD_RESPONSE_SET_CH:
+                m_chan = m_chanPend;
+                m_haveChan = true;
+                ret_val = true;    
+                break;
+        }
+    }
+    return ret_val;
+}
+
+bool XBeeApiCmdAt::setChannel( uint8_t const p_chan )
+{
+    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_device->SendFrame( &req );
+    return true;
+}
+    
+bool XBeeApiCmdAt::requestFirmwareVersion( void )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtFirmwareVersionRequest req;
+    m_haveFwVer = false;
+    m_device->SendFrame( &req );       
+    return true;
+}
+
+bool XBeeApiCmdAt::requestChannel( void )
+{
+    XBeeApiCmdAt::XBeeApiCmdAtChannelRequest req;
+    m_haveChan = false;
+    m_device->SendFrame( &req );
+    return true;
+}
+
+bool XBeeApiCmdAt::getFirmwareVersion( uint16_t* const p_ver )
+{
+    if( m_haveFwVer )
+    {
+        *p_ver = m_fwVer;
+    }
+    return m_haveFwVer;
+    
+}
+
+bool XBeeApiCmdAt::getHardwareVersion( uint16_t* const p_ver )
+{
+    if( m_haveHwVer )
+    {
+        *p_ver = m_hwVer;
+    }
+    return m_haveHwVer;
+}
+
+bool XBeeApiCmdAt::getChannel( uint8_t* const p_chan )
+{
+    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 )
+{
+}
+
+extern Serial pc;
+
+
+template<typename par>
+bool blockingGet( XBeeApiCmdAtBlocking* p_t, 
+                  bool (XBeeApiCmdAtBlocking::*p_req)( void ), 
+                  bool (XBeeApiCmdAtBlocking::*p_get)( par* const ), 
+                  par* const p_par, 
+                  uint16_t p_timeout, 
+                  uint16_t p_slice )
+{
+    bool ret_val = false;
+    uint16_t counter = p_timeout;
+
+    if( (p_t->*p_get)( p_par ) )
+    {
+        ret_val = true;
+    } 
+    else if( (p_t->*p_req)() )
+    {
+        bool cont = false;
+
+        do{
+            wait_ms( p_slice );
+            if( (p_t->*p_get)( p_par ) )
+            {
+                ret_val = true;
+            }
+            else if( counter > p_slice ) {
+                counter -= p_slice;    
+                cont = true;
+            } 
+        } while( cont );
+    }
+    
+    return( ret_val );
+}
+
+bool XBeeApiCmdAtBlocking::getHardwareVersionS( uint16_t* const p_ver )
+{
+    return XBeeApiCmdAt::getHardwareVersion( p_ver );
+}
+
+bool XBeeApiCmdAtBlocking::getFirmwareVersionS( uint16_t* const p_ver )
+{
+    return XBeeApiCmdAt::getFirmwareVersion( p_ver );
+}
+
+bool XBeeApiCmdAtBlocking::getChannelS( uint8_t* const p_chan )
+{
+    return XBeeApiCmdAt::getChannel( p_chan );
+}
+
+bool XBeeApiCmdAtBlocking::getHardwareVersion( uint16_t* const p_ver )
+{
+    return blockingGet( this,
+                        &XBeeApiCmdAtBlocking::requestHardwareVersion,
+                        &XBeeApiCmdAtBlocking::getHardwareVersionS,
+                         p_ver,
+                         m_timeout, m_slice );
+}
+
+bool XBeeApiCmdAtBlocking::getFirmwareVersion( uint16_t* const p_ver )
+{
+    return blockingGet( this,
+                        &XBeeApiCmdAtBlocking::requestFirmwareVersion,
+                        &XBeeApiCmdAtBlocking::getFirmwareVersionS,
+                        p_ver,
+                        m_timeout, m_slice );
+}
+
+bool XBeeApiCmdAtBlocking::getChannel( uint8_t* const p_chan )
+{
+    return blockingGet( this,
+                        &XBeeApiCmdAtBlocking::requestChannel,
+                        &XBeeApiCmdAtBlocking::getChannelS,
+                        p_chan,
+                        m_timeout, m_slice );
+}
+       
+bool XBeeApiCmdAtBlocking::setChannel( uint8_t const p_chan )
+{
+}
+
+
+XBeeApiCmdAt::XBeeApiCmdAtFirmwareVersionRequest::XBeeApiCmdAtFirmwareVersionRequest( void ) : XBeeApiFrame( )
+{
+     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 );
+}
+
+XBeeApiCmdAt::XBeeApiCmdAtChannelRequest::XBeeApiCmdAtChannelRequest( void ) : XBeeApiFrame( )
+{
+     m_apiId = XBEE_CMD_AT_CMD;
+     m_data = cmd_ch;
+     m_dataLen = sizeof( cmd_ch );
+}
+
+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 );
+}