//*****************************************************************************
//
//! \brief Email Application Main Task - Initializes SimpleLink Driver
//! and Handles UART Commands
//!
//! \param pvParameters - pointer to the task parameter
//!
//! \return void
//! \note
//! \warning
//
//*****************************************************************************
static void SimpleEmail(void *pvParameters)
{
long lRetVal = -1;
// Initialize Network Processor
lRetVal = Network_IF_InitDriver(ROLE_STA);
if(lRetVal < 0)
{
UART_PRINT("Failed to start SimpleLink Device\n\r");
LOOP_FOREVER();
}
//Glow GreenLED to indicate successful initialization
GPIO_IF_LedOn(MCU_ON_IND);
//Set Default Parameters for Email
lRetVal = SetDefaultParameters();
if(lRetVal < 0)
{
UART_PRINT("Failed to set default params for Email\r\n");
LOOP_FOREVER();
}
//Initialize Push Botton Switch
Button_IF_Init(SmartConfigInterruptHandler,SendEmailInterruptHandler);
while(1)
{
UART_PRINT("Cmd#");
//
// Get command from UART
//
memset(ucUARTBuffer,0,200);
uiUartCmd=GetCmd(&ucUARTBuffer[0], 200);
if(uiUartCmd)
{
//
// Parse the command
//
lRetVal = UARTCommandHandler(ucUARTBuffer);
if(lRetVal < 0)
{
UART_PRINT("Failed to parse the command.\r\n");
LOOP_FOREVER();
}
}
}
}
//****************************************************************************
//
//! Task function implementing the TCP server and showcasing the
//! deepsleep functionality
//!
//! \param none
//!
//! This function
//! 1. Creates a TCP socket and binds to it
//! 2. Listens on the socket
//! 3. Accepts a client connection
//! 4. Receives a packet on the socket
//! 5. Closes the socket
//!
//! \return None.
//
//****************************************************************************
void TCPServerTask(void *pvParameters)
{
int iSocketDesc, iClientFD;
struct sockaddr_in sClientAddr;
int iRecvLen;
unsigned int iClientAddrLen = sizeof(sClientAddr);
unsigned char aucRecvBuffer[MAX_BUF];
DisplayBanner(APPLICATION_NAME);
DBG_PRINT("DEEPSLEEP: Test Begin\n\r");
//
// GPIO Configuration
//
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Start the driver
//
Network_IF_InitDriver(ROLE_STA);
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
LedTimerConfigNStart();
// Initialize AP security params
SecurityParams.Key = SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
Network_IF_ConnectAP(SSID_NAME,SecurityParams);
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//
// Create and Bind TCP server socket
//
iSocketDesc = CreateTCPServerSocket(APP_TCP_PORT);
if(iSocketDesc < 0)
{
DBG_PRINT("DEEPSLEEP: Socket create failed\n");
goto end;
}
DBG_PRINT("DEEPSLEEP: Socket created\n\r");
DBG_PRINT("DEEPSLEEP: Listening on Socket...\n\r");
//
// Start Listening on the socket
//
if( listen(iSocketDesc, 5) != 0)
{
DBG_PRINT("DEEPSLEEP: Listen failed\n\r");
goto end;
}
while(FOREVER)
{
//
// Accept new client connections (Here just one)
//
DBG_PRINT("DEEPSLEEP: Waiting for client.......\n\r");
iClientFD = accept(iSocketDesc,
(struct sockaddr*)&sClientAddr,
&iClientAddrLen);
DBG_PRINT("DEEPSLEEP: Connected to client [0x%x] \n\r",
htonl(sClientAddr.sin_addr.s_addr));
do
{
//
// Receive on the socket
//
iRecvLen = recv(iClientFD,aucRecvBuffer,MAX_BUF,0);
if(iRecvLen > 0)
{
DBG_PRINT("DEEPSLEEP: received %d bytes\n\r", iRecvLen);
DBG_PRINT("DEEPSLEEP: received message : %s\n\r", aucRecvBuffer);
}
}while(iRecvLen > 0);
//
// Close the client descriptor
//
close(iClientFD);
}
//
// Close the socket. Commented as not expected to reach here
//
//close(iSocketDesc);
end:
DBG_PRINT("DEEPSLEEP: Test Complete\n\r");
//
// Loop here
//
while(1);
}
static void TFTPTask(void *pvParameters)
{
SlSecParams_t secParams;
unsigned char *pucFileBuffer = NULL; // Data read or to be written
unsigned long uiFileSize;
const char *FileRead = "readFromServer.txt"; // File to be read using TFTP. Change string to filename
const char *FileWrite = "writeToServer.txt"; // File to be written using TFTP. Change string to filename.
long pFileHandle; // Pointer to file handle
SlFsFileInfo_t pFsFileInfo;
long lRetVal = -1;
unsigned short uiTftpErrCode;
//get wifi information
// get_wifi_info(ap_ssid, secPrams);
// Configuring security parameters for the AP
secParams.Key = (_i8*)SSID_KEY;
secParams.KeyLen = 30;
secParams.Type = SL_SEC_TYPE_WPA_WPA2;
lRetVal = Network_IF_InitDriver(ROLE_STA);
// Connecting to WLAN AP - Set with static parameters defined at the top
// After this call we will be connected and have IP address
lRetVal = Network_IF_ConnectAP((char*)SSID,secParams);
UART_PRINT("Connecting to TFTP server %d.%d.%d.%d\n\r",\
SL_IPV4_BYTE(TFTP_IP, 3),SL_IPV4_BYTE(TFTP_IP, 2),
SL_IPV4_BYTE(TFTP_IP, 1),SL_IPV4_BYTE(TFTP_IP, 0));
if(TFTP_READ)
{
uiFileSize = FILE_SIZE_MAX;
pucFileBuffer = new unsigned char[uiFileSize];
if(NULL == pucFileBuffer)
{
UART_PRINT("Can't Allocate Resources\r\n");
LOOP_FOREVER();
}
memset(pucFileBuffer,'\0',uiFileSize);
lRetVal = sl_TftpRecv(TFTP_IP, FileRead, (char *)pucFileBuffer,\
&uiFileSize, &uiTftpErrCode );
UART_PRINT("file read is %s\n", pucFileBuffer);
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsGetInfo((unsigned char *)FileRead, 0, &pFsFileInfo);
if(lRetVal < 0 )
lRetVal = sl_FsOpen((unsigned char *)FileRead,\
FS_MODE_OPEN_CREATE(FILE_SIZE_MAX,_FS_FILE_OPEN_FLAG_COMMIT|\
_FS_FILE_PUBLIC_WRITE), NULL,&pFileHandle);
else
lRetVal = sl_FsOpen((unsigned char *)FileRead,FS_MODE_OPEN_WRITE, \
NULL,&pFileHandle);
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsWrite(pFileHandle,0, pucFileBuffer, uiFileSize);
if(lRetVal < 0)
{
free(pucFileBuffer);
lRetVal = sl_FsClose(pFileHandle,0,0,0);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
UART_PRINT("TFTP Read Successful \r\n");
lRetVal = sl_FsClose(pFileHandle,0,0,0);
}
if(TFTP_WRITE)
{
/* open same file which has been written with the server's file content */
lRetVal = sl_FsOpen((unsigned char *)FileRead,FS_MODE_OPEN_READ, \
NULL,&pFileHandle);
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsGetInfo((unsigned char *)FileRead, 0, &pFsFileInfo);
if(lRetVal < 0)
{
lRetVal = sl_FsClose(pFileHandle,0,0,0);
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
uiFileSize = (&pFsFileInfo)->FileLen;
lRetVal = sl_FsRead(pFileHandle, 0, pucFileBuffer, uiFileSize);
if(lRetVal < 0)
{
lRetVal = sl_FsClose(pFileHandle,0,0,0);
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_FsClose(pFileHandle,0,0,0);
/* write to server with different file name */
lRetVal = sl_TftpSend(TFTP_IP, FileWrite,(char *) pucFileBuffer,\
&uiFileSize, &uiTftpErrCode );
if(lRetVal < 0)
{
free(pucFileBuffer);
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
UART_PRINT("TFTP Write Successful \r\n");
}
LOOP_FOREVER();
}
//*****************************************************************************
//
//! Task implementing MQTT client communication to other web client through
//! a broker
//!
//! \param none
//!
//! This function
//! 1. Initializes network driver and connects to the default AP
//! 2. Initializes the mqtt library and set up MQTT connection configurations
//! 3. set up the button events and their callbacks(for publishing)
//! 4. handles the callback signals
//!
//! \return None
//!
//*****************************************************************************
void MqttClient(void *pvParameters)
{
long lRetVal = -1;
int iCount = 0;
int iNumBroker = 0;
int iConnBroker = 0;
event_msg RecvQue;
unsigned char policyVal;
connect_config *local_con_conf = (connect_config *)app_hndl;
//
// Configure LED
//
GPIO_IF_LedConfigure(LED1|LED2|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Reset The state of the machine
//
Network_IF_ResetMCUStateMachine();
//
// Start the driver
//
lRetVal = Network_IF_InitDriver(ROLE_STA);
if(lRetVal < 0)
{
UART_PRINT("Failed to start SimpleLink Device\n\r",lRetVal);
LOOP_FOREVER();
}
// switch on Green LED to indicate Simplelink is properly up
GPIO_IF_LedOn(MCU_ON_IND);
// Start Timer to blink Red LED till AP connection
LedTimerConfigNStart();
// Initialize AP security params
SecurityParams.Key = (signed char *)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
lRetVal = Network_IF_ConnectAP(SSID_NAME, SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Connection to an AP failed\n\r");
LOOP_FOREVER();
}
lRetVal = sl_WlanProfileAdd(SSID_NAME,strlen(SSID_NAME),0,&SecurityParams,0,1,0);
//set AUTO policy
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,0),
&policyVal, 1 /*PolicyValLen*/);
//
// Disable the LED blinking Timer as Device is connected to AP
//
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
UtilsDelay(20000000);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Register Push Button Handlers
//
Button_IF_Init(pushButtonInterruptHandler2,pushButtonInterruptHandler3);
//
// Initialze MQTT client lib
//
lRetVal = sl_ExtLib_MqttClientInit(&Mqtt_Client);
if(lRetVal != 0)
{
// lib initialization failed
UART_PRINT("MQTT Client lib initialization failed\n\r");
LOOP_FOREVER();
}
/******************* connection to the broker ***************************/
iNumBroker = sizeof(usr_connect_config)/sizeof(connect_config);
if(iNumBroker > MAX_BROKER_CONN)
{
UART_PRINT("Num of brokers are more then max num of brokers\n\r");
LOOP_FOREVER();
}
connect_to_broker:
while(iCount < iNumBroker)
{
//create client context
local_con_conf[iCount].clt_ctx =
sl_ExtLib_MqttClientCtxCreate(&local_con_conf[iCount].broker_config,
&local_con_conf[iCount].CallBAcks,
&(local_con_conf[iCount]));
//
// Set Client ID
//
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_CLIENT_ID,
local_con_conf[iCount].client_id,
strlen((char*)(local_con_conf[iCount].client_id)));
//
// Set will Params
//
if(local_con_conf[iCount].will_params.will_topic != NULL)
{
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_WILL_PARAM,
&(local_con_conf[iCount].will_params),
sizeof(SlMqttWill_t));
}
//
// setting username and password
//
if(local_con_conf[iCount].usr_name != NULL)
{
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_USER_NAME,
local_con_conf[iCount].usr_name,
strlen((char*)local_con_conf[iCount].usr_name));
if(local_con_conf[iCount].usr_pwd != NULL)
{
sl_ExtLib_MqttClientSet((void*)local_con_conf[iCount].clt_ctx,
SL_MQTT_PARAM_PASS_WORD,
local_con_conf[iCount].usr_pwd,
strlen((char*)local_con_conf[iCount].usr_pwd));
}
}
//
// connectin to the broker
//
if((sl_ExtLib_MqttClientConnect((void*)local_con_conf[iCount].clt_ctx,
local_con_conf[iCount].is_clean,
local_con_conf[iCount].keep_alive_time) & 0xFF) != 0)
{
UART_PRINT("\n\rBroker connect fail for conn no. %d \n\r",iCount+1);
//delete the context for this connection
sl_ExtLib_MqttClientCtxDelete(local_con_conf[iCount].clt_ctx);
break;
}
else
{
UART_PRINT("\n\rSuccess: conn to Broker no. %d\n\r ", iCount+1);
local_con_conf[iCount].is_connected = true;
iConnBroker++;
}
//
// Subscribe to topics
//
if(sl_ExtLib_MqttClientSub((void*)local_con_conf[iCount].clt_ctx,
local_con_conf[iCount].topic,
local_con_conf[iCount].qos, TOPIC_COUNT) < 0)
{
UART_PRINT("\n\r Subscription Error for conn no. %d\n\r", iCount+1);
UART_PRINT("Disconnecting from the broker\r\n");
sl_ExtLib_MqttClientDisconnect(local_con_conf[iCount].clt_ctx);
local_con_conf[iCount].is_connected = false;
//delete the context for this connection
sl_ExtLib_MqttClientCtxDelete(local_con_conf[iCount].clt_ctx);
iConnBroker--;
break;
}
else
{
int iSub;
UART_PRINT("Client subscribed on following topics:\n\r");
for(iSub = 0; iSub < local_con_conf[iCount].num_topics; iSub++)
{
UART_PRINT("%s\n\r", local_con_conf[iCount].topic[iSub]);
}
}
iCount++;
}
if(iConnBroker < 1)
{
//
// no succesful connection to broker
//
goto end;
}
iCount = 0;
for(;;)
{
osi_MsgQRead( &g_PBQueue, &RecvQue, OSI_WAIT_FOREVER);
if(PUSH_BUTTON_SW2_PRESSED == RecvQue.event)
{
Button_IF_EnableInterrupt(SW2);
//
// send publish message
//
sl_ExtLib_MqttClientSend((void*)local_con_conf[iCount].clt_ctx,
pub_topic_sw2,data_sw2,strlen((char*)data_sw2),QOS2,RETAIN);
UART_PRINT("\n\r CC3200 Publishes the following message \n\r");
UART_PRINT("Topic: %s\n\r",pub_topic_sw2);
UART_PRINT("Data: %s\n\r",data_sw2);
}
else if(PUSH_BUTTON_SW3_PRESSED == RecvQue.event)
{
Button_IF_EnableInterrupt(SW3);
//
// send publish message
//
sl_ExtLib_MqttClientSend((void*)local_con_conf[iCount].clt_ctx,
pub_topic_sw3,data_sw3,strlen((char*)data_sw3),QOS2,RETAIN);
UART_PRINT("\n\r CC3200 Publishes the following message \n\r");
UART_PRINT("Topic: %s\n\r",pub_topic_sw3);
UART_PRINT("Data: %s\n\r",data_sw3);
}
else if(BROKER_DISCONNECTION == RecvQue.event)
{
iConnBroker--;
/* Derive the value of the local_con_conf or clt_ctx from the message */
sl_ExtLib_MqttClientCtxDelete(((connect_config*)(RecvQue.hndl))->clt_ctx);
if(!IS_CONNECTED(g_ulStatus))
{
UART_PRINT("device has disconnected from AP \n\r");
UART_PRINT("retry connection to the AP\n\r");
while(!(IS_CONNECTED(g_ulStatus)) || !(IS_IP_ACQUIRED(g_ulStatus)))
{
osi_Sleep(10);
}
goto connect_to_broker;
}
if(iConnBroker < 1)
{
//
// device not connected to any broker
//
goto end;
}
}
}
end:
//
// Deinitializating the client library
//
sl_ExtLib_MqttClientExit();
UART_PRINT("\n\r Exiting the Application\n\r");
LOOP_FOREVER();
}
//****************************************************************************
//
//! Task function implementing the UDP client and showcasing the hibernate
//! functionality
//!
//! \param none
//!
//! This function
//! 1. Creates a UDP socket
//! 2. Broadcasts a packet on the socket
//! 3. Closes the socket
//! 4. Enters the HIBernate mode
//!
//! \return None.
//
//****************************************************************************
void HIBUDPBroadcastTask(void *pvParameters)
{
int iSocketDesc;
long lRetVal;
struct sockaddr_in sBroadcastAddr;
char pcBroadcastMessage[]="32xx HIB example application";
//
// Check the wakeup source. If first itme entry or wakeup from HIB
//
if(MAP_PRCMSysResetCauseGet() == 0)
{
DisplayBanner(APPNAME);
DBG_PRINT("HIB: Wake up on Power ON\n\r");
}
else if(MAP_PRCMSysResetCauseGet() == PRCM_HIB_EXIT)
{
DBG_PRINT("HIB: Woken up from Hibernate\n\r");
}
else
{
}
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// Configure Timer for blinking the LED for IP acquisition
//
LedTimerConfigNStart();
//
//
// Reset The state of the machine
//
Network_IF_ResetMCUStateMachine();
//
// Start the driver
//
lRetVal = Network_IF_InitDriver(ROLE_STA);
if(lRetVal < 0)
{
UART_PRINT("Failed to start SimpleLink Device\n\r");
LOOP_FOREVER();
}
// Initialize AP security params
SecurityParams.Key = (signed char*)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
lRetVal = Network_IF_ConnectAP(SSID_NAME, SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Connection to AP failed\n\r",lRetVal);
LOOP_FOREVER();
}
//
// Disable the LED blinking Timer as Device is connected to AP
//
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//
// Create UDP socket
//
iSocketDesc = sl_Socket(AF_INET, SOCK_DGRAM, 0);
if(iSocketDesc < 0)
{
DBG_PRINT("HIB: Socket create failed\n\r");
goto end;
}
DBG_PRINT("HIB: Socket created\n\r");
//
// Assign socket structure values for a braodcast message
//
sBroadcastAddr.sin_family = AF_INET;
sBroadcastAddr.sin_addr.s_addr= sl_Htonl(0xFFFFFFFF);
sBroadcastAddr.sin_port= sl_Htons(APP_UDP_PORT);
//
// Broadcast message
//
lRetVal = sendto(iSocketDesc, (char *)&pcBroadcastMessage[0],
sizeof(pcBroadcastMessage), 0,
(struct sockaddr *)&sBroadcastAddr,sizeof(sBroadcastAddr));
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
UNUSED(lRetVal);
DBG_PRINT("HIB: sent message\n\r");
//
// Close the socket
//
close(iSocketDesc);
DBG_PRINT("HIB: Socket closed\n\r");
//
// Stop the driver
//
lRetVal = Network_IF_DeInitDriver();
if(lRetVal < 0)
{
UART_PRINT("Failed to stop SimpleLink Device\n\r");
LOOP_FOREVER();
}
//
// Switch Off RED & Green LEDs to indicate that Device is
// disconnected from AP and Simplelink is shutdown
//
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Enter HIB here configuring the wakeup-timer
//
EnterHIBernate();
end:
DBG_PRINT("HIB: Test Complete\n\r");
//
// Loop here
//
LOOP_FOREVER();
}
//****************************************************************************
//
//! Task function implementing the gettime functionality using an NTP server
//!
//! \param none
//!
//! This function
//! 1. Initializes the required peripherals
//! 2. Initializes network driver and connects to the default AP
//! 3. Creates a UDP socket, gets the NTP server IP address using DNS
//! 4. Periodically gets the NTP time and displays the time
//!
//! \return None.
//
//****************************************************************************
void GetNTPTimeTask(void *pvParameters)
{
int iSocketDesc;
long lRetVal = -1;
UART_PRINT("GET_TIME: Test Begin\n\r");
//
// Configure LED
//
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
//
// Reset The state of the machine
//
Network_IF_ResetMCUStateMachine();
//
// Start the driver
//
lRetVal = Network_IF_InitDriver(ROLE_STA);
if(lRetVal < 0)
{
UART_PRINT("Failed to start SimpleLink Device\n\r",lRetVal);
LOOP_FOREVER();
}
// switch on Green LED to indicate Simplelink is properly up
GPIO_IF_LedOn(MCU_ON_IND);
// Start Timer to blink Red LED till AP connection
LedTimerConfigNStart();
// Initialize AP security params
SecurityParams.Key = (signed char *)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
//
// Connect to the Access Point
//
lRetVal = Network_IF_ConnectAP(SSID_NAME, SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Connection to an AP failed\n\r");
LOOP_FOREVER();
}
//
// Disable the LED blinking Timer as Device is connected to AP
//
LedTimerDeinitStop();
//
// Switch ON RED LED to indicate that Device acquired an IP
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//
// Create UDP socket
//
iSocketDesc = sl_Socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(iSocketDesc < 0)
{
ERR_PRINT(iSocketDesc);
goto end;
}
g_sAppData.iSockID = iSocketDesc;
UART_PRINT("Socket created\n\r");
//
// Get the NTP server host IP address using the DNS lookup
//
lRetVal = Network_IF_GetHostIP((char*)g_acSNTPserver, \
&g_sAppData.ulDestinationIP);
if( lRetVal >= 0)
{
struct SlTimeval_t timeVal;
timeVal.tv_sec = SERVER_RESPONSE_TIMEOUT; // Seconds
timeVal.tv_usec = 0; // Microseconds. 10000 microseconds resolution
lRetVal = sl_SetSockOpt(g_sAppData.iSockID,SL_SOL_SOCKET,SL_SO_RCVTIMEO,\
(unsigned char*)&timeVal, sizeof(timeVal));
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
while(1)
{
//
// Get the NTP time and display the time
//
lRetVal = GetSNTPTime(GMT_DIFF_TIME_HRS, GMT_DIFF_TIME_MINS);
if(lRetVal < 0)
{
UART_PRINT("Server Get Time failed\n\r");
break;
}
//
// Wait a while before resuming
//
MAP_UtilsDelay(SLEEP_TIME);
}
}
else
{
UART_PRINT("DNS lookup failed. \n\r");
}
//
// Close the socket
//
close(iSocketDesc);
UART_PRINT("Socket closed\n\r");
end:
//
// Stop the driver
//
lRetVal = Network_IF_DeInitDriver();
if(lRetVal < 0)
{
UART_PRINT("Failed to stop SimpleLink Device\n\r");
LOOP_FOREVER();
}
//
// Switch Off RED & Green LEDs to indicate that Device is
// disconnected from AP and Simplelink is shutdown
//
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
UART_PRINT("GET_TIME: Test Complete\n\r");
//
// Loop here
//
LOOP_FOREVER();
}
