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