LsrModule.cpp

00001 /**
00002  * @file LsrModule.cpp
00003  * @author LS Research LLC
00004  * @version 1.0
00005  *
00006  * @section LICENSE
00007  *
00008  * This program is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU General Public License as
00010  * published by the Free Software Foundation; either version 2 of
00011  * the License, or (at your option) any later version.
00012  * 
00013  * This program is distributed in the hope that it will be useful, but
00014  * WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00016  * General Public License for more details at
00017  * http://www.gnu.org/copyleft/gpl.html
00018  *
00019  * @section DESCRIPTION
00020  *
00021  * Implementation of contents in LsrModule.h.
00022  */
00023 
00024 /**
00025  * Modified by Mark Harris at SAIT.ca
00026  * Improved functionality for mbed
00027  */
00028 
00029 #include "LsrModule.h "
00030 #include "mbed.h"
00031 
00032 /**
00033 * C function pointer typedef.
00034 *
00035 */
00036 typedef void (*ptrRxMsgCallback)(void);
00037 
00038 /**
00039 * Table used for subscribing callback functions for
00040 * received UART messages.
00041 */
00042 ptrRxMsgCallback ptrRxMsgCallbackTable[69];
00043 
00044 
00045 /**
00046 * This table contains the min and max length for each message type.  The first array index
00047 * is the message type and the second index is the min value (0) or max value (1).
00048 */
00049 const uint8_t cau8RxMsgLengthAndTypeTable[69][2] = {
00050     {12, 39},   // 0x81 - Query Firmware Version Response
00051     {0, 0},     // 0x82 - Invalid message type
00052     {0, 0},     // 0x83 - Invalid message type
00053     {0, 0},     // 0x84 - Invalid message type
00054     {0, 0},     // 0x85 - Invalid message type
00055     {0, 0},     // 0x86 - Invalid message type
00056     {0, 0},     // 0x87 - Invalid message type
00057     {0, 0},     // 0x88 - Invalid message type
00058     {0, 0},     // 0x89 - Invalid message type
00059     {0, 0},     // 0x8A - Invalid message type
00060     {0, 0},     // 0x8B - Invalid message type
00061     {5, 5},     // 0x8C - Set Security Transmit Frame Counter Ack
00062     {11, 11},   // 0x8D - Query Security Transmit Frame Counter Response
00063     {0, 0},     // 0x8E - Invalid message type
00064     {0, 0},     // 0x8F - Invalid message type
00065     {5, 5},     // 0x90 - Set Basic RF Settings Ack
00066     {39, 39},   // 0x91 - Query Basic RF Settings Response
00067     {5, 5},     // 0x92 - Save Settings to NV Memory Ack
00068     {5, 5},     // 0x93 - Reset Request Ack
00069     {9, 9},     // 0x94 - Query Supply Voltage Response
00070     {21, 21},   // 0x95 - Query Statistics Response
00071     {5, 5},     // 0x96 - Clear Statistics Ack
00072     {0, 0},     // 0x97 - Invalid message type
00073     {5, 5},     // 0x98 - Set Host Data Rate Ack
00074     {0, 0},     // 0x99 - Invalid message type
00075     {0, 0},     // 0x9A - Invalid message type
00076     {0, 0},     // 0x9B - Invalid message type
00077     {0, 0},     // 0x9C - Invalid message type
00078     {0, 0},     // 0x9D - Invalid message type
00079     {0, 0},     // 0x9E - Invalid message type
00080     {0, 0},     // 0x9F - Invalid message type
00081     {7, 7},     // 0xA0 - Send Simple Short Address RF Data Packet Ack
00082     {17, 115},  // 0xA1 - Received Simple Short Address RF Data Packet
00083     {7, 7},     // 0xA2 - Send Advanced Short Address RF Data Packet Ack
00084     {21, 119},  // 0xA3 - Received Advanced Short Address RF Data Packet
00085     {7, 7},     // 0xA4 - Send Simple Long Address RF Data Packet Ack
00086     {29, 127},  // 0xA5 - Received Simple Long Address RF Data Packet
00087     {7, 7},     // 0xA6 - Send Advanced Long Address RF Data Packet Ack
00088     {33, 131},  // 0xA7 - Received Advanced Long Address RF Data Packet
00089     {0, 0},     // 0xA8 - Invalid message type
00090     {0, 0},     // 0xA9 - Invalid message type
00091     {0, 0},     // 0xAA - Invalid message type
00092     {0, 0},     // 0xAB - Invalid message type
00093     {0, 0},     // 0xAC - Invalid message type
00094     {0, 0},     // 0xAD - Invalid message type
00095     {13, 131},  // 0xAE - Received Promiscuous Mode Packet
00096     {0, 0},     // 0xAF - Invalid message type
00097     {0, 0},     // 0xB0 - Invalid message type
00098     {0, 0},     // 0xB1 - Invalid message type
00099     {0, 0},     // 0xB2 - Invalid message type
00100     {0, 0},     // 0xB3 - Invalid message type
00101     {0, 0},     // 0xB4 - Invalid message type
00102     {0, 0},     // 0xB5 - Invalid message type
00103     {0, 0},     // 0xB6 - Invalid message type
00104     {0, 0},     // 0xB7 - Invalid message type
00105     {0, 0},     // 0xB8 - Invalid message type
00106     {0, 0},     // 0xB9 - Invalid message type
00107     {0, 0},     // 0xBA - Invalid message type
00108     {0, 0},     // 0xBB - Invalid message type
00109     {0, 0},     // 0xBC - Invalid message type
00110     {0, 0},     // 0xBD - Invalid message type
00111     {0, 0},     // 0xBE - Invalid message type
00112     {0, 0},     // 0xBF - Invalid message type
00113     {0, 0},     // 0xC0 - Invalid message type
00114     {0, 0},     // 0xC1 - Invalid message type
00115     {0, 0},     // 0xC2 - Invalid message type
00116     {0 ,0},     // 0xC3 - Invalid message type
00117     {5, 5},     // 0xC4 - Channel Energy Scan Ack
00118     {23, 23}    // 0xC5 - Channel Energy Scan Results
00119 };
00120 
00121 /**
00122 * Construnctor.
00123 *
00124 * Example:
00125 *
00126 * LsrModule(false, 19200);
00127 *
00128 */
00129 LsrModule::LsrModule(PinName tx, PinName rx, int baudRate) : Serial(tx, rx)
00130 {
00131     baud(baudRate);
00132     
00133     ptrHostState = &LsrModule::HostRxWaitForMsgStartByteState;
00134     
00135     //attach(this, &LsrModule::RunHostRxStateMachine);
00136 }   /*** End LsrModule ***/
00137 
00138 
00139 /**
00140 * Destructor.  Called automatically, de-allocates resources.
00141 *
00142 */
00143 LsrModule::~LsrModule(void)
00144 {
00145     pu8RxBuffer = NULL;
00146     ptrHostState = NULL;
00147     ptrHostProcessCallbackState = NULL;
00148     
00149     for (u8ForLoopCounter = 0; u8ForLoopCounter < sizeof(ptrRxMsgCallbackTable); u8ForLoopCounter++)
00150     {
00151         ptrRxMsgCallbackTable[u8ForLoopCounter] = NULL;
00152     }
00153 }   /*** End ~LsrModule ***/
00154 
00155 
00156 /**
00157 * Creates a callback for specific received UART message.  Call this function from your main application in 
00158 * this manner: "SubscribeRxMsgCallback(0xA1, &simpleShortAddrCallback)", where simpleShortAddrCallback is 
00159 * defined like this: void simpleShortAddrCallback(void) in your main application.  
00160 * IMPORTANT: All user defined callback methods must return void and take no parameters (void).
00161 *
00162 * @return True: Subscribed callback.  False: Did not subscribe callback.
00163 *
00164 */
00165 bool LsrModule::SubscribeRxMsgCallback(uint8_t u8RxMsgType ///< The received message for which you want the callback to execute.
00166                     , void (*callback)(void) ///< C function pointer to the specified callback function.
00167                      )
00168 {
00169     if ((u8RxMsgType > LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE) && (u8RxMsgType < LSR_MODULE_MAX_SERIAL_RX_MSG_TYPE))
00170     {
00171         ptrRxMsgCallbackTable[u8RxMsgType- LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE] = callback;
00172         return true;
00173     }
00174 
00175     return false;
00176 }   /*** End SubscribeRxMsgCallback ***/
00177 
00178 
00179 /**
00180 * Removes a callback for specific received UART message.  See SubscribeRxMsgCallback's description for 
00181 * more information.
00182 *
00183 * @return True: Unsubscribed callback.  False: Did not unsubscribed callback.
00184 *
00185 */
00186 bool LsrModule::UnsubscribeRxMsgCallback(uint8_t u8RxMsgType ///< The received message for which you want the callback to be removed.
00187                        )
00188 {
00189     if ((u8RxMsgType > LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE) && (u8RxMsgType < LSR_MODULE_MAX_SERIAL_RX_MSG_TYPE))
00190     {
00191         ptrRxMsgCallbackTable[u8RxMsgType - LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE] = NULL;
00192         return true;
00193     }
00194 
00195     return false;
00196 }   /*** End UnsubscribeRxMsgCallback ***/
00197 
00198 
00199 /**
00200 * Executes host RX state machine.  This function must be executed continually from the loop function in your main
00201 * application.
00202 *
00203 */
00204 void LsrModule::RunHostRxStateMachine(void)
00205 {
00206     (this->*ptrHostState)();
00207 }   /*** End RunHostRxStateMachine ***/
00208 
00209 
00210 /**
00211 * Flushes appropriate serial port.
00212 *
00213 */
00214 void LsrModule::SerialFlush(void)
00215 {
00216     // Serial.flush(); 
00217     // i think this is meant to clean out the rx buffer
00218     /*** End SerialFlush ***/
00219 }
00220 
00221 /**
00222 * Adds header to the UART transmit buffer.
00223 *
00224 */
00225 void LsrModule::AddSerialMsgHeader(uint8_t u8MsgType, uint8_t u8MsgLength)
00226 {
00227     SerialFlush();
00228     u8UartTxBufferIndex = LSR_MODULE_MSG_START_BYTE_INDEX;
00229     au8UartTxBuffer[u8UartTxBufferIndex++] = LSR_MODULE_SERIAL_MSG_START_BYTE;
00230     au8UartTxBuffer[u8UartTxBufferIndex++] = u8MsgLength;
00231     au8UartTxBuffer[u8UartTxBufferIndex++] = u8MsgType;
00232     u8TxMsgChecksum = (LSR_MODULE_SERIAL_MSG_START_BYTE + u8MsgLength + u8MsgType);
00233 }   /*** End LsrModuleAddSerialMsgHeader ***/
00234 
00235 
00236 /**
00237 * Adds data bytes to the UART transmit buffer.
00238 *
00239 */
00240 void LsrModule::AddSerialByteToMsgBuffer(uint8_t u8Data ///< The data to add.
00241                                            )
00242 {
00243     au8UartTxBuffer[u8UartTxBufferIndex++] = u8Data;
00244     u8TxMsgChecksum += u8Data;
00245 }   /*** End LsrModuleAddSerialByteToMsgBuffer ***/
00246 
00247 
00248 /**
00249 * Adds message trailer to the UART transmit buffer.
00250 *
00251 */
00252 void LsrModule::AddSerialMsgTrailer(void)
00253 {
00254     au8UartTxBuffer[u8UartTxBufferIndex++] = u8TxMsgChecksum;
00255     au8UartTxBuffer[u8UartTxBufferIndex] = LSR_MODULE_SERIAL_MSG_END_BYTE;
00256     WriteSerialMsg();
00257 }   /*** End AddSerialMsgTrailer ***/
00258 
00259 
00260 /**
00261 * Writes the UART transmit buffer using the appropriate serial port.
00262 *
00263 */
00264 void LsrModule::WriteSerialMsg(void)
00265 {
00266     //write (const uint8_t *buffer, int length, const event_callback_t &callback, int event=SERIAL_EVENT_TX_COMPLETE)
00267     write(au8UartTxBuffer, au8UartTxBuffer[LSR_MODULE_MSG_LENGTH_BYTE_INDEX]);
00268     
00269 }   /*** End WriteSerialMsg ***/
00270 
00271 
00272 /**
00273 * Sends message type 0x01 (Query Version) to the module via UART communication.  This will spark
00274 * a response message from the module to the Arduino of type 0x81.  Subscribing to 0x81 in 
00275 * your main application will allow you to parse the response data.  See the description for 
00276 * SubscribeRxMsgCallback for more information.
00277 *
00278 */
00279 void LsrModule::QueryVersionMsg(void)
00280 {
00281     AddSerialMsgHeader(LSR_MODULE_QUERY_VERSION_MSG_TYPE, 5);
00282     AddSerialMsgTrailer();
00283 }   /*** End QueryVersionMsg ***/
00284 
00285 
00286 /**
00287 * Sends message type 0x0C (Sets Security Transmit Frame Counter) to the module via UART communication.  
00288 * This frame counter is used with RF messages transmitted with security to ensure sequential freshness. 
00289 * This sets the starting frame count and is automatically incremented on every secured packet sent.  
00290 * This will spark an ACK message from the module to the Arduino of type 0x8C.  Subscribing to 0x8C in 
00291 * your main application will allow you to parse the response data.  See the description for 
00292 * SubscribeRxMsgCallback for more information.
00293 *
00294 * Example:
00295 *
00296 * uint32_t u32FrameCounter = 0xAEDFEDFA;
00297 * SetSecurityTransmitFrameCounterMsg(&u32FrameCounter);
00298 *
00299 */
00300 void LsrModule::SetSecurityTransmitFrameCounterMsg(uint32_t* pu32FrameCounter ///< Pointer to 4 byte frame counter (LSB to MSB).
00301                              )
00302 {
00303     DWordu_t dwuFrameCounter;
00304 
00305     dwuFrameCounter.u32 = *pu32FrameCounter;
00306       
00307     AddSerialMsgHeader(LSR_MODULE_SET_SECURITY_TX_FRAME_COUNTER_MSG_TYPE, 11);
00308     AddSerialByteToMsgBuffer(dwuFrameCounter.dws.lb);
00309     AddSerialByteToMsgBuffer(dwuFrameCounter.dws.mlb);
00310     AddSerialByteToMsgBuffer(dwuFrameCounter.dws.mhb);
00311     AddSerialByteToMsgBuffer(dwuFrameCounter.dws.hb);
00312     AddSerialByteToMsgBuffer(0x00);        // Add filler byte.
00313     AddSerialByteToMsgBuffer(0x00);        // Add filler byte.
00314     AddSerialMsgTrailer();
00315 }   /*** End SetSecurityTransmitFrameCounterMsg ***/ 
00316 
00317 
00318 /**
00319 * Sends message type 0x0D (Query Security Transmit Frame Counter) to the module via UART communication.  This
00320 * will spark a response message from the module to the Arduino of type 0x8D.  Subscribing to 0x8D in your main 
00321 * application will allow you to parse the response data.  See the description for SubscribeRxMsgCallback
00322 * for more information.
00323 *
00324 */
00325 void LsrModule::QuerySecurityTransmitFrameCounterMsg(void)
00326 {
00327     AddSerialMsgHeader(LSR_MODULE_QUERY_SECURITY_TX_FRAME_COUNTER_MSG_TYPE, 5);
00328     AddSerialMsgTrailer();
00329 }   /*** End QuerySecurityTransmitFrameCounterMsg ***/ 
00330 
00331 
00332 /**
00333 * Sends message type 0x10 (Set Basic RF Settings) to the module via UART communication.
00334 * This will spark an ACK message from the module to the Arduino of type 0x90.  Subscribing to 0x90 in 
00335 * your main application will allow you to parse the response data.  See the description for 
00336 * SubscribeRxMsgCallback for more information.
00337 *
00338 */
00339 void LsrModule::SetBasicRfSettingsMsg(uint16_t u16PanId ///< Personal Area Network (PAN) ID assigned to module.
00340                                        , uint16_t u16AddrShort ///< 2 byte short address assigned to module.
00341                        , uint8_t* pu8AddrLong ///< Pointer to 8 byte long address assigned to module.  Do not assign a zero, even if using short addressing.
00342                        , uint8_t u8RfChannel ///< RF channel assigned to module.
00343                        , uint8_t u8TxPowerLevel ///< Transmit power assigned to module.
00344                        , uint8_t u8ReceiverConfig ///< 1 byte bitmask of receiver options.
00345                        , uint8_t* pu8SecurityKey ///< Pointer to 32 byte security key assigned to module.
00346                     )
00347 {
00348     Wordu_t wuPanId;
00349     Wordu_t wuShortAddr;
00350     
00351     wuPanId.u16 = u16PanId;
00352     wuShortAddr.u16 = u16AddrShort;
00353     
00354     if ((u8RfChannel >= LSR_MODULE_RF_CHANNEL_MIN) && (u8RfChannel <= LSR_MODULE_RF_CHANNEL_MAX) &&
00355         (u8TxPowerLevel <= LSR_MODULE_TX_POWER_LEVEL_MAX) &&
00356         (u8ReceiverConfig <= LSR_MODULE_RX_CONFIG_MAX))
00357     {
00358         AddSerialMsgHeader(LSR_MODULE_SET_BASIC_RF_SETTINGS_MSG_TYPE, 39);
00359         AddSerialByteToMsgBuffer(wuPanId.ws.lb);
00360         AddSerialByteToMsgBuffer(wuPanId.ws.hb);
00361         AddSerialByteToMsgBuffer(wuShortAddr.ws.lb);
00362         AddSerialByteToMsgBuffer(wuShortAddr.ws.hb);
00363 
00364         for (u8ForLoopCounter = 0; u8ForLoopCounter < 8; u8ForLoopCounter++)
00365         {
00366             AddSerialByteToMsgBuffer(*pu8AddrLong);
00367             pu8AddrLong++;
00368         }
00369     
00370         AddSerialByteToMsgBuffer(u8RfChannel);
00371         AddSerialByteToMsgBuffer(u8TxPowerLevel);
00372         AddSerialByteToMsgBuffer(u8ReceiverConfig);
00373 
00374         AddSerialByteToMsgBuffer(0x00);        // Add filler byte.
00375         AddSerialByteToMsgBuffer(0x00);        // Add filler byte.
00376         AddSerialByteToMsgBuffer(0x00);        // Add filler byte.
00377 
00378         for (u8ForLoopCounter = 0; u8ForLoopCounter < 16; u8ForLoopCounter++)
00379         {
00380             AddSerialByteToMsgBuffer(*pu8SecurityKey);
00381             pu8SecurityKey++;
00382         }
00383 
00384         AddSerialMsgTrailer();
00385     }
00386 }   /*** End SetBasicRfSettingsMsg ***/
00387 
00388 
00389 /**
00390 * Sends message type 0x11 (Query Basic RF Settings) to the module via UART communication.  This will spark
00391 * a response message from the module to the Arduino of type 0x91.  Subscribing to 0x91 in your main 
00392 * application will allow you to parse the response data.  See the description for SubscribeRxMsgCallback 
00393 * for more information.
00394 *
00395 */
00396 void LsrModule::QueryBasicRfSettingsMsg(void)
00397 {
00398     AddSerialMsgHeader(LSR_MODULE_QUERY_BASIC_RF_SETTINGS_MSG_TYPE, 5);
00399     AddSerialMsgTrailer();
00400 }   /*** End QueryBasicRfSettingsMsg ***/
00401 
00402 
00403 /**
00404 * Sends message type 0x12 (Save Settings to non-volatile Memory) to the module via UART communication.  Calling
00405 * this command will make your module retain all basic configuration settings on boot up.  This will spark an ACK 
00406 * message from the module to the Arduino of type 0x92.  Subscribing to 0x92 in your main application will allow 
00407 * you to parse the response data.  See the description for SubscribeRxMsgCallback for more information.
00408 *
00409 */
00410 void LsrModule::SaveSettingsToNVMemoryMsg(void)
00411 {
00412     AddSerialMsgHeader(LSR_MODULE_SAVE_SETTINGS_TO_NV_MEMORY_MSG_TYPE, 5);
00413     AddSerialMsgTrailer();
00414 }   /*** End SaveSettingsToNVMemoryMsg ***/
00415 
00416 
00417 /**
00418 * Sends message type 0x13 (Reset Request) to the module via UART communication.  This will make your module perform
00419 * a restart.  This will spark an ACK message from the module to the Arduino of type 0x93.  Subscribing to 0x93 in 
00420 * your main application will allow you to parse the response data.  See the description for SubscribeRxMsgCallback
00421 * for more information.
00422 *
00423 */
00424 void LsrModule::ResetRequestMsg(void)
00425 {
00426     AddSerialMsgHeader(LSR_MODULE_RESET_REQUEST_MSG_TYPE, 5);
00427     AddSerialMsgTrailer();
00428 }   /*** End ResetRequestMsg ***/
00429 
00430 
00431 /**
00432 * Sends message type 0x14 (Query Supply Voltage) to the module via UART communication.  This will spark a 
00433 * response message from the module to the Arduino of type 0x94.  Subscribing to 0x94 in your main application
00434 * will allow you to parse the response data.  See the description for SubscribeRxMsgCallback for more information.
00435 *
00436 */
00437 void LsrModule::QuerySupplyVoltageMsg(void)
00438 {
00439     AddSerialMsgHeader(LSR_MODULE_QUERY_SUPPLY_VOLTAGE_MSG_TYPE, 5);
00440     AddSerialMsgTrailer();
00441 }   /*** End QuerySupplyVoltageMsg ***/
00442 
00443 
00444 /**
00445 * Sends message type 0x15 (Query Statistics) to the module via UART communication.  Statistics include packets sent, 
00446 * acks received, packets received and broadcast packets received.  This will spark a response message from the module 
00447 * to the Arduino of type 0x95.  Subscribing to 0x94 in your main application will allow you to parse the response 
00448 * data.  See the description for SubscribeRxMsgCallback for more information.
00449 *
00450 */
00451 void LsrModule::QueryStatisticsMsg(void)
00452 {
00453     AddSerialMsgHeader(LSR_MODULE_QUERY_STATISTICS_MSG_TYPE, 5);
00454     AddSerialMsgTrailer();
00455 }   /*** End QueryStatisticsMsg ***/
00456 
00457 
00458 /**
00459 * Sends message type 0x16 (Clear Statistics) to the module via UART communication.  This will spark an ACK message 
00460 * from the module to the Arduino of type 0x96.  Subscribing to 0x96 in your main application will allow you to 
00461 * Parse the response data.  See the description for SubscribeRxMsgCallback for more information.
00462 *
00463 */
00464 void LsrModule::ClearStatisticsMsg(void)
00465 {
00466     AddSerialMsgHeader(LSR_MODULE_CLEAR_STATISTICS_MSG_TYPE, 5);
00467     AddSerialMsgTrailer();
00468 }   /*** End ClearStatisticsMsg ***/
00469 
00470 
00471 /**
00472 * Sends message type 0x18 (Set Host Data Rate) to the module via UART communication.  This will spark an ACK message 
00473 * from the module to the Arduino of type 0x98.  Subscribing to 0x98 in your main application will allow you to parse 
00474 * the response data.  See the description for SubscribeRxMsgCallback for more information.
00475 *
00476 */
00477 void LsrModule::SetHostDataRateMsg(uint8_t u8HostDataRate ///< Data rate for module to use when communicating via UART:
00478                                  ///< 0 = 1,200 bits/s
00479                                  ///< 1 = 2,400 bits/s
00480                                  ///< 2 = 4,800 bits/s
00481                                  ///< 3 = 9,600 bits/s
00482                                  ///< 4 = 19,200 bits/s
00483                                  ///< 5 = 38,400 bits/s
00484                                  ///< 6 = 57,600 bits/s
00485                                  ///< 7 = 115,200 bits/s
00486                                      )
00487 {
00488     if (u8HostDataRate <= LSR_MODULE_HOST_DATA_RATE_MAX)
00489     {
00490         AddSerialMsgHeader(LSR_MODULE_SET_HOST_DATA_RATE_MSG_TYPE, 6);
00491         AddSerialByteToMsgBuffer(u8HostDataRate);
00492         AddSerialMsgTrailer();
00493         
00494         // 2.4 ms for the data rate change packet to be transmitted.
00495         wait_ms(3);
00496         
00497         switch (u8HostDataRate)
00498         {
00499             case LSR_MODULE_HOST_DATA_RATE_1200:
00500                 baud(1200);
00501                 break;
00502             case LSR_MODULE_HOST_DATA_RATE_2400:
00503                 baud(2400);
00504                 break;
00505             case LSR_MODULE_HOST_DATA_RATE_4800:
00506                 baud(4800);
00507                 break;
00508             case LSR_MODULE_HOST_DATA_RATE_9600:
00509                 baud(9600);
00510                 break;
00511             case LSR_MODULE_HOST_DATA_RATE_19200:
00512                 baud(19200);
00513                 break;
00514             case LSR_MODULE_HOST_DATA_RATE_38400:
00515                 baud(38400);
00516                 break;
00517             case LSR_MODULE_HOST_DATA_RATE_57600:
00518                 baud(57600);
00519                 break;
00520             case LSR_MODULE_HOST_DATA_RATE_115200:
00521                 baud(115200);
00522                 break;
00523             case LSR_MODULE_HOST_DATA_RATE_230400:
00524                 baud(230400);
00525                 break;
00526             case LSR_MODULE_HOST_DATA_RATE_460800:
00527                 baud(460800);
00528                 break;
00529             case LSR_MODULE_HOST_DATA_RATE_921600:
00530                 baud(921600);
00531                 break;
00532         }
00533     }
00534 }   /*** End SetHostDataRateMsg ***/
00535 
00536 
00537 /**
00538 * Sends message type 0x19 (Set RF Data Rate) to the module via UART communication.  This will spark an ACK message 
00539 * from the module to the Arduino of type 0x98.  Subscribing to 0x98 in your main application will allow you to parse 
00540 * the response data.  See the description for SubscribeRxMsgCallback for more information.
00541 *
00542 */
00543 void LsrModule::SetRfDataRateMsg(uint8_t u8RfDataRate ///< Data rate for module to use when communicating via radio:
00544                                  ///< 0 = 1,200 bits/s
00545                                  ///< 1 = 2,400 bits/s
00546                                  ///< 2 = 4,800 bits/s
00547                                  ///< 3 = 9,600 bits/s
00548                                  ///< 4 = 19,200 bits/s
00549                                  ///< 5 = 38,400 bits/s
00550                                  ///< 6 = 57,600 bits/s
00551                                  ///< 7 = 115,200 bits/s
00552                                      )
00553 {
00554     if (u8RfDataRate <= LSR_MODULE_RF_DATA_RATE_MAX)
00555     {
00556         AddSerialMsgHeader(LSR_MODULE_SET_RF_DATA_RATE_MSG_TYPE, 6);
00557         AddSerialByteToMsgBuffer(u8RfDataRate);
00558         AddSerialMsgTrailer();
00559     }
00560 }   /*** End SetRfDataRateMsg ***/
00561 
00562 /**
00563 * Sends message type 0x20 (Send Simple Short Address RF Data Packet) to the module via UART communication.
00564 * This will spark an ACK message from the module to the Arduino of type 0xA0.  Subscribing to 0xA0 in 
00565 * your main application will allow you to parse the response data.  See the description for SubscribeRxMsgCallback
00566 * for more information.
00567 *
00568 * Example:
00569 *
00570 * uint8_t u8Data[5] = {4, 7, 3, 5, 8};
00571 * uint8_t u8PacketID;
00572 *
00573 * SendSimpleShortAddrRfDataPacketMsg(&u8Data, sizeof(u8Data, 213, 0, packetID++);
00574 *
00575 */
00576 void LsrModule::SendSimpleShortAddrRfDataPacketMsg(uint8_t* pu8Data ///< Pointer to data being sent.
00577                                                     , uint8_t u8DataLength ///< Length of data being sent.
00578                             , uint16_t u16DestAddress ///< 2 byte destination address.
00579                             , uint8_t u8TxOptions ///< 1 byte bit mask of transmit options.
00580                             , uint8_t u8PacketId ///< ID assigned to packet.
00581                              )
00582 {
00583     if ((u8TxOptions <= LSR_MODULE_TX_OPTIONS_MAX) &&
00584         ((((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) != 0) && (u8DataLength <= (LSR_MODULE_SIMPLE_SHORT_RF_DATA_LENGTH - LSR_MODULE_SECURITY_OVERHEAD))) ||
00585          (((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) == 0) && (u8DataLength <= LSR_MODULE_SIMPLE_SHORT_RF_DATA_LENGTH))))
00586     {
00587         AddSerialMsgHeader(LSR_MODULE_SEND_SIMPLE_SHORT_RF_DATA_PACKET_MSG_TYPE, (u8DataLength + 9));
00588     
00589         AddSerialByteToMsgBuffer(u8TxOptions);
00590         AddSerialByteToMsgBuffer(u16DestAddress % 256);
00591         AddSerialByteToMsgBuffer(u16DestAddress >> 8);
00592         AddSerialByteToMsgBuffer(u8PacketId);
00593           
00594         while (u8DataLength != 0)
00595         {
00596             AddSerialByteToMsgBuffer(*pu8Data);
00597             pu8Data++;
00598             u8DataLength--;
00599         }
00600         
00601         AddSerialMsgTrailer();
00602     }
00603 }   /*** End SendSimpleShortAddrRfDataPacketMsg ***/
00604 
00605 
00606 /**
00607 * Sends message type 0x22 (Send Advanced Short Address RF Data Packet) to the module via UART communication.
00608 * This will spark an ACK message from the module to the Arduino of type 0xA2.  Subscribing to 0xA2 in 
00609 * your main application will allow you to parse the response data.  See the description for SubscribeRxMsgCallback
00610 * for more information.
00611 *
00612 * Example:
00613 *
00614 * uint8_t u8Data[5] = {4, 7, 3, 5, 8};
00615 * uint8_t u8PacketID;
00616 *
00617 * SendAdvancedShortAddrRfDataPacketMsg(&u8Data, sizeof(u8Data, 1111, 213, 0, packetID++);
00618 *
00619 */
00620 void LsrModule::SendAdvancedShortAddrRfDataPacketMsg(uint8_t* pu8Data ///< Pointer to data being sent.
00621                                                       , uint8_t u8DataLength ///< Length of data being sent.
00622                               , uint16_t u16DestPanId ///< 2 byte Personal Area Network (PAN) ID.
00623                               , uint16_t u16DestAddress ///< 2 byte destination address.
00624                               , uint8_t u8TxOptions ///< 1 byte bit mask of transmit options.
00625                               , uint8_t u8PacketId ///< ID assigned to packet.
00626                             )
00627 {
00628     if ((u8TxOptions <= LSR_MODULE_TX_OPTIONS_MAX) &&
00629         ((((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) != 0) && (u8DataLength <= (LSR_MODULE_ADVANCED_SHORT_RF_DATA_LENGTH - LSR_MODULE_SECURITY_OVERHEAD))) ||
00630          (((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) == 0) && (u8DataLength <= LSR_MODULE_ADVANCED_SHORT_RF_DATA_LENGTH))))
00631     {
00632         AddSerialMsgHeader(LSR_MODULE_SEND_ADVANCED_SHORT_RF_DATA_PACKET_MSG_TYPE, (u8DataLength + 11));
00633     
00634         AddSerialByteToMsgBuffer(u8TxOptions);
00635         AddSerialByteToMsgBuffer(u16DestPanId % 256);
00636         AddSerialByteToMsgBuffer(u16DestPanId >> 8);
00637         AddSerialByteToMsgBuffer(u16DestAddress % 256);
00638         AddSerialByteToMsgBuffer(u16DestAddress >> 8);
00639         AddSerialByteToMsgBuffer(u8PacketId);
00640           
00641         while (u8DataLength != 0)
00642         {
00643             AddSerialByteToMsgBuffer(*pu8Data);
00644             pu8Data++;
00645             u8DataLength--;
00646         }
00647         
00648         AddSerialMsgTrailer();
00649     }
00650 }   /*** End SendAdvancedShortAddrRfDataPacketMsg ***/
00651 
00652 
00653 /**
00654 * Sends message type 0x24 (Send Simple Long Address RF Data Packet) to the module via UART communication.
00655 * This will spark an ACK message from the module to the Arduino of type 0xA4.  Subscribing to 0xA4 in 
00656 * your main application will allow you to parse the response data.  See the description for SubscribeRxMsgCallback
00657 * for more information.
00658 *
00659 * Example:
00660 *
00661 * uint8_t u8Data[5] = {4, 7, 3, 5, 8};
00662 * uint8_t u8DestAddress[8] = {2, 3, 6, 5, 2, 3, 6, 5};
00663 * uint8_t u8PacketID;
00664 *
00665 * SendSimpleLongAddrRfDataPacketMsg(&u8Data, sizeof(u8Data), &u8DestAddress, 0, packetID++);
00666 *
00667 */
00668 void LsrModule::SendSimpleLongAddrRfDataPacketMsg(uint8_t* pu8Data ///< Pointer to data being sent.
00669                                                    , uint8_t u8DataLength ///< Length of data being sent.
00670                            , uint8_t* pu8DestAddress ///< Pointer to 8 byte destination address.
00671                            , uint8_t u8TxOptions ///< 1 byte bit mask of transmit options.
00672                            , uint8_t u8PacketId ///< ID assigned to packet.
00673                             )
00674 {
00675     if ((u8TxOptions <= LSR_MODULE_TX_OPTIONS_MAX) &&
00676         ((((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) != 0) && (u8DataLength <= (LSR_MODULE_SIMPLE_LONG_RF_DATA_LENGTH - LSR_MODULE_SECURITY_OVERHEAD))) ||
00677          (((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) == 0) && (u8DataLength <= LSR_MODULE_SIMPLE_LONG_RF_DATA_LENGTH))))
00678     {
00679         AddSerialMsgHeader(LSR_MODULE_SEND_SIMPLE_LONG_RF_DATA_PACKET_MSG_TYPE, (u8DataLength + 15));
00680     
00681         AddSerialByteToMsgBuffer(u8TxOptions);
00682         
00683         for (u8ForLoopCounter = 0; u8ForLoopCounter < 8; u8ForLoopCounter++)
00684         {
00685             AddSerialByteToMsgBuffer(*pu8DestAddress);
00686             pu8DestAddress++;
00687         }
00688         
00689         AddSerialByteToMsgBuffer(u8PacketId);
00690           
00691         while (u8DataLength != 0)
00692         {
00693             AddSerialByteToMsgBuffer(*pu8Data);
00694             pu8Data++;
00695             u8DataLength--;
00696         }
00697         
00698         AddSerialMsgTrailer();
00699     }
00700 }   /*** End SendSimpleLongAddrRfDataPacketMsg ***/
00701 
00702 
00703 /**
00704 * Sends message type 0x26 (Send Advanced Long Address RF Data Packet) to the module via UART communication.
00705 * This will spark an ACK message from the module to the Arduino of type 0xA6.  Subscribing to 0xA6 in 
00706 * your main application will allow you to parse the response data.  See the description for SubscribeRxMsgCallback
00707 * for more information.
00708 *
00709 * Example:
00710 *
00711 * uint8_t u8Data[5] = {4, 7, 3, 5, 8};
00712 * uint8_t u8DestAddress[8] = {2, 3, 6, 5, 2, 3, 6, 5};
00713 * uint8_t u8PacketID;
00714 *
00715 * SendAdvancedLongAddrRfDataPacketMsg(&u8Data, sizeof(u8Data), 1111, &u8DestAddress, 0, packetID++);
00716 *
00717 */
00718 void LsrModule::SendAdvancedLongAddrRfDataPacketMsg(uint8_t* pu8Data ///< Pointer to data being sent.
00719                                                      , uint8_t u8DataLength ///< Length of data being sent.
00720                              , uint16_t u16DestPanId ///< 2 byte Personal Area Network (PAN) ID.
00721                              , uint8_t* pu8DestAddress ///< Pointer to 8 byte destination address.
00722                              , uint8_t u8TxOptions ///< 1 byte bit mask of transmit options.
00723                              , uint8_t u8PacketId ///< ID assigned to packet.
00724                                )
00725 {
00726     if ((u8TxOptions <= LSR_MODULE_TX_OPTIONS_MAX) &&
00727         ((((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) != 0) && (u8DataLength <= (LSR_MODULE_ADVANCED_LONG_RF_DATA_LENGTH - LSR_MODULE_SECURITY_OVERHEAD))) ||
00728          (((u8TxOptions & LSR_MODULE_TX_OPTIONS_USE_SECURITY_BITMASK) == 0) && (u8DataLength <= LSR_MODULE_ADVANCED_LONG_RF_DATA_LENGTH))))
00729     {
00730         AddSerialMsgHeader(LSR_MODULE_SEND_ADVANCED_LONG_RF_DATA_PACKET_MSG_TYPE, (u8DataLength + 17));
00731     
00732         AddSerialByteToMsgBuffer(u8TxOptions);
00733         AddSerialByteToMsgBuffer(u16DestPanId % 256);
00734         AddSerialByteToMsgBuffer(u16DestPanId >> 8);
00735 
00736         for (u8ForLoopCounter = 0; u8ForLoopCounter < 8; u8ForLoopCounter++)
00737         {
00738             AddSerialByteToMsgBuffer(*pu8DestAddress);
00739             pu8DestAddress++;
00740         }
00741 
00742         AddSerialByteToMsgBuffer(u8PacketId);
00743           
00744         while (u8DataLength != 0)
00745         {
00746             AddSerialByteToMsgBuffer(*pu8Data);
00747             pu8Data++;
00748             u8DataLength--;
00749         }
00750         
00751         AddSerialMsgTrailer();
00752     }
00753 }   /*** End SendAdvancedLongAddrRfDataPacketMsg ***/
00754 
00755 
00756 /**
00757 * Sends message type 0x44 (Channel Energy Scan) to the module via UART communication.  This will spark a response message from the module 
00758 * to the host of type 0xC5.  Subscribing to 0xC5 in your main application will allow you to parse the response 
00759 * data.  See the description for SubscribeRxMsgCallback for more information.
00760 *
00761 * Example (Channel 5 for SiFLEX02, Channel 15 for ProFLEX01):
00762 *
00763 * ChannelEnergyScanMsg(11110111, 7);
00764 *
00765 */
00766 void LsrModule::ChannelEnergyScanMsg(uint16_t u16ChannelMask ///< Two byte bitmask (LSB to MSB) of the RF channels to perfom an enrgy scan on.
00767                                       , uint8_t u8ScanDuration ///< Duration to scan for:
00768                                    ///< 0 = 61.4 mSec
00769                                    ///< 1 = 92.2 mSec
00770                                    ///< 2 = 154 mSec
00771                                    ///< 3 = 276 mSec
00772                                    ///< 4 = 522 mSec
00773                                    ///< 5 = 1.01 Sec
00774                                    ///< 6 = 2.00 Sec
00775                                    ///< 7 = 3.96 Sec
00776                                    ///< 8 = 7.90 Sec
00777                                    ///< 9 = 15.8 Sec
00778                                    ///< 10 = 31.5 Sec
00779                                    ///< 11 = 62.9 Sec
00780                                    ///< 12 = 126 Sec
00781                                    ///< 13 = 252 Sec
00782                                    ///< 14 = 503 Sec
00783                                                                 
00784                                        )
00785 {
00786     Wordu_t wuChannelMask;
00787     
00788     wuChannelMask.u16 = u16ChannelMask;
00789     
00790     if (u8ScanDuration <= LSR_MODULE_SCAN_DURATION_MAX)
00791     {
00792         AddSerialMsgHeader(LSR_MODULE_CHANNEL_ENERGY_SCAN_MSG_TYPE, 8);
00793         AddSerialByteToMsgBuffer(wuChannelMask.ws.lb);
00794         AddSerialByteToMsgBuffer(wuChannelMask.ws.hb);
00795         AddSerialByteToMsgBuffer(u8ScanDuration);
00796         AddSerialMsgTrailer();
00797     }
00798 }   /*** End ChannelEnergyScanMsg ***/
00799 
00800 /**
00801 * Sends message type 0x51 (Query Host Interface Configuration) to the module via UART communication.  This will spark a 
00802 * response message from the module to the host of type 0xD1.  Subscribing to 0xD1 in your main application
00803 * will allow you to parse the response data.  See the description for SubscribeRxMsgCallback for more information.
00804 *
00805 */
00806 void LsrModule::QueryHostInterfaceConfiguration(void)
00807 {
00808     AddSerialMsgHeader(LSR_MODULE_QUERY_HOST_INTERFACE_CONFIGURATION, 5);
00809     AddSerialMsgTrailer();
00810 }   /*** End QuerySupplyVoltageMsg ***/
00811 
00812 
00813 
00814 /**
00815 * Verifies msg type and length.
00816 * @return True: Valid msg length and type.  False: Invalid msg length or type.
00817 *
00818 */
00819 bool LsrModule::ValidMsgLengthAndType(uint8_t u8MsgType ///< Received UART message type.
00820                                        , uint8_t u8MsgLength ///< Received UART message length.
00821                                         )
00822 {
00823     if ((u8MsgLength >= cau8RxMsgLengthAndTypeTable[u8MsgType - LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE][0]) &&
00824         (u8MsgLength <= cau8RxMsgLengthAndTypeTable[u8MsgType - LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE][1]))
00825     {
00826         return true;
00827     }
00828     return false;
00829 }  /*** End ValidMsgLengthAndType ***/
00830 
00831 
00832 /**
00833 * Verifies message checksum.
00834 * @return True: Valid checksum.  False: Invalid checksum.
00835 *
00836 */
00837 bool LsrModule::ValidRxChecksum(uint8_t* pu8MsgBuffer ///< Pointer to received UART buffer.
00838                                  , uint8_t u8MsgLength ///< Received UART message length.
00839                                   )
00840 {
00841     uint8_t u8Checksum = 0;
00842 
00843     for (u8ForLoopCounter = 0; u8ForLoopCounter < (u8MsgLength - 2); u8ForLoopCounter++)
00844     {
00845         u8Checksum += au8UartRxBuffer[u8ForLoopCounter];
00846     }
00847 
00848     if (au8UartRxBuffer[u8MsgLength-2] == u8Checksum)
00849     {
00850         return true;
00851     }
00852     
00853     return false;
00854 }  /*** End ValidRxChecksum ***/
00855 
00856 
00857 /**
00858 * Calls appropriate callback function for received message.
00859 * 
00860 */
00861 void LsrModule::HostProcessCallbackMsgStart(uint8_t* pu8MsgBuffer ///< Pointer to received message.
00862                                              , uint8_t u8Length ///< Length of received message.
00863                                               )
00864 {
00865     if ((ptrRxMsgCallbackTable[(*(pu8MsgBuffer + LSR_MODULE_MSG_TYPE_BYTE_INDEX)) - LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE]) != NULL)
00866     {
00867         ptrRxMsgCallbackTable[(*(pu8MsgBuffer + LSR_MODULE_MSG_TYPE_BYTE_INDEX)) - LSR_MODULE_MIN_SERIAL_RX_MSG_TYPE]();
00868     }
00869 }   /*** End HostProcessCallbackMsgStart ***/
00870 
00871 
00872 /**
00873 * Determines if appropriate serial port is available.
00874 * @return True: Serial is available.  False: Serial is unavailable.
00875 *
00876 */
00877 bool LsrModule::SerialAvailable(void)
00878 {
00879     if (readable())
00880     {
00881         return true;
00882     }
00883     
00884     return false;
00885 }   /*** End SerialAvailable ***/
00886 
00887 
00888 /**
00889 * Reads appropriate serial port.
00890 * @return Byte read.
00891 *
00892 */
00893 uint8_t LsrModule::SerialRead(void)
00894 {
00895     return getc();
00896     
00897 }   /*** End SerialRead ***/
00898 
00899 
00900 /**
00901 * Refreshes and restarts Rx state machine.
00902 *
00903 */
00904 void LsrModule::SerialRxCleanupRestart(void)
00905 {
00906     SerialFlush();
00907     u8UartRxBufferIndex = LSR_MODULE_MSG_START_BYTE_INDEX;
00908     ptrHostState = &LsrModule::HostRxWaitForMsgStartByteState;
00909 }   /*** End SerialRxCleanupRestart ***/
00910 
00911 
00912 /**
00913 * Waits for data packet start byte.
00914 *
00915 */
00916 void LsrModule::HostRxWaitForMsgStartByteState(void)
00917 {
00918     while (readable() && (SerialRead() == LSR_MODULE_SERIAL_MSG_START_BYTE))
00919     {
00920         au8UartRxBuffer[u8UartRxBufferIndex++] = LSR_MODULE_SERIAL_MSG_START_BYTE;
00921         ptrHostState = &LsrModule::HostRxGetMsgLengthState;
00922     }
00923 }   /*** End HostRxWaitForMsgStartByteState ***/
00924 
00925 
00926 /**
00927 * Gets data packet length byte.
00928 *
00929 */
00930 void LsrModule::HostRxGetMsgLengthState(void)
00931 {
00932     while (readable())
00933     {
00934         u8RxReadByte = SerialRead();
00935 
00936         if ((u8RxReadByte >= LSR_MODULE_MIN_SERIAL_RX_MSG_LENGTH) &&
00937             (u8RxReadByte <= LSR_MODULE_MAX_SERIAL_RX_MSG_LENGTH))
00938         {
00939             au8UartRxBuffer[u8UartRxBufferIndex++] = u8RxReadByte;
00940             ptrHostState = &LsrModule::HostRxGetMsgTypeState;
00941         }
00942         else
00943         {
00944             ptrHostState = &LsrModule::SerialRxCleanupRestart;
00945         }
00946     }
00947 }   /*** End HostRxGetMsgLengthState ***/
00948 
00949 
00950 /**
00951 * Gets data packet type byte.
00952 *
00953 */
00954 void LsrModule::HostRxGetMsgTypeState(void)
00955 {
00956     while (readable())
00957     {
00958 
00959         u8RxReadByte = SerialRead();
00960         
00961         if (ValidMsgLengthAndType(u8RxReadByte, au8UartRxBuffer[LSR_MODULE_MSG_LENGTH_BYTE_INDEX]))
00962         {
00963             au8UartRxBuffer[u8UartRxBufferIndex++] = u8RxReadByte;
00964             ptrHostState = &LsrModule::HostRxWaitToGetRestOfMsgState;
00965         }
00966         else
00967         {
00968             ptrHostState = &LsrModule::SerialRxCleanupRestart;
00969         }
00970     }
00971 }   /*** End HostRxGetMsgTypeState ***/
00972 
00973 
00974 /**
00975 * Grabs rest of data packet bytes.
00976 *
00977 */
00978 void LsrModule::HostRxWaitToGetRestOfMsgState(void)
00979 {
00980     while (readable())
00981     {
00982         u8RxReadByte = SerialRead();
00983         au8UartRxBuffer[u8UartRxBufferIndex++] = u8RxReadByte;
00984         
00985         if (u8UartRxBufferIndex > LSR_MODULE_MAX_SERIAL_RX_MSG_LENGTH)
00986         {
00987             ptrHostState = &LsrModule::SerialRxCleanupRestart;
00988         }
00989         else if ((u8RxReadByte == LSR_MODULE_SERIAL_MSG_END_BYTE) && (u8UartRxBufferIndex == au8UartRxBuffer[LSR_MODULE_MSG_LENGTH_BYTE_INDEX]))
00990         {
00991             ptrHostState = &LsrModule::HostRxValidateMsgState;
00992         }
00993     }
00994 }   /*** End HostRxWaitToGetRestOfMsgState ***/
00995 
00996 
00997 /**
00998 * Validates received message.
00999 *
01000 */
01001 void LsrModule::HostRxValidateMsgState(void)
01002 {
01003 
01004     if (ValidRxChecksum(au8UartRxBuffer, au8UartRxBuffer[LSR_MODULE_MSG_LENGTH_BYTE_INDEX]))    // Is checksum good?
01005     {
01006         ptrHostState = &LsrModule::HostRxGoodMsgState;     // Good checksum - next state
01007     }
01008     else
01009     {
01010         ptrHostState = &LsrModule::SerialRxCleanupRestart;   // Bad checksum - restart
01011     }
01012 }   /*** End HostRxValidateMsgState ***/
01013 
01014 
01015 /**
01016 * Calls appropriate received UART message callback and starts state machine over.
01017 *
01018 */
01019 void LsrModule::HostRxGoodMsgState(void)
01020 {   
01021     pu8RxBuffer = au8UartRxBuffer;
01022     u8RxMsgLength = au8UartRxBuffer[LSR_MODULE_MSG_LENGTH_BYTE_INDEX];
01023     HostProcessCallbackMsgStart(au8UartRxBuffer, u8RxMsgLength);
01024     ptrHostState = &LsrModule::SerialRxCleanupRestart;      // Start new RX sequence
01025 }   /*** End HostRxGoodMsgState ***/