//****************************************************************************
// MAIN FUNCTION
//****************************************************************************
int main(void)
{
long lRetVal;
char cCmdBuff[20];
signed char cCmd = APP_SLEEP;
SlSockAddrIn_t sAddr;
SlSockAddrIn_t sLocalAddr;
SlSockAddrIn_t sBrdAddr;
int iCounter;
int iAddrSize;
int iSockID;
int iStatus;
long lLoopCount = 0;
short sTestBufLen;
struct SlTimeval_t timeVal;
//
// Board Initialization
//
BoardInit();
//
// uDMA Initialization
//
UDMAInit();
//
// Configure the pinmux settings for the peripherals exercised
// Note: pinmux has been modified after the output from pin mux tools
// to enable sleep clk for the peripherals exercised
//
PinMuxConfig();
//
// Initialize the platform
//
platform_init();
//
// Initialise the UART terminal
//
InitTerm();
//
// Display banner
//
DisplayBanner();
//
// starting the simplelink
//
lRetVal = sl_Start(NULL, NULL, NULL);
if (lRetVal < 0)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
//
// Swtich to STA mode if device is not
//
SwitchToStaMode(lRetVal);
//
// set connection policy
//
sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(0, 0, 0, 0, 0), NULL, 0);
//
// Set the power management policy of NWP
//
lRetVal = sl_WlanPolicySet(SL_POLICY_PM, SL_NORMAL_POLICY, NULL, 0);
UART_PRINT("Trying to Connect to AP: %s ...\r\n",SSID_NAME);
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
LOOP_FOREVER();
}
// filling the buffer
for (iCounter=0 ; iCounter<BUF_SIZE ; iCounter++)
{
g_cBsdBuf[iCounter] = (char)(iCounter % 10);
}
sTestBufLen = BUF_SIZE;
//filling the UDP server socket address
sLocalAddr.sin_family = SL_AF_INET;
sLocalAddr.sin_port = sl_Htons((unsigned short)PORT_NUM);
sLocalAddr.sin_addr.s_addr = 0;
//filling the UDP server socket address
sBrdAddr.sin_family = SL_AF_INET;
sBrdAddr.sin_port = sl_Htons((unsigned short)PORT_NUM);
sBrdAddr.sin_addr.s_addr = sl_Htonl((unsigned int)g_ulDestinationIp);
iAddrSize = sizeof(SlSockAddrIn_t);
// creating a UDP socket
iSockID = sl_Socket(SL_AF_INET,SL_SOCK_DGRAM, 0);
/* setting time out for socket recv */
timeVal.tv_sec = 5; // Seconds
timeVal.tv_usec = 0; // Microseconds. 10000 microseconds resolution
sl_SetSockOpt(iSockID,SL_SOL_SOCKET,SL_SO_RCVTIMEO, (_u8 *)&timeVal, sizeof(timeVal));
// binding the UDP socket to the UDP server address
iStatus = sl_Bind(iSockID, (SlSockAddr_t *)&sLocalAddr, iAddrSize);
if( iStatus < 0 )
{
// error
sl_Close(iSockID);
ASSERT_ON_ERROR(iStatus);
}
//
// setting Apps power policy
//
lp3p0_setup_power_policy(POWER_POLICY_STANDBY);
UART_PRINT("enter one of the following command:\n\r");
UART_PRINT("sleep - for putting the system into LPDS mode\n\r");
UART_PRINT(" GPIO 13 and timer(5 sec) are the wk source configured\n\r");
UART_PRINT("recv - for receiving 1000 UDP packets\n\r");
UART_PRINT("send - for broadcasting 1000 UDP packets\n\r");
do{
UART_PRINT("cmd#");
//
// get cmd over UART
//
GetCmd(cCmdBuff, 20);
//
// parse the command
//
ParseCmd(cCmdBuff, &cCmd);
if(cCmd == APP_SLEEP)
{
//
// set timer and gpio as wake src
//
set_rtc_as_wk_src(WK_LPDS, LPDS_DUR_SEC, false);
set_gpio_as_wk_src(WK_LPDS, GPIO_SRC_WKUP, PRCM_LPDS_FALL_EDGE);
cc_idle_task_pm();
}
else if(cCmd == APP_RECV)
{
lLoopCount = 0;
/// waits for 1000 packets from a UDP client
while (lLoopCount < g_ulPacketCount)
{
iStatus = sl_RecvFrom(iSockID, g_cBsdBuf, sTestBufLen, 0,
( SlSockAddr_t *)&sAddr, (SlSocklen_t*)&iAddrSize );
if( iStatus < 0 )
{
//error
break;
}
lLoopCount++;
}
UART_PRINT("Recieved %u packets successfully \n\r",lLoopCount);
if(lLoopCount != g_ulPacketCount)
{
if(iStatus == SL_EAGAIN)
{
UART_PRINT("timed out\n\r");
}
else
{
UART_PRINT("recv error: %d\n\r", iStatus);
}
}
}
else if(cCmd == APP_SEND)
{
lLoopCount = 0;
// sending 1000 packets to the UDP server
while (lLoopCount < g_ulPacketCount)
{
// sending packet
iStatus = sl_SendTo(iSockID, g_cBsdBuf, sTestBufLen, 0,
(SlSockAddr_t *)&sBrdAddr, iAddrSize);
if( iStatus <= 0 )
{
// error
UART_PRINT("send error\n\r");
break;
}
lLoopCount++;
}
UART_PRINT("Sent %u packets successfully\n\r",lLoopCount);
}
}while(FOREVER);
}
//*****************************************************************************
//
//! \brief Task Created by main fucntion.This task starts simpleink, set NWP
//! power policy, connects to an AP. Give Signal to the other task about
//! the connection.wait for the message form the interrupt handlers and
//! the other task. Accordingly print the wake up cause from the low
//! power modes.
//!
//! \param pvParameters is a general void pointer (not used here).
//!
//! \return none
//
//*****************************************************************************
void TimerGPIOTask(void *pvParameters)
{
cc_hndl tTimerHndl = NULL;
cc_hndl tGPIOHndl = NULL;
unsigned char ucQueueMsg = 0;
unsigned char ucSyncMsg = 0;
int iRetVal = 0;
//
// Displays the Application Banner
//
DisplayBanner();
//
// creating the queue for signalling about connection events
//
iRetVal = osi_MsgQCreate(&g_tConnection, NULL, sizeof( unsigned char ), 3);
if (iRetVal < 0)
{
UART_PRINT("unable to create the msg queue\n\r");
LOOP_FOREVER();
}
//
// starting the simplelink
//
iRetVal = sl_Start(NULL, NULL, NULL);
if (iRetVal < 0)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
//
// Swtich to STA mode if device is not
//
SwitchToStaMode(iRetVal);
//
// Set the power management policy of NWP
//
iRetVal = sl_WlanPolicySet(SL_POLICY_PM, SL_NORMAL_POLICY, NULL, 0);
if (iRetVal < 0)
{
UART_PRINT("unable to configure network power policy\n\r");
LOOP_FOREVER();
}
//
// connecting to the Access Point
//
if(-1 == WlanConnect())
{
sl_Stop(SL_STOP_TIMEOUT);
UART_PRINT("Connection to AP failed\n\r");
}
else
{
UART_PRINT("Connected to AP\n\r");
//
//signal the other task about the sl start and connection to the AP
//
iRetVal = osi_MsgQWrite(&g_tConnectionFlag, &ucSyncMsg,
OSI_WAIT_FOREVER);
if (iRetVal < 0)
{
UART_PRINT("unable to create the msg queue\n\r");
LOOP_FOREVER();
}
}
//
// Queue management related configurations
//
iRetVal = osi_MsgQCreate(&g_tWkupSignalQueue, NULL,
sizeof( unsigned char ), 10);
if (iRetVal < 0)
{
UART_PRINT("unable to create the msg queue\n\r");
LOOP_FOREVER();
}
//
// setting Timer as one of the wakeup source
//
tTimerHndl = SetTimerAsWkUp();
//
// setting some GPIO as one of the wakeup source
//
tGPIOHndl = SetGPIOAsWkUp();
/* handles, if required, can be used to stop the timer, but not used here*/
UNUSED(tTimerHndl);
UNUSED(tGPIOHndl);
//
// setting Apps power policy
//
lp3p0_setup_power_policy(POWER_POLICY_STANDBY);
while(FOREVER)
{
//
// waits for the message from the various interrupt handlers(GPIO,
// Timer) and the UDPServerTask.
//
osi_MsgQRead(&g_tWkupSignalQueue, &ucQueueMsg, OSI_WAIT_FOREVER);
switch(ucQueueMsg){
case 1:
UART_PRINT("timer\n\r");
break;
case 2:
UART_PRINT("GPIO\n\r");
break;
case 3:
UART_PRINT("host irq\n\r");
break;
default:
UART_PRINT("invalid msg\n\r");
break;
}
}
}
//*****************************************************************************
//
//! \brief Task Created by main fucntion. This task prints the wake up reason
//! (from hibernate or from restart). start simplelink, set NWP power
//! policy and connects to an AP. Creates UDP client and send UDP
//! packets at around 1Mbit/sec for certain time. Disconnect form AP
//! and stops the simplelink.Setup GPIO and Timer as wakeup source from
//! low power modes. Go into HIBernate.
//!
//! \param pvParameters is a general void pointer (not used here).
//!
//! \return none
//
//*****************************************************************************
void TimerGPIOTask(void *pvParameters)
{
cc_hndl tTimerHndl;
cc_hndl tGPIOHndl;
int iSockDesc = 0;
int iRetVal = 0;
int iCounter = 0;
sockaddr_in sServerAddr;
unsigned char *pcSendBuff;
unsigned char cSyncMsg;
//
// creating the queue for signalling about connection events
//
iRetVal = osi_MsgQCreate(&g_tConnection, NULL, sizeof( unsigned char ), 3);
if (iRetVal < 0)
{
UART_PRINT("unable to create the msg queue\n\r");
LOOP_FOREVER();
}
// filling the buffer
for (iCounter=0 ; iCounter<BUFF_SIZE ; iCounter++)
{
g_cBsdBuf[iCounter] = (char)(iCounter % 10);
}
pcSendBuff = g_cBsdBuf;
if(MAP_PRCMSysResetCauseGet() == PRCM_POWER_ON)
{
//
// Displays the Application Banner
//
DisplayBanner();
//
// starting the simplelink
//
iRetVal = sl_Start(NULL, NULL, NULL);
if (iRetVal < 0)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
//
// Switch to STA mode if device is not in this mode
//
SwitchToStaMode(iRetVal);
//
// Set the power management policy of NWP
//
iRetVal = sl_WlanPolicySet(SL_POLICY_PM, SL_NORMAL_POLICY, NULL, 0);
if (iRetVal < 0)
{
UART_PRINT("unable to configure network power policy\n\r");
LOOP_FOREVER();
}
}
else if(MAP_PRCMSysResetCauseGet() == PRCM_HIB_EXIT)
{
UART_PRINT("woken from hib\n\r");
//
// starting the simplelink
//
iRetVal = sl_Start(NULL, NULL, NULL);
if (iRetVal < 0)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
}
else if(MAP_PRCMSysResetCauseGet() == PRCM_WDT_RESET)
{
UART_PRINT("woken from WDT Reset\n\r");
//
// starting the simplelink
//
iRetVal = sl_Start(NULL, NULL, NULL);
if (iRetVal < 0)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
}
else
{
UART_PRINT("woken cause unknown\n\r");
}
//
// connecting to the Access Point
//
if(-1 == WlanConnect())
{
UART_PRINT("Connection to AP failed\n\r");
goto no_network_connection;
}else{
UART_PRINT("Connected to AP\n\r");
}
//
// creating a UDP socket
//
iSockDesc = sl_Socket(SL_AF_INET,SL_SOCK_DGRAM, 0);
if(iSockDesc < 0)
{
UART_PRINT("sock error\n\r");
LOOP_FOREVER();
}
//
// configure the UDP Server address
//
sServerAddr.sin_family = SL_AF_INET;
sServerAddr.sin_port = sl_Htons(APP_UDP_PORT);
sServerAddr.sin_addr.s_addr = sl_Htonl(SERVER_IP_ADDRESS);
//
// Set 5 sec timer allowing 5 sec of UDP Tx.
//
tTimerHndl = SetTimer();
g_ucTrafficEnable = 1;
while(g_ucTrafficEnable == 1)
{
//
// sending message
//
iRetVal = sendto(iSockDesc, pcSendBuff,BUFF_SIZE, 0,
(struct sockaddr *)&sServerAddr,sizeof(sServerAddr));
if(iRetVal < 0)
{
UART_PRINT("send error\n\r");
LOOP_FOREVER();
}
ManageDelay(128,BUFF_SIZE);
}
UART_PRINT("sent\n\r");
//
// stop and delete the timer
//
cc_timer_stop(tTimerHndl);
cc_timer_delete(tTimerHndl);
//
//close the socket
//
close(iSockDesc);
if(iRetVal < 0)
{
UART_PRINT("could not close the socket\n\r");
}
//
// disconnect from the Access Point
//
WlanDisconnect();
no_network_connection:
//
// stop the simplelink with reqd. timeout value (30 ms)
//
sl_Stop(SL_STOP_TIMEOUT);
//
// setting Timer as one of the wakeup source
//
tTimerHndl = SetTimerAsWkUp();
//
// setting some GPIO as one of the wakeup source
//
tGPIOHndl = SetGPIOAsWkUp();
/* handles, if required, can be used to stop the timer, but not used here*/
UNUSED(tTimerHndl);
UNUSED(tGPIOHndl);
//
// Setting up HIBERNATE as the lowest power mode for the system.
//
lp3p0_setup_power_policy(POWER_POLICY_HIBERNATE);
//
// idle wait will push the system into the lowest power mode(HIBERNATE).
//
iRetVal = osi_MsgQCreate(&g_tWaitForHib, NULL, sizeof( unsigned char ), 1);
if (iRetVal < 0)
{
UART_PRINT("unable to create the msg queue\n\r");
LOOP_FOREVER();
}
osi_MsgQRead(&g_tWaitForHib, &cSyncMsg, OSI_WAIT_FOREVER);
//
// infinite loop (must not reach here)
//
LOOP_FOREVER();
}
