Revision 8:1b48b619d7f6, committed 2014-01-31

Comitter:

johnb

Date:

Fri Jan 31 01:16:56 2014 +0000

Parent:

7:2f1e157cdd1c

Child:

9:ba90e9efd68b

Commit message:

Work-in-progress commit. Add blocking version of XBeeApiCmdAt

Changed in this revision

--- a/Base/XBeeDevice.cpp	Thu Jan 30 21:28:57 2014 +0000
+++ b/Base/XBeeDevice.cpp	Fri Jan 31 01:16:56 2014 +0000
@@ -109,8 +109,6 @@
     }
 }
     
-extern Serial pc;
-    
 void XBeeDevice::checkRxDecode( void )
 {
     uint8_t buff[INITIAL_PEEK_LEN];

--- /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 );
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Utility/XBeeApiCmdAt.hpp	Fri Jan 31 01:16:56 2014 +0000
@@ -0,0 +1,131 @@
+/**
+   @file
+   @brief Class to abstract AT commands send to the XBee API
+   
+   AT commands have the payload:
+   
+     Byte 1     : Frame ID
+     Byte 2 & 3 : AT command
+     Byte 4-n   : Parameter Value 
+   
+   @author John Bailey 
+
+   @copyright Copyright 2014 John Bailey
+
+   @section LICENSE
+   
+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.
+
+*/
+
+#if !defined XBEEAPICMDAT_HPP
+#define      XBEEAPICMDAT_HPP
+
+#include "XBeeApiFrame.hpp"
+#include "XBeeDevice.hpp"
+
+#include <stdint.h>
+
+class XBeeApiCmdAt : public XBeeApiFrameDecoder
+{
+    protected:
+        bool m_haveHwVer;
+        bool m_haveFwVer;
+        bool m_haveChan;
+        uint16_t m_hwVer;
+        uint16_t m_fwVer;
+        uint8_t m_chan;
+        uint8_t m_chanPend;
+    
+        class XBeeApiCmdAtFirmwareVersionRequest : public XBeeApiFrame
+        {
+            public:
+                XBeeApiCmdAtFirmwareVersionRequest( void );
+        };
+
+        class XBeeApiCmdAtHardwareVersionRequest : public XBeeApiFrame
+        {
+            public:
+                XBeeApiCmdAtHardwareVersionRequest( void );
+        };
+
+        class XBeeApiCmdAtChannelRequest : public XBeeApiFrame
+        {
+            public:
+                XBeeApiCmdAtChannelRequest( void );
+        };
+
+        class XBeeApiCmdAtChannelSet : public XBeeApiFrame
+        {
+            uint8_t m_buffer[ 10 ];
+            public:
+                XBeeApiCmdAtChannelSet( const uint8_t p_chan );
+        };
+
+    public:
+       XBeeApiCmdAt( );
+       virtual ~XBeeApiCmdAt( void ) {};
+       
+       bool requestHardwareVersion( void );
+       bool requestFirmwareVersion( void );
+       bool requestChannel( void );
+
+       virtual bool getHardwareVersion( uint16_t* const p_ver );
+       virtual bool getFirmwareVersion( uint16_t* const p_ver );
+       virtual bool getChannel( uint8_t* const p_chan );
+       
+       virtual bool setChannel( uint8_t const p_chan );
+       
+       /* Implement XBeeApiCmdDecoder interface */
+       virtual bool decodeCallback( const uint8_t* const p_data, size_t p_len );
+
+       typedef uint16_t panId_t;
+       typedef uint8_t  channel_t;
+};
+
+class XBeeApiCmdAtBlocking : public XBeeApiCmdAt
+{
+    protected:
+        uint16_t m_timeout;
+        uint16_t m_slice;
+
+       /* The following are "shadow" methods which allow access to the methods in the base class
+          which we're overriding.  We need these as we need to be able to pass a method pointer
+          (e.g. to getHardwareVersion() ) and there's no way to get a method pointer to the parent 
+          class implementation as opposed to the implementation in this class.  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
+               was to call the implementation in the base class.  Using static_cast<> doesn't have
+               any effect and taking the address of XBeeApiCmdAt::getHardwareVersion ends up with
+               XBeeApiCmdAtBlocking::getHardwareVersion being called due to polymorphism. */
+
+       bool getHardwareVersionS( uint16_t* const p_ver );
+       bool getFirmwareVersionS( uint16_t* const p_ver );
+       bool getChannelS( uint8_t* const p_chan );
+
+    public:
+       XBeeApiCmdAtBlocking( const uint16_t p_timeout = 1000, const uint16_t p_slice = 100);
+       
+       virtual ~XBeeApiCmdAtBlocking( void ) {};
+       /* Implement XBeeApiCmdAt's virtual methods */
+       virtual bool getHardwareVersion( uint16_t* const p_ver );
+       virtual bool getFirmwareVersion( uint16_t* const p_ver );
+       virtual bool getChannel( uint8_t* const p_chan );
+       
+       virtual bool setChannel( uint8_t const p_chan );
+};
+
+#endif
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Utility/XBeeApiSetupHelper.cpp	Fri Jan 31 01:16:56 2014 +0000
@@ -0,0 +1,36 @@
+/** 
+
+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 "XBeeApiSetupHelper.hpp"
+
+void xbeeSetNetworkTypeP2P( XBeeApiCmdAt* const p_xbeeCmd,
+                            const XBeeApiCmdAt::panId_t p_id,
+                            const XBeeApiCmdAt::channel_t p_chan )
+{
+#if 0
+    XBeeDevice::XBeeDeviceReturn_t ret_val = XBeeDevice::XBEEDEVICE_OK;
+    
+    p_xbeeCmd->setCoordinatorEnable( false );
+    p_xbeeCmd->disableEndDeviceAssociation();
+    p_xbeeCmd->setChannel( p_chan );
+    p_xbeeCmd->setPanId( p_id );
+    
+    return ret_val;
+#endif 
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Utility/XBeeApiSetupHelper.hpp	Fri Jan 31 01:16:56 2014 +0000
@@ -0,0 +1,53 @@
+/**
+   @file
+   @brief Functions to help with XBee configuration
+      
+   @author John Bailey 
+
+   @copyright Copyright 2014 John Bailey
+
+   @section LICENSE
+   
+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.
+
+*/
+
+#if !defined XBEEAPISETUPHELPER_HPP
+#define      XBEEAPISETUPHELPER_HPP
+
+#include "XBeeDevice.hpp"
+#include "XBeeApiCmdAt.hpp"
+
+typedef enum {
+    XBEE_NETWORK_TYPE_P2P,
+    XBEE_NETWORK_TYPE_NON_BEACON,
+    XBEE_NETWORK_TYPE_UNKNOWN
+} XBeeNetworkType_e;
+
+/** Set the XBee to use the P2P networking model.  Thie helper function
+    assumes that the XBee device and the passed XBeeApiCmdAt-type object have already
+    been configured.
+
+    This function will block until the settings have been successfully applied or a failure
+    has been encountered.
+
+    \param p_xbeeCmd Pointer to an XBeeApiCmdAt object which has already been registered
+                     as a decoder with an XBee device.
+    \param p_id Network ID to use
+    \param p_chan Channel to use
+*/      
+extern void xbeeSetNetworkTypeP2P( XBeeApiCmdAt* const           p_xbeeCmd,
+                                   const XBeeApiCmdAt::panId_t   p_id,
+                                   const XBeeApiCmdAt::channel_t p_chan );
+
+#endif /* !defined( XBEEAPISETUPHELPER_HPP ) */
\ No newline at end of file