//*****************************************************************************
//
//! Check the device mode and switch to P2P mode
//! restart the NWP to activate P2P mode
//!
//! \param None
//!
//! \return status code - Success:0, Failure:-ve
//
//*****************************************************************************
long StartDeviceInP2P()
{
long lRetVal = -1;
// Reset CC3200 Network State Machine
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of application
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(NULL,NULL,NULL);
ASSERT_ON_ERROR(lRetVal);
if(lRetVal != ROLE_P2P)
{
lRetVal = sl_WlanSetMode(ROLE_P2P);
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_Stop(0xFF);
// reset the Status bits
CLR_STATUS_BIT_ALL(g_ulStatus);
lRetVal = sl_Start(NULL,NULL,NULL);
if(lRetVal < 0 || lRetVal != ROLE_P2P)
{
ASSERT_ON_ERROR(P2P_MODE_START_FAILED);
}
else
{
UART_PRINT("Started SimpleLink Device: P2P Mode\n\r");
return SUCCESS;
}
}
return SUCCESS;
}
static void Init()
{
long lRetVal = -1;
BoardInit();
UDMAInit();
PinMuxConfig();
InitTerm();
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if (lRetVal < 0) {
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT(
"Failed to configure the device in its default state \n\r");
LOOP_FOREVER()
;
}
//
// Asumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0) {
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER()
;
}
UART_PRINT("Connecting to AP: '%s'...\r\n", SSID_NAME);
// Connecting to WLAN AP - Set with static parameters defined at common.h
// After this call we will be connected and have IP address
lRetVal = WlanConnect();
if (lRetVal < 0) {
UART_PRINT("Connection to AP failed \n\r");
LOOP_FOREVER()
;
}
UART_PRINT("Connected to AP: '%s' \n\r", SSID_NAME);
#ifdef NEW_ID
iobeam_Reset();
#endif
}
//****************************************************************************
//
//! \brief Start simplelink, connect to the ap and run the ping test
//!
//! This function starts the simplelink, connect to the ap and start the ping
//! test on the default gateway for the ap
//!
//! \param[in] pvParameters - Pointer to the list of parameters that
//! can bepassed to the task while creating it
//!
//! \return None
//
//****************************************************************************
void WlanStationMode( void *pvParameters )
{
long lRetVal = -1;
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
{
UART_PRINT("Failed to configure the device in its default state\n\r");
}
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
LOOP_FOREVER();
}
UART_PRINT("Connection established w/ AP and IP is aquired \n\r");
gizwits_main();
}
//****************************************************************************
//
//! \brief Handles HTTP Server Task
//!
//! \param[in] pvParameters is the data passed to the Task
//!
//! \return None
//
//****************************************************************************
static void HTTPServerTask(void *pvParameters)
{
long lRetVal = -1;
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state\n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
memset(g_ucSSID,'\0',AP_SSID_LEN_MAX);
//Read Device Mode Configuration
ReadDeviceConfiguration();
//Connect to Network
lRetVal = ConnectToNetwork();
//Stop Internal HTTP Server
lRetVal = sl_NetAppStop(SL_NET_APP_HTTP_SERVER_ID);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//Start Internal HTTP Server
lRetVal = sl_NetAppStart(SL_NET_APP_HTTP_SERVER_ID);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//Handle Async Events
while(1)
{
}
}
//*****************************************************************************
//
//! Network_IF_InitDriver
//! The function initializes a CC3200 device and triggers it to start operation
//!
//! \param uiMode (device mode in which device will be configured)
//!
//! \return none
//
//*****************************************************************************
void
Network_IF_InitDriver(unsigned int uiMode)
{
long retVal = -1;
// Reset CC3200 Network State Machine
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of application
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
retVal = ConfigureSimpleLinkToDefaultState();
if(retVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == retVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER(__LINE__);
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
retVal = sl_Start(NULL,NULL,NULL);
if (retVal < 0 || retVal != uiMode)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER(__LINE__);
}
UART_PRINT("Started SimpleLink Device: STA Mode\n\r");
}
//*****************************************************************************
//
//! Function to connect to server and download the requested file
//!
//! \param none
//!
//! \return Error-code or SUCCESS
//!
//*****************************************************************************
static long ServerFileDownload()
{
long lRetVal = -1;
struct sockaddr_in addr;
HTTPCli_Struct cli;
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its desired state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
{
UART_PRINT("Failed to configure the device in its default state, "
"Error-code: %d\n\r", DEVICE_NOT_IN_STATION_MODE);
}
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
ASSERT_ON_ERROR(DEVICE_START_FAILED);
}
UART_PRINT("Device started as STATION \n\r");
// Connecting to WLAN AP - Set with static parameters defined at the top
// After this call we will be connected and have IP address
lRetVal = WlanConnect();
UART_PRINT("Connected to the AP: %s\r\n", SSID_NAME);
lRetVal = sl_NetAppDnsGetHostByName((signed char *)HOST_NAME,
strlen((const char *)HOST_NAME),
&g_ulDestinationIP,SL_AF_INET);
if(lRetVal < 0)
{
ASSERT_ON_ERROR(GET_HOST_IP_FAILED);
}
// Set up the input parameters for HTTP Connection
addr.sin_family = AF_INET;
addr.sin_port = htons(HOST_PORT);
addr.sin_addr.s_addr = sl_Htonl(g_ulDestinationIP);
// Testing HTTPCli open call: handle, address params only
HTTPCli_construct(&cli);
lRetVal = HTTPCli_connect(&cli, (struct sockaddr *)&addr, 0, NULL);
if (lRetVal < 0)
{
UART_PRINT("Connection to server failed\n\r");
ASSERT_ON_ERROR(SERVER_CONNECTION_FAILED);
}
else
{
UART_PRINT("Connection to server created successfully\r\n");
}
// Download the file, verify the file and replace the exiting file
lRetVal = GetData(&cli);
if(lRetVal < 0)
{
UART_PRINT("Device couldn't download the file from the server\n\r");
}
HTTPCli_destruct(&cli);
return SUCCESS;
}
//*****************************************************************************
//
//! This function demonstrates how certificate can be used with SSL.
//! The procedure includes the following steps:
//! 1) connect to an open AP
//! 2) get the server name via a DNS request
//! 3) define all socket options and point to the CA certificate
//! 4) connect to the server via TCP
//!
//! \param None
//!
//! \return 0 on success else error code
//! \return LED1 is turned solid in case of success
//! LED2 is turned solid in case of failure
//!
//*****************************************************************************
static long ssl()
{
SlSockAddrIn_t Addr;
int iAddrSize;
unsigned char ucMethod = SL_SO_SEC_METHOD_SSLV3;
unsigned int uiIP,uiCipher = SL_SEC_MASK_SSL_RSA_WITH_RC4_128_SHA;
long lRetVal = -1;
int iSockID;
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
lRetVal = InitializeAppVariables();
ASSERT_ON_ERROR(lRetVal);
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
return lRetVal;
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
///
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
return lRetVal;
}
UART_PRINT("Device started as STATION \n\r");
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
UART_PRINT("Connection established w/ AP and IP is aquired \n\r");
//Set time of the device for certificate verification.
lRetVal = set_time();
if(lRetVal < 0)
{
UART_PRINT("Unable to set time in the device");
return lRetVal;
}
lRetVal = sl_NetAppDnsGetHostByName(g_Host, strlen((const char *)g_Host),
(unsigned long*)&uiIP, SL_AF_INET);
if(lRetVal < 0)
{
UART_PRINT("Device couldn't retrive the host name \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
Addr.sin_family = SL_AF_INET;
Addr.sin_port = sl_Htons(GOOGLE_DST_PORT);
Addr.sin_addr.s_addr = sl_Htonl(uiIP);
iAddrSize = sizeof(SlSockAddrIn_t);
//
// opens a secure socket
//
iSockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, SL_SEC_SOCKET);
if( iSockID < 0 )
{
UART_PRINT("Device unable to create secure socket \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
//
// configure the socket as SSLV3.0
//
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, SL_SO_SECMETHOD, &ucMethod,\
sizeof(ucMethod));
if(lRetVal < 0)
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
//
//configure the socket as RSA with RC4 128 SHA
//
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, SL_SO_SECURE_MASK, &uiCipher,\
sizeof(uiCipher));
if(lRetVal < 0)
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
//
//configure the socket with GOOGLE CA certificate - for server verification
//
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, \
SL_SO_SECURE_FILES_CA_FILE_NAME, \
SL_SSL_CA_CERT_FILE_NAME, \
strlen(SL_SSL_CA_CERT_FILE_NAME));
if(lRetVal < 0)
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
lRetVal = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, \
SO_SECURE_DOMAIN_NAME_VERIFICATION, \
g_Host, strlen((const char *)g_Host));
if( lRetVal < 0 )
{
UART_PRINT("Device couldn't set socket options \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
/* connect to the peer device - Google server */
lRetVal = sl_Connect(iSockID, ( SlSockAddr_t *)&Addr, iAddrSize);
if(lRetVal < 0)
{
UART_PRINT("Device couldn't connect to Google server \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
return SUCCESS;
}
//****************************************************************************
// MAIN FUNCTION
//****************************************************************************
void main()
{
long retVal = -1;
unsigned long ulResetCause;
unsigned long ulDestinationIP;
//
// Board Initialization
//
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
//
// Configuring UART
//
InitTerm();
//
// Initialize WDT
//
WDT_IF_Init(NULL,80000000 * 10);
//
// Get the reset cause
//
ulResetCause = PRCMSysResetCauseGet();
//
// If watchdog triggered reset request hibernate
// to clean boot the system
//
if( ulResetCause == PRCM_WDT_RESET )
{
HIBEntrePreamble();
MAP_PRCMOCRRegisterWrite(0,1);
MAP_PRCMHibernateWakeupSourceEnable(PRCM_HIB_SLOW_CLK_CTR);
MAP_PRCMHibernateIntervalSet(330);
MAP_PRCMHibernateEnter();
}
//
// uDMA Initialization
//
UDMAInit();
//
// Display banner
//
DisplayBanner(APPLICATION_NAME);
if( ulResetCause == PRCM_HIB_EXIT && (MAP_PRCMOCRRegisterRead(0) & 1) == 1 )
{
UART_PRINT("Reset Cause : Watchdog Reset\n\r");
}
else
{
UART_PRINT("Reset Cause : Power On\n\r");
//
// Initialize the variables.
//
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its desired state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
retVal = ConfigureSimpleLinkToDefaultState();
if(retVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == retVal)
UART_PRINT("Failed to configure the device in its default"
" state \n\r");
LOOP_FOREVER();
}
}
//
// Set destination IP
//
ulDestinationIP = IP_ADDR;
//
// Asumption is that the device is configured in station mode already
// and it is in its default state
//
retVal = sl_Start(0, 0, 0);
//
// Acknowledge the watchdog so that it doesn't resets
//
WatchdogAck();
if (retVal < 0 || retVal != ROLE_STA)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
//
//Connecting to WLAN AP
//
retVal = WlanConnect();
//
// Acknowledge the watchdog so that it doesn't resets
//
WatchdogAck();
if(retVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
LOOP_FOREVER();
}
UART_PRINT("Connected to AP : %s \n\r",SSID_NAME);
UART_PRINT("Device IP : %d.%d.%d.%d\n\r\n\r",
SL_IPV4_BYTE(g_ulIpAddr,3),
SL_IPV4_BYTE(g_ulIpAddr,2),
SL_IPV4_BYTE(g_ulIpAddr,1),
SL_IPV4_BYTE(g_ulIpAddr,0));
UART_PRINT("\nStarting UDP Client\n\n\r");
UART_PRINT("Source IP : %d.%d.%d.%d\n\r"
"Destination IP : %d.%d.%d.%d\n\r"
"PORT : %d\n\r",
SL_IPV4_BYTE(g_ulIpAddr,3),
SL_IPV4_BYTE(g_ulIpAddr,2),
SL_IPV4_BYTE(g_ulIpAddr,1),
SL_IPV4_BYTE(g_ulIpAddr,0),
SL_IPV4_BYTE(ulDestinationIP,3),
SL_IPV4_BYTE(ulDestinationIP,2),
SL_IPV4_BYTE(ulDestinationIP,1),
SL_IPV4_BYTE(ulDestinationIP,0),
g_uiPortNum);
//
// Acknowledge the watchdog so that it doesn't resets
//
WatchdogAck();
//
// Send packets
//
BsdUdpClient(PORT_NUM,ulDestinationIP);
//
// power off the network processor
//
sl_Stop(SL_STOP_TIMEOUT);
while (1)
{
_SlNonOsMainLoopTask();
}
}
//*****************************************************************************
//
//! Network_IF_InitDriver
//! The function initializes a CC3200 device and triggers it to start operation
//!
//! \param uiMode (device mode in which device will be configured)
//!
//! \return 0 : sucess, -ve : failure
//
//*****************************************************************************
long
Network_IF_InitDriver(unsigned int uiMode)
{
long lRetVal = -1;
// Reset CC3200 Network State Machine
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of application
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(NULL,NULL,NULL);
if (lRetVal < 0 || lRetVal != ROLE_STA)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Started SimpleLink Device: STA Mode\n\r");
if(uiMode == ROLE_AP)
{
UART_PRINT("Switching to AP mode on application request\n\r");
// Switch to AP role and restart
lRetVal = sl_WlanSetMode(uiMode);
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_Stop(0xFF);
lRetVal = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(lRetVal);
// Check if the device is up in AP Mode
if (ROLE_AP == lRetVal)
{
// If the device is in AP mode, we need to wait for this event
// before doing anything
while(!IS_IP_ACQUIRED(g_ulStatus))
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#else
osi_Sleep(1);
#endif
}
}
else
{
// We don't want to proceed if the device is not coming up in AP-mode
ASSERT_ON_ERROR(DEVICE_NOT_IN_AP_MODE);
}
UART_PRINT("Re-started SimpleLink Device: AP Mode\n\r");
}
else if(uiMode == ROLE_P2P)
{
UART_PRINT("Switching to P2P mode on application request\n\r");
// Switch to AP role and restart
lRetVal = sl_WlanSetMode(uiMode);
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_Stop(0xFF);
lRetVal = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(lRetVal);
// Check if the device is in station again
if (ROLE_P2P != lRetVal)
{
// We don't want to proceed if the device is not coming up in P2P-mode
ASSERT_ON_ERROR(DEVICE_NOT_IN_P2P_MODE);
}
UART_PRINT("Re-started SimpleLink Device: P2P Mode\n\r");
}
else
{
// Device already started in STA-Mode
}
return 0;
}
//****************************************************************************
//
//! \brief Start simplelink, connect to the ap and run the ping test
//!
//! This function starts the simplelink, connect to the ap and start the ping
//! test on the default gateway for the ap
//!
//! \param[in] pvParameters - Pointer to the list of parameters that
//! can bepassed to the task while creating it
//!
//! \return None
//
//****************************************************************************
void WlanStationMode( void *pvParameters )
{
long lRetVal = -1;
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
{
UART_PRINT("Failed to configure the device in its default state\n\r");
}
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
LOOP_FOREVER();
}
UART_PRINT("Connection established w/ AP and IP is aquired \n\r");
UART_PRINT("Pinging...! \n\r");
//
// Checking the Lan connection by pinging to AP gateway
//
lRetVal = CheckLanConnection();
if(lRetVal < 0)
{
UART_PRINT("Device couldn't ping the gateway \n\r");
LOOP_FOREVER();
}
// Turn on GREEN LED when device gets PING response from AP
GPIO_IF_LedOn(MCU_EXECUTE_SUCCESS_IND);
//
// Checking the internet connection by pinging to external host
//
lRetVal = CheckInternetConnection();
if(lRetVal < 0)
{
UART_PRINT("Device couldn't ping the external host \n\r");
LOOP_FOREVER();
}
// Turn on ORAGE LED when device gets PING response from AP
GPIO_IF_LedOn(MCU_ORANGE_LED_GPIO);
UART_PRINT("Device pinged both the gateway and the external host \n\r");
UART_PRINT("WLAN STATION example executed successfully \n\r");
//
// power off the network processor
//
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
LOOP_FOREVER();
}
int main(void)
{
long lRetVal = -1;
//
// Initialize Board configurations
//
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
#ifndef NOTERM
InitTerm();
#endif
// configure RED LED
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its "
"default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
//Start simplelink
lRetVal = sl_Start(0,0,0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
/* Connect to our AP using SmartConfig method */
lRetVal = SmartConfigConnect();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
}
LOOP_FOREVER();
}
//*****************************************************************************
//
//! Configure the device as xmpp client
//!
//! \param pvParameters pointer to parameters
//!
//! \return None
//
//*****************************************************************************
static void XmppClient(void *pvParameters)
{
SlNetAppXmppOpt_t XmppOption;
SlNetAppXmppUserName_t UserName;
SlNetAppXmppPassword_t Password;
SlNetAppXmppDomain_t Domain;
SlNetAppXmppResource_t Resource;
unsigned char pRemoteJid[REMOTE_USERID_LEN];
unsigned char pRecvMessage[RECV_MSG_LEN];
signed short Status = 0;
long lRetVal = -1;
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
{
UART_PRINT("Failed to configure the device in its default state\n\r");
}
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
// Connecting to WLAN AP - Set with static parameters defined at the top
// After this call we will be connected and have IP address
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Unable to connect wlan.\n\r");
LOOP_FOREVER();
}
// Configuring different parameters which are required for XMPP connection
XmppOption.Port = XMPP_DST_PORT;
XmppOption.Family = SL_AF_INET;
XmppOption.SecurityMethod = SO_SECMETHOD_SSLV3;
XmppOption.SecurityCypher = SECURE_MASK_SSL_RSA_WITH_RC4_128_SHA;
XmppOption.Ip = XMPP_IP_ADDR;
//DNS query to get IP address of XMPP Server
// lRetVal = sl_NetAppDnsGetHostByName(XMPP_DOMAIN_NAME, \
// strlen((const char *)XMPP_DOMAIN_NAME), \
// (unsigned long*)&XmppOption.Ip, SL_AF_INET);
//
// if(lRetVal < 0)
// {
// UART_PRINT("Device couldn't retrive the host name \n\r");
// GPIO_IF_LedOn(MCU_RED_LED_GPIO);
// LOOP_FOREVER();
// }
lRetVal = sl_NetAppXmppSet(SL_NET_APP_XMPP_ID, NETAPP_XMPP_ADVANCED_OPT, \
sizeof(SlNetAppXmppOpt_t), (unsigned char *)&XmppOption);
if(lRetVal < 0)
{
UART_PRINT("Unable to connect wlan.\n\r");
LOOP_FOREVER();
}
// Configure Client's user name
memcpy(UserName.UserName, CLIENT_USER_NAME, strlen(CLIENT_USER_NAME));
UserName.Length = strlen(CLIENT_USER_NAME);
lRetVal = sl_NetAppXmppSet(SL_NET_APP_XMPP_ID, NETAPP_XMPP_USER_NAME, \
UserName.Length, \
(unsigned char *)&UserName);
if(lRetVal < 0)
{
UART_PRINT("Unable to set XMPP user id.\n\r");
LOOP_FOREVER();
}
// Configure Client's password
memcpy(Password.Password, CLIENT_PASSWORD, strlen(CLIENT_PASSWORD));
Password.Length = strlen(CLIENT_PASSWORD);
lRetVal = sl_NetAppXmppSet(SL_NET_APP_XMPP_ID, NETAPP_XMPP_PASSWORD, \
Password.Length, \
(unsigned char *)&Password);
if(lRetVal < 0)
{
UART_PRINT("Unable to set XMPP user password.\n\r");
LOOP_FOREVER();
}
memcpy(Domain.DomainName, XMPP_DOMAIN_NAME, strlen(XMPP_DOMAIN_NAME));
Domain.Length = strlen(XMPP_DOMAIN_NAME);
lRetVal = sl_NetAppXmppSet(SL_NET_APP_XMPP_ID, NETAPP_XMPP_DOMAIN, \
Domain.Length, \
(unsigned char *)&Domain);
if(lRetVal < 0)
{
UART_PRINT("Unable to XMPP domain.\n\r");
LOOP_FOREVER();
}
memcpy(Resource.Resource, XMPP_RESOURCE,strlen(XMPP_RESOURCE));
Resource.Length = strlen(XMPP_RESOURCE);
lRetVal = sl_NetAppXmppSet(SL_NET_APP_XMPP_ID, NETAPP_XMPP_RESOURCE, \
Resource.Length, \
(unsigned char *)&Resource);
if(lRetVal < 0)
{
UART_PRINT("Unable to set XMPP resources.\n\r");
LOOP_FOREVER();
}
while(sl_NetAppXmppConnect() < 0)
{
MAP_UtilsDelay(10000);
}
Status = sl_NetAppXmppRecv(pRemoteJid, REMOTE_USERID_LEN, pRecvMessage, \
RECV_MSG_LEN );
while(1)
{
while ( Status < 0)
{
MAP_UtilsDelay(10000);
Status = sl_NetAppXmppRecv(pRemoteJid, REMOTE_USERID_LEN, \
pRecvMessage, RECV_MSG_LEN );
}
//
// Toggle Orange LED to indicate if it gets some chat message
//
GPIO_IF_LedOn(MCU_ORANGE_LED_GPIO);
MAP_UtilsDelay(800000);
GPIO_IF_LedOff(MCU_ORANGE_LED_GPIO);
Status = sl_NetAppXmppSend(pRemoteJid, strlen((char*)pRemoteJid), \
pRecvMessage, strlen((char*)pRecvMessage) );
}
}
int main(void)
{
long lRetVal = -1;
//
// Initialize Board configurations
//
BoardInit();
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
{
UART_PRINT("Failed to configure the device in its default state\n\r");
}
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
/* Connect to our AP using SmartConfig method */
lRetVal = SetConnectionPolicy();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
// revert all settings
lRetVal = sl_WlanProfileDel(0xFF);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
LOOP_FOREVER();
}
//****************************************************************************
//
//! \brief start simplelink, wait for the sta to connect to the device and
//! run the ping test for that sta
//!
//! \param pvparameters is the pointer to the list of parameters that can be
//! passed to the task while creating it
//!
//! \return None
//
//****************************************************************************
void WlanAPMode( void *pvParameters )
{
int iTestResult = 0;
unsigned char ucDHCP;
long retVal = -1;
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
retVal = ConfigureSimpleLinkToDefaultState();
if(retVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == retVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER(__LINE__);
}
UART_PRINT("Device is configured in default state \n\r");
//
// Asumption is that the device is configured in station mode already
// and it is in its default state
//
retVal = sl_Start(NULL,NULL,NULL);
if (retVal < 0)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER(__LINE__);
}
UART_PRINT("Device started as STATION \n\r");
//
// Configure the networking mode and ssid name(for AP mode)
//
if(retVal != ROLE_AP)
{
if(ConfigureMode(retVal) !=ROLE_AP)
{
UART_PRINT("Unable to set AP mode, exiting Application...\n\r");
sl_Stop(SL_STOP_TIMEOUT);
return;
}
}
while(!IS_IP_ACQUIRED(g_ulStatus))
{
//looping till ip is acquired
}
unsigned char len = sizeof(_NetCfgIpV4Args_t);
_NetCfgIpV4Args_t ipV4 = {0};
retVal = sl_NetCfgGet(SL_IPV4_STA_P2P_CL_GET_INFO,&ucDHCP,&len,
(unsigned char *)&ipV4);
if (retVal < 0)
{
UART_PRINT("Failed to get network configuration \n\r");
LOOP_FOREVER(__LINE__);
}
UART_PRINT("Connect a client to Device\n\r");
while(!IS_IP_LEASED(g_ulStatus))
{
//wating for the client to connect
}
UART_PRINT("Client is connected to Device\n\r");
iTestResult = PingTest(g_ulStaIp);
UNUSED(ucDHCP);
UNUSED(iTestResult);
sl_WlanSetMode(ROLE_STA);
/* Switch off Network processor */
sl_Stop(SL_STOP_TIMEOUT);
UART_PRINT("Application exits\n\r");
while(1);
}
int connectToAccessPoint(){
long lRetVal = -1;
GPIO_IF_LedConfigure(LED1|LED3);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
lRetVal = InitializeAppVariables();
ASSERT_ON_ERROR(lRetVal);
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
return lRetVal;
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
///
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
return lRetVal;
}
UART_PRINT("Device started as STATION \n\r");
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
return lRetVal;
}
UART_PRINT("Connection established w/ AP and IP is aquired \n\r");
return 0;
}
//****************************************************************************
// MAIN FUNCTION
//****************************************************************************
void main()
{
long lRetVal = -1;
//
// Board Initialization
//
BoardInit();
//
// uDMA Initialization
//
UDMAInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
//
// Configuring UART
//
InitTerm();
//
// Display banner
//
DisplayBanner(APPLICATION_NAME);
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its desired state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Asumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || lRetVal != ROLE_STA)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
UART_PRINT("Connecting 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();
}
UART_PRINT("Connected to AP: %s \n\r",SSID_NAME);
UART_PRINT("Device IP: %d.%d.%d.%d\n\r\n\r",
SL_IPV4_BYTE(g_ulIpAddr,3),
SL_IPV4_BYTE(g_ulIpAddr,2),
SL_IPV4_BYTE(g_ulIpAddr,1),
SL_IPV4_BYTE(g_ulIpAddr,0));
#ifdef USER_INPUT_ENABLE
lRetVal = UserInput();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
#else
lRetVal = BsdUdpClient(PORT_NUM);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
lRetVal = BsdUdpServer(PORT_NUM);
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
#endif
UART_PRINT("Exiting Application ...\n\r");
//
// power off the network processor
//
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
while (1)
{
_SlNonOsMainLoopTask();
}
}
//****************************************************************************
//
//! Task function implements the Antenna Selection functionality
//!
//! \param none
//!
//! This function
//! 1. Starts Device in STA Mode
//! 2. Scans, Sort and Stores all the AP with Antenna 1
//! 3. Scans, Sort and Stores all the AP with Antenna 2
//! 4. Switch to AP Mode and Wait for AP Configuration from Browser
//! 5. Switch to STA Mode and Connect to Configured AP with Selected Antenna
//!
//! \return None.
//
//****************************************************************************
void AntennaSelection(void* pTaskParams)
{
int iDeviceMode = 0;
unsigned char ucCountSSID;
unsigned char ucCountSSIDAnt2;
long lRetVal = -1;
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
{
UART_PRINT("Failed to configure the device in its default state\n\r");
}
LOOP_FOREVER(__LINE__);
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER(__LINE__);
}
UART_PRINT("Device started as STATION \n\r");
//
// Start the driver
//
iDeviceMode = InitDriver();
if (iDeviceMode == ROLE_AP)
{
//Device in AP Mode, Wait for Initialization to Complete
while (g_ucIpObtained == 0)
{
MAP_UtilsDelay(100);
}
}
sl_WlanSetMode(ROLE_STA);
if (iDeviceMode == ROLE_AP)
DeInitDriverAP();
else
DeInitDriver();
g_ucIpObtained = 0;
g_ucConnectionStatus = 0;
InitDriver();
//Select Antenna 1
AntennaSelect(1);
//Get Scan Result
ucCountSSID = GetScanResult(&g_netEntries[0]);
//Select Antenna 2
AntennaSelect(2);
//Get Scan Result
ucCountSSIDAnt2 = GetScanResult(&g_netEntriesAnt2[0]);
//Sort Scan Result
SortByRSSI(&g_netEntries[0],ucCountSSID);
SortByRSSI(&g_netEntriesAnt2[0],ucCountSSIDAnt2);
while(!g_ucAntSelectDone)
{
//Switch to AP Mode
sl_WlanSetMode(ROLE_AP);
DeInitDriver();
g_ucIpObtained = 0;
g_ucConnectionStatus = 0;
//Initialize the SLHost Driver
InitDriver();
//Wait for Ip Acquired Event in AP Mode
while (g_ucIpObtained == 0)
{
MAP_UtilsDelay(100);
}
//
// Wait for AP Configuraiton, Open Browser and Configure AP
//
while (g_ucProfileAdded && !g_ucAntSelectDone)
{
MAP_UtilsDelay(100);
}
g_ucProfileAdded = 1;
//Switch to STA Mode
sl_WlanSetMode(ROLE_STA);
//AP Configured, Restart in STA Mode
DeInitDriverAP();
g_ucIpObtained = 0;
g_ucConnectionStatus = 0;
//MAP_UtilsDelay(10000000);
InitDriver();
//
// Connect to the Configured Access Point
//
WlanConnect();
g_ucConnectedToConfAP = g_ucConnectionStatus;
sl_WlanDisconnect();
}
while (1)
{
}
}
//*****************************************************************************
//
//! Main which invokes the WPS provisioning APIs
//!
//! \param none
//!
//! \return 0
//
//*****************************************************************************
void
main()
{
long lRetVal = -1;
//
// Initialize board configurations
BoardInit();
//
// Configure the pinmux settings for the peripherals exercised
//
PinMuxConfig();
#ifndef NOTERM
//
// Configuring UART
//
InitTerm();
#endif
// configure RED LED
GPIO_IF_LedConfigure(LED1);
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Initialzing the CC3200 networking layers
//
lRetVal = sl_Start(NULL, NULL, NULL);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
//
// Connecting to WLAN AP with WPS security, using Push Button method.
// The AP parameters are set with static values defined at the top.
// After this function call we will be connected and have IP address.
//
lRetVal = WpsConnectPushButton();
if(lRetVal < 0)
{
ERR_PRINT("Connect through push button failed\n\r");
LOOP_FOREVER();
}
//
// Turn ON the RED LED to indicate connection success
//
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
//
// Wait for a while
//
MAP_UtilsDelay(80000000);
//
// Disconnect from the WLAN AP.
// After this function call we will be disconnected
//
lRetVal = WlanDisconnect();
if(lRetVal < 0)
{
ERR_PRINT("Disconect failed\n\r");
LOOP_FOREVER();
}
MAP_UtilsDelay(8000000);
//
// Turn OFF the RED LED to indicate connection disconnected
//
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
//
// Connecting to WLAN AP with WPS security, using Pin Code method.
// The default pin code is as specified in WPS_PIN_CODE.
// The AP parameters are set with static values defined at the top.
// After this function call we will be connected and have IP address.
//
lRetVal = WpsConnectPinCode();
if(lRetVal < 0)
{
ERR_PRINT("Connect through pin code failed\n\r");
LOOP_FOREVER();
}
//
// Turn ON the RED LED to indicate connection success
//
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
//
// Wait for a while
//
MAP_UtilsDelay(80000000);
//
// Disconnect from the WLAN AP.
// After this function call we will be disconnected
//
lRetVal = WlanDisconnect();
if(lRetVal < 0)
{
ERR_PRINT("Disconnect failed\n\r");
LOOP_FOREVER();
}
//
// Turn OFF the RED LED to indicate connection disconnected
//
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
while (1)
{
_SlNonOsMainLoopTask();
}
}
int main()
{
UserIn User;
int iFlag = 1;
long lRetVal = -1;
char cChar;
unsigned char policyVal;
//
// Initialize Board configuration
//
BoardInit();
//
//
//Pin muxing
//
PinMuxConfig();
// Configuring UART
//
InitTerm();
DisplayBanner(APPLICATION_NAME);
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
UART_PRINT("Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
CLR_STATUS_BIT_ALL(g_ulStatus);
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
//
// reset all network policies
//
lRetVal = sl_WlanPolicySet( SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(0,0,0,0,0),
&policyVal,
1 /*PolicyValLen*/);
if (lRetVal < 0)
{
UART_PRINT("Failed to set policy \n\r");
LOOP_FOREVER();
}
while (iFlag)
{
User = UserInput();
switch(User.choice)
{
case(1):
/*******An example of Tx continuous on user selected channel, rate 11,
* user selected number of packets, minimal delay between packets*******/
lRetVal = Tx_continuous(User.channel,User.rate,User.packets, \
User.Txpower,0);
if(lRetVal < 0)
{
UART_PRINT("Error during transmission of raw data\n\r");
LOOP_FOREVER();
}
break;
case(2):
/******An example of Rx statistics using user selected channel *******/
lRetVal = RxStatisticsCollect();
if(lRetVal < 0)
{
UART_PRINT("Error while collecting statistics data\n\r");
LOOP_FOREVER();
}
break;
}
UART_PRINT("\n\rEnter \"1\" to restart or \"0\" to quit: ");
//
// Wait to receive a character over UART
//
cChar = MAP_UARTCharGet(CONSOLE);
//
// Echo the received character
//
MAP_UARTCharPut(CONSOLE, cChar);
UART_PRINT("\n\r");
iFlag = atoi(&cChar);
}
UART_PRINT("\r\nEnding the application....");
//
// power off network processor
//
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
LOOP_FOREVER();
}
//*****************************************************************************
//
//! NwpFilter - Function which Creates and Enables the Filter
//!
//! \param pvParameters
//!
//! \return 0
//!
//*****************************************************************************
static int NwpFilter(void *pvParameters)
{
long lRetVal = 0;
InitializeAppVariables();
//
// Following function configure the device to default state by cleaning
// the persistent settings stored in NVMEM (viz. connection profiles &
// policies, power policy etc)
//
// Applications may choose to skip this step if the developer is sure
// that the device is in its default state at start of applicaton
//
// Note that all profiles and persistent settings that were done on the
// device will be lost
//
lRetVal = ConfigureSimpleLinkToDefaultState();
if(lRetVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == lRetVal)
{
UART_PRINT("Failed to configure the device in its default state\n\r");
}
LOOP_FOREVER();
}
UART_PRINT("Device is configured in default state \n\r");
//
// Assumption is that the device is configured in station mode already
// and it is in its default state
//
lRetVal = sl_Start(0, 0, 0);
if (lRetVal < 0 || ROLE_STA != lRetVal)
{
UART_PRINT("Failed to start the device \n\r");
LOOP_FOREVER();
}
UART_PRINT("Device started as STATION \n\r");
//
// Reset policy settings
//
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION, \
SL_CONNECTION_POLICY(0,0,0,0,0), 0, 0);
//
// This function creates two different filters:
// (1) Filter packets according to remote MAC
// (2) Filter packets according to remote IP address
//
lRetVal=CreateFilters();
if (lRetVal < 0)
{
UART_PRINT("Filter creation failed\n\r");
LOOP_FOREVER();
}
//
// Activate pre-defined filters - The filters will be deleted upon reset
//
if(EnableAllFilters() < 0)
{
UART_PRINT("Unable to enable filter \n\r");
LOOP_FOREVER();
}
//
//Connecting to WLAN AP
//
lRetVal = WlanConnect();
if(lRetVal < 0)
{
UART_PRINT("Failed to establish connection w/ an AP \n\r");
LOOP_FOREVER();
}
UART_PRINT("Connection established w/ AP and IP is aquired \n\r");
//
// After calling this function, you can start sending data to CC3200 IP
// address on PORT_NUM TCP connection will be refused if remote MAC/IP is of
// the filtered. It's also possible to enable the filters after TCP
// connection, resulting in TCP packets to not being received
//
lRetVal = BsdTcpServer(PORT_NUM);
if(lRetVal < 0)
{
UART_PRINT("Failure in TCP server\n\r");
LOOP_FOREVER();
}
//
// Power off Network processor
//
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
return 0;
}
