Connectivity_TestApp.cpp

00001 /*!
00002 * Copyright (c) 2015, Freescale Semiconductor, Inc.
00003 * All rights reserved.
00004 *
00005 * \file Connectivity_TestApp.c
00006 *
00007 * Redistribution and use in source and binary forms, with or without modification,
00008 * are permitted provided that the following conditions are met:
00009 *
00010 * o Redistributions of source code must retain the above copyright notice, this list
00011 *   of conditions and the following disclaimer.
00012 *
00013 * o Redistributions in binary form must reproduce the above copyright notice, this
00014 *   list of conditions and the following disclaimer in the documentation and/or
00015 *   other materials provided with the distribution.
00016 *
00017 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
00018 *   contributors may be used to endorse or promote products derived from this
00019 *   software without specific prior written permission.
00020 *
00021 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
00022 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
00023 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
00024 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
00025 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
00026 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
00027 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
00028 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
00029 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00030 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00031 */
00032 
00033 /************************************************************************************
00034 *************************************************************************************
00035 * Include
00036 *************************************************************************************
00037 ************************************************************************************/
00038 
00039 #include "Application_Interface.h "
00040 #include "Connectivity_Test_Platform.h"
00041 /************************************************************************************
00042 *************************************************************************************
00043 * Private type definitions
00044 *************************************************************************************
00045 ************************************************************************************/
00046 
00047 /************************************************************************************
00048 *************************************************************************************
00049 * Macros
00050 *************************************************************************************
00051 ************************************************************************************/
00052 #define gPrbs9BufferLength_c     ( 65 )
00053 #define gContTxModSelectPN9_c    ( 2 )
00054 #define gContTxModSelectOnes_c   ( 1 )
00055 #define gContTxModSelectZeros_c  ( 0 )
00056 #define SelfNotificationEvent()  \
00057                                  do                                        \
00058                                  {                                         \
00059                                     gTaskEventFlags |= gCTSelf_EVENT_c;    \
00060                                     mainTask->signal_set(gEventsAny_c);    \
00061                                  }while(0);
00062 #define ResetMCU()  NVIC_SystemReset()
00063 
00064 #define gUART_RX_EVENT_c         (1<<0)
00065 #define gMcps_Cnf_EVENT_c        (1<<1)
00066 #define gMcps_Ind_EVENT_c        (1<<2)
00067 #define gMlme_EdCnf_EVENT_c      (1<<3)
00068 #define gMlme_CcaCnf_EVENT_c     (1<<4)
00069 #define gMlme_TimeoutInd_EVENT_c (1<<5)
00070 #define gRangeTest_EVENT_c       (1<<6)
00071 #define gCTSelf_EVENT_c          (1<<7)
00072 #define gTimePassed_EVENT_c      (1<<8)
00073 
00074 #define gEventsAny_c             (1<<9)
00075 
00076 #define Delay_ms(a)        
00077 #define FlaggedDelay_ms(a)       ConnTestTimeout.attach_us(DelayTimeElapsed, (a) * 1000)
00078 
00079 #ifdef gPHY_802_15_4g_d
00080 #define GetTimestampUS() PhyTime_GetTimestampUs()
00081 #define GetTransmissionTime(payload, bitrate) ((((gPhyFSKPreambleLength_c + \
00082                                                   gPhyMRFSKPHRLength_c + gPhyMRFSKSFDLength_c + \
00083                                                     sizeof(smacHeader_t) + payload +  gPhyFCSSize_c )*8000 )/ bitrate))
00084 #else
00085 #define GetTimestampUS() (16*PhyTime_GetTimestamp())
00086 #define GetTransmissionTime(payload, bitrate) (((6 + sizeof(smacHeader_t) + payload + 2)*32))
00087 //bitrate is fixed for 2.4 GHz
00088 #define crtBitrate      (0)
00089 #endif
00090 /************************************************************************************
00091 *************************************************************************************
00092 * Public memory declarations
00093 *************************************************************************************
00094 ************************************************************************************/
00095 
00096 uint32_t       gTaskEventFlags;
00097 
00098 /*smac related variables*/
00099 bool_t bTxDone;
00100 bool_t bRxDone;
00101 bool_t bScanDone;
00102 bool_t gCCaGotResult;
00103 bool_t gIsChannelIdle;
00104 bool_t bEdDone;
00105 bool_t failedPRBS9;
00106 uint8_t u8LastRxRssiValue;
00107 bool_t evTestParameters;
00108 uint8_t au8ScanResults[129];
00109 
00110 /*serial manager related variables*/
00111 uint8_t gu8UartData;
00112 bool_t evDataFromUART;
00113 uint8_t mAppSer;
00114 
00115 /*connectivity test state machine variables*/
00116 operationModes_t testOpMode;                                                    
00117 operationModes_t prevOpMode; 
00118 
00119 channels_t       testChannel;
00120 uint8_t          testPower;
00121 uint8_t          testPayloadLen;
00122 uint8_t          contTxModBitValue;
00123 uint8_t          ccaThresh;
00124 bool_t shortCutsEnabled;
00125 ConnectivityStates_t       connState;
00126 ContinuousTxRxTestStates_t cTxRxState;
00127 PerTxStates_t              perTxState;
00128 PerRxStates_t              perRxState;
00129 RangeTxStates_t            rangeTxState;
00130 RangeRxStates_t            rangeRxState;
00131 EditRegsStates_t    eRState; 
00132 oRStates_t          oRState;
00133 rRStates_t          rRState;
00134 dRStates_t          dRState;
00135 CSenseTCtrlStates_t   cstcState;
00136 uint8_t ChannelToScan; 
00137 smacTestMode_t contTestRunning;
00138 
00139 /*asp related variables*/
00140 AppToAspMessage_t aspTestRequestMsg;
00141 
00142 extern uint8_t u8Prbs9Buffer[gPrbs9BufferLength_c];
00143 
00144 Serial uart(USBTX,USBRX);
00145 Thread *mainTask;
00146 Thread *uartTask;
00147 
00148 /************************************************************************************
00149 *************************************************************************************
00150 * Private memory declarations
00151 *************************************************************************************
00152 ************************************************************************************/
00153 static uint8_t gau8RxDataBuffer[gMaxSmacSDULength_c  + sizeof(txPacket_t)];                         
00154 static uint8_t gau8TxDataBuffer[gMaxSmacSDULength_c  + sizeof(rxPacket_t)];                        
00155 
00156 static txPacket_t * gAppTxPacket;
00157 static rxPacket_t * gAppRxPacket;
00158 
00159 static uint8_t timePassed;
00160 Timeout RangeTestTmr;
00161 Timeout ConnTestTimeout;
00162 Timer AppDelayTmr;
00163 /************************************************************************************
00164 *************************************************************************************
00165 * Private prototypes
00166 *************************************************************************************
00167 ************************************************************************************/
00168 #if CT_Feature_Calibration
00169 extern void StoreTrimValueToFlash (uint32_t trimValue, CalibrationOptionSelect_t option);
00170 #endif
00171 
00172 /*platform independent functions*/
00173 static void SerialUIStateMachine(void);
00174 static bool_t SerialContinuousTxRxTest(void);
00175 static bool_t PacketErrorRateTx(void);
00176 static bool_t PacketErrorRateRx(void);
00177 static void SetRadioRxOnNoTimeOut(void);
00178 static void HandleEvents(int32_t evSignals);
00179 static void PrintTestParameters(bool_t bEraseLine);
00180 
00181 static void PrintPerRxFinalLine(uint16_t u16Received, uint16_t u16Total);
00182 extern uint32_t HexString2Dec(uint8_t * au8String);
00183 static bool_t stringComp(uint8_t * au8leftString, uint8_t * au8RightString, uint8_t bytesToCompare);
00184 /********************************/
00185 
00186 static void RangeTest_Timer_CallBack ();
00187 static bool_t RangeTx(void);
00188 static bool_t RangeRx(void);
00189 
00190 static bool_t EditRegisters(void);
00191 #if CT_Feature_Direct_Registers || CT_Feature_Indirect_Registers
00192 bool_t OverrideRegisters(void);
00193 bool_t ReadRegisters(void);
00194 bool_t DumpRegisters(void);
00195 bool_t bIsRegisterDirect = TRUE;
00196 #endif
00197 
00198 static bool_t CSenseAndTCtrl(void);
00199 static void TransmissionControlHandler(void);
00200 static void CarrierSenseHandler(void);
00201 static smacErrors_t TestMode ( smacTestMode_t  mode);
00202 static void PacketHandler_Prbs9(void);
00203 static void DelayTimeElapsed();
00204 static void IncrementChannelOnEdEvent();
00205 extern void ReadRFRegs(registerAddressSize_t, registerAddressSize_t);
00206 extern void PrintTestParameters(bool_t bEraseLine);
00207 
00208 /*************************************/
00209 /************************************************************************************
00210 *************************************************************************************
00211 * Public functions
00212 *************************************************************************************
00213 ************************************************************************************/
00214 void InitProject(void);
00215 void InitSmac(void);
00216 void main_task(void const *argument);
00217 void UartRxCallBack(void);
00218 void PrintMenu(char * const pu8Menu[], uint8_t port);
00219 
00220 /************************************************************************************
00221 *
00222 * InitProject
00223 *
00224 ************************************************************************************/
00225 void InitProject(void)
00226 {   
00227   /*Global Data init*/
00228   testPayloadLen = gMaxSmacSDULength_c;
00229   
00230   testOpMode       = gDefaultOperationMode_c;
00231   testChannel      = gDefaultChannelNumber_c;
00232   testPower        = gDefaultOutputPower_c;
00233   testPayloadLen   = gDefaultPayload_c;
00234   contTestRunning  = gTestModeForceIdle_c;
00235   shortCutsEnabled = FALSE; 
00236   connState        = gConnInitState_c;
00237   cTxRxState       = gCTxRxStateInit_c;
00238   perTxState       = gPerTxStateInit_c;
00239   perRxState       = gPerRxStateInit_c;
00240   rangeTxState     = gRangeTxStateInit_c;
00241   rangeRxState     = gRangeRxStateInit_c;
00242   prevOpMode       = gDefaultOperationMode_c;
00243   oRState          = gORStateInit_c;
00244   rRState          = gRRStateInit_c;
00245   dRState          = gDRStateInit_c;
00246   ccaThresh        = gDefaultCCAThreshold_c;
00247   bEdDone          = FALSE;
00248   evDataFromUART = FALSE; 
00249   
00250   InitProject_custom();
00251 }
00252 
00253 /************************************************************************************
00254 *************************************************************************************
00255 * SAP functions
00256 *************************************************************************************
00257 ************************************************************************************/
00258 
00259 //(Management) Sap handler for managing timeout indication and ED confirm
00260 smacErrors_t smacToAppMlmeSap(smacToAppMlmeMessage_t* pMsg, instanceId_t instance)
00261 {
00262   switch(pMsg->msgType)
00263   {
00264   case gMlmeEdCnf_c:
00265     au8ScanResults[pMsg->msgData.edCnf.scannedChannel] = pMsg->msgData.edCnf.energyLeveldB;
00266     gTaskEventFlags |= gMlme_EdCnf_EVENT_c;
00267     mainTask->signal_set(gEventsAny_c);
00268     break;
00269   case gMlmeCcaCnf_c:
00270     gTaskEventFlags |= gMlme_CcaCnf_EVENT_c;
00271     mainTask->signal_set(gEventsAny_c);
00272     if(pMsg->msgData.ccaCnf.status == gErrorNoError_c)
00273       gIsChannelIdle = TRUE;
00274     else
00275       gIsChannelIdle = FALSE;
00276     break;
00277   case gMlmeTimeoutInd_c:
00278     gTaskEventFlags |= gMlme_TimeoutInd_EVENT_c;
00279     mainTask->signal_set(gEventsAny_c);
00280     break;
00281   default:
00282     break;
00283   }
00284   MEM_BufferFree(pMsg);
00285   return gErrorNoError_c;
00286 }
00287 //(Data) Sap handler for managing data confirm and data indication
00288 smacErrors_t smacToAppMcpsSap(smacToAppDataMessage_t* pMsg, instanceId_t instance)
00289 {
00290   switch(pMsg->msgType)
00291   {
00292   case gMcpsDataInd_c:
00293     if(pMsg->msgData.dataInd.pRxPacket->rxStatus == rxSuccessStatus_c)
00294     {
00295       u8LastRxRssiValue = pMsg->msgData.dataInd.u8LastRxRssi;
00296       gTaskEventFlags |= gMcps_Ind_EVENT_c;
00297       mainTask->signal_set(gEventsAny_c);
00298     }
00299     break;
00300   case gMcpsDataCnf_c:
00301     if(pMsg->msgData.dataCnf.status == gErrorNoError_c)
00302     {
00303       gTaskEventFlags |= gMcps_Cnf_EVENT_c;
00304       mainTask->signal_set(gEventsAny_c);      
00305     }
00306     break;
00307   default:
00308     break;
00309   }
00310   
00311   MEM_BufferFree(pMsg);
00312   return gErrorNoError_c;
00313 }
00314 
00315 static void HandleEvents(int32_t evSignals)
00316 {
00317   if(evSignals & gUART_RX_EVENT_c)
00318   {
00319     if(shortCutsEnabled)
00320     {
00321       ShortCutsParser(gu8UartData);  
00322     }
00323     else
00324     {
00325       evDataFromUART = TRUE;
00326     }
00327   }
00328   if(evSignals & gMcps_Cnf_EVENT_c)
00329   {
00330     bTxDone = TRUE;
00331   }
00332   if(evSignals & gMcps_Ind_EVENT_c)
00333   {
00334     bRxDone = TRUE;
00335   }
00336   if(evSignals & gMlme_TimeoutInd_EVENT_c)
00337   {
00338   }
00339   if(evSignals & gRangeTest_EVENT_c)
00340   {
00341     bRxDone=TRUE; 
00342   }
00343   if(evSignals & gMlme_EdCnf_EVENT_c)
00344   {
00345     if (cTxRxState == gCTxRxStateRunnigScanTest_c)
00346     {
00347       IncrementChannelOnEdEvent();
00348     }
00349     if (cTxRxState == gCTxRxStateRunnigEdTest_c)
00350     {
00351       cTxRxState = gCTxRxStateRunningEdTestGotResult_c;
00352     }
00353     if (connState == gConnCSenseAndTCtrl_c)
00354     {
00355       bScanDone = TRUE;
00356     }
00357     bEdDone = TRUE;
00358   }
00359   if(evSignals & gMlme_CcaCnf_EVENT_c)
00360   {
00361     gCCaGotResult = TRUE;
00362     uart.printf("Channel %d is ", (uint32_t)testChannel);
00363     if(gIsChannelIdle)
00364       uart.printf("Idle\r\n");
00365     else
00366       uart.printf("Busy\r\n");
00367   }
00368   if(evSignals & gCTSelf_EVENT_c)
00369   {
00370   }
00371 }
00372 
00373 
00374 /*************************************************************************/
00375 /*Main Task: Application entry point*/
00376 /*************************************************************************/
00377 void main_task(void const *argument)
00378 {
00379   static bool_t bIsInitialized = FALSE;
00380   static bool_t bUserInteraction = FALSE;
00381   //Initialize Memory Manager, Timer Manager and LEDs.
00382   if( !bIsInitialized )
00383   {
00384     
00385     MEM_Init();
00386     //initialize PHY
00387     Phy_Init();
00388 
00389     InitApp();
00390       
00391     /*Prints the Welcome screens in the terminal*/  
00392     PrintMenu(cu8FreescaleLogo, mAppSer);
00393   
00394     connState = gConnIdleState_c; 
00395     bIsInitialized = TRUE;
00396   }
00397   if(!bUserInteraction)
00398   {
00399     while(1)
00400     { 
00401       Thread::signal_wait(gEventsAny_c);
00402       if(gu8UartData == '\r')
00403       {
00404         SelfNotificationEvent();
00405         bUserInteraction = TRUE;
00406         break;
00407       }
00408       else
00409       {
00410         PrintMenu(cu8FreescaleLogo, mAppSer);
00411       }
00412     }
00413   }
00414   if(bUserInteraction)
00415   {
00416     while(1)
00417     {
00418       Thread::signal_wait(gEventsAny_c);
00419       HandleEvents(gTaskEventFlags);
00420       gTaskEventFlags = 0;
00421       SerialUIStateMachine();  
00422     }
00423   } 
00424 }
00425 
00426 /*************************************************************************/
00427 /*InitApp: Initializes application mdoules and data*/
00428 /*************************************************************************/
00429 void InitApp()
00430 {
00431   
00432   gAppTxPacket = (txPacket_t*)gau8TxDataBuffer;   //Map TX packet to buffer
00433   gAppRxPacket = (rxPacket_t*)gau8RxDataBuffer;   //Map Rx packet to buffer     
00434   gAppRxPacket->u8MaxDataLength = gMaxSmacSDULength_c;
00435   
00436   uart.baud(115200);
00437     
00438   //Initialise SMAC
00439   InitSmac();
00440   //Tell SMAC who to call when it needs to pass a message to the application thread.
00441   Smac_RegisterSapHandlers((SMAC_APP_MCPS_SapHandler_t)smacToAppMcpsSap,(SMAC_APP_MLME_SapHandler_t)smacToAppMlmeSap,0);
00442   
00443   InitProject();
00444   
00445   InitApp_custom();
00446   
00447   ASP_Init(0, mAppSer);
00448   
00449   SMACFillHeader(&(gAppTxPacket->smacHeader), gBroadcastAddress_c);                   //@CMA, Conn Test. Start with broadcast address default
00450   (void)MLMEPAOutputAdjust(testPower);
00451   (void)MLMESetChannelRequest(testChannel);                                     //@CMA, Conn Test. Start Foperation at default channel
00452 }
00453 
00454 /************************************************************************************
00455 *
00456 * Connectivity Test State Machine
00457 *
00458 ************************************************************************************/
00459 void SerialUIStateMachine(void)
00460 {
00461   if((gConnSelectTest_c == connState) && evTestParameters)
00462   {
00463 #if CT_Feature_Calibration
00464     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
00465 #endif
00466     (void)MLMESetChannelRequest(testChannel);   
00467     (void)MLMEPAOutputAdjust(testPower);
00468     PrintTestParameters(TRUE);
00469     evTestParameters = FALSE;
00470   }
00471   switch(connState)
00472   {
00473   case gConnIdleState_c:
00474     PrintMenu(cu8MainMenu, mAppSer);
00475     PrintTestParameters(FALSE);
00476     shortCutsEnabled = TRUE;           
00477     connState = gConnSelectTest_c;
00478     break;
00479   case gConnSelectTest_c:
00480     if(evDataFromUART){
00481       if('1' == gu8UartData)
00482       {
00483         cTxRxState = gCTxRxStateInit_c;
00484         connState = gConnContinuousTxRxState_c;
00485       }
00486       else if('2' == gu8UartData)
00487       {
00488         perTxState = gPerTxStateInit_c;
00489         perRxState = gPerRxStateInit_c;
00490         connState = gConnPerState_c;
00491       }
00492       else if('3' == gu8UartData)
00493       {
00494         rangeTxState = gRangeTxStateInit_c;
00495         rangeRxState = gRangeRxStateInit_c;
00496         connState = gConnRangeState_c;
00497       }
00498       else if('4' == gu8UartData)
00499       {
00500         cstcState = gCsTcStateInit_c;
00501         connState = gConnCSenseAndTCtrl_c;
00502       }
00503 #if CT_Feature_Direct_Registers || CT_Feature_Indirect_Registers
00504       else if('5' == gu8UartData)
00505       {
00506         eRState = gERStateInit_c;
00507         connState = gConnRegEditState_c;
00508       }
00509 #endif
00510 #if CT_Feature_Bitrate_Select
00511       else if('6' == gu8UartData)
00512       {
00513         bsState = gBSStateInit_c;
00514         connState = gConnBitrateSelectState_c;
00515       }
00516 #endif
00517 #if CT_Feature_Calibration
00518       else if('7' == gu8UartData)
00519       {
00520         connState = gConnEDMeasCalib_c;
00521         edCalState= gEdCalStateInit_c;
00522       }
00523 #endif
00524       else if('p' == gu8UartData)
00525       {
00526         ResetMCU();
00527       }
00528       evDataFromUART = FALSE;
00529       SelfNotificationEvent();
00530     }
00531     break;
00532   case gConnContinuousTxRxState_c:
00533     if(SerialContinuousTxRxTest()) 
00534     {
00535       connState = gConnIdleState_c;
00536       SelfNotificationEvent();
00537     }
00538     break;
00539   case gConnPerState_c:
00540     if(mTxOperation_c == testOpMode)
00541     {
00542       if(PacketErrorRateTx())
00543       {
00544         connState = gConnIdleState_c;
00545         SelfNotificationEvent();
00546       }
00547     }
00548     else
00549     {
00550       if(PacketErrorRateRx())
00551       {
00552         connState = gConnIdleState_c;
00553         SelfNotificationEvent();
00554       }
00555     }
00556     break;
00557   case gConnRangeState_c:
00558     if(mTxOperation_c == testOpMode)
00559     {
00560       if(RangeTx())
00561       {
00562         connState = gConnIdleState_c;
00563         SelfNotificationEvent();
00564       }
00565     }
00566     else
00567     {
00568       if(RangeRx())
00569       {
00570         connState = gConnIdleState_c;
00571         SelfNotificationEvent();
00572       }
00573     }
00574     break;
00575   case gConnRegEditState_c:
00576     if(EditRegisters()) 
00577     {
00578       connState = gConnIdleState_c;
00579       SelfNotificationEvent();
00580     }
00581     break;
00582 #if CT_Feature_Bitrate_Select
00583   case gConnBitrateSelectState_c:
00584     if(Bitrate_Select()) 
00585     {
00586       connState = gConnIdleState_c;
00587     }
00588     break;
00589 #endif
00590   case gConnCSenseAndTCtrl_c:
00591     if(CSenseAndTCtrl()) 
00592     {
00593       connState = gConnIdleState_c;
00594       SelfNotificationEvent();
00595     }
00596     break;
00597 #if CT_Feature_Calibration
00598   case gConnEDMeasCalib_c:
00599     if(EDCalibrationMeasurement())
00600     {
00601       connState = gConnIdleState_c;
00602       SelfNotificationEvent();
00603     }
00604     break;
00605 #endif
00606   default:
00607     break;
00608     
00609   }
00610   if(prevOpMode != testOpMode)
00611   {
00612     perTxState = gPerTxStateInit_c;
00613     perRxState = gPerRxStateInit_c;
00614     rangeTxState = gRangeTxStateInit_c;
00615     rangeRxState = gRangeRxStateInit_c;
00616     prevOpMode = testOpMode;
00617     SelfNotificationEvent();
00618   }
00619 }
00620 
00621 /************************************************************************************
00622 *
00623 * Continuous Tests State Machine
00624 *
00625 ************************************************************************************/
00626 bool_t SerialContinuousTxRxTest(void)
00627 {
00628   bool_t bBackFlag = FALSE;
00629   uint8_t u8Index, u8TempEnergyValue, u8TempScanValue;
00630   
00631   if(evTestParameters)
00632   {
00633     (void)TestMode(gTestModeForceIdle_c);
00634 #if CT_Feature_Calibration
00635     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
00636 #endif
00637     (void)MLMESetChannelRequest(testChannel);                                 
00638     (void)MLMEPAOutputAdjust(testPower);
00639     
00640     if(gTestModePRBS9_c == contTestRunning)
00641     {
00642       cTxRxState = gCTxRxStateRunningPRBS9Test_c;
00643     } 
00644     (void)TestMode(contTestRunning);
00645     
00646     if(gCTxRxStateSelectTest_c == cTxRxState)
00647     {
00648       PrintTestParameters(TRUE);
00649     }
00650     else
00651     {
00652       PrintTestParameters(FALSE);
00653       uart.printf("\r\n");     
00654     }
00655     
00656     if(gCTxRxStateRunnigRxTest_c == cTxRxState)
00657     {
00658       bRxDone = FALSE;
00659       gAppRxPacket->u8MaxDataLength = gMaxSmacSDULength_c;
00660       (void)MLMERXEnableRequest(gAppRxPacket, 0);
00661     }
00662     evTestParameters = FALSE;
00663   }
00664   
00665   switch(cTxRxState)
00666   {
00667   case gCTxRxStateIdle_c:
00668     if((evDataFromUART) && ('\r' == gu8UartData))
00669     {
00670       cTxRxState = gCTxRxStateInit_c;
00671       evDataFromUART = FALSE;  
00672       SelfNotificationEvent();
00673     }
00674     break;
00675   case gCTxRxStateInit_c:
00676     PrintMenu(cu8ShortCutsBar, mAppSer);
00677     PrintMenu(cu8ContinuousTestMenu, mAppSer); 
00678     //Phy in StandBy, smacstate in Idle. 
00679     (void)TestMode(gTestModeForceIdle_c);  
00680     while(MLMESetChannelRequest(testChannel));                                   
00681     uart.printf(cu8ContinuousTestTags[contTestRunning]);
00682     if(contTestRunning == gTestModeContinuousTxModulated_c)
00683     {
00684       uart.printf(cu8TxModTestTags[contTxModBitValue]);
00685     }
00686     (void)TestMode(contTestRunning);
00687     uart.printf("\r\n\r\n");       
00688     PrintTestParameters(FALSE);
00689     shortCutsEnabled = TRUE;           
00690     cTxRxState = gCTxRxStateSelectTest_c; 
00691     break;
00692   case gCTxRxStateSelectTest_c:
00693     if(evDataFromUART)
00694     {           
00695       if('1' == gu8UartData)
00696       {
00697         contTestRunning = gTestModeForceIdle_c;              
00698         cTxRxState = gCTxRxStateInit_c;
00699         SelfNotificationEvent();
00700       }
00701       else if('2' == gu8UartData)
00702       {
00703         shortCutsEnabled = FALSE;
00704         (void)TestMode(gTestModeForceIdle_c);
00705         contTestRunning = gTestModePRBS9_c;  
00706         MLMESetChannelRequest(testChannel);      
00707         uart.printf("\f\r\nPress [p] to stop the Continuous PRBS9 test\r\n");
00708         (void)TestMode(contTestRunning);
00709         cTxRxState = gCTxRxStateRunningPRBS9Test_c;
00710       }
00711       else if('3' == gu8UartData)
00712       {
00713         contTestRunning = gTestModeContinuousTxModulated_c;               
00714         cTxRxState = gCTxRxStateRunningTXModSelectOpt;
00715         //        uart.printf( "\f\r\n To use this mode shunt pins 3-4 on J18");
00716         uart.printf("\f\r\nPress 2 for PN9, 1 to modulate values of 1 and 0 to modulate values of 0");
00717         
00718       }
00719       else if('4' == gu8UartData)
00720       {
00721         if(gTestModeContinuousTxUnmodulated_c != contTestRunning) 
00722         { 
00723           contTestRunning = gTestModeContinuousTxUnmodulated_c;               
00724           cTxRxState = gCTxRxStateInit_c;
00725           SelfNotificationEvent();
00726         }
00727       }
00728       else if('5' == gu8UartData)
00729       {
00730         shortCutsEnabled = FALSE;
00731         (void)TestMode(gTestModeForceIdle_c);  
00732         MLMESetChannelRequest(testChannel);
00733         contTestRunning = gTestModeForceIdle_c;
00734         uart.printf("\f\r\nPress [p] to stop receiving broadcast packets \r\n");                                               
00735         bRxDone = FALSE;
00736         gAppRxPacket->u8MaxDataLength = gMaxSmacSDULength_c;
00737         (void)MLMERXEnableRequest(gAppRxPacket, 0);
00738         cTxRxState = gCTxRxStateRunnigRxTest_c;
00739       }
00740       else if('6' == gu8UartData)
00741       {
00742         (void)TestMode(gTestModeForceIdle_c);
00743         contTestRunning = gTestModeForceIdle_c;
00744         uart.printf("\f\r\nPress [p] to stop the Continuous ED test\r\n");               
00745         cTxRxState = gCTxRxStateRunnigEdTest_c;
00746         FlaggedDelay_ms(200);
00747       }
00748       else if('7' == gu8UartData)
00749       {
00750         (void)TestMode(gTestModeForceIdle_c);
00751         contTestRunning = gTestModeForceIdle_c;
00752         ChannelToScan= gDefaultChannelNumber_c;                            
00753         uart.printf("\f\r\nPress [p] to stop the Continuous SCAN test\r\n");
00754         bScanDone = FALSE;
00755         cTxRxState = gCTxRxStateRunnigScanTest_c;
00756         SelfNotificationEvent();
00757       }
00758       else if('8' == gu8UartData)
00759       {
00760         (void)TestMode(gTestModeForceIdle_c);                        
00761         uart.printf("\f\r\nPress [p] to stop the Continuous CCA test\r\n");
00762         contTestRunning = gTestModeForceIdle_c;                
00763         cTxRxState = gCTxRxStateRunnigCcaTest_c;
00764         FlaggedDelay_ms(100);
00765         MLMECcaRequest();
00766       }
00767 #if CT_Feature_BER_Test
00768       else if ('9' == gu8UartData)
00769       {
00770         uart.printf( "\f\r\nPress [p] to stop the Continuous BER test\r\n");
00771         contTestRunning = gTestModeContinuousRxBER_c;               
00772         cTxRxState = gCTxRxStateInit_c;
00773         SelfNotificationEvent();
00774       }
00775 #endif
00776       else if('p' == gu8UartData)
00777       { 
00778         (void)TestMode(gTestModeForceIdle_c);
00779         (void)MLMESetChannelRequest(testChannel); 
00780         AppDelayTmr.stop();
00781         timePassed = FALSE;
00782         bBackFlag = TRUE;
00783       }
00784       evDataFromUART = FALSE;
00785     }
00786     break;
00787   case gCTxRxStateRunningTXModSelectOpt:
00788     if(evDataFromUART)
00789     { 
00790       if(gu8UartData == '2')
00791         contTxModBitValue = gContTxModSelectPN9_c;
00792       else
00793         if(gu8UartData == '1')
00794           contTxModBitValue = gContTxModSelectOnes_c;
00795         else
00796           if(gu8UartData == '0')
00797             contTxModBitValue = gContTxModSelectZeros_c;
00798         
00799         evDataFromUART = FALSE;
00800         cTxRxState = gCTxRxStateInit_c;
00801         SelfNotificationEvent();
00802     }
00803     break;
00804   case gCTxRxStateRunningPRBS9Test_c:
00805     if(bTxDone || failedPRBS9)
00806     {
00807       failedPRBS9 = FALSE;
00808       bTxDone     = FALSE;
00809       PacketHandler_Prbs9();
00810     }
00811     if(evDataFromUART && 'p' == gu8UartData)
00812     {
00813       contTestRunning = gTestModeForceIdle_c;
00814       (void)TestMode(gTestModeForceIdle_c);
00815       (void)MLMESetChannelRequest(testChannel); 
00816       AppDelayTmr.stop();
00817       timePassed = FALSE;
00818       uart.printf("\r\n\r\n Press [enter] to go back to the Continuous test menu ");
00819       cTxRxState = gCTxRxStateIdle_c;
00820       evDataFromUART = FALSE;
00821       shortCutsEnabled = TRUE;
00822     }
00823     break;
00824   case gCTxRxStateRunnigRxTest_c:
00825     if(bRxDone)
00826     {
00827       if (gAppRxPacket->rxStatus == rxSuccessStatus_c)
00828       {
00829         uart.printf("New Packet: 0x");
00830         for(u8Index = 0; u8Index < (gAppRxPacket->u8DataLength); u8Index++){
00831           uart.printf( "%02X",(gAppRxPacket->smacPdu.smacPdu[u8Index]));
00832         }
00833         uart.printf(" \r\n");
00834       }
00835       bRxDone = FALSE;
00836       gAppRxPacket->u8MaxDataLength = gMaxSmacSDULength_c;
00837       (void)MLMERXEnableRequest(gAppRxPacket, 0);
00838     }
00839     if((evDataFromUART) && ('p' == gu8UartData))
00840     {
00841       (void)MLMERXDisableRequest();
00842       (void)TestMode(gTestModeForceIdle_c);
00843       uart.printf("\r\n\r\n Press [enter] to go back to the Continuous test menu ");
00844       cTxRxState = gCTxRxStateIdle_c;
00845       evDataFromUART = FALSE;
00846     }
00847     break;
00848   case gCTxRxStateRunnigEdTest_c:
00849     if(timePassed)
00850     {
00851       timePassed = FALSE;
00852       FlaggedDelay_ms(100);
00853       MLMEScanRequest(testChannel);
00854     }
00855     if((evDataFromUART) && ('p' == gu8UartData))
00856     {
00857       uart.printf("\r\n\r\n Press [enter] to go back to the Continuous test menu ");
00858       cTxRxState = gCTxRxStateIdle_c;
00859       evDataFromUART = FALSE;
00860       timePassed = FALSE;
00861       AppDelayTmr.stop();
00862     }
00863     
00864     break;
00865   case gCTxRxStateRunningEdTestGotResult_c:
00866     uart.printf("Energy on the Channel %d : ", (uint32_t)testChannel);
00867     u8TempEnergyValue = au8ScanResults[testChannel];
00868     if(u8TempEnergyValue != 0)
00869       uart.printf( "-");
00870     uart.printf("%d dBm\r\n ",(uint32_t)u8TempEnergyValue); 
00871     cTxRxState = gCTxRxStateRunnigEdTest_c;
00872     break; 
00873   case gCTxRxStateRunnigCcaTest_c:
00874     if(timePassed && gCCaGotResult)
00875     {
00876       gCCaGotResult = FALSE;
00877       timePassed = FALSE;
00878       MLMECcaRequest();
00879       FlaggedDelay_ms(100);
00880     }
00881     if((evDataFromUART) && ('p' == gu8UartData))
00882     {
00883       uart.printf("\r\n\r\n Press [enter] to go back to the Continuous test menu ");
00884       cTxRxState = gCTxRxStateIdle_c;
00885       evDataFromUART = FALSE;
00886       timePassed = FALSE;
00887       AppDelayTmr.stop();
00888     }
00889     break;
00890   case gCTxRxStateRunnigScanTest_c:
00891     if(bScanDone && timePassed)
00892     {                                              
00893       //Enters here until all channels have been scanned. Then starts to print.
00894       uart.printf("Results : ");
00895       for(u8Index = gMinChannel_c; u8Index <= gMaxChannel_c ; u8Index++)
00896       {                                                         
00897         u8TempScanValue= au8ScanResults[u8Index];
00898         if(u8TempScanValue != 0)
00899           uart.printf("-");
00900         uart.printf("%d, ", (uint32_t) u8TempScanValue);
00901       }
00902       uart.printf("\b \r\n");
00903       bScanDone = FALSE;                                                   
00904       ChannelToScan = gDefaultChannelNumber_c;                             // Restart channel count
00905       timePassed = FALSE;
00906     }                                                                         
00907     
00908     if((evDataFromUART) && ('p' == gu8UartData))
00909     {
00910       uart.printf("\r\n\r\n Press [enter] to go back to the Continuous test menu ");
00911       cTxRxState = gCTxRxStateIdle_c;
00912       evDataFromUART = FALSE;
00913     }
00914     else
00915     {
00916       if(ChannelToScan == gDefaultChannelNumber_c)
00917       {
00918         smacErrors_t err = MLMEScanRequest((channels_t)ChannelToScan);                                            
00919         if(err == gErrorNoError_c)
00920           ChannelToScan++;
00921       }
00922       //Each of the other channels is scanned after SMAC notifies us that 
00923       //it has obtained the energy value on the currently scanned channel 
00924       //(channel scanning is performed asynchronously). See IncrementChannelOnEdEvent().
00925     }
00926     break;
00927   default:
00928     break;
00929   }
00930   return bBackFlag;
00931 }
00932 
00933 /************************************************************************************
00934 *
00935 * PER Handler for board that is performing TX
00936 *
00937 ************************************************************************************/
00938 bool_t PacketErrorRateTx(void)
00939 {
00940   const uint16_t u16TotalPacketsOptions[] = {1,25,100,500,1000,2000,5000,10000,65535};
00941   static uint16_t u16TotalPackets;
00942   static uint16_t u16SentPackets;
00943   static uint32_t miliSecDelay;
00944   static uint32_t u32MinDelay = 4;
00945   uint8_t u8Index;
00946   bool_t bBackFlag = FALSE;
00947   
00948   if(evTestParameters)
00949   {
00950     (void)MLMERXDisableRequest();
00951 #if CT_Feature_Calibration
00952     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
00953 #endif
00954     (void)MLMESetChannelRequest(testChannel);                                 
00955     (void)MLMEPAOutputAdjust(testPower);
00956     PrintTestParameters(TRUE);
00957     evTestParameters = FALSE;
00958   }
00959   
00960   switch(perTxState)
00961   {
00962   case gPerTxStateInit_c:
00963     PrintMenu(cu8ShortCutsBar, mAppSer);
00964     PrintMenu(cu8PerTxTestMenu, mAppSer);
00965     PrintTestParameters(FALSE);
00966     shortCutsEnabled = TRUE;           
00967     perTxState = gPerTxStateSelectPacketNum_c;
00968     miliSecDelay = 0;
00969     u32MinDelay = 4;
00970     (void)MLMERXDisableRequest();
00971     break;
00972   case gPerTxStateSelectPacketNum_c:
00973     if(evDataFromUART)
00974     {
00975       if((gu8UartData >= '0') && (gu8UartData <= '8'))
00976       {
00977         u16TotalPackets = u16TotalPacketsOptions[gu8UartData - '0'];
00978         shortCutsEnabled = FALSE;  
00979         u32MinDelay += (GetTransmissionTime(testPayloadLen, crtBitrate) / 1000);
00980         uart.printf("\r\n\r\n Please type TX interval in miliseconds ( > %d ms ) and press [ENTER]\r\n", u32MinDelay);
00981         perTxState = gPerTxStateInputPacketDelay_c;
00982       }
00983       else if('p' == gu8UartData)
00984       { 
00985         bBackFlag = TRUE;
00986       }
00987       evDataFromUART = FALSE;
00988     }
00989     break;
00990   case gPerTxStateInputPacketDelay_c:
00991     if(evDataFromUART)
00992     {
00993       if(gu8UartData == '\r')
00994       {
00995         if(miliSecDelay < u32MinDelay)
00996         {
00997           uart.printf("\r\n\tError: TX Interval too small\r\n");
00998           perTxState = gPerTxStateInit_c;
00999           SelfNotificationEvent();
01000         }
01001         else
01002         {
01003           perTxState = gPerTxStateStartTest_c;
01004           SelfNotificationEvent();
01005         }
01006       }
01007       else if((gu8UartData >= '0') && (gu8UartData <='9'))
01008       {
01009         miliSecDelay = miliSecDelay*10 + (gu8UartData - '0');
01010         uart.printf("%d", (uint32_t)(gu8UartData - '0'));
01011       }
01012       else if('p' == gu8UartData)
01013       { 
01014         perTxState = gPerTxStateInit_c;
01015         SelfNotificationEvent();
01016       }
01017       evDataFromUART = FALSE;
01018     }
01019     break;
01020   case gPerTxStateStartTest_c:
01021     gAppTxPacket->u8DataLength = testPayloadLen;
01022     u16SentPackets = 0;
01023     
01024     gAppTxPacket->smacPdu.smacPdu[0] = (u16TotalPackets >> 8);
01025     gAppTxPacket->smacPdu.smacPdu[1] = (uint8_t)u16TotalPackets;
01026     gAppTxPacket->smacPdu.smacPdu[2] = ((u16SentPackets+1) >> 8);
01027     gAppTxPacket->smacPdu.smacPdu[3] = (uint8_t)(u16SentPackets+1);
01028     FLib_MemCpy(&(gAppTxPacket->smacPdu.smacPdu[4]), (void*)"SMAC PER Demo",13);
01029     if(17 < testPayloadLen)
01030     {
01031       for(u8Index=17;u8Index<testPayloadLen;u8Index++)
01032       {     
01033         gAppTxPacket->smacPdu.smacPdu[u8Index] = (u8Index%10)+'0';            
01034       }
01035     }
01036     bTxDone = FALSE;
01037     (void)MCPSDataRequest(gAppTxPacket);
01038     u16SentPackets++;
01039     uart.printf("\f\r\n Running PER Tx, Sending %d Packets",(uint32_t)u16TotalPackets);
01040     perTxState = gPerTxStateRunningTest_c;
01041     FlaggedDelay_ms(miliSecDelay);
01042     break;
01043   case gPerTxStateRunningTest_c:
01044     if(bTxDone && timePassed)
01045     {
01046       uart.printf("\r\n Packet %d ",(uint32_t)u16SentPackets);
01047       if(u16SentPackets == u16TotalPackets)
01048       {    
01049         uart.printf("\r\n\r\nSending last %d  frames \r\n",(uint32_t)mTotalFinalFrames_c);
01050         FLib_MemCpy(&(gAppTxPacket->smacPdu.smacPdu[4]), (void *)"DONE",4);
01051         gAppTxPacket->u8DataLength = 8;
01052         u16SentPackets = 0;
01053         u16TotalPackets = mTotalFinalFrames_c;
01054         gAppTxPacket->u8DataLength = 8;
01055         perTxState = gPerTxStateSendingLastFrames_c;
01056       }
01057       else
01058       {
01059         gAppTxPacket->smacPdu.smacPdu[2] = ((u16SentPackets+1) >> 8);
01060         gAppTxPacket->smacPdu.smacPdu[3] = (uint8_t)(u16SentPackets+1);
01061         gAppTxPacket->u8DataLength = testPayloadLen;
01062       }
01063       bTxDone = FALSE;
01064       (void)MCPSDataRequest(gAppTxPacket);
01065       u16SentPackets++;
01066       timePassed = FALSE;
01067       FlaggedDelay_ms(miliSecDelay);
01068     }
01069     if(evDataFromUART && gu8UartData == ' ')
01070     {
01071       uart.printf("\r\n\r\n-Test interrupted by user. Press [ENTER] to continue\r\n\r\n");
01072       perTxState = gPerTxStateIdle_c;
01073     }
01074     break;
01075   case gPerTxStateSendingLastFrames_c:
01076     if(bTxDone && timePassed)
01077     {
01078       bTxDone = FALSE;
01079       timePassed = FALSE;
01080       uart.printf("\r\n Final Packet %d",(uint32_t)u16SentPackets);
01081       if(u16SentPackets == u16TotalPackets)
01082       {
01083         uart.printf( "\r\n PER Tx DONE \r\n");
01084         uart.printf( "\r\n\r\n Press [enter] to go back to the PER Tx test menu ");
01085         perTxState = gPerTxStateIdle_c;
01086         AppDelayTmr.stop();
01087         timePassed = FALSE;
01088       }
01089       else
01090       {
01091         gAppTxPacket->u8DataLength = 8;
01092         (void)MCPSDataRequest(gAppTxPacket);
01093         u16SentPackets++;
01094         FlaggedDelay_ms(miliSecDelay);
01095       } 
01096     }
01097     if(evDataFromUART && gu8UartData == ' ')
01098     {
01099       uart.printf("\r\n\r\n-Test interrupted by user. Press [ENTER] to continue\r\n\r\n");
01100       perTxState = gPerTxStateIdle_c;
01101     }
01102     break;  
01103   case gPerTxStateIdle_c:
01104     if((evDataFromUART) && ('\r' == gu8UartData))
01105     {
01106       perTxState = gPerTxStateInit_c;
01107       evDataFromUART = FALSE;
01108       SelfNotificationEvent();
01109     }
01110     break;
01111   default:
01112     break;
01113   }
01114   
01115   return bBackFlag;
01116 }
01117 
01118 /************************************************************************************
01119 *
01120 * PER Handler for board that is performing RX
01121 *
01122 ************************************************************************************/
01123 bool_t PacketErrorRateRx(void)
01124 {
01125   static uint16_t u16ReceivedPackets;
01126   static uint16_t u16PacketsIndex;  
01127   static uint16_t u16TotalPackets;
01128   static uint16_t u16FinalPacketsCount;
01129   static uint32_t u32RssiSum;
01130   static uint8_t  u8AverageRssi;
01131   uint8_t u8TempRssivalue;
01132   
01133   bool_t bBackFlag = FALSE;
01134   if(evTestParameters)
01135   {
01136 #if CT_Feature_Calibration
01137     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
01138 #endif
01139     (void)MLMESetChannelRequest(testChannel);                                 
01140     (void)MLMEPAOutputAdjust(testPower);
01141     PrintTestParameters(TRUE);
01142     evTestParameters = FALSE;
01143   }
01144   switch(perRxState)
01145   {
01146   case gPerRxStateInit_c:
01147     u16TotalPackets = 0;
01148     u16ReceivedPackets = 0;
01149     u16PacketsIndex = 0;
01150     u32RssiSum = 0;
01151     PrintMenu(cu8ShortCutsBar, mAppSer);
01152     PrintMenu(cu8PerRxTestMenu, mAppSer);
01153     PrintTestParameters(FALSE);
01154     shortCutsEnabled = TRUE;           
01155     perRxState = gPerRxWaitStartTest_c;
01156     break;
01157   case gPerRxWaitStartTest_c:
01158     if(evDataFromUART)
01159     {
01160       if(' ' == gu8UartData)
01161       {
01162         uart.printf("\f\n\rPER Test Rx Running\r\n\r\n");
01163         SetRadioRxOnNoTimeOut();                                      
01164         shortCutsEnabled = FALSE;  
01165         perRxState = gPerRxStateStartTest_c;
01166       }
01167       else if('p' == gu8UartData)
01168       { 
01169         bBackFlag = TRUE;
01170       }
01171       evDataFromUART = FALSE;
01172     }
01173     break;
01174   case gPerRxStateStartTest_c:
01175     if(bRxDone)
01176     {
01177       if (gAppRxPacket->rxStatus == rxSuccessStatus_c)
01178       {
01179         if(stringComp((uint8_t*)"SMAC PER Demo",&gAppRxPacket->smacPdu.smacPdu[4],13))
01180         {
01181           u16TotalPackets = ((uint16_t)gAppRxPacket->smacPdu.smacPdu[0] <<8) + gAppRxPacket->smacPdu.smacPdu[1];
01182           u16PacketsIndex = ((uint16_t)gAppRxPacket->smacPdu.smacPdu[2] <<8) + gAppRxPacket->smacPdu.smacPdu[3];
01183           u16ReceivedPackets++;
01184           u8TempRssivalue= u8LastRxRssiValue;                               //@CMA, Conn Test. New line
01185           u32RssiSum += u8TempRssivalue;
01186           u8AverageRssi = (uint8_t)(u32RssiSum/u16ReceivedPackets);
01187           uart.printf("Packet %d . Packet index: %d . Rssi during RX: - %d\r\n",(uint32_t)u16ReceivedPackets, (uint32_t)u16PacketsIndex, (uint32_t)u8LastRxRssiValue);
01188           if(u16PacketsIndex == u16TotalPackets)
01189           {
01190             u16FinalPacketsCount = 0; 
01191             perRxState = gPerRxStateReceivingLastFrames_c;
01192           }
01193         }
01194         else if(stringComp((uint8_t*)"DONE",&gAppRxPacket->smacPdu.smacPdu[4],4))
01195         {
01196           u16FinalPacketsCount = 0; 
01197           perRxState = gPerRxStateReceivingLastFrames_c;
01198         }
01199       }
01200       else
01201       { 
01202         if(u16TotalPackets)
01203         {
01204           u16PacketsIndex++;
01205           if(u16PacketsIndex == u16TotalPackets)
01206           {
01207             u16FinalPacketsCount = 0; 
01208             perRxState = gPerRxStateReceivingLastFrames_c;
01209           }
01210         }
01211       }
01212       
01213       SetRadioRxOnNoTimeOut();
01214     }
01215     if(evDataFromUART)
01216     {
01217       if(' ' == gu8UartData)
01218       {
01219         (void)MLMERXDisableRequest();
01220         uart.printf("\r\nAverage Rssi during PER: -");
01221         uart.printf("%d",(uint32_t)u8AverageRssi);
01222         uart.printf(" dBm\r\n");
01223         uart.printf( "\n\rPER Test Rx Stopped\r\n\r\n");
01224         PrintPerRxFinalLine(u16ReceivedPackets,u16TotalPackets);
01225         perRxState = gPerRxStateIdle_c;
01226       } 
01227       evDataFromUART = FALSE;
01228     }         
01229     break;
01230   case gPerRxStateReceivingLastFrames_c:
01231     if(bRxDone)
01232     {
01233       u16FinalPacketsCount++; 
01234       if(mTotalFinalFrames_c == u16FinalPacketsCount)
01235       {
01236         uart.printf("\r\nAverage Rssi during PER: -");
01237         uart.printf("%d",(uint32_t)u8AverageRssi);
01238         uart.printf(" dBm\r\n");
01239         uart.printf( "\n\rPER Test Finished\r\n\r\n");
01240         PrintPerRxFinalLine(u16ReceivedPackets,u16TotalPackets);              
01241         perRxState = gPerRxStateIdle_c;
01242       }
01243       else
01244       {  
01245         SetRadioRxOnNoTimeOut();
01246       }
01247     }
01248     if(evDataFromUART)
01249     {
01250       if(' ' == gu8UartData)
01251       {
01252         (void)MLMERXDisableRequest();
01253         uart.printf("\r\nAverage Rssi during PER: -");
01254         uart.printf("%d",(uint32_t)u8AverageRssi);
01255         uart.printf(" dBm\r\n");
01256         uart.printf( "\n\rPER Test Rx Stopped\r\n\r\n");
01257         PrintPerRxFinalLine(u16ReceivedPackets,u16TotalPackets);
01258         perRxState = gPerRxStateIdle_c;
01259       } 
01260       evDataFromUART = FALSE;
01261     } 
01262     break;
01263   case gPerRxStateIdle_c:
01264     if((evDataFromUART) && ('\r' == gu8UartData))
01265     {
01266       perRxState = gPerRxStateInit_c;
01267       SelfNotificationEvent();
01268     }
01269     evDataFromUART = FALSE;
01270     break;
01271   default:
01272     break;
01273   }
01274   return bBackFlag;
01275 }
01276 
01277 /************************************************************************************
01278 *
01279 * Range Test Handler for board that is performing TX
01280 *
01281 ************************************************************************************/
01282 bool_t RangeTx(void)
01283 {
01284   bool_t bBackFlag = FALSE;
01285   static uint32_t u32RSSISum;
01286   static uint16_t u16ReceivedPackets;
01287   static uint16_t u16PacketsDropped;
01288   uint8_t  u8AverageRSSI;
01289   uint8_t  u8CurrentRSSI;
01290   
01291   if(evTestParameters)
01292   {
01293 #if CT_Feature_Calibration
01294     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
01295 #endif
01296     (void)MLMESetChannelRequest(testChannel);                               
01297     (void)MLMEPAOutputAdjust(testPower);
01298     PrintTestParameters(TRUE);
01299     evTestParameters = FALSE;
01300   }
01301   
01302   switch(rangeTxState)
01303   {
01304   case gRangeTxStateInit_c:
01305     u32RSSISum = 0;
01306     u16ReceivedPackets = 0;
01307     u16PacketsDropped = 0;
01308     PrintMenu(cu8ShortCutsBar, mAppSer);
01309     PrintMenu(cu8RangeTxTestMenu, mAppSer);
01310     PrintTestParameters(FALSE);
01311     shortCutsEnabled = TRUE;           
01312     rangeTxState = gRangeTxWaitStartTest_c;
01313     break;
01314   case gRangeTxWaitStartTest_c:
01315     if(evDataFromUART)
01316     {
01317       if(' ' == gu8UartData)
01318       {
01319         shortCutsEnabled = FALSE; 
01320         uart.printf( "\f\r\nRange Test Tx Running\r\n");
01321         rangeTxState = gRangeTxStateStartTest_c;
01322         FlaggedDelay_ms(200);
01323       }
01324       else if('p' == gu8UartData)
01325       { 
01326         bBackFlag = TRUE;
01327       }
01328       evDataFromUART = FALSE;
01329     }
01330     break;
01331   case gRangeTxStateStartTest_c:
01332     if(!timePassed) //waiting 200 ms
01333       break;
01334     timePassed = FALSE;
01335     bTxDone = FALSE;
01336     gAppTxPacket->u8DataLength = 16;
01337     gAppTxPacket->smacPdu.smacPdu[0]  = 0;
01338     FLib_MemCpy(&(gAppTxPacket->smacPdu.smacPdu[1]), (void*)"SMAC Range Demo",15);
01339     MLMERXDisableRequest();                                                
01340     //RangeTestTmr.stop();                                           //@CMA, Conn Test. Stop Rx timer
01341     (void)MCPSDataRequest(gAppTxPacket);
01342     rangeTxState = gRangeTxStateRunningTest_c;
01343     break;
01344   case gRangeTxStateRunningTest_c:
01345     if(bTxDone)
01346     {                                         
01347       RangeTestTmr.attach_us(RangeTest_Timer_CallBack, 80000);  //@CMA, Conn Test. Start Timer
01348       SetRadioRxOnNoTimeOut();
01349       rangeTxState = gRangeTxStatePrintTestResults_c;
01350     }
01351     break;
01352   case gRangeTxStatePrintTestResults_c:
01353     if(bRxDone)
01354     {                                                       
01355       if(gAppRxPacket->rxStatus == rxSuccessStatus_c)
01356       { 
01357         if(stringComp((uint8_t*)"SMAC Range Demo",&gAppRxPacket->smacPdu.smacPdu[1],15))
01358         {
01359           u8CurrentRSSI = (gAppRxPacket->smacPdu.smacPdu[0]); 
01360           u32RSSISum += u8CurrentRSSI;  
01361           u16ReceivedPackets++;
01362           u8AverageRSSI = (uint8_t)(u32RSSISum/u16ReceivedPackets);
01363           uart.printf( "\r\n RSSI = -");
01364           uart.printf("%d", (uint32_t)u8CurrentRSSI);   
01365           uart.printf(" dBm");
01366         }
01367         else
01368         {                                   
01369           RangeTestTmr.attach_us(RangeTest_Timer_CallBack, 80000);    //@CMA, Conn Test. Start Timer 
01370           SetRadioRxOnNoTimeOut();                                             
01371         }
01372       }
01373       else
01374       {
01375         u16PacketsDropped++;
01376         uart.printf( "\r\nPacket Dropped");
01377         bRxDone= FALSE;                                                  //@CMA, Conn Test. Added
01378       }
01379       if(evDataFromUART && (' ' == gu8UartData))
01380       {
01381         uart.printf( "\n\r\n\rRange Test Tx Stopped\r\n\r\n");
01382         u8AverageRSSI = (uint8_t)(u32RSSISum/u16ReceivedPackets);
01383         uart.printf( "Average RSSI     -");
01384         uart.printf("%d", (uint32_t)u8AverageRSSI); 
01385         uart.printf(" dBm");
01386         uart.printf( "\r\nPackets dropped ");
01387         uart.printf("%d", (uint32_t)u16PacketsDropped);  
01388         uart.printf( "\r\n\r\n Press [enter] to go back to the Range Tx test menu");
01389         rangeTxState = gRangeTxStateIdle_c;
01390         (void)MLMERXDisableRequest();
01391         AppDelayTmr.stop();
01392         timePassed = FALSE;
01393       }
01394       else
01395       {
01396         rangeTxState = gRangeTxStateStartTest_c;
01397         FlaggedDelay_ms(200);
01398       }
01399       evDataFromUART = FALSE;
01400     } 
01401     
01402     break;
01403   case gRangeTxStateIdle_c:
01404     if((evDataFromUART) && ('\r' == gu8UartData))
01405     {
01406       rangeTxState = gRangeTxStateInit_c;
01407       SelfNotificationEvent();
01408     }
01409     evDataFromUART = FALSE;
01410     break;
01411   default:
01412     break;
01413   }
01414   return bBackFlag;
01415 }
01416 
01417 /************************************************************************************
01418 *
01419 * Range Test Handler for board that is performing RX
01420 *
01421 ************************************************************************************/
01422 bool_t RangeRx(void)
01423 {
01424   bool_t bBackFlag = FALSE;
01425   static uint32_t u32RSSISum;
01426   static uint16_t u16ReceivedPackets;
01427   uint8_t  u8AverageRSSI, u8TempRSSIvalue;
01428   uint8_t  u8CurrentRSSI;
01429   
01430   if(evTestParameters)
01431   {
01432 #if CT_Feature_Calibration
01433     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
01434 #endif
01435     (void)MLMESetChannelRequest(testChannel);                                
01436     (void)MLMEPAOutputAdjust(testPower);
01437     PrintTestParameters(TRUE);
01438     evTestParameters = FALSE;
01439   }
01440   
01441   switch(rangeRxState)
01442   {
01443   case gRangeRxStateInit_c:
01444     u32RSSISum = 0;
01445     u16ReceivedPackets = 0;
01446     PrintMenu(cu8ShortCutsBar, mAppSer);
01447     PrintMenu(cu8RangeRxTestMenu, mAppSer);
01448     PrintTestParameters(FALSE);
01449     shortCutsEnabled = TRUE;           
01450     rangeRxState = gRangeRxWaitStartTest_c;
01451     break;
01452   case gRangeRxWaitStartTest_c:
01453     if(evDataFromUART)
01454     {
01455       if(' ' == gu8UartData)
01456       {
01457         shortCutsEnabled = FALSE; 
01458         uart.printf( "\f\r\nRange Test Rx Running\r\n");
01459         rangeRxState = gRangeRxStateStartTest_c;
01460       }
01461       else if('p' == gu8UartData)
01462       { 
01463         bBackFlag = TRUE;
01464       }
01465       evDataFromUART = FALSE;
01466       SelfNotificationEvent();
01467     }
01468     break;
01469   case gRangeRxStateStartTest_c:
01470     SetRadioRxOnNoTimeOut();
01471     rangeRxState = gRangeRxStateRunningTest_c;
01472     break;
01473   case gRangeRxStateRunningTest_c:
01474     if(evDataFromUART && (' ' == gu8UartData))
01475     {             
01476       (void)MLMERXDisableRequest();
01477       uart.printf( "\n\r\n\rRange Test Rx Stopped\r\n\r\n");
01478       u8AverageRSSI = (uint8_t)(u32RSSISum/u16ReceivedPackets);
01479       uart.printf( "Average RSSI     ");
01480       if(u8AverageRSSI != 0)
01481       {
01482         uart.printf("-");
01483       }
01484       uart.printf("%d", (uint32_t)u8AverageRSSI);  
01485       uart.printf(" dBm");
01486       uart.printf( "\r\n\r\n Press [enter] to go back to the Range Rx test menu");
01487       rangeRxState = gRangeRxStateIdle_c;
01488     }
01489     evDataFromUART = FALSE;
01490     if(bRxDone)
01491     {
01492       if(gAppRxPacket->rxStatus == rxSuccessStatus_c)
01493       { 
01494         if(stringComp((uint8_t*)"SMAC Range Demo",&gAppRxPacket->smacPdu.smacPdu[1],15))
01495         {
01496           bRxDone = FALSE;
01497           FlaggedDelay_ms(4);
01498         }
01499         else
01500         {
01501           SetRadioRxOnNoTimeOut();
01502         }
01503       }
01504       else
01505       {
01506         SetRadioRxOnNoTimeOut();
01507       }
01508     }
01509     if(timePassed)
01510     {
01511       timePassed = FALSE;
01512       bTxDone = FALSE;
01513       u8TempRSSIvalue= u8LastRxRssiValue;                                      
01514       gAppTxPacket->smacPdu.smacPdu[0] = u8TempRSSIvalue;
01515       FLib_MemCpy(&(gAppTxPacket->smacPdu.smacPdu[1]), (void *)"SMAC Range Demo",15);
01516       gAppTxPacket->u8DataLength = 16;
01517       (void)MCPSDataRequest(gAppTxPacket);
01518       rangeRxState = gRangeRxStatePrintTestResults_c;
01519     }
01520     break;
01521   case gRangeRxStatePrintTestResults_c:
01522     if(bTxDone)
01523     {       
01524       u8CurrentRSSI= u8LastRxRssiValue;                                   
01525       u32RSSISum += u8CurrentRSSI;
01526       u16ReceivedPackets++;
01527       u8AverageRSSI = (uint8_t)(u32RSSISum/u16ReceivedPackets);
01528       uart.printf( "\r\n RSSI = -");
01529       uart.printf("%d", (uint32_t)u8CurrentRSSI);   
01530       uart.printf(" dBm");
01531       rangeRxState = gRangeRxStateStartTest_c;
01532       SelfNotificationEvent();
01533     }
01534     break;
01535   case gRangeRxStateIdle_c:
01536     if((evDataFromUART) && ('\r' == gu8UartData))
01537     {
01538       rangeRxState = gRangeRxStateInit_c;
01539       SelfNotificationEvent();
01540     }
01541     evDataFromUART = FALSE;
01542     break;
01543   default:
01544     break;
01545   }
01546   return bBackFlag;
01547 }
01548 
01549 /************************************************************************************
01550 *
01551 * Handler for viewing/modifying XCVR registers
01552 *
01553 ************************************************************************************/
01554 bool_t EditRegisters(void)
01555 {
01556   bool_t bBackFlag = FALSE;
01557   if(evTestParameters)
01558   {
01559 #if CT_Feature_Calibration
01560     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
01561 #endif
01562     (void)MLMESetChannelRequest(testChannel);                                
01563     (void)MLMEPAOutputAdjust(testPower);
01564     PrintTestParameters(TRUE);
01565     evTestParameters = FALSE;
01566   }
01567   
01568   switch(eRState)
01569   {
01570   case gERStateInit_c:
01571     PrintMenu(cu8ShortCutsBar, mAppSer);
01572     PrintMenu(cu8RadioRegistersEditMenu, mAppSer);
01573     PrintTestParameters(FALSE);
01574     shortCutsEnabled = TRUE;           
01575     eRState = gERWaitSelection_c;
01576     break;
01577   case gERWaitSelection_c:
01578     if(evDataFromUART)
01579     {
01580 #if CT_Feature_Direct_Registers
01581       if('1' == gu8UartData)
01582       {
01583         bIsRegisterDirect = TRUE;
01584         oRState = gORStateInit_c;
01585         eRState = gERStateOverrideReg_c;
01586         SelfNotificationEvent();
01587       }
01588       else if('2' == gu8UartData)
01589       {
01590         bIsRegisterDirect = TRUE;
01591         rRState = gRRStateInit_c;
01592         eRState = gERStateReadReg_c;
01593         SelfNotificationEvent();
01594       }
01595 #if CT_Feature_Indirect_Registers
01596       else if('3' == gu8UartData)
01597       {
01598         bIsRegisterDirect = FALSE;
01599         oRState = gORStateInit_c;
01600         eRState = gERStateOverrideReg_c;
01601         SelfNotificationEvent();
01602       }
01603       else if('4' == gu8UartData)
01604       {
01605         bIsRegisterDirect = FALSE;
01606         rRState = gRRStateInit_c;
01607         eRState = gERStateReadReg_c;
01608         SelfNotificationEvent();
01609       }
01610       else if('5' == gu8UartData)
01611       {
01612         dRState = gDRStateInit_c;
01613         eRState  = gERStateDumpAllRegs_c;
01614         SelfNotificationEvent();
01615       }
01616 #else
01617       else if('3' == gu8UartData)
01618       {
01619         dRState = gDRStateInit_c;
01620         eRState  = gERStateDumpAllRegs_c;
01621         SelfNotificationEvent();
01622       }
01623 #endif
01624       else
01625 #endif
01626       if('p' == gu8UartData)
01627       { 
01628         bBackFlag = TRUE;
01629       }
01630       evDataFromUART = FALSE;
01631     }
01632     break;
01633   case gERStateOverrideReg_c:
01634     if(OverrideRegisters()) 
01635     {
01636       eRState = gERStateInit_c;
01637       SelfNotificationEvent();
01638     }    
01639     break;
01640   case gERStateReadReg_c:
01641     if(ReadRegisters()) 
01642     {
01643       eRState = gERStateInit_c;
01644       SelfNotificationEvent();
01645     }    
01646     break;
01647   case gERStateDumpAllRegs_c:
01648     if(DumpRegisters()) {
01649       eRState = gERStateInit_c;
01650       SelfNotificationEvent();
01651     }
01652     break;
01653   default:
01654     break;
01655   }
01656   return bBackFlag;
01657 }
01658 
01659 /************************************************************************************
01660 *
01661 * Dump registers
01662 *
01663 ************************************************************************************/
01664 bool_t DumpRegisters(void)
01665 {
01666   bool_t bBackFlag = FALSE;
01667   
01668   switch(dRState)
01669   {
01670   case gDRStateInit_c:
01671     uart.printf( "\f\r\rDump Registers\r\n");   
01672     uart.printf( "\r\n-Press [space] to dump registers\r\n");
01673     uart.printf( "\r\n-Press [p] Previous Menu\r\n");
01674     shortCutsEnabled = FALSE;   
01675     dRState = gDRStateDumpRegs_c;
01676     SelfNotificationEvent();
01677     break;
01678   case gDRStateDumpRegs_c:
01679     if(evDataFromUART){
01680       if(gu8UartData == 'p') 
01681       {
01682         bBackFlag = TRUE;
01683       }
01684       else if (gu8UartData == ' ') 
01685       {
01686         uart.printf( "\r\n -Dumping registers... \r\n");
01687         const registerLimits_t* interval = registerIntervals;
01688         
01689         while(!((*interval).regStart == 0 && (*interval).regEnd == 0))
01690         {
01691           uart.printf( "\r\n -Access type: ");
01692           if( (*interval).bIsRegisterDirect )
01693             uart.printf("direct\r\n");
01694           else
01695             uart.printf("indirect\r\n");
01696           bIsRegisterDirect = (*interval).bIsRegisterDirect;
01697           ReadRFRegs((*interval).regStart, (*interval).regEnd);
01698           interval++;
01699         }
01700         dRState = gDRStateInit_c;
01701         SelfNotificationEvent();
01702       }
01703     }
01704     evDataFromUART = FALSE;
01705     break;
01706   default:
01707     break;
01708   }
01709   return bBackFlag;  
01710 }
01711 
01712 /************************************************************************************
01713 *
01714 * Read and print register values with addresses from u8RegStartAddress 
01715 * to u8RegStopAddress
01716 *
01717 ************************************************************************************/
01718 void ReadRFRegs(registerAddressSize_t rasRegStartAddress, registerAddressSize_t rasRegStopAddress)
01719 { 
01720   
01721   static uint16_t rasRegAddress; 
01722   registerSize_t rsRegValue; 
01723   uart.printf( " ---------------------------------------  "); 
01724   for(rasRegAddress = rasRegStartAddress; rasRegAddress <= rasRegStopAddress; rasRegAddress+=(gRegisterSize_c))
01725   { 
01726     uart.printf( "\r\n|    Address : 0x"); 
01727     uart.printf("%x", (uint8_t*)rasRegAddress); 
01728     aspTestRequestMsg.msgType = aspMsgTypeXcvrReadReq_c;
01729     aspTestRequestMsg.msgData.aspXcvrData.addr = (uint16_t)rasRegAddress;
01730     aspTestRequestMsg.msgData.aspXcvrData.len  = gRegisterSize_c;
01731     aspTestRequestMsg.msgData.aspXcvrData.mode = !bIsRegisterDirect;
01732     
01733     APP_ASP_SapHandler(&aspTestRequestMsg, 0);
01734     rsRegValue = *((registerSize_t*)aspTestRequestMsg.msgData.aspXcvrData.data);              
01735     uart.printf( " Data value : 0x");                
01736     uart.printf("%x", (uint8_t*)rsRegValue);  
01737     uart.printf( "   |");
01738   }    
01739   uart.printf( "\r\n ---------------------------------------  \r\n"); 
01740 }
01741 
01742 /************************************************************************************
01743 *
01744 * Read register
01745 *
01746 ************************************************************************************/
01747 bool_t ReadRegisters(void)
01748 {
01749   bool_t bBackFlag = FALSE;
01750   static uint8_t au8RxString[5];
01751   static uint8_t u8Index;
01752   static registerAddressSize_t rasRegAddress;
01753   static registerSize_t rsRegValue;
01754   static char    auxToPrint[2];
01755   
01756   switch(rRState)
01757   {
01758   case gRRStateInit_c:
01759     uart.printf( "\f\r\rRead Registers\r\n");           
01760     uart.printf( "\r\n-Press [p] Previous Menu\r\n");
01761     shortCutsEnabled = FALSE;   
01762     rRState = gRRStateStart_c;
01763     SelfNotificationEvent();
01764     break;
01765   case gRRStateStart_c:
01766     uart.printf( "\r\n -write the Register address in Hex and [enter]: 0x");
01767     u8Index = 0;
01768     rRState = gRRWaitForTheAddress_c; 
01769     break;
01770   case gRRWaitForTheAddress_c:
01771     if(evDataFromUART)
01772     {
01773       if((!isAsciiHex(gu8UartData)) && ('\r' != gu8UartData))
01774       {
01775         if('p' == gu8UartData)
01776         { 
01777           bBackFlag = TRUE;
01778         }
01779         else
01780         {
01781           uart.printf( "\r\n -Invalid Character!! ");
01782           rRState = gRRStateStart_c; 
01783           SelfNotificationEvent();
01784         }
01785       }
01786       else if((gRegisterAddressASCII_c == u8Index) && ('\r' != gu8UartData))
01787       { 
01788         uart.printf( "\r\n -Value out of Range!! ");
01789         rRState = gRRStateStart_c;
01790         SelfNotificationEvent();
01791       }
01792       else if(isAsciiHex(gu8UartData))
01793       {
01794         au8RxString[u8Index++] = gu8UartData;
01795         auxToPrint[0] = gu8UartData;
01796         auxToPrint[1] = '\0';
01797         uart.printf( auxToPrint);
01798       }
01799       else
01800       {
01801         au8RxString[u8Index] = 0;
01802         rasRegAddress = (registerAddressSize_t)HexString2Dec(au8RxString);
01803         aspTestRequestMsg.msgType = aspMsgTypeXcvrReadReq_c;
01804         aspTestRequestMsg.msgData.aspXcvrData.addr = (uint16_t)rasRegAddress;
01805         aspTestRequestMsg.msgData.aspXcvrData.len  = gRegisterSize_c;
01806         aspTestRequestMsg.msgData.aspXcvrData.mode = !bIsRegisterDirect;
01807         APP_ASP_SapHandler(&aspTestRequestMsg, 0);
01808         rsRegValue = *((registerSize_t*)aspTestRequestMsg.msgData.aspXcvrData.data);
01809         
01810         uart.printf( "\r\n -Register value : 0x");
01811         uart.printf("%x", (uint8_t*)rsRegValue);
01812         uart.printf( "\r\n");
01813         
01814         rRState = gRRStateStart_c; 
01815         SelfNotificationEvent();
01816       }
01817       evDataFromUART = FALSE;
01818     }
01819     break;
01820   default:
01821     break;
01822   }
01823   return bBackFlag;  
01824 }
01825 
01826 /************************************************************************************
01827 *
01828 * Override Register
01829 *
01830 ************************************************************************************/
01831 bool_t OverrideRegisters(void)
01832 {
01833   bool_t bBackFlag = FALSE;
01834   static uint8_t au8RxString[5];
01835   static uint8_t u8Index;
01836   static registerAddressSize_t rasRegAddress;
01837   static registerSize_t rsRegValue;
01838   static char auxToPrint[2];
01839   
01840   switch(oRState)
01841   {
01842   case gORStateInit_c:
01843     uart.printf("\f\r\nWrite Registers\r\n");          
01844     uart.printf("\r\n-Press [p] Previous Menu\r\n");
01845     shortCutsEnabled = FALSE;   
01846     oRState = gORStateStart_c;
01847     SelfNotificationEvent();
01848     break;
01849   case gORStateStart_c:
01850     uart.printf("\r\n -write the Register address in Hex and [enter]: 0x");
01851     u8Index = 0;
01852     oRState = gORWaitForTheAddress_c; 
01853     break;
01854   case gORWaitForTheAddress_c:
01855     if(evDataFromUART){
01856       if((!isAsciiHex(gu8UartData)) && ('\r' != gu8UartData))
01857       {
01858         if('p' == gu8UartData)
01859         { 
01860           bBackFlag = TRUE;
01861         }
01862         else
01863         {
01864           uart.printf("\r\n -Invalid Character!! ");
01865           oRState = gORStateStart_c;  
01866           SelfNotificationEvent();
01867         }
01868       }
01869       else if((gRegisterAddressASCII_c == u8Index) && ('\r' != gu8UartData))
01870       { 
01871         uart.printf("\r\n -Value out of Range!! ");
01872         oRState = gORStateStart_c;
01873         SelfNotificationEvent();
01874       }
01875       else if(isAsciiHex(gu8UartData))
01876       {
01877         au8RxString[u8Index++] = gu8UartData;
01878         auxToPrint[0] = gu8UartData;
01879         auxToPrint[1] = '\0';
01880         uart.printf(auxToPrint);
01881       }
01882       else
01883       {
01884         au8RxString[u8Index] = 0;
01885         rasRegAddress = (registerAddressSize_t)HexString2Dec(au8RxString);
01886         uart.printf("\r\n -write the Register value to override in Hex and [enter]: 0x");
01887         u8Index = 0;
01888         oRState = gORWaitForTheValue_c; 
01889       }
01890       evDataFromUART = FALSE;
01891     }
01892     break;
01893   case gORWaitForTheValue_c:
01894     if(evDataFromUART)
01895     {
01896       if((!isAsciiHex(gu8UartData)) && ('\r' != gu8UartData))
01897       {
01898         if('p' == gu8UartData)
01899         { 
01900           bBackFlag = TRUE;
01901         }
01902         else
01903         {
01904           uart.printf("\r\n -Invalid Character!! ");
01905           oRState = gORStateStart_c;  
01906           SelfNotificationEvent();
01907         }
01908       }
01909       else if((2 == u8Index) && ('\r' != gu8UartData))
01910       { 
01911         uart.printf("\r\n -Value out of Range!! ");
01912         oRState = gORStateStart_c;  
01913         SelfNotificationEvent();
01914       }
01915       else if(isAsciiHex(gu8UartData))
01916       {
01917         au8RxString[u8Index++] = gu8UartData;
01918         auxToPrint[0] = gu8UartData;
01919         auxToPrint[1] = '\0';
01920         uart.printf(auxToPrint);
01921       }
01922       else
01923       {
01924         au8RxString[u8Index] = 0;
01925         rsRegValue = (registerSize_t)HexString2Dec(au8RxString);
01926         aspTestRequestMsg.msgType = aspMsgTypeXcvrWriteReq_c;
01927         aspTestRequestMsg.msgData.aspXcvrData.addr = (uint16_t)rasRegAddress;
01928         aspTestRequestMsg.msgData.aspXcvrData.len  = gRegisterAddress_c;
01929         aspTestRequestMsg.msgData.aspXcvrData.mode = !bIsRegisterDirect;
01930         FLib_MemCpy(aspTestRequestMsg.msgData.aspXcvrData.data, &rsRegValue, gRegisterSize_c);
01931         APP_ASP_SapHandler(&aspTestRequestMsg, 0);
01932         
01933         uart.printf("\r\n Register overridden \r\n");
01934         u8Index = 0;
01935         oRState = gORStateStart_c; 
01936         SelfNotificationEvent();
01937       }
01938       evDataFromUART = FALSE;
01939     }
01940     break;
01941   default:
01942     break;
01943   }
01944   return bBackFlag;  
01945 }
01946 
01947 /************************************************************************************
01948 *
01949 * Handler for Carrier Sense Test and Transmission Control Test
01950 *
01951 ************************************************************************************/
01952 bool_t CSenseAndTCtrl(void)
01953 {
01954   bool_t bBackFlag = FALSE;
01955   static uint8_t testSelector = 0;
01956   
01957   if(evTestParameters){
01958     (void)MLMESetChannelRequest(testChannel);   
01959 #if CT_Feature_Calibration
01960     (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
01961 #endif
01962     (void)MLMEPAOutputAdjust(testPower);
01963     PrintTestParameters(TRUE);
01964     evTestParameters = FALSE;
01965   }
01966   
01967   switch(cstcState)
01968   {
01969   case gCsTcStateInit_c:
01970     TestMode(gTestModeForceIdle_c);
01971     PrintMenu(cu8ShortCutsBar, mAppSer);
01972     PrintMenu(cu8RadioCSTCSelectMenu, mAppSer);
01973     PrintTestParameters(FALSE);
01974     shortCutsEnabled = TRUE;
01975     bTxDone = FALSE;
01976     bScanDone = FALSE;
01977     timePassed = FALSE;
01978     
01979     cstcState = gCsTcStateSelectTest_c;
01980     break;
01981   case gCsTcStateSelectTest_c:
01982     if(evDataFromUART)
01983     {
01984       if('1' == gu8UartData)
01985       {
01986         cstcState = gCsTcStateCarrierSenseStart_c;
01987         testSelector = 1;
01988         SelfNotificationEvent();
01989       }
01990       else if ('2' == gu8UartData)
01991       {
01992         cstcState = gCsTcStateTransmissionControlStart_c;
01993         testSelector = 2;
01994         SelfNotificationEvent();
01995       }
01996       else if( 'p' == gu8UartData)
01997       {
01998         cstcState = gCsTcStateInit_c;
01999         testSelector = 0;
02000         bBackFlag = TRUE;
02001       }
02002       evDataFromUART = FALSE;
02003     }
02004     break;
02005   default:
02006     if(testSelector == 1)
02007       CarrierSenseHandler();
02008     else if(testSelector == 2)
02009       TransmissionControlHandler();
02010     break;
02011   }
02012   return bBackFlag;  
02013 }
02014 
02015 /************************************************************************************
02016 *
02017 * Handler for Transmission Control Test called by above function
02018 *
02019 ************************************************************************************/
02020 void TransmissionControlHandler(void)
02021 {
02022   const uint16_t u16TotalPacketsOptions[] = {1,25,100,500,1000,2000,5000,10000,65535};
02023   static uint16_t u16TotalPackets;
02024   static uint16_t u16PacketCounter = 0;
02025   static uint16_t miliSecDelay = 0;
02026   static phyTime_t startTime;
02027   int8_t fillIndex = 0;
02028   uint8_t* smacPduPtr;
02029   uint32_t totalTimeMs;
02030   
02031   switch(cstcState)
02032   {
02033   case gCsTcStateTransmissionControlStart_c:
02034     PrintMenu(cu8ShortCutsBar, mAppSer);
02035     PrintMenu(cu8CsTcTestMenu, mAppSer);
02036     PrintTestParameters(FALSE);
02037     miliSecDelay = 0;
02038     u16TotalPackets = 0;
02039     u16PacketCounter = 0;
02040     fillIndex = testPayloadLen / gPrbs9BufferLength_c;
02041     
02042     while(fillIndex > 0)
02043     {
02044       fillIndex--;
02045       smacPduPtr = gAppTxPacket->smacPdu.smacPdu + fillIndex * gPrbs9BufferLength_c;
02046       FLib_MemCpy(smacPduPtr, u8Prbs9Buffer, gPrbs9BufferLength_c);
02047     }
02048     smacPduPtr = gAppTxPacket->smacPdu.smacPdu + ((testPayloadLen / gPrbs9BufferLength_c)*gPrbs9BufferLength_c);
02049     FLib_MemCpy(smacPduPtr, u8Prbs9Buffer, (testPayloadLen % gPrbs9BufferLength_c));
02050     
02051     gAppTxPacket->u8DataLength = testPayloadLen;
02052     
02053     cstcState = gCsTcStateTransmissionControlSelectNumOfPackets_c;
02054     break;
02055   case gCsTcStateTransmissionControlSelectNumOfPackets_c:
02056     if(evDataFromUART)
02057     {
02058       if((gu8UartData >= '0') && (gu8UartData <= '8'))
02059       {
02060         u16TotalPackets = u16TotalPacketsOptions[gu8UartData - '0'];  
02061         cstcState = gCsTcStateTransmissionControlSelectInterpacketDelay_c;
02062         uart.printf("\r\n\r\n Please type InterPacket delay in miliseconds and press [ENTER]");
02063         uart.printf("\r\n(During test, exit by pressing [SPACE])\r\n\r\n");
02064         SelfNotificationEvent();
02065       }
02066       else if('p' == gu8UartData)
02067       { 
02068         cstcState = gCsTcStateInit_c;
02069         SelfNotificationEvent();
02070       }
02071       evDataFromUART = FALSE;
02072     }
02073     break;
02074   case gCsTcStateTransmissionControlSelectInterpacketDelay_c:
02075     if(evDataFromUART)
02076     {
02077       if(gu8UartData == '\r' && miliSecDelay != 0)
02078       {
02079         cstcState = gCsTcStateTransmissionControlPerformingTest_c;
02080         startTime = GetTimestampUS();
02081         (void)MLMEScanRequest(testChannel);
02082       }
02083       else if((gu8UartData >= '0') && (gu8UartData <='9'))
02084       {
02085         miliSecDelay = miliSecDelay*10 + (gu8UartData - '0');
02086         uart.printf("%d",(uint32_t)(gu8UartData - '0'));
02087       }
02088       else if('p' == gu8UartData)
02089       { 
02090         cstcState = gCsTcStateInit_c;
02091         SelfNotificationEvent();
02092       }
02093       evDataFromUART = FALSE;
02094     }
02095     break;
02096   case gCsTcStateTransmissionControlPerformingTest_c:
02097     if(bScanDone)
02098     {
02099       bScanDone = FALSE;
02100       (void)MCPSDataRequest(gAppTxPacket);
02101     }
02102     if(bTxDone)
02103     {
02104       bTxDone = FALSE;                                                  
02105       u16PacketCounter++;
02106       uart.printf("\r\n\tPacket number: ");
02107       uart.printf("%d", (uint32_t)(u16PacketCounter));
02108       uart.printf("; RSSI value: -");
02109       uart.printf("%d",(uint32_t)au8ScanResults[testChannel]);
02110       uart.printf(" dBm\r\n");
02111       if(u16PacketCounter < u16TotalPackets)
02112       {
02113         totalTimeMs  = (uint32_t)(GetTimestampUS() - startTime);
02114         totalTimeMs -= GetTransmissionTime(testPayloadLen, crtBitrate);
02115         totalTimeMs = (totalTimeMs % 1000 < 500) ? totalTimeMs/1000 : (totalTimeMs/1000)+1;
02116         if(totalTimeMs > miliSecDelay)
02117         {
02118           uart.printf( " Overhead + Transmission + ED = ~");
02119           uart.printf("%d", totalTimeMs);
02120           uart.printf("ms\r\n Interpacket delay too small (Press [ENTER] to continue)\r\n");
02121           cstcState = gCsTcStateTransmissionControlEndTest_c;
02122           SelfNotificationEvent();
02123           break;
02124         }
02125         FlaggedDelay_ms(miliSecDelay - totalTimeMs);
02126       }
02127       else
02128       {        
02129         uart.printf("\r\n\r\nFinished transmitting ");
02130         uart.printf("%d", (uint32_t)u16TotalPackets);
02131         uart.printf(" packets!\r\n\r\n");
02132         uart.printf("\r\n -Press [ENTER] to end Transmission Control Test");
02133         cstcState = gCsTcStateTransmissionControlEndTest_c;
02134       }
02135     }
02136     if(timePassed)
02137     {
02138       timePassed = FALSE;
02139       startTime = GetTimestampUS();
02140       (void)MLMEScanRequest(testChannel);
02141     }
02142     if(evDataFromUART && gu8UartData == ' ')
02143     {
02144       uart.printf("\r\n\r\n-Test interrupted by user. Press [ENTER] to continue\r\n\r\n");
02145       cstcState = gCsTcStateTransmissionControlEndTest_c;
02146     }
02147     break;
02148   case gCsTcStateTransmissionControlEndTest_c:    
02149     if(evDataFromUART && gu8UartData == '\r')
02150     {
02151       cstcState = gCsTcStateInit_c;
02152       SelfNotificationEvent();
02153     }
02154     evDataFromUART = FALSE;
02155     break;
02156   }
02157 }
02158 /************************************************************************************
02159 *
02160 * Handler for Carrier Sense Test
02161 *
02162 ************************************************************************************/
02163 void CarrierSenseHandler(void)
02164 {
02165   int8_t fillIndex = 0;
02166   uint8_t* smacPduPtr;
02167   switch(cstcState)
02168   {
02169   case gCsTcStateCarrierSenseStart_c:
02170 #if CT_Feature_Calibration
02171     if( gMode1Bitrate_c == crtBitrate )
02172     {
02173       (void)MLMESetAdditionalRFOffset(gOffsetIncrement + 30);
02174     }
02175     else
02176     {
02177       (void)MLMESetAdditionalRFOffset(gOffsetIncrement + 60);
02178     }
02179 #endif
02180     (void)MLMESetChannelRequest(testChannel);
02181     
02182     uart.printf( "\r\n\r\n Press [SPACE] to begin/interrupt test");
02183     uart.printf(  "\r\n Press [p] to return to previous menu");
02184 //    PrintTestParameters(FALSE);
02185     shortCutsEnabled = FALSE;
02186     uart.printf("\r\n");
02187     
02188     fillIndex = testPayloadLen / gPrbs9BufferLength_c;
02189     while(fillIndex > 0)
02190     {
02191       fillIndex--;
02192       smacPduPtr = gAppTxPacket->smacPdu.smacPdu + fillIndex * gPrbs9BufferLength_c;
02193       FLib_MemCpy(smacPduPtr, u8Prbs9Buffer, gPrbs9BufferLength_c);
02194     }
02195     smacPduPtr = gAppTxPacket->smacPdu.smacPdu + ((testPayloadLen / gPrbs9BufferLength_c)*gPrbs9BufferLength_c);
02196     FLib_MemCpy(smacPduPtr, u8Prbs9Buffer, (testPayloadLen % gPrbs9BufferLength_c));
02197     
02198     gAppTxPacket->u8DataLength = testPayloadLen;
02199     
02200     cstcState = gCsTcStateCarrierSenseSelectType_c;
02201     break;
02202   case gCsTcStateCarrierSenseSelectType_c:
02203     if(evDataFromUART)
02204     {
02205       if(' ' == gu8UartData)
02206       {
02207         cstcState = gCsTcStateCarrierSensePerformingTest_c;
02208         (void)MLMEScanRequest(testChannel);
02209       }
02210       else if ('p' == gu8UartData)
02211       {
02212 #if CT_Feature_Calibration
02213         (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
02214 #endif
02215         (void)MLMESetChannelRequest(testChannel);
02216         cstcState = gCsTcStateInit_c;
02217         SelfNotificationEvent();
02218       }
02219       evDataFromUART = FALSE;
02220     }
02221     break;
02222   case gCsTcStateCarrierSensePerformingTest_c:
02223     if(bScanDone)
02224     {
02225       bScanDone = FALSE;
02226       uart.printf( "\r\n\tSampling done. RSSI value: -");
02227       uart.printf("%d", (uint32_t) au8ScanResults[testChannel]);
02228       uart.printf( "dBm");
02229       if(au8ScanResults[testChannel] > ccaThresh)
02230       {
02231         (void)MCPSDataRequest(gAppTxPacket);
02232       }
02233       else
02234       {
02235           (void)MLMEScanRequest(testChannel);
02236       }
02237     }
02238     if(bTxDone)
02239     {
02240       bTxDone = FALSE;
02241 
02242       uart.printf("\r\n Transmission Performed\r\n");
02243       uart.printf("\r\n -Press [ENTER] to end Carrier Sense Test");
02244       cstcState = gCsTcStateCarrierSenseEndTest_c;
02245     }
02246     if(evDataFromUART && gu8UartData == ' ')
02247     {
02248       uart.printf("\r\n\r\n-Test interrupted by user. Press [ENTER] to continue\r\n\r\n");
02249       cstcState = gCsTcStateCarrierSenseEndTest_c;
02250     }
02251     break;
02252   case gCsTcStateCarrierSenseEndTest_c:
02253     if(evDataFromUART && gu8UartData == '\r')
02254     {
02255 #if CT_Feature_Calibration
02256       (void)MLMESetAdditionalRFOffset(gOffsetIncrement);
02257 #endif
02258       (void)MLMESetChannelRequest(testChannel);
02259       cstcState = gCsTcStateInit_c;
02260       SelfNotificationEvent();
02261     }
02262     evDataFromUART = FALSE;
02263     break;
02264   }
02265 }
02266 
02267 /************************************************************************************
02268 *
02269 * Auxiliary Functions
02270 *
02271 ************************************************************************************/
02272 
02273 /**************************************************************************************/
02274 void SetRadioRxOnNoTimeOut(void)
02275 {
02276   bRxDone = FALSE;
02277   gAppRxPacket->u8MaxDataLength = gMaxSmacSDULength_c;
02278   (void)MLMERXEnableRequest(gAppRxPacket, 0);
02279 }
02280 
02281 /**************************************************************************************/
02282 void PrintPerRxFinalLine(uint16_t u16Received, uint16_t u16Total)
02283 {
02284   uart.printf("Received ");
02285   uart.printf("%d",(uint32_t)u16Received);
02286   uart.printf(" of ");
02287   uart.printf("%d",(uint32_t)u16Total);
02288   uart.printf(" packets transmitted \r\n");
02289   uart.printf("\r\n Press [enter] to go back to the Per Rx test menu");
02290 }
02291 
02292 /************************************************************************************
02293 * 
02294 * 
02295 * By employing this function, users can execute a test of the radio. Test mode 
02296 * implements the following:
02297 *   -PRBS9 Mode, 
02298 *   -Force_idle, 
02299 *   -Continuos TX without modulation, 
02300 *   -Continuos TX with modulation.(0's,1's and PN patterns)
02301 *
02302 ************************************************************************************/
02303 smacErrors_t TestMode
02304 (
02305 smacTestMode_t  mode  /*IN: The test mode to start.*/
02306 )
02307 {
02308   aspTestRequestMsg.msgType = aspMsgTypeTelecTest_c;
02309   
02310 #if(TRUE == smacParametersValidation_d)
02311   if(gMaxTestMode_c <= mode)
02312   {
02313     return gErrorOutOfRange_c;
02314   }
02315 #endif
02316   
02317   if(gTestModeForceIdle_c == mode)
02318   {
02319     aspTestRequestMsg.msgData.aspTelecTest.mode = gTestForceIdle_c;
02320   }                                                                             
02321   else if(gTestModeContinuousTxModulated_c == mode)
02322   {
02323     if(contTxModBitValue==gContTxModSelectOnes_c)
02324     {
02325       aspTestRequestMsg.msgData.aspTelecTest.mode = gTestContinuousTxNoModOne_c;
02326     }
02327     else if(contTxModBitValue == gContTxModSelectZeros_c)
02328     {
02329       aspTestRequestMsg.msgData.aspTelecTest.mode = gTestContinuousTxNoModZero_c;
02330     }
02331     else if(contTxModBitValue == gContTxModSelectPN9_c)
02332     {
02333 #ifdef gPHY_802_15_4g_d
02334       aspTestRequestMsg.msgData.aspTelecTest.mode = gTestContinuousTxContPN9_c;
02335 #else
02336       aspTestRequestMsg.msgData.aspTelecTest.mode = gTestPulseTxPrbs9_c;
02337 #endif
02338     }
02339   } 
02340   else if(gTestModeContinuousTxUnmodulated_c == mode)
02341   { 
02342     aspTestRequestMsg.msgData.aspTelecTest.mode = gTestContinuousTxNoMod_c;
02343   } 
02344   else if(gTestModeContinuousRxBER_c == mode)
02345   {
02346     aspTestRequestMsg.msgData.aspTelecTest.mode = gTestContinuousRx_c;
02347   }
02348   else if(gTestModePRBS9_c == mode)
02349   {   
02350     /*Set Data Mode*/
02351     gAppTxPacket->u8DataLength = gPrbs9BufferLength_c;
02352     FLib_MemCpy(gAppTxPacket->smacPdu.smacPdu, u8Prbs9Buffer, gPrbs9BufferLength_c);
02353     PacketHandler_Prbs9(); 
02354   }
02355   if(gTestModePRBS9_c != mode)
02356     (void)APP_ASP_SapHandler(&aspTestRequestMsg, 0);
02357   
02358   return gErrorNoError_c;
02359 }
02360 
02361 /************************************************************************************
02362 * PacketHandler_Prbs9
02363 * 
02364 * This function sends OTA the content of a PRBS9 polynomial of 65 bytes of payload.
02365 *
02366 *
02367 ************************************************************************************/
02368 
02369 void PacketHandler_Prbs9(void)                                                  
02370 {
02371   smacErrors_t err;
02372   /*@CMA, Need to set Smac to Idle in order to get PRBS9 to work after a second try on the Conn Test menu*/
02373   (void)MLMERXDisableRequest();                                               
02374   (void)MLMETXDisableRequest();
02375   err = MCPSDataRequest(gAppTxPacket);  
02376   if(err != gErrorNoError_c)
02377   {
02378     failedPRBS9 = TRUE;
02379     SelfNotificationEvent(); //in case data isn't sent, no confirm event will fire. 
02380     //this way we need to make sure the application will not freeze.
02381   }
02382 }
02383 
02384 /*****************************************************************************
02385 * UartRxCallBack function
02386 *
02387 * Interface assumptions:
02388 * This callback is triggered when a new byte is received over the UART
02389 *
02390 * Return Value:
02391 * None
02392 *****************************************************************************/
02393 void UartRxCallBack(void) 
02394 {
02395   gu8UartData = uart.getc();
02396   gTaskEventFlags |= gUART_RX_EVENT_c;
02397   mainTask->signal_set(gEventsAny_c);  
02398 }
02399 
02400 /*@CMA, Conn Test. Range Test CallBack*/
02401 void RangeTest_Timer_CallBack ()
02402 {
02403   gTaskEventFlags |= gRangeTest_EVENT_c;
02404   mainTask->signal_set(gEventsAny_c);  
02405 }
02406 
02407 
02408 
02409 /************************************************************************************
02410 *
02411 * Increments channel on the ED Confirm event and fires a new ED measurement request
02412 *
02413 ************************************************************************************/
02414 void IncrementChannelOnEdEvent()
02415 {
02416   bScanDone = FALSE;
02417   smacErrors_t err;
02418   if (ChannelToScan <= gMaxChannel_c)                              
02419   {                                                                  
02420     err = MLMEScanRequest((channels_t)ChannelToScan);                                          
02421     if(err == gErrorNoError_c)
02422       ChannelToScan++;                                                //Increment channel to scan
02423   }
02424   else 
02425   {
02426     bScanDone = TRUE;                                               //PRINT ALL CHANNEL RESULTS
02427     FlaggedDelay_ms(300);                                           //Add delay between channel scanning series.
02428   } 
02429 }
02430 
02431 /***********************************************************************
02432 *********************Utilities Software********************************
02433 ************************************************************************/
02434 
02435 bool_t stringComp(uint8_t * au8leftString, uint8_t * au8RightString, uint8_t bytesToCompare)
02436 {
02437   do
02438   {
02439   }while((*au8leftString++ == *au8RightString++) && --bytesToCompare);
02440   return(0 == bytesToCompare);
02441 }
02442 
02443 uint32_t HexString2Dec(uint8_t* au8String)
02444 {
02445   uint8_t u8LocIndex=0;
02446   uint8_t u8LocIndex2=0;
02447   uint32_t u32DecValue = 0;
02448   
02449   while(au8String[u8LocIndex]){
02450     u8LocIndex++;
02451   }
02452   
02453   while(u8LocIndex--){
02454     if((au8String[u8LocIndex] >= '0') && (au8String[u8LocIndex] <= '9'))
02455       u32DecValue |= ((uint32_t)(au8String[u8LocIndex] - '0'))<<(u8LocIndex2*4);
02456     else if((au8String[u8LocIndex] >= 'A') && (au8String[u8LocIndex] <= 'F')){
02457       u32DecValue |= ((uint32_t)(au8String[u8LocIndex] - 'A' + 0x0A))<<(u8LocIndex2*4);    
02458     }else{
02459       u32DecValue |= ((uint32_t)(au8String[u8LocIndex] - 'a' + 0x0A))<<(u8LocIndex2*4);        
02460     }
02461     u8LocIndex2++;
02462   }
02463   
02464   return u32DecValue;
02465 }
02466 
02467 static void DelayTimeElapsed()
02468 {
02469   timePassed = TRUE;
02470   gTaskEventFlags |= gTimePassed_EVENT_c;
02471   mainTask->signal_set(gEventsAny_c);  
02472 }
02473 
02474 /***********************************************************************************
02475 *
02476 * PrintMenu
02477 *
02478 ************************************************************************************/
02479 void PrintMenu(char * const pu8Menu[], uint8_t port)
02480 {
02481   uint8_t u8Index = 0;
02482   (void)port;
02483   while(pu8Menu[u8Index]){
02484     uart.printf(pu8Menu[u8Index]);
02485     u8Index++;
02486   }
02487 }
02488 
02489 /***********************************************************************
02490 ************************************************************************/
02491 
02492 /************************************************************************************
02493 *
02494 * PrintTestParameters
02495 *
02496 ************************************************************************************/
02497 void PrintTestParameters(bool_t bEraseLine)
02498 {
02499   uint8_t u8lineLen = 63;
02500   uint8_t u8Index;
02501   
02502   if(bEraseLine)
02503   {
02504     for(u8Index = 0;u8Index<u8lineLen;u8Index++)
02505     {
02506       uart.printf("\b");
02507     }
02508   }
02509   
02510   uart.printf("Mode ");
02511   if(mTxOperation_c == testOpMode)
02512   {
02513     uart.printf("Tx");
02514   }
02515   else
02516   {
02517     uart.printf("Rx");
02518   }
02519   uart.printf(", Channel ");
02520   uart.printf("%d", (uint32_t)testChannel);
02521   uart.printf(", Power ");
02522   uart.printf("%d",(uint32_t)testPower);
02523   uart.printf(", Payload ");
02524   uart.printf("%d", (uint32_t)testPayloadLen);
02525   uart.printf(", CCA Thresh ");
02526   if(ccaThresh != 0)
02527   {
02528     uart.printf("-");
02529   }
02530   uart.printf("%d", (uint32_t)ccaThresh);
02531   uart.printf("dBm");
02532   uart.printf(" >");
02533 }
02534 /*****************************************************************************/
02535 
02536 void uart_task(void const *args)
02537 {
02538    while(1)
02539    {
02540      if(uart.readable())
02541      {
02542        UartRxCallBack();
02543      }
02544    }
02545 }
02546 
02547 int main()
02548 {
02549   mainTask = new Thread(main_task);
02550   uartTask = new Thread(uart_task);
02551   while(1)
02552   {
02553     
02554   }
02555   return 0;
02556 }