main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 
00004 #include "Phy.h"
00005 #include "SMAC_Interface.h"
00006 #include "SMAC_Config.h"
00007 #include "MemManager.h"
00008 #include "circular_buffer.h"
00009 
00010 char * const cu8FreescaleLogo[]={  
00011   "\f\r\n",
00012   "\n\r\n\r\n\r      #\n",
00013   "\r     ###\n",
00014   "\r    ###  *\n",
00015   "\r     #  ***\n",
00016   "\r       ***  #\n",
00017   "\r        *  ###\n",
00018   "\r          ###\n",
00019   "\r        *  #\n",
00020   "\r       ***\n",
00021   "\r      ***  #\n",
00022   "\r    #  *  ###\n",
00023   "\r   ###   ###\n",
00024   "\r  ###  *  #         F R E E S C A L E\n",
00025   "\r   #  ***\n",
00026   "\r     ***            S E M I C O N D U C T O R\n",
00027   "\r   #  *\n",
00028   "\r  ###               2 0 1 5\n",
00029   "\r ###\n",
00030   "\r  #           Wireless Uart Demo\r\n\n",
00031   NULL
00032 };
00033 
00034 #define gMcps_Cnf_EVENT_c        (1<<1)
00035 #define gMcps_Ind_EVENT_c        (1<<2)
00036 #define gMlme_EdCnf_EVENT_c      (1<<3)
00037 #define gMlme_CcaCnf_EVENT_c     (1<<4)
00038 #define gMlme_TimeoutInd_EVENT_c (1<<5)
00039 #define gWUSelf_EVENT_c          (1<<6)
00040 
00041 #define gDefaultBaudRate_UART_c 115200UL
00042 
00043 Serial uart(USBTX, USBRX);
00044 CircularBuffer uartBuf;
00045 
00046 #ifdef VERBOSE
00047 static bool_t bCCAFailed;
00048 static bool_t bACKFailed;
00049 #endif
00050 uint32_t gTaskEventFlags;
00051 static uint8_t gau8TxDataBuffer[gMaxSmacSDULength_c  + sizeof(rxPacket_t)];  
00052 txPacket_t *gAppTxPacket;
00053 rxPacket_t *gAppRxPacket;
00054 static txContextConfig_t txConfigContext;
00055 
00056 
00057 void PrintMenu(char * const pu8Menu[])
00058 {
00059   uint8_t u8Index = 0;
00060   while(pu8Menu[u8Index]){
00061     uart.printf(pu8Menu[u8Index]);
00062     u8Index++;
00063   }
00064 }
00065 
00066 
00067 void InitProject(void);
00068 void InitApp(void);
00069 
00070 extern smacErrors_t smacToAppMlmeSap(smacToAppMlmeMessage_t* pMsg, instanceId_t instance);
00071 extern smacErrors_t smacToAppMcpsSap(smacToAppDataMessage_t* pMsg, instanceId_t instance);
00072 
00073 DigitalOut led1(LED_GREEN);
00074 InterruptIn sw2(SW2);
00075 uint32_t button_pressed;
00076 Thread *thread2;
00077 Thread *eventsThread;
00078 
00079 void uartSetBaudRate(uint32_t b)
00080 {
00081     uart.baud(b);
00082 }
00083 
00084 void sw2_press(void)
00085 {
00086     thread2->signal_set(0x1);
00087 }
00088 
00089 void led_thread(void const *argument)
00090 {
00091     while (true) {
00092         led1 = !led1;
00093         Thread::wait(200);
00094     }
00095 }
00096 
00097 void button_thread(void const *argument)
00098 {
00099     while (true) {
00100         Thread::signal_wait(0x1);
00101         button_pressed++;
00102     }
00103 }
00104 
00105 void events_thread(void const *argument)
00106 {
00107     uint8_t rcvd = 0, c = 0; 
00108 
00109     while (true)
00110     {
00111         Thread::signal_wait(0x1);
00112         if(gMcps_Cnf_EVENT_c == (gTaskEventFlags & gMcps_Cnf_EVENT_c))
00113         {
00114             //get back in RX
00115             MLMERXEnableRequest(gAppRxPacket, 0); 
00116             //uart.printf("McpsDataCnf: Packet sent\r\n");
00117 
00118         }
00119         
00120         if(gMcps_Ind_EVENT_c == (gTaskEventFlags & gMcps_Ind_EVENT_c))
00121         {
00122             rcvd = gAppRxPacket->smacPdu.smacPdu[0];
00123 
00124             //get back in RX
00125             //gAppRxPacket = (rxPacket_t*)MEM_BufferAlloc(gMaxSmacSDULength_c + sizeof(rxPacket_t));
00126             //gAppRxPacket->u8MaxDataLength = gMaxSmacSDULength_c;
00127             uart.printf("%c", rcvd);
00128             MLMERXEnableRequest(gAppRxPacket, 0);
00129 
00130             
00131         }
00132         
00133         if(gMlme_TimeoutInd_EVENT_c == (gTaskEventFlags & gMlme_TimeoutInd_EVENT_c))
00134         {
00135             uart.printf("MlmeTimeoutInd: \r\n");
00136         }
00137         
00138         if(gMlme_EdCnf_EVENT_c == (gTaskEventFlags & gMlme_EdCnf_EVENT_c))
00139         {
00140             uart.printf("EdCnf: \r\n");
00141         }
00142         
00143         if(gMlme_CcaCnf_EVENT_c == (gTaskEventFlags & gMlme_CcaCnf_EVENT_c))
00144         {
00145             uart.printf("CcaCnf: \r\n");
00146         }
00147         
00148         if(gWUSelf_EVENT_c == (gTaskEventFlags & gWUSelf_EVENT_c))
00149         {
00150             if (buffer_Ok_c == uartBuf.getFromBuffer(&c))
00151             {
00152                 gAppTxPacket->smacPdu.smacPdu[0] = c;
00153                 gAppTxPacket->u8DataLength = 1;
00154                 (void)MLMERXDisableRequest();
00155                 (void)MCPSDataRequest(gAppTxPacket);
00156             }
00157         }
00158        
00159         gTaskEventFlags = 0;
00160     }
00161 }
00162 
00163 int main()
00164 {
00165     MEM_Init();
00166     Thread thread(led_thread);
00167     thread2 = new Thread(button_thread);
00168     eventsThread = new Thread(events_thread);
00169     Phy_Init();
00170     InitSmac();
00171     
00172     uartSetBaudRate(gDefaultBaudRate_UART_c);
00173     
00174     //Tell SMAC who to call when it needs to pass a message to the application thread.
00175     Smac_RegisterSapHandlers((SMAC_APP_MCPS_SapHandler_t)smacToAppMcpsSap,(SMAC_APP_MLME_SapHandler_t)smacToAppMlmeSap,0);
00176 
00177     InitApp();
00178     
00179     PrintMenu(cu8FreescaleLogo);
00180         
00181     button_pressed = 0;
00182     sw2.fall(&sw2_press);
00183     while (true) 
00184     {
00185         if(uart.readable())
00186         { 
00187             (void)uartBuf.addToBuffer(uart.getc());
00188         }
00189         if ( uartBuf.getCount() )
00190         {
00191             gTaskEventFlags |= gWUSelf_EVENT_c;
00192             eventsThread->signal_set(0x1);
00193         }   
00194         Thread::yield();
00195     }
00196 }
00197 
00198 void InitApp()
00199 {
00200   gAppTxPacket = (txPacket_t*)gau8TxDataBuffer;   //Map TX packet to buffer
00201   gAppRxPacket = (rxPacket_t*)MEM_BufferAlloc(gMaxSmacSDULength_c + sizeof(rxPacket_t));
00202   
00203   InitProject();
00204   
00205   SMACFillHeader(&(gAppTxPacket->smacHeader), gDefaultAddress_c);                  
00206   
00207   (void)MLMEPAOutputAdjust(gDefaultOutputPower_c);
00208   (void)MLMESetChannelRequest(gDefaultChannelNumber_c);         
00209   (void)MLMEConfigureTxContext(&txConfigContext);
00210   //AppDelayTmr = TMR_AllocateTimer();
00211   gAppRxPacket->u8MaxDataLength = gMaxSmacSDULength_c;
00212   (void)MLMERXEnableRequest(gAppRxPacket, 0);
00213 }
00214 
00215 /* (Management) Sap handler for managing timeout indication and ED confirm
00216    This is running in INTERRUPT context, so need to send messages to one of the task */
00217 smacErrors_t smacToAppMlmeSap(smacToAppMlmeMessage_t* pMsg, instanceId_t instance)
00218 {
00219   switch(pMsg->msgType)
00220   {
00221     case gMlmeEdCnf_c:
00222         gTaskEventFlags |= gMlme_EdCnf_EVENT_c;
00223         break;
00224     case gMlmeCcaCnf_c:
00225         gTaskEventFlags |= gMlme_CcaCnf_EVENT_c;
00226         break;
00227     case gMlmeTimeoutInd_c:
00228         gTaskEventFlags |= gMlme_TimeoutInd_EVENT_c;
00229         break;
00230     default:
00231         break;
00232   }
00233   eventsThread->signal_set(0x1);
00234   MEM_BufferFree(pMsg);
00235   return gErrorNoError_c;
00236 }
00237 
00238 /* (Data) Sap handler for managing data confirm and data indication
00239    This is running in INTERRUPT context, so need to send messages to one of the task */
00240 smacErrors_t smacToAppMcpsSap(smacToAppDataMessage_t* pMsg, instanceId_t instance)
00241 {  
00242     switch(pMsg->msgType)
00243     {
00244         case gMcpsDataInd_c:
00245             if(pMsg->msgData.dataInd.pRxPacket->rxStatus == rxSuccessStatus_c)
00246             {       
00247                 gTaskEventFlags |= gMcps_Ind_EVENT_c;
00248             }
00249             break;
00250 
00251         case gMcpsDataCnf_c:
00252 #ifdef VERBOSE
00253             if(pMsg->msgData.dataCnf.status == gErrorChannelBusy_c)
00254             {
00255                 bCCAFailed = TRUE;
00256             }
00257 
00258             if(pMsg->msgData.dataCnf.status == gErrorNoAck_c)
00259             {
00260                 bACKFailed = TRUE;
00261             }
00262 #endif
00263 
00264             gTaskEventFlags |= gMcps_Cnf_EVENT_c;
00265             break;
00266 
00267         default:
00268             break;
00269     }
00270     eventsThread->signal_set(0x1);
00271     MEM_BufferFree(pMsg);
00272 
00273     return gErrorNoError_c;
00274 }
00275 
00276 void InitProject(void)
00277 {   
00278   /*Global Data init*/
00279 #ifdef VERBOSE
00280   bACKFailed                        = FALSE;
00281   bCCAFailed                        = FALSE;
00282 #endif
00283 
00284   gTaskEventFlags = 0;
00285 
00286   txConfigContext.autoAck           = FALSE;
00287   txConfigContext.ccaBeforeTx       = FALSE;
00288   txConfigContext.retryCountAckFail = 0;
00289   txConfigContext.retryCountCCAFail = 0;
00290 }