//--tested, working--//
uint8_t WiFiClass::status()
{
if (!_initialized) {
init();
}
if(role == ROLE_AP)
return WL_AP_MODE;
//
//This class variable is maintained by the slWlanEvenHandler
//
_SlNonOsMainLoopTask();
return WiFi_status;
}
//****************************************************************************
//
//! Confgiures the mode in which the device will work
//!
//! \param iMode is the current mode of the device
//!
//! This function
//! 1. prompt user for desired configuration and accordingly configure the
//! networking mode(STA or AP).
//! 2. also give the user the option to configure the ssid name in case of
//! AP mode.
//!
//! \return 0: success, -ve: failure.
//
//****************************************************************************
long ConfigureMode(int iMode)
{
char cCharacter = 'a';
char pcSsidName[33];
unsigned short len;
long lRetVal = -1;
while(cCharacter != '1' && cCharacter != '2' && cCharacter != '3')
{
UART_PRINT("Do you Want to Switch Mode\n\r1. STA mode\n\r2. AP Mode\n\r"
"3. P2P Mode :");
cCharacter = MAP_UARTCharGet(CONSOLE);
MAP_UARTCharPut(CONSOLE,cCharacter);
MAP_UARTCharPut(CONSOLE,'\n');
MAP_UARTCharPut(CONSOLE,'\r');
}
if(cCharacter == '1')
{
lRetVal = sl_WlanSetMode(ROLE_STA);
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("mode configured\n\r");
}
else if(cCharacter == '2')
{
UART_PRINT("Enter the SSID name: ");
GetSsidName(pcSsidName,33);
_SlNonOsMainLoopTask();
lRetVal = sl_WlanSetMode(ROLE_AP);
ASSERT_ON_ERROR(lRetVal);
len = strlen(pcSsidName);
lRetVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_SSID, len,
(unsigned char*) pcSsidName);
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("mode configured\n\r");
}
else if(cCharacter == '3')
{
lRetVal = sl_WlanSetMode(ROLE_P2P);
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("mode configured\n\r");
}
else
{
UART_PRINT("Wrong input\n\r");
}
return 0;
}
//******************************************************************************
// \brief Connecting to a WLAN Access point
//
// This function connects to the required AP (SSID_NAME).
// This code example assumes the AP doesn't use WIFI security.
// The function will return once we are connected and have acquired IP address
//
// \param[in] None
//
// \return None
//
// \note
//
// \warning If the WLAN connection fails or we don't aquire an IP address,
// We will be stuck in this function forever.
//******************************************************************************
void WlanConnect()
{
SlSecParams_t secParams;
secParams.Key = "";
secParams.KeyLen = 0;
secParams.Type = SL_SEC_TYPE_OPEN;
sl_WlanConnect(SSID_NAME, strlen(SSID_NAME), 0, &secParams, 0);
while((0 == (g_Status & CONNECTED)) || (0 == (g_Status & IP_AQUIRED)))
{
_SlNonOsMainLoopTask();
}
}
void Wifi_Connect(char *pConfig, SlSecParams_t *secParams) {
int32_t retVal;
retVal = configureSimpleLinkToDefaultState(pConfig); // set policies
if(retVal < 0)Crash(4000000);
retVal = sl_Start(0, pConfig, 0);
if((retVal < 0) || (ROLE_STA != retVal) ) Crash(8000000);
secParams->Key = PASSKEY;
secParams->KeyLen = strlen(PASSKEY);
secParams->Type = SEC_TYPE; // OPEN, WPA, or WEP
sl_WlanConnect(SSID_NAME, strlen(SSID_NAME), 0, secParams, 0);
while((0 == (g_Status&CONNECTED)) || (0 == (g_Status&IP_AQUIRED))){
_SlNonOsMainLoopTask();
}
UARTprintf("Connected\n");
}
unsigned char CC3200Helpers_IsConnected()
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
if ( ROLE_AP == s_eRequestedWlanMode )
{
return 0 != s_flAcquiredIP;
}
if ( ROLE_STA == s_eRequestedWlanMode )
{
return s_flWLANConnected && s_flAcquiredIP;
}
return 0;
}
//*****************************************************************************
//! \brief This function checks the internet connection by pinging
//! the external-host (HOST_NAME)
//!
//! \param None
//!
//! \return 0 on success, negative error-code on error
//!
//*****************************************************************************
static long CheckInternetConnection() {
SlPingStartCommand_t pingParams = { 0 };
SlPingReport_t pingReport = { 0 };
unsigned long ulIpAddr = 0;
long lRetVal = -1;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_PING_DONE);
g_ulPingPacketsRecv = 0;
// Set the ping parameters
pingParams.PingIntervalTime = PING_INTERVAL;
pingParams.PingSize = PING_PKT_SIZE;
pingParams.PingRequestTimeout = PING_TIMEOUT;
pingParams.TotalNumberOfAttempts = NO_OF_ATTEMPTS;
pingParams.Flags = 0;
pingParams.Ip = g_ulGatewayIP;
// Check for Internet connection
lRetVal = sl_NetAppDnsGetHostByName(HOST_NAME, sizeof(HOST_NAME), &ulIpAddr,
SL_AF_INET);
ASSERT_ON_ERROR(__LINE__, lRetVal);
// Replace the ping address to match HOST_NAME's IP address
pingParams.Ip = ulIpAddr;
// Try to ping HOST_NAME
lRetVal = sl_NetAppPingStart((SlPingStartCommand_t*) &pingParams,
SL_AF_INET, (SlPingReport_t*) &pingReport, SimpleLinkPingReport);
ASSERT_ON_ERROR(__LINE__, lRetVal);
// Wait
while (!IS_PING_DONE(g_ulStatus)) {
// Wait for Ping Event
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
if (0 == g_ulPingPacketsRecv) {
// Problem with internet connection
return INTERNET_CONNECTION_FAILED;
}
// Internet connection is successful
return SUCCESS;
}
/*!
\brief Connecting to a WLAN Access point
This function connects to the required AP (SSID_NAME).
The function will return once we are connected and have acquired IP address
\param[in] None
\return 0 on success, negative error-code on error
\note
\warning If the WLAN connection fails or we don't acquire an IP address,
We will be stuck in this function forever.
*/
static _i32 establishConnectionWithAP()
{
SlSecParams_t secParams = {0};
_i32 retVal = 0;
secParams.Key = "";
secParams.KeyLen = 0;
secParams.Type = SL_SEC_TYPE_OPEN;
retVal = sl_WlanConnect(UNSEC_SSID_NAME, pal_Strlen(UNSEC_SSID_NAME), 0, &secParams, 0);
ASSERT_ON_ERROR(retVal);
/* Wait */
while((!IS_CONNECTED(g_Status)) || (!IS_IP_ACQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }
return SUCCESS;
}
/*!
\brief Connecting to a WLAN Access point
This function connects to the required AP (SSID_NAME).
The function will return once we are connected and have acquired IP address
\param[in] None
\return 0 on success, negative error-code on error
\note
\warning If the WLAN connection fails or we don't acquire an IP address,
We will be stuck in this function forever.
*/
_i32 establishConnectionWithAP()
{
_i32 retVal = 0;
SlSecParams_t secParams = {0};
secParams.Key = (_i8 *)PASSKEY;
secParams.KeyLen = pal_Strlen(PASSKEY);
secParams.Type = SEC_TYPE;
retVal = sl_WlanConnect((_i8 *)SSID_NAME, pal_Strlen(SSID_NAME), 0, &secParams, 0);
ASSERT_ON_ERROR(retVal);
/* Wait */
while((!IS_CONNECTED(g_Status)) || (!IS_IP_ACQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }
return SUCCESS;
}
/*!
\brief This function checks the internet connection by pinging
the external-host (HOST_NAME)
\param[in] None
\return 0 on success, negative error-code on error
*/
static _i32 checkInternetConnection()
{
SlPingStartCommand_t pingParams = {0};
SlPingReport_t pingReport = {0};
_u32 ipAddr = 0;
_i32 retVal = -1;
CLR_STATUS_BIT(g_Status, STATUS_BIT_PING_DONE);
g_PingPacketsRecv = 0;
/* Set the ping parameters */
pingParams.PingIntervalTime = PING_INTERVAL;
pingParams.PingSize = PING_PKT_SIZE;
pingParams.PingRequestTimeout = PING_TIMEOUT;
pingParams.TotalNumberOfAttempts = NO_OF_ATTEMPTS;
pingParams.Flags = 0;
pingParams.Ip = g_GatewayIP;
/* Check for Internet connection */
retVal = sl_NetAppDnsGetHostByName((_i8 *)HOST_NAME, pal_Strlen(HOST_NAME), &ipAddr, SL_AF_INET);
ASSERT_ON_ERROR(retVal);
/* Replace the ping address to match HOST_NAME's IP address */
pingParams.Ip = ipAddr;
/* Try to ping HOST_NAME */
retVal = sl_NetAppPingStart( (SlPingStartCommand_t*)&pingParams, SL_AF_INET,
(SlPingReport_t*)&pingReport, SimpleLinkPingReport);
ASSERT_ON_ERROR(retVal);
/* Wait */
while(!IS_PING_DONE(g_Status)) { _SlNonOsMainLoopTask(); }
if (0 == g_PingPacketsRecv)
{
/* Problem with internet connection*/
ASSERT_ON_ERROR(INTERNET_CONNECTION_FAILED);
}
/* Internet connection is successful */
return SUCCESS;
}
//*****************************************************************************
//
//! \brief Disconnecting from a WLAN Accesspoint
//!
//! \param[in] None
//!
//! \return 0 : Success, -ve : failure
//
//*****************************************************************************
long
WlanDisconnect()
{
long lRetVal = -1;
lRetVal = sl_WlanDisconnect();
if(0 == lRetVal)
{
// Wait
while(IS_CONNECTED(g_ulStatus))
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
}
return lRetVal;
}
//*****************************************************************************
//
//! \brief Connecting to a WLAN Accesspoint
//! This function connects to the required AP (SSID_NAME).
//! This code example assumes the AP doesn't use WIFI security.
//! The function will return only once we are connected
//! and have acquired IP address
//!
//! \param[in] None
//!
//! \return None
//!
//! \note 0 on success else error code
//!
//! \warning If the WLAN connection fails or we don't aquire an IP address,
//! We will be stuck in this function forever.
//
//*****************************************************************************
long
WpsConnectPinCode()
{
SlSecParams_t secParams;
long lRetVal = -1;
secParams.Key = WPS_PIN_CODE;
secParams.KeyLen = strlen(WPS_PIN_CODE);
secParams.Type = SL_SEC_TYPE_WPS_PIN;
lRetVal = sl_WlanConnect(SSID_NAME, strlen(SSID_NAME), 0, &secParams, 0);
ASSERT_ON_ERROR(lRetVal);
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
_SlNonOsMainLoopTask();
}
return SUCCESS;
}
//****************************************************************************
// MAIN FUNCTION
//****************************************************************************
void main()
{
Init();
int ret = initTemperatureSensor();
if (ret == 0) { // 0 is success
IOBEAM_LOG("Temperature sensor initialized.\r\n");
Iobeam iobeam;
ret = iobeam_Init(&iobeam, PROJECT_ID, PROJECT_TOKEN, DEVICE_ID);
if (ret < 0) {
IOBEAM_ERR("iobeam init failed, quitting...\r\n");
goto err_iobeam;
}
iobeam.RegisterDevice();
iobeam.StartTimeKeeping();
float temperature = 0.0;
while (1) {
IOBEAM_LOG("---------\r\n");
ret = getTemperature(&temperature);
if (ret < 0) {
IOBEAM_ERR("Error getting temp: %d\r\n", ret);
break;
}
IOBEAM_LOG("temperature: %f\r\n", temperature);
ret = iobeam.SendFloat("temperature", temperature);
IOBEAM_LOG("success: %d\r\n", ret);
delay(MEASURE_DELAY_SECS);
}
iobeam_Finish();
}
err_iobeam:
sl_Stop(SL_STOP_TIMEOUT);
IOBEAM_LOG("Exiting Application ...\n\r");
while (1) {
_SlNonOsMainLoopTask();
}
}
//--tested, working--//
IPAddress WiFiClass::localIP()
{
//
//the local IP is maintained with callbacks, so _SlNonOsMainLoopTask()
//is critical. The IP is "written" into the buffer to avoid memory errors
//
_SlNonOsMainLoopTask();
SlNetCfgIpV4Args_t config = {0};
unsigned char len = sizeof(SlNetCfgIpV4Args_t);
sl_NetCfgGet(SL_IPV4_STA_P2P_CL_GET_INFO, NULL, &len, (unsigned char*)&config);
//
//change the uint32_t IP to the IPAddress class and return
//
IPAddress retIP(0,0,0,0);
retIP = sl_Htonl(config.ipV4);
return retIP;
}
//*****************************************************************************
//
// Ping an IP Address
// Arguments:
// [1] IP address to ping
// [2] (optional) max number of tries
// [3] (optional) timeout in milliseconds
//
//*****************************************************************************
int
CMD_ping(int argc, char **argv)
{
SlPingStartCommand_t PingParams;
SlPingReport_t Report;
_NetCfgIpV4Args_t ipV4;
unsigned char len = sizeof(_NetCfgIpV4Args_t);;
unsigned char IsDHCP = 0;
/* Read the IP parameter */
sl_NetCfgGet(SL_IPV4_STA_P2P_CL_GET_INFO,&IsDHCP,&len,
(unsigned char *)&ipV4);
/* Set the ping parameters */
PingParams.PingIntervalTime = PING_INTERVAL;
PingParams.PingSize = PING_SIZE;
PingParams.PingRequestTimeout = PING_TIMEOUT;
PingParams.TotalNumberOfAttempts = NO_OF_ATTEMPTS;
PingParams.Flags = 0;
PingParams.Ip = ipV4.ipV4Gateway; /* Fill the GW IP address, which is our AP address */
/* Check for LAN connection */
UARTprintf("Pinging the Gateway...\n");
sl_NetAppPingStart((SlPingStartCommand_t*)&PingParams, SL_AF_INET,
(SlPingReport_t*)&Report, SimpleLinkPingReport);
while(0 == (g_Status & PING_DONE))
{
_SlNonOsMainLoopTask();
}
g_Status &= ~(1 << PING_DONE_STATUS_BIT);
UARTprintf("Ping Done\n");
if (!g_PingPacketsRecv)
{
/* Problem with LAN connection */
UARTprintf("Problem with the LAN connection\n");
return -1;
}
return 0;
}
//****************************************************************************
//
//! \brief Connecting to a WLAN Accesspoint
//!
//! This function connects to the required AP (SSID_NAME) with Security
//! parameters specified in te form of macros at the top of this file
//!
//! \param None
//!
//! \return None
//!
//! \warning If the WLAN connection fails or we don't aquire an IP
//! address, It will be stuck in this function forever.
//
//****************************************************************************
static long WlanConnect()
{
SlSecParams_t secParams = {0};
long lRetVal = 0;
secParams.Key = SECURITY_KEY;
secParams.KeyLen = strlen(SECURITY_KEY);
secParams.Type = SECURITY_TYPE;
lRetVal = sl_WlanConnect(SSID_NAME, strlen(SSID_NAME), 0, &secParams, 0);
ASSERT_ON_ERROR(lRetVal);
// Wait for WLAN Event
while((!IS_CONNECTED(g_ulStatus))|| (!IS_IP_ACQUIRED(g_ulStatus)))
{
_SlNonOsMainLoopTask();
}
return SUCCESS;
}
_SlNonOsRetVal_t _SlNonOsSemGet(_SlNonOsSemObj_t* pSyncObj,
_SlNonOsSemObj_t WaitValue, _SlNonOsSemObj_t SetValue,
_SlNonOsTime_t Timeout)
{
while (Timeout > 0) {
if (WaitValue == *pSyncObj) {
*pSyncObj = SetValue;
break;
}
if (Timeout != NONOS_WAIT_FOREVER) {
Timeout--;
}
_SlNonOsMainLoopTask();
}
if (0 == Timeout) {
return NONOS_RET_ERR;
} else {
return NONOS_RET_OK;
}
}
//****************************************************************************
//
//! \brief Connecting to a WLAN Accesspoint
//!
//! This function connects to the required AP (SSID_NAME) with Security
//! parameters specified in te form of macros at the top of this file
//!
//! \param[in] None
//!
//! \return status value
//!
//! \warning If the WLAN connection fails or we don't aquire an IP
//! address, It will be stuck in this function forever.
//
//****************************************************************************
static long WlanConnect()
{
SlSecParams_t secParams = {0};
long lRetVal = 0;
secParams.Key = (signed char*)SECURITY_KEY;
secParams.KeyLen = strlen(SECURITY_KEY);
secParams.Type = SECURITY_TYPE;
lRetVal = sl_WlanConnect((signed char*)SSID_NAME, strlen(SSID_NAME), 0, \
&secParams, 0);
ASSERT_ON_ERROR(lRetVal);
while(g_ulStatus != 1)
{
// Wait for WLAN Event
_SlNonOsMainLoopTask();
}
return SUCCESS;
}
//*****************************************************************************
//! \brief This function checks the LAN connection by pinging the AP's gateway
//!
//! \param None
//!
//! \return 0 on success, negative error-code on error
//!
//*****************************************************************************
static long CheckLanConnection()
{
SlPingStartCommand_t pingParams = {0};
SlPingReport_t pingReport = {0};
long lRetVal = -1;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_PING_DONE);
g_ulPingPacketsRecv = 0;
// Set the ping parameters
pingParams.PingIntervalTime = PING_INTERVAL;
pingParams.PingSize = PING_PKT_SIZE;
pingParams.PingRequestTimeout = PING_TIMEOUT;
pingParams.TotalNumberOfAttempts = NO_OF_ATTEMPTS;
pingParams.Flags = 0;
pingParams.Ip = g_ulGatewayIP;
// Check for LAN connection
lRetVal = sl_NetAppPingStart((SlPingStartCommand_t*)&pingParams, SL_AF_INET,
(SlPingReport_t*)&pingReport, SimpleLinkPingReport);
ASSERT_ON_ERROR(lRetVal);
// Wait for NetApp Event
while(!IS_PING_DONE(g_ulStatus))
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
if(0 == g_ulPingPacketsRecv)
{
//Problem with LAN connection
ASSERT_ON_ERROR(LAN_CONNECTION_FAILED);
}
// LAN connection is successful
return SUCCESS;
}
//****************************************************************************
//
//! \brief Connecting to a WLAN Accesspoint
//!
//! This function connects to the required AP (SSID_NAME) with Security
//! parameters specified in te form of macros at the top of this file
//!
//! \param[in] None
//!
//! \return status value
//!
//! \warning If the WLAN connection fails or we don't aquire an IP
//! address, It will be stuck in this function forever.
//
//****************************************************************************
long NetWlanConnect(const char *cssid, SlSecParams_t *secParams)
{
long lRetVal = 0;
lRetVal = sl_WlanConnect((signed char *)cssid, strlen(cssid), 0, secParams, 0);
if( lRetVal != 0)
{
return lRetVal;
}
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
// Wait for WLAN Event
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
return SUCCESS;
}
_SlNonOsRetVal_t _SlNonOsSemGet(_SlNonOsSemObj_t* pSyncObj, _SlNonOsSemObj_t WaitValue, _SlNonOsSemObj_t SetValue, _SlNonOsTime_t Timeout)
{
#ifdef _SlSyncWaitLoopCallback
_SlNonOsTime_t timeOutRequest = Timeout;
#endif
while (Timeout>0)
{
if (WaitValue == *pSyncObj)
{
*pSyncObj = SetValue;
break;
}
if (Timeout != NONOS_WAIT_FOREVER)
{
Timeout--;
}
_SlNonOsMainLoopTask();
#ifdef _SlSyncWaitLoopCallback
if( (__NON_OS_SYNC_OBJ_SIGNAL_VALUE == WaitValue) && (timeOutRequest != NONOS_NO_WAIT) )
{
if (WaitValue == *pSyncObj)
{
*pSyncObj = SetValue;
break;
}
_SlSyncWaitLoopCallback();
}
#endif
}
if (0 == Timeout)
{
return NONOS_RET_ERR;
}
else
{
return NONOS_RET_OK;
}
}
/*!
\brief Connecting to a WLAN Access point using SmartConfig provisioning
This function enables SmartConfig provisioning for adding a new connection
profile to CC3100. Since we have set the connection policy to Auto, once
SmartConfig is complete, CC3100 will connect automatically to the new
connection profile added by smartConfig.
\param[in] None
\return 0 on success, negative error-code on error
\note
\warning If the WLAN connection fails or we don't acquire an IP
address, We will be stuck in this function forever.
*/
static _i32 SmartConfigConnect()
{
_u8 policyVal = 0;
_i32 retVal = -1;
/* Clear all profiles */
/* This is of course not a must, it is used in this example to make sure
* we will connect to the new profile added by SmartConfig
*/
retVal = sl_WlanProfileDel(WLAN_DEL_ALL_PROFILES);
ASSERT_ON_ERROR(retVal);
/* set AUTO policy */
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1, 0, 0, 0, 0),
&policyVal,
1); /*PolicyValLen*/
ASSERT_ON_ERROR(retVal);
/* Start SmartConfig
* This example uses the unsecured SmartConfig method
*/
retVal = sl_WlanSmartConfigStart(0, /* groupIdBitmask */
SMART_CONFIG_CIPHER_NONE, /* cipher */
0, /* publicKeyLen */
0, /* group1KeyLen */
0, /* group2KeyLen */
(const _u8 *)"", /* publicKey */
(const _u8 *)"", /* group1Key */
(const _u8 *)""); /* group2Key */
ASSERT_ON_ERROR(retVal);
/* Wait */
while((!IS_CONNECTED(g_Status)) || (!IS_IP_ACQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }
return SUCCESS;
}
//****************************************************************************
//
//! read the current configuration and displays the same.
//!
//! \param iMode is the current mode of the device
//! This function
//! 1. display the current networking mode and also dislays the ssid name
//! in cas eof AP mode.
//!
//! \return 0: success, -ve: failure
//
//****************************************************************************
long DisplayCurrentConfig(int iMode)
{
char pcSsidName[32];
unsigned short len;
unsigned short config_opt;
long lRetVal = -1;
if(iMode == ROLE_STA)
{
UART_PRINT("Device is in STA mode\n\r");
}
else if(iMode == ROLE_AP)
{
UART_PRINT("Device is in AP mode\n\r");
while(!g_usIpObtained)
{
_SlNonOsMainLoopTask();
}
len = 32;
config_opt = WLAN_AP_OPT_SSID;
lRetVal = sl_WlanGet(SL_WLAN_CFG_AP_ID, &config_opt , &len,
(unsigned char*) pcSsidName);
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("AP name: %s\n\r",pcSsidName);
}
else if(iMode == ROLE_P2P)
{
UART_PRINT("Device is in P2P mode\n\r");
}
else
{
UART_PRINT("Could not retreive mode\n\r");
}
return 0;
}
/*!
\brief Connecting to a WLAN Access point
This function connects to the required AP (ENT_SSID_NAME).
The function will return once we are connected and have acquired IP address
\param[in] None
\return 0 on success, negative error-code on error
\note
\warning If the WLAN connection fails or we don't acquire an IP address,
We will be stuck in this function forever.
*/
static _i32 establishConnectionWithAP()
{
SlSecParams_t secParams = {0};
SlSecParamsExt_t eapParams = {0};
_i32 retVal = -1;
secParams.Key = ENT_PASS_KEY;
secParams.KeyLen = pal_Strlen(ENT_PASS_KEY);
secParams.Type = ENT_SEC_TYPE;
eapParams.EapMethod = ENT_SEC_METHOD;
eapParams.User = ENT_USER_NAME;
eapParams.UserLen = pal_Strlen(ENT_USER_NAME);
eapParams.AnonUserLen = 0;
retVal = sl_WlanConnect(ENT_SSID_NAME, pal_Strlen(ENT_SSID_NAME), NULL, &secParams, &eapParams);
ASSERT_ON_ERROR(retVal);
/* Wait */
while((!IS_CONNECTED(g_Status)) || (!IS_IP_ACQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }
return SUCCESS;
}
int WiFiClass::startSmartConfig()
{
unsigned char policyVal;
if (!_initialized) {
init();
}
if(sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,1),
&policyVal,
1 /*PolicyValLen*/) < 0) return -1;
if(sl_WlanProfileDel(WLAN_DEL_ALL_PROFILES) < 0)
return -1;
sl_WlanSmartConfigStart(0, //groupIdBitmask
SMART_CONFIG_CIPHER_NONE, //cipher
0, //publicKeyLen
0, //group1KeyLen
0, //group2KeyLen
NULL, //publicKey
NULL, //group1Key
NULL); //group2Key
/* Block until connected */
uint8_t iCount;
while(WiFi.status() != WL_CONNECTED) {
_SlNonOsMainLoopTask();
}
if(sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,0),
&policyVal,
1 /*PolicyValLen*/) < 0) return -1;
}
//****************************************************************************
//
//! \brief Connecting to a WLAN Accesspoint
//!
//! This function connects to the required AP (SSID_NAME) with Security
//! parameters specified in te form of macros at the top of this file
//!
//! \param[in] None
//!
//! \return status value
//!
//! \warning If the WLAN connection fails or we don't aquire an IP
//! address, It will be stuck in this function forever.
//
//****************************************************************************
static long WlanConnect()
{
SlSecParams_t secParams = {0};
long lRetVal = 0;
secParams.Key = (signed char*)SECURITY_KEY;
secParams.KeyLen = strlen(SECURITY_KEY);
secParams.Type = SECURITY_TYPE;
lRetVal = sl_WlanConnect((signed char*)SSID_NAME, strlen(SSID_NAME), 0, \
&secParams, 0);
ASSERT_ON_ERROR(lRetVal);
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
// Wait for WLAN Event
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
return SUCCESS;
}
//*****************************************************************************
//! \brief This function puts the device in its default state. It:
//! - Set the mode to STATION
//! - Configures connection policy to Auto and AutoSmartConfig
//! - Deletes all the stored profiles
//! - Enables DHCP
//! - Disables Scan policy
//! - Sets Tx power to maximum
//! - Sets power policy to normal
//! - Unregister mDNS services
//! - Remove all filters
//!
//! \param none
//! \return On success, zero is returned. On error, negative is returned
//*****************************************************************************
static long ConfigureSimpleLinkToDefaultState()
{
SlVersionFull ver = {0};
_WlanRxFilterOperationCommandBuff_t RxFilterIdMask = {0};
unsigned char ucVal = 1;
unsigned char ucConfigOpt = 0;
unsigned char ucConfigLen = 0;
unsigned char ucPower = 0;
long lRetVal = -1;
long lMode = -1;
lMode = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(lMode);
// If the device is not in station-mode, try configuring it in station-mode
if (ROLE_STA != lMode)
{
if (ROLE_AP == lMode)
{
// 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();
#endif
}
}
// Switch to STA role and restart
lRetVal = sl_WlanSetMode(ROLE_STA);
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_Stop(0xFF);
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(lRetVal);
// Check if the device is in station again
if (ROLE_STA != lRetVal)
{
// We don't want to proceed if the device is not coming up in STA-mode
return DEVICE_NOT_IN_STATION_MODE;
}
}
// Get the device's version-information
ucConfigOpt = SL_DEVICE_GENERAL_VERSION;
ucConfigLen = sizeof(ver);
lRetVal = sl_DevGet(SL_DEVICE_GENERAL_CONFIGURATION, &ucConfigOpt,
&ucConfigLen, (unsigned char *)(&ver));
ASSERT_ON_ERROR(lRetVal);
UART_PRINT("Host Driver Version: %s\n\r",SL_DRIVER_VERSION);
UART_PRINT("Build Version %d.%d.%d.%d.31.%d.%d.%d.%d.%d.%d.%d.%d\n\r",
ver.NwpVersion[0],ver.NwpVersion[1],ver.NwpVersion[2],ver.NwpVersion[3],
ver.ChipFwAndPhyVersion.FwVersion[0],ver.ChipFwAndPhyVersion.FwVersion[1],
ver.ChipFwAndPhyVersion.FwVersion[2],ver.ChipFwAndPhyVersion.FwVersion[3],
ver.ChipFwAndPhyVersion.PhyVersion[0],ver.ChipFwAndPhyVersion.PhyVersion[1],
ver.ChipFwAndPhyVersion.PhyVersion[2],ver.ChipFwAndPhyVersion.PhyVersion[3]);
// Set connection policy to Auto + SmartConfig
// (Device's default connection policy)
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1, 0, 0, 0, 1), NULL, 0);
ASSERT_ON_ERROR(lRetVal);
// Remove all profiles
lRetVal = sl_WlanProfileDel(0xFF);
ASSERT_ON_ERROR(lRetVal);
//
// Device in station-mode. Disconnect previous connection if any
// The function returns 0 if 'Disconnected done', negative number if already
// disconnected Wait for 'disconnection' event if 0 is returned, Ignore
// other return-codes
//
lRetVal = sl_WlanDisconnect();
if(0 == lRetVal)
{
// Wait
while(IS_CONNECTED(g_ulStatus))
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
}
// Enable DHCP client
lRetVal = sl_NetCfgSet(SL_IPV4_STA_P2P_CL_DHCP_ENABLE,1,1,&ucVal);
ASSERT_ON_ERROR(lRetVal);
// Disable scan
ucConfigOpt = SL_SCAN_POLICY(0);
lRetVal = sl_WlanPolicySet(SL_POLICY_SCAN , ucConfigOpt, NULL, 0);
ASSERT_ON_ERROR(lRetVal);
// Set Tx power level for station mode
// Number between 0-15, as dB offset from max power - 0 will set max power
ucPower = 0;
lRetVal = sl_WlanSet(SL_WLAN_CFG_GENERAL_PARAM_ID,
WLAN_GENERAL_PARAM_OPT_STA_TX_POWER, 1, (unsigned char *)&ucPower);
ASSERT_ON_ERROR(lRetVal);
// Set PM policy to normal
lRetVal = sl_WlanPolicySet(SL_POLICY_PM , SL_NORMAL_POLICY, NULL, 0);
ASSERT_ON_ERROR(lRetVal);
// Unregister mDNS services
lRetVal = sl_NetAppMDNSUnRegisterService(0, 0);
ASSERT_ON_ERROR(lRetVal);
// Remove all 64 filters (8*8)
memset(RxFilterIdMask.FilterIdMask, 0xFF, 8);
lRetVal = sl_WlanRxFilterSet(SL_REMOVE_RX_FILTER, (_u8 *)&RxFilterIdMask,
sizeof(_WlanRxFilterOperationCommandBuff_t));
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
ASSERT_ON_ERROR(lRetVal);
InitializeAppVariables();
return lRetVal; // Success
}
//*****************************************************************************
//
//! 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 This function configure the SimpleLink device in its default state. It:
- Sets the mode to STATION
- Configures connection policy to Auto and AutoSmartConfig
- Deletes all the stored profiles
- Enables DHCP
- Disables Scan policy
- Sets Tx power to maximum
- Sets power policy to normal
- Unregisters mDNS services
- Remove all filters
\param[in] none
\return On success, zero is returned. On error, negative is returned
*/
static _i32 configureSimpleLinkToDefaultState()
{
SlVersionFull ver = {0};
_WlanRxFilterOperationCommandBuff_t RxFilterIdMask = {0};
_u8 val = 1;
_u8 configOpt = 0;
_u8 configLen = 0;
_u8 power = 0;
_i32 retVal = -1;
_i32 mode = -1;
mode = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(mode);
/* If the device is not in station-mode, try configuring it in station-mode */
if (ROLE_STA != mode)
{
if (ROLE_AP == mode)
{
/* If the device is in AP mode, we need to wait for this event before doing anything */
while(!IS_IP_ACQUIRED(g_Status)) { _SlNonOsMainLoopTask(); }
}
/* Switch to STA role and restart */
retVal = sl_WlanSetMode(ROLE_STA);
ASSERT_ON_ERROR(retVal);
retVal = sl_Stop(SL_STOP_TIMEOUT);
ASSERT_ON_ERROR(retVal);
retVal = sl_Start(0, 0, 0);
ASSERT_ON_ERROR(retVal);
/* Check if the device is in station again */
if (ROLE_STA != retVal)
{
/* We don't want to proceed if the device is not coming up in station-mode */
ASSERT_ON_ERROR(DEVICE_NOT_IN_STATION_MODE);
}
}
/* Get the device's version-information */
configOpt = SL_DEVICE_GENERAL_VERSION;
configLen = sizeof(ver);
retVal = sl_DevGet(SL_DEVICE_GENERAL_CONFIGURATION, &configOpt, &configLen, (unsigned char *)(&ver));
ASSERT_ON_ERROR(retVal);
/* Set connection policy to Auto + SmartConfig (Device's default connection policy) */
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION, SL_CONNECTION_POLICY(1, 0, 0, 0, 1), NULL, 0);
ASSERT_ON_ERROR(retVal);
/* Remove all profiles */
retVal = sl_WlanProfileDel(0xFF);
ASSERT_ON_ERROR(retVal);
/*
* Device in station-mode. Disconnect previous connection if any
* The function returns 0 if 'Disconnected done', negative number if already disconnected
* Wait for 'disconnection' event if 0 is returned, Ignore other return-codes
*/
retVal = sl_WlanDisconnect();
if(0 == retVal)
{
/* Wait */
while(IS_CONNECTED(g_Status)) { _SlNonOsMainLoopTask(); }
}
/* Enable DHCP client*/
retVal = sl_NetCfgSet(SL_IPV4_STA_P2P_CL_DHCP_ENABLE,1,1,&val);
ASSERT_ON_ERROR(retVal);
/* Disable scan */
configOpt = SL_SCAN_POLICY(0);
retVal = sl_WlanPolicySet(SL_POLICY_SCAN , configOpt, NULL, 0);
ASSERT_ON_ERROR(retVal);
/* Set Tx power level for station mode
Number between 0-15, as dB offset from max power - 0 will set maximum power */
power = 0;
retVal = sl_WlanSet(SL_WLAN_CFG_GENERAL_PARAM_ID, WLAN_GENERAL_PARAM_OPT_STA_TX_POWER, 1, &power);
ASSERT_ON_ERROR(retVal);
/* Set PM policy to normal */
retVal = sl_WlanPolicySet(SL_POLICY_PM , SL_NORMAL_POLICY, NULL, 0);
ASSERT_ON_ERROR(retVal);
/* Unregister mDNS services */
retVal = sl_NetAppMDNSUnRegisterService(0, 0);
ASSERT_ON_ERROR(retVal);
/* Remove all 64 filters (8*8) */
pal_Memset(RxFilterIdMask.FilterIdMask, 0xFF, 8);
retVal = sl_WlanRxFilterSet(SL_REMOVE_RX_FILTER, (_u8 *)&RxFilterIdMask,
sizeof(_WlanRxFilterOperationCommandBuff_t));
ASSERT_ON_ERROR(retVal);
retVal = sl_Stop(SL_STOP_TIMEOUT);
ASSERT_ON_ERROR(retVal);
retVal = initializeAppVariables();
ASSERT_ON_ERROR(retVal);
return retVal; /* Success */
}
/*
* Application's entry point
*/
int main(int argc, char** argv)
{
SlSecParams_t secParams = {0};
_i32 retVal = -1;
retVal = initializeAppVariables();
ASSERT_ON_ERROR(retVal);
/* Stop WDT and initialize the system-clock of the MCU */
stopWDT();
initClk();
/* Configure command line interface */
CLI_Configure();
displayBanner();
/*
* Following function configures 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)
CLI_Write(" Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
CLI_Write(" Device is configured in default state \n\r");
/*
* Initializing the CC3100 device
* Assumption is that the device is configured in station mode already
* and it is in its default state
*/
retVal = sl_Start(0, 0, 0);
if ((retVal < 0) ||
(ROLE_STA != retVal) )
{
CLI_Write(" Failed to start the device \n\r");
LOOP_FOREVER();
}
CLI_Write(" Device started as STATION \n\r");
/* Delete all profiles (0xFF) stored and reset policy settings */
retVal = sl_WlanProfileDel(0xFF);
if(retVal < 0)
{
LOOP_FOREVER();
}
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION ,
SL_CONNECTION_POLICY(0, 0, 0, 0, 0), 0, 0);
if(retVal < 0)
{
LOOP_FOREVER();
}
/* Add unsecured AP profile with priority 6 (7 is highest) */
retVal = sl_WlanProfileAdd((_i8 *)UNSEC_SSID_NAME,
pal_Strlen(UNSEC_SSID_NAME), g_BSSID, 0, 0, 6, 0);
if(retVal < 0)
{
LOOP_FOREVER();
}
/* Add WPA2 secured AP profile with priority 7 (highest) */
secParams.Type = SL_SEC_TYPE_WPA;
secParams.Key = SEC_SSID_KEY;
secParams.KeyLen = pal_Strlen(SEC_SSID_KEY);
retVal = sl_WlanProfileAdd((_i8 *)SEC_SSID_NAME,
pal_Strlen(SEC_SSID_NAME), g_BSSID, &secParams, 0, 7, 0);
if(retVal < 0)
{
LOOP_FOREVER();
}
/*
* Enable auto connect (connection to stored profiles according to priority)
* Connection should first be established to higher (secured) profile as in
* this example
*/
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION ,
SL_CONNECTION_POLICY(1,0,0,0,0), 0, 0);
if(retVal < 0)
{
LOOP_FOREVER();
}
/* Wait for the connection to be established */
while((!IS_CONNECTED(g_Status)) || (!IS_IP_ACQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }
CLI_Write(" Device connected to the AP using 'auto' connection policy\n\r");
/* Delete all profiles (0xFF) stored */
retVal = sl_WlanProfileDel(0xFF);
if(retVal < 0)
{
LOOP_FOREVER();
}
g_Status = 0;
/* Restart the device */
retVal = sl_Stop(SL_STOP_TIMEOUT);
if(retVal < 0)
{
LOOP_FOREVER();
}
retVal = sl_Start(0, 0, 0);
if ((retVal < 0) ||
(ROLE_STA != retVal) )
{
CLI_Write(" Failed to start the device \n\r");
LOOP_FOREVER();
}
/*
* Set connection policy to Fast - Device will connect to the last connected AP.
* This feature can be used to reconnect to AP
*/
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1, 1, 0, 0, 0), 0, 0);
if(retVal < 0)
{
LOOP_FOREVER();
}
/* Connect to the open AP */
retVal = establishConnectionWithAP();
if(retVal < 0)
{
CLI_Write(" Failed to establish connection w/ an AP \n\r");
LOOP_FOREVER();
}
CLI_Write(" Device was connected to the AP using host-driver API \n\r");
g_Status = 0; /* Status variable */
/* Restart the Device */
retVal = sl_Stop(SL_STOP_TIMEOUT);
if(retVal < 0)
{
LOOP_FOREVER();
}
retVal = sl_Start(0, 0, 0);
if ((retVal < 0) ||
(ROLE_STA != retVal) )
{
CLI_Write(" Failed to start the device \n\r");
LOOP_FOREVER();
}
/* Wait for the connection to be established */
while((!IS_CONNECTED(g_Status)) || (!IS_IP_ACQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }
CLI_Write(" Device connected to the AP using 'fast' connection policy\n\r");
/* Delete all profiles (0xFF) stored */
retVal = sl_WlanProfileDel(0xFF);
if(retVal < 0)
{
LOOP_FOREVER();
}
/* Set Auto SmartConfig policy */
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION , SL_CONNECTION_POLICY(1,0,0,0,1), 0, 0);
if(retVal < 0)
{
LOOP_FOREVER();
}
/* Restart the Device */
g_Status = 0;
retVal = sl_Stop(SL_STOP_TIMEOUT);
if(retVal < 0)
{
LOOP_FOREVER();
}
retVal = sl_Start(0, 0, 0);
if ((retVal < 0) ||
(ROLE_STA != retVal) )
{
CLI_Write(" Failed to start the device \n\r");
LOOP_FOREVER();
}
/*
* After restarting , device will wait for a command for 2 second and start
* the SmartConfig process if no command is received
*/
CLI_Write(" Device waiting to be connected using SmartConfig technology \n\r");
while((!IS_CONNECTED(g_Status)) || (!IS_IP_ACQUIRED(g_Status))) { _SlNonOsMainLoopTask(); }
CLI_Write(" Device connected to the AP \n\r");
/*
* Cleaning all profiles and setting the default connection policy before exiting the application
* Set connection policy to Auto + SmartConfig (Device's default connection policy)
*/
retVal = sl_WlanProfileDel(0xFF);
if(retVal < 0)
{
LOOP_FOREVER();
}
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION, SL_CONNECTION_POLICY(1, 0, 0, 0, 1), NULL, 0);
if(retVal < 0)
{
LOOP_FOREVER();
}
return 0;
}
//*****************************************************************************
//
//! Network_IF_ConnectAP Connect to an Access Point using the specified SSID
//!
//! \param[in] pcSsid is a string of the AP's SSID
//! \param[in] SecurityParams is Security parameter for AP
//!
//! \return On success, zero is returned. On error, -ve value is returned
//
//*****************************************************************************
long
Network_IF_ConnectAP(char *pcSsid, SlSecParams_t SecurityParams)
{
#ifndef NOTERM
char acCmdStore[128];
unsigned short usConnTimeout;
unsigned char ucRecvdAPDetails;
#endif
long lRetVal;
unsigned long ulIP = 0;
unsigned long ulSubMask = 0;
unsigned long ulDefGateway = 0;
unsigned long ulDns = 0;
//
// Disconnect from the AP
//
Network_IF_DisconnectFromAP();
//
// This triggers the CC3200 to connect to specific AP
//
lRetVal = sl_WlanConnect((signed char *)pcSsid, strlen((const char *)pcSsid),
NULL, &SecurityParams, NULL);
ASSERT_ON_ERROR(lRetVal);
//
// Wait for ~10 sec to check if connection to desire AP succeeds
//
while(g_usConnectIndex < 15)
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#else
osi_Sleep(1);
#endif
MAP_UtilsDelay(8000000);
if(IS_CONNECTED(g_ulStatus) && IS_IP_ACQUIRED(g_ulStatus))
{
break;
}
g_usConnectIndex++;
}
#ifndef NOTERM
//
// Check and loop until AP connection successful, else ask new AP SSID name
//
while(!(IS_CONNECTED(g_ulStatus)) || !(IS_IP_ACQUIRED(g_ulStatus)))
{
//
// Disconnect the previous attempt
//
Network_IF_DisconnectFromAP();
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
UART_PRINT("Device could not connect to %s\n\r",pcSsid);
do
{
ucRecvdAPDetails = 0;
UART_PRINT("\n\r\n\rPlease enter the AP(open) SSID name # ");
//
// Get the AP name to connect over the UART
//
lRetVal = GetCmd(acCmdStore, sizeof(acCmdStore));
if(lRetVal > 0)
{
// remove start/end spaces if any
lRetVal = TrimSpace(acCmdStore);
//
// Parse the AP name
//
strncpy(pcSsid, acCmdStore, lRetVal);
if(pcSsid != NULL)
{
ucRecvdAPDetails = 1;
pcSsid[lRetVal] = '\0';
}
}
}while(ucRecvdAPDetails == 0);
//
// Reset Security Parameters to OPEN security type
//
SecurityParams.Key = (signed char *)"";
SecurityParams.KeyLen = 0;
SecurityParams.Type = SL_SEC_TYPE_OPEN;
UART_PRINT("\n\rTrying to connect to AP: %s ...\n\r",pcSsid);
//
// Get the current timer tick and setup the timeout accordingly
//
usConnTimeout = g_usConnectIndex + 15;
//
// This triggers the CC3200 to connect to specific AP
//
lRetVal = sl_WlanConnect((signed char *)pcSsid,
strlen((const char *)pcSsid), NULL,
&SecurityParams, NULL);
ASSERT_ON_ERROR(lRetVal);
//
// Wait ~10 sec to check if connection to specifed AP succeeds
//
while(!(IS_CONNECTED(g_ulStatus)) || !(IS_IP_ACQUIRED(g_ulStatus)))
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#else
osi_Sleep(1);
#endif
MAP_UtilsDelay(8000000);
if(g_usConnectIndex >= usConnTimeout)
{
break;
}
g_usConnectIndex++;
}
}
#endif
//
// Put message on UART
//
UART_PRINT("\n\rDevice has connected to %s\n\r",pcSsid);
//
// Get IP address
//
lRetVal = Network_IF_IpConfigGet(&ulIP,&ulSubMask,&ulDefGateway,&ulDns);
ASSERT_ON_ERROR(lRetVal);
//
// Send the information
//
UART_PRINT("Device IP Address is %d.%d.%d.%d \n\r\n\r",
SL_IPV4_BYTE(ulIP, 3),SL_IPV4_BYTE(ulIP, 2),
SL_IPV4_BYTE(ulIP, 1),SL_IPV4_BYTE(ulIP, 0));
return 0;
}