//****************************************************************************
//
//! \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};
signed 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);
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
// Wait for WLAN Event
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
UNUSED(lretVal);
return SUCCESS;
}
//*****************************************************************************
//
//! \brief Starts Smart Configuration
//!
//! \param none
//!
//! \return void
//! \note
//! \warning
//*****************************************************************************
void SmartConfigTask(void* pValue)
{
long lRetVal = -1;
DispatcherUartSendPacket((char*)pucUARTSmartConfigString,
sizeof(pucUARTSmartConfigString));
//Turn off the Network Status LED
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
LedTimerConfigNStart();
//Reset the Network Status before Entering Smart Config
Network_IF_UnsetMCUMachineState(STATUS_BIT_CONNECTION);
Network_IF_UnsetMCUMachineState(STATUS_BIT_IP_AQUIRED);
lRetVal = SmartConfigConnect();
if(lRetVal < 0)
{
ERR_PRINT(lRetVal);
LOOP_FOREVER();
}
//
// Wait until IP is acquired
//
while (!(IS_CONNECTED(Network_IF_CurrentMCUState())) ||
!(IS_IP_ACQUIRED(Network_IF_CurrentMCUState())));
LedTimerDeinitStop();
// Red LED on
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
//Enable GPIO Interrupt
Button_IF_EnableInterrupt(SW2);
}
//****************************************************************************
//
//! \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 0 on success else error code
//!
//! \warning If the WLAN connection fails or we don't aquire an IP
//! address, It will be stuck in this function forever.
//
//****************************************************************************
long WlanConnect()
{
long lRetVal = -1;
SlSecParams_t secParams;
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);
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
// Toggle LEDs to Indicate Connection Progress
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
MAP_UtilsDelay(800000);
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
MAP_UtilsDelay(800000);
}
//
// Red LED on to indicate AP connection
//
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
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 None
//!
//! \return 0 on success else error code
//!
//! \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)))
{
// Toggle LEDs to Indicate Connection Progress
_SlNonOsMainLoopTask();
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
MAP_UtilsDelay(800000);
_SlNonOsMainLoopTask();
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
MAP_UtilsDelay(800000);
}
return SUCCESS;
}
static int wlan_connect(const char *ssid, const char *pass, unsigned char sec_type)
{
SlSecParams_t secParams = {0};
long lRetVal = 0;
secParams.Key = (signed char*)pass;
secParams.KeyLen = strlen(pass);
secParams.Type = sec_type;
lRetVal = sl_WlanConnect((signed char*)ssid, strlen(ssid), 0, &secParams, 0);
ASSERT_ON_ERROR(lRetVal);
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
_SlNonOsMainLoopTask();
SlDateTime_t dateTime= {0};
dateTime.sl_tm_day = 1; // Day of month (DD format) range 1-13
dateTime.sl_tm_mon = 1; // Month (MM format) in the range of 1-12
dateTime.sl_tm_year = 1970; // Year (YYYY format)
dateTime.sl_tm_hour = 0; // Hours in the range of 0-23
dateTime.sl_tm_min = 0; // Minutes in the range of 0-59
dateTime.sl_tm_sec = 1; // Seconds in the range of 0-59
lRetVal = sl_DevSet(SL_DEVICE_GENERAL_CONFIGURATION, SL_DEVICE_GENERAL_CONFIGURATION_DATE_TIME,
sizeof(SlDateTime_t),(unsigned char *)(&dateTime));
ASSERT_ON_ERROR(lRetVal);
return 0;
}
static int StartSerialSock(unsigned short port, unsigned int slot)
{
if(!IS_IP_ACQUIRED(wifi_state.status)) {RETURN_ERROR(ERROR_UNKNOWN, "Uninit fail");}
if(IS_SOCK_STARTED(slot)) {RETURN_ERROR(ERROR_UNKNOWN, "Uninit fail");}
LOG(LOG_VERBOSE, "Starting socket %d on port %d...", slot, port);
int retval;
socket_state[slot].addr_local.sin_family = SL_AF_INET;
socket_state[slot].addr_local.sin_port = sl_Htons(port);
socket_state[slot].addr_local.sin_addr.s_addr = 0;
socket_state[slot].parent_id = sl_Socket(SL_AF_INET, SL_SOCK_STREAM, 0);
if(socket_state[slot].parent_id < 0) {RETURN_ERROR(socket_state[slot].parent_id, "Socket create fail");}
retval = sl_Bind(socket_state[slot].parent_id, (SlSockAddr_t*)&(socket_state[slot].addr_local), sizeof(SlSockAddrIn_t));
if(retval < 0){
sl_Close(socket_state[slot].parent_id);
RETURN_ERROR(retval, "Socket bind fail");
}
retval = ListenSerialSock(slot);
LOG(LOG_VERBOSE, "Socket started.");
socket_state[slot].status = SOCKET_STARTED;
return RET_SUCCESS;
}
void Task_WifiAP(void* params)
{
(void)params; //avoid unused warning
long retval;
LOG(LOG_IMPORTANT, "Starting WiFi AP Mode.");
SetLEDBlink(LED_1, LED_BLINK_PATTERN_WIFI_CONNECTING);
if(WifiDefaultSettings() == RET_FAILURE) {
goto error;
}
if((retval = sl_Start(0,0,0)) < 0) {
goto error;
}
if(retval != ROLE_AP) {
if(WifiSetModeAP() != ROLE_AP) {
sl_Stop(SL_STOP_TIMEOUT);
goto error;
}
}
//Wait for an IP address to be acquired
while(!IS_IP_ACQUIRED(wifi_state.status)) {};
SetLEDBlink(LED_1, LED_BLINK_PATTERN_WIFI_AP);
LOG(LOG_IMPORTANT, "AP Started - Ready for client.");
#ifdef DO_STACK_CHECK
wifi_state.stack_watermark = uxTaskGetStackHighWaterMark(NULL);
#endif
//start socket handler.
xTaskCreate(Task_SocketServer,
"Socket Server",
SOCKET_TASK_STACK_SIZE/sizeof(portSTACK_TYPE),
0,
SOCKET_TASK_PRIORITY,
0);
#ifdef DO_STACK_CHECK
wifi_state.stack_watermark = uxTaskGetStackHighWaterMark(NULL);
#endif
//exit (delete this task)
WifiTaskEndCallback(&Task_WifiAP);
vTaskDelete(NULL);
error:
SetLED(LED_1, LED_BLINK_PATTERN_WIFI_FAILED);
TASK_RETURN_ERROR(ERROR_UNKNOWN, "WIFI AP fail");
return;
return;
}
static int WifiConnectSTA()
{
LOG(LOG_IMPORTANT ,"Waiting for auto connect...");
while((!IS_CONNECTED(wifi_state.status)) || (!IS_IP_ACQUIRED(wifi_state.status))) {
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
return RET_SUCCESS;
}
//*****************************************************************************
//
//! \brief Connecting to a WLAN Accesspoint using SmartConfig provisioning
//!
//! Enables SmartConfig provisioning for adding a new connection profile
//! to CC3200. Since we have set the connection policy to Auto, once
//! SmartConfig is complete, CC3200 will connect automatically to the new
//! connection profile added by smartConfig.
//!
//! \param[in] None
//!
//! \return None
//!
//! \note
//!
//! \warning If the WLAN connection fails or we don't
//! acquire an IP address, We will be stuck in this
//! function forever.
//
//*****************************************************************************
int SmartConfigConnect()
{
unsigned char policyVal;
long lRetVal = -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
//
lRetVal = sl_WlanProfileDel(WLAN_DEL_ALL_PROFILES);
ASSERT_ON_ERROR(lRetVal);
//set AUTO policy
lRetVal = sl_WlanPolicySet( SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,1),
&policyVal,
1 /*PolicyValLen*/);
ASSERT_ON_ERROR(lRetVal);
// Start SmartConfig
// This example uses the unsecured SmartConfig method
//
lRetVal = sl_WlanSmartConfigStart(0, /*groupIdBitmask*/
SMART_CONFIG_CIPHER_NONE, /*cipher*/
0, /*publicKeyLen*/
0, /*group1KeyLen*/
0, /*group2KeyLen */
NULL, /*publicKey */
NULL, /*group1Key */
NULL); /*group2Key*/
ASSERT_ON_ERROR(lRetVal);
// Wait for WLAN Event
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
_SlNonOsMainLoopTask();
}
//
// Turn ON the RED LED to indicate connection success
//
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
//wait for few moments
MAP_UtilsDelay(80000000);
//reset to default AUTO policy
lRetVal = sl_WlanPolicySet( SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,0),
&policyVal,
1 /*PolicyValLen*/);
ASSERT_ON_ERROR(lRetVal);
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 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;
}
//****************************************************************************
//
//! \brief Connecting to a WLAN Access point
//!
//! This function connects to the required AP (SSID_NAME) with Security
//! parameters specified in the form of macros at the top of this file
//!
//! \param[in] None
//!
//! \return None
//!
//! \warning If the WLAN connection fails or we don't acquire 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 *)P2P_SECURITY_KEY;
secParams.KeyLen = strlen(P2P_SECURITY_KEY);
secParams.Type = P2P_SECURITY_TYPE;
lRetVal = sl_WlanConnect((signed char *)P2P_REMOTE_DEVICE,
strlen((const char *)P2P_REMOTE_DEVICE), 0,
&secParams, 0);
ASSERT_ON_ERROR(lRetVal);
// Wait till Device acquired an IP in P2P mode
while(! IS_P2P_REQ_RCVD(g_ulStatus))
{
_SlNonOsMainLoopTask();
}
// Connect with the device requesting the connection
lRetVal = sl_WlanConnect((signed char *)g_p2p_dev,
strlen((const char *)g_p2p_dev),
0, &secParams, 0);
ASSERT_ON_ERROR(lRetVal);
#ifdef P2P_ROLE_TYPE_NEGOTIATE
while(! IS_IP_ACQUIRED(g_ulStatus))
#else
while(! IS_IP_LEASED(g_ulStatus))
#endif
{
_SlNonOsMainLoopTask();
if(IS_CONNECT_FAILED(g_ulStatus))
{
// Error, connection is failed
ASSERT_ON_ERROR(NETWORK_CONNECTION_FAILED);
}
}
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 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;
}
//****************************************************************************
//
//! \brief Connecting to a WLAN Access point
//!
//! This function connects to the required AP (SSID_NAME) with Security
//! parameters specified in the form of macros at the top of this file
//!
//! \param[in] None
//!
//! \return None
//!
//! \warning If the WLAN connection fails or we don't acquire an IP
//! address, It will be stuck in this function forever.
//
//****************************************************************************
static long WlanConnect()
{
SlSecParams_t secParams = {0};
long retVal = 0;
secParams.Key = SECURITY_KEY;
secParams.KeyLen = strlen(SECURITY_KEY);
secParams.Type = SECURITY_TYPE;
retVal = sl_WlanConnect(P2P_REMOTE_DEVICE, strlen(P2P_REMOTE_DEVICE), 0,
&secParams, 0);
ASSERT_ON_ERROR(__LINE__, retVal);
// Wait till Device acquired an IP in P2P mode
while(! IS_P2P_REQ_RCVD(g_ulStatus))
{
_SlNonOsMainLoopTask();
}
// Connect with the device requesting the connection
retVal = sl_WlanConnect(g_p2p_dev, strlen(g_p2p_dev), 0, &secParams, 0);
ASSERT_ON_ERROR(__LINE__, retVal);
#ifdef P2P_ROLE_TYPE_NEGOTIATE
while(! IS_IP_ACQUIRED(g_ulStatus))
#else
while(! IS_IP_LEASED(g_ulStatus))
#endif
{
_SlNonOsMainLoopTask();
if(IS_CONNECT_FAILED(g_ulStatus))
{
// Error, connection is failed
UART_PRINT("Connection Failed\r\n");
return -1;
}
}
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;
}
/*!
\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;
}
/*!
\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;
}
/*!
\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[in] none
\return On success, zero is returned. On error, negative is returned
*/
static _i32 configureSimpleLinkToDefaultState(_i8 *pConfig)
{
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, pConfig, 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));
}
/* 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, pConfig, 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, (_u8 *)(&ver));
ASSERT_ON_ERROR(retVal);
printf("Host Driver Version: %s\n",SL_DRIVER_VERSION);
printf("Build Version %d.%d.%d.%d.31.%d.%d.%d.%d.%d.%d.%d.%d\n",
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) */
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));
}
/* 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, (_u8 *)&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) */
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 */
}
//*****************************************************************************
//! \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
}
/*
* 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;
}
void Microphone( void *pvParameters )
{
long lRetVal = -1;
#ifdef MULTICAST
//Wait for Network Connection
while((!IS_IP_ACQUIRED(g_ulStatus)))
{
}
#endif //MULTICAST
while(1)
{
while(g_ucMicStartFlag || g_loopback)
{
int iBufferFilled = 0;
iBufferFilled = GetBufferSize(pRecordBuffer);
if(iBufferFilled >= (2*PACKET_SIZE))
{
if(!g_loopback)
{
#ifndef MULTICAST
lRetVal = sendto(g_UdpSock.iSockDesc, \
(char*)(pRecordBuffer->pucReadPtr),PACKET_SIZE,\
0,(struct sockaddr*)&(g_UdpSock.Client),\
sizeof(g_UdpSock.Client));
if(lRetVal < 0)
{
UART_PRINT("Unable to send data\n\r");
LOOP_FOREVER();
}
#else //MULTICAST
lRetVal = SendMulticastPacket();
if(lRetVal < 0)
{
UART_PRINT("Unable to send data\n\r");
LOOP_FOREVER();
}
#endif //MULTICAST
}
else
{
lRetVal = FillBuffer(pPlayBuffer,\
(unsigned char*)(pRecordBuffer->pucReadPtr), \
PACKET_SIZE);
if(lRetVal < 0)
{
UART_PRINT("Unable to fill buffer\n\r");
}
g_iReceiveCount++;
}
UpdateReadPtr(pRecordBuffer, PACKET_SIZE);
g_iSentCount++;
}
}
MAP_UtilsDelay(1000);
}
}
//*****************************************************************************
//
//! 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;
}
//*****************************************************************************
//
//! 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;
}
//*****************************************************************************
//
//! Network_IF_ConnectAP Connect to an Access Point using the specified SSID
//!
//! \param pcSsid is a string of the AP's SSID
//!
//! \return none
//
//*****************************************************************************
int
Network_IF_ConnectAP(char *pcSsid, SlSecParams_t SecurityParams)
{
char acCmdStore[128];
unsigned short usConnTimeout;
int iRetVal;
unsigned long ulIP = 0;
unsigned long ulSubMask = 0;
unsigned long ulDefGateway = 0;
unsigned long ulDns = 0;
unsigned char ucRecvdAPDetails;
Network_IF_DisconnectFromAP();
//
// This triggers the CC3200 to connect to specific AP
//
sl_WlanConnect(pcSsid, strlen(pcSsid), NULL, &SecurityParams, NULL);
//
// Wait to check if connection to DIAGNOSTIC_AP succeeds
//
while(g_usConnectIndex < 10)
{
MAP_UtilsDelay(8000000);
g_usConnectIndex++;
if(IS_CONNECTED(g_ulStatus))
{
break;
}
}
//
// Check and loop until async event from network processor indicating Wlan
// Connect success was received
//
while(!(IS_CONNECTED(g_ulStatus)))
{
//
// Disconnect the previous attempt
//
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
//
iRetVal = GetCmd(acCmdStore, sizeof(acCmdStore));
if(iRetVal > 0)
{
//
// Parse the AP name
//
pcSsid = strtok(acCmdStore, ":");
if(pcSsid != NULL)
{
ucRecvdAPDetails = 1;
}
}
} while(ucRecvdAPDetails == 0);
UART_PRINT("\n\rTrying to connect to AP: %s ...\n\r",pcSsid);
/*UART_PRINT("Key: %s, Len: %d, KeyID: %d, Type: %d\n\r",
SecurityParams.Key, SecurityParams.KeyLen
, SecurityParams.Type);
*/
//
// Get the current timer tick and setup the timeout accordingly
//
usConnTimeout = g_usConnectIndex + 10;
//
// This triggers the CC3200 to connect to specific AP
//
sl_WlanConnect(pcSsid, strlen(pcSsid), NULL, &SecurityParams, NULL);
//
// Wait to check if connection to specifed AP succeeds
//
while(!(IS_CONNECTED(g_ulStatus)))
{
if(g_usConnectIndex >= usConnTimeout)
{
break;
}
MAP_UtilsDelay(8000000);
g_usConnectIndex++;
}
}
//
// Wait until IP is acquired
//
while(!(IS_IP_ACQUIRED(g_ulStatus)));
//
// Put message on UART
//
UART_PRINT("\n\rDevice has connected to %s\n\r",pcSsid);
//
// Get IP address
//
Network_IF_IpConfigGet(&ulIP,&ulSubMask,&ulDefGateway,&ulDns);
//
// 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;
}
long ConnectToNetwork()
{
long lRetVal = -1;
unsigned int uiConnectTimeoutCnt =0;
//Start Simplelink Device
lRetVal = sl_Start(NULL,NULL,NULL);
ASSERT_ON_ERROR(lRetVal);
if(lRetVal != ROLE_STA)
{
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();
#endif
}
}
//
// Configure to STA Mode
//
lRetVal = ConfigureMode(ROLE_STA);
if(lRetVal !=ROLE_STA)
{
UART_PRINT("Unable to set STA mode...\n\r");
lRetVal = sl_Stop(SL_STOP_TIMEOUT);
CLR_STATUS_BIT_ALL(g_ulStatus);
return DEVICE_NOT_IN_STATION_MODE;
}
}
//waiting for the device to Auto Connect
while(uiConnectTimeoutCnt<AUTO_CONNECTION_TIMEOUT_COUNT &&
((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus))))
{
//Turn Green LED On
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
//Turn Green LED Off
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
osi_Sleep(50);
uiConnectTimeoutCnt++;
}
//Couldn't connect Using Auto Profile
if(uiConnectTimeoutCnt==AUTO_CONNECTION_TIMEOUT_COUNT)
{
CLR_STATUS_BIT_ALL(g_ulStatus);
//Turn Green LED On
GPIO_IF_LedOn(MCU_GREEN_LED_GPIO);
//Connect Using Smart Config
lRetVal = SmartConfigConnect();
ASSERT_ON_ERROR(lRetVal);
//Waiting for the device to Auto Connect
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
MAP_UtilsDelay(500);
}
//Turn Green LED Off
GPIO_IF_LedOff(MCU_GREEN_LED_GPIO);
}
return SUCCESS;
}
static int WifiDefaultSettings(void)
{
long retval = -1;
unsigned char val = 1;
unsigned char config, config_len;
//filters
_WlanRxFilterOperationCommandBuff_t filter_mask = {
.Padding = {0}
};
//initialize the SimpleLink API
retval = sl_Start(0,0,0);
if(retval < 0) {
RETURN_ERROR(ERROR_UNKNOWN, "SL start fail");
}
//set device in station mode
if(retval != ROLE_STA) {
if(retval == ROLE_AP) { //we need to wait for an event before doing anything
while(!IS_IP_ACQUIRED(wifi_state.status)) {
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
}
//change mode to Station
retval = sl_WlanSetMode(ROLE_STA);
if(retval < 0) {
RETURN_ERROR(ERROR_UNKNOWN, "WLAN mode fail");
}
//restart
retval = sl_Stop(0xFF);
if(retval < 0) {
RETURN_ERROR(ERROR_UNKNOWN, "SL stop fail");
}
retval = sl_Start(0,0,0);
if(retval < 0) {
RETURN_ERROR(ERROR_UNKNOWN, "SL start fail");
}
if(retval != ROLE_STA) {
RETURN_ERROR(ERROR_UNKNOWN, "WLAN mode fail");
}
}
//get SimpleLink version
config = SL_DEVICE_GENERAL_VERSION;
config_len = sizeof(SlVersionFull);
retval = sl_DevGet(SL_DEVICE_GENERAL_CONFIGURATION, &config, &config_len, (unsigned char*)&wifi_state.version);
if(retval<0) {
RETURN_ERROR(retval, "WIFI conf fail");
}
//default connection policy
retval = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1, 0, 0, 0, 0),
NULL,
0);
if(retval<0) {
RETURN_ERROR(retval, "WIFI policy fail");
}
//disconnect
retval = sl_WlanDisconnect();
if(retval == 0) { //not yet disconnected
while(IS_CONNECTED(wifi_state.status)) {
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
}
//Enable DHCP client
retval = sl_NetCfgSet(SL_IPV4_STA_P2P_CL_DHCP_ENABLE,1,1,&val);
if(retval<0) {
RETURN_ERROR(retval, "WIFI conf fail");
}
//Disable scan policy
config = SL_SCAN_POLICY(0);
retval = sl_WlanPolicySet(SL_POLICY_SCAN, config, NULL, 0);
if(retval<0) {
RETURN_ERROR(retval, "WIFI policy fail");
}
//Set Tx power level for station mode
//Number between 0-15, as dB offset from max power - 0 will set max power
val = 0;
retval = sl_WlanSet(SL_WLAN_CFG_GENERAL_PARAM_ID,
WLAN_GENERAL_PARAM_OPT_STA_TX_POWER, 1, (unsigned char *)&val);
if(retval<0) {
RETURN_ERROR(retval, "WIFI set fail");
}
// Set PM policy to normal
retval = sl_WlanPolicySet(SL_POLICY_PM , SL_NORMAL_POLICY, NULL, 0);
if(retval<0) {
RETURN_ERROR(retval, "WIFI policy fail");
}
// Unregister mDNS services
retval = sl_NetAppMDNSUnRegisterService(0, 0);
if(retval<0) {
RETURN_ERROR(retval, "mDNS fail");
}
//Set mDNS device hostname
char hostname[64];
char macstring[20];
unsigned char maclen = SL_MAC_ADDR_LEN;
retval = sl_NetCfgGet(SL_MAC_ADDRESS_GET,
NULL,
&maclen,
wifi_state.mac);
if(retval < 0) {
RETURN_ERROR(retval, "WIFI conf fail");
}
snprintf(macstring, 20, "%02X%02X%02X%02X%02X%02X", wifi_state.mac[0],
wifi_state.mac[1], wifi_state.mac[2],
wifi_state.mac[3], wifi_state.mac[4],
wifi_state.mac[5]);
snprintf(hostname, 64, "LeashDebugger%s", macstring);
retval = sl_NetAppSet (SL_NET_APP_DEVICE_CONFIG_ID,
NETAPP_SET_GET_DEV_CONF_OPT_DEVICE_URN,
strlen((const char *)hostname),
(unsigned char *) hostname);
// Remove all 64 filters (8*8)
memset(filter_mask.FilterIdMask, 0xFF, 8);
retval = sl_WlanRxFilterSet(SL_REMOVE_RX_FILTER, (uint8_t*)&filter_mask,
sizeof(_WlanRxFilterOperationCommandBuff_t));
if(retval<0) {
RETURN_ERROR(retval, "WIFI filter fail");
}
retval = sl_Stop(SL_STOP_TIMEOUT);
if(retval < 0) {
RETURN_ERROR(ERROR_UNKNOWN, "SL stop fail");
}
wifi_state.status = 0;
return RET_SUCCESS;
}
//****************************************************************************
//
//! \brief Connects to the Network in AP or STA Mode - If ForceAP Jumper is
//! Placed, Force it to AP mode
//!
//! \return 0 - Success
//! -1 - Failure
//
//****************************************************************************
long ConnectToNetwork()
{
long lRetVal = -1;
unsigned int uiConnectTimeoutCnt =0;
// staring simplelink
lRetVal = sl_Start(NULL,NULL,NULL);
ASSERT_ON_ERROR( lRetVal);
// Device is in AP Mode and Force AP Jumper is not Connected
if(ROLE_STA != lRetVal && g_uiDeviceModeConfig == ROLE_STA )
{
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();
#endif
}
}
//Switch to STA Mode
lRetVal = ConfigureMode(ROLE_STA);
ASSERT_ON_ERROR( lRetVal);
}
//Device is in STA Mode and Force AP Jumper is Connected
if(ROLE_AP != lRetVal && g_uiDeviceModeConfig == ROLE_AP )
{
//Switch to AP Mode
lRetVal = ConfigureMode(ROLE_AP);
ASSERT_ON_ERROR( lRetVal);
}
//No Mode Change Required
if(lRetVal == ROLE_AP)
{
//waiting for the AP to acquire IP address from Internal DHCP Server
// 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
}
//Stop Internal HTTP Server
lRetVal = sl_NetAppStop(SL_NET_APP_HTTP_SERVER_ID);
ASSERT_ON_ERROR( lRetVal);
//Start Internal HTTP Server
lRetVal = sl_NetAppStart(SL_NET_APP_HTTP_SERVER_ID);
ASSERT_ON_ERROR( lRetVal);
char cCount=0;
//Blink LED 3 times to Indicate AP Mode
for(cCount=0;cCount<3;cCount++)
{
//Turn RED LED On
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
osi_Sleep(400);
//Turn RED LED Off
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
osi_Sleep(400);
}
char ssid[32];
unsigned short len = 32;
unsigned short config_opt = WLAN_AP_OPT_SSID;
sl_WlanGet(SL_WLAN_CFG_AP_ID, &config_opt , &len, (unsigned char* )ssid);
UART_PRINT("\n\r Connect to : \'%s\'\n\r\n\r",ssid);
}
else
{
//Stop Internal HTTP Server
lRetVal = sl_NetAppStop(SL_NET_APP_HTTP_SERVER_ID);
ASSERT_ON_ERROR( lRetVal);
//Start Internal HTTP Server
lRetVal = sl_NetAppStart(SL_NET_APP_HTTP_SERVER_ID);
ASSERT_ON_ERROR( lRetVal);
//waiting for the device to Auto Connect
while(uiConnectTimeoutCnt<AUTO_CONNECTION_TIMEOUT_COUNT &&
((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus))))
{
//Turn RED LED On
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
osi_Sleep(50);
//Turn RED LED Off
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
osi_Sleep(50);
uiConnectTimeoutCnt++;
}
//Couldn't connect Using Auto Profile
if(uiConnectTimeoutCnt == AUTO_CONNECTION_TIMEOUT_COUNT)
{
//Blink Red LED to Indicate Connection Error
GPIO_IF_LedOn(MCU_RED_LED_GPIO);
CLR_STATUS_BIT_ALL(g_ulStatus);
//Connect Using Smart Config
lRetVal = SmartConfigConnect();
ASSERT_ON_ERROR(lRetVal);
//Waiting for the device to Auto Connect
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
MAP_UtilsDelay(500);
}
}
//Turn RED LED Off
GPIO_IF_LedOff(MCU_RED_LED_GPIO);
g_iInternetAccess = ConnectionTest();
}
return SUCCESS;
}
//*****************************************************************************
//
//! UARTCommandHandler
//!
//! @brief The function handles commands arrived from CLI
//!
//! @param usBuffer is the receive buffer from the UART interface to PC
//!
//! @return 0 on success or error code on failure
//!
//
//*****************************************************************************
long UARTCommandHandler(char *usBuffer)
{
int iIndex = 0;
int iParamcount = 0;
long lRetVal = -1;
signed char cStatus1 = 0;
signed char cStatus2 = 0;
if(usBuffer == NULL)
{
UART_PRINT("Null pointer\r\n");
return -1;
}
switch(usBuffer[1])
{
//**********************************************
// Case 01: Connect to default AP
//**********************************************
case UART_COMMAND_SIMPLE_CONFIG_START:
if(!IS_CONNECTED(Network_IF_CurrentMCUState()))
{
LedTimerConfigNStart();
// Setting Acess Point's security parameters
SecurityParams.Key = (signed char *)SECURITY_KEY;
SecurityParams.KeyLen = strlen(SECURITY_KEY);
SecurityParams.Type = SECURITY_TYPE;
lRetVal = Network_IF_ConnectAP(SSID_NAME,SecurityParams);
if(lRetVal < 0)
{
UART_PRINT("Error: %d Connecting to an AP.", lRetVal);
return lRetVal;
}
}
//
// 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);
DispatcherUartSendPacket((char*)pucUARTOKString,
sizeof(pucUARTOKString));
break;
//**********************************************
// Case 02: Configure sender (source) email
//**********************************************
// TODO Phase 2: Include
/*
case UART_COMMAND_EMAIL_SOURCE:
memset(serveruser,0,sizeof(serveruser));
memset(pcServerpass,0,sizeof(pcServerpass));
pcOfserveruser = &serveruser[0];
ofpcServerpass = &pcServerpass[0];
// '<' To maintain RFC 2821 format
*pcOfserveruser++= '<';
iIndex = 2;
while ((int)usBuffer[iIndex] != 0x0D)
{
//look for comma ',' for separation of params
if((int)usBuffer[iIndex] == 44)
{
iParamcount++;
}
else
{
if(iParamcount==1)
{
//Enter smtp server username (email address)
*pcOfserveruser++ = usBuffer[iIndex];
}
if(iParamcount==2)
{
//Enter username's password
*ofpcServerpass++ = usBuffer[iIndex];
}
}
iIndex++;
}
// '>' To maintain RFC 2821 format
*pcOfserveruser++= '>';
*pcOfserveruser++= '\0';
*ofpcServerpass++= '\0';
//Set variables in smtp.c
cStatus1 = smtpSetVariable(serveruser, USERNAME_VAR);
cStatus2 = smtpSetVariable(pcServerpass, PASSWORD_VAR);
//If error in return
if(cStatus1 == 0 && cStatus2 == 0)
{
DispatcherUartSendPacket((char*)pucUARTOKString, sizeof(pucUARTOKString));
}
else
{
DispatcherUartSendPacket((char*)putUARTErrorInputString, \
sizeof(putUARTErrorInputString));
}
break;
*/
//**********************************************
// Case 03: Configure sender (source) email
//**********************************************
case UART_COMMAND_EMAIL_HEADER:
memset(pcEmailto,0,sizeof(pcEmailto));
pcOfemailto = &pcEmailto[0];
pcOfemailsubject = &pcEmailsubject[0];
// '<' To maintain RFC 2821 format
*pcOfemailto++= '<';
iIndex = 2;
while ((int)usBuffer[iIndex] != 0x0D && usBuffer[iIndex] != '\0')
{
//look for comma ',' for separation of params
if((int)usBuffer[iIndex] == 44)
{
iParamcount++;
}
else
{
if(iParamcount==1)
{
//Enter destination email address
*pcOfemailto++ = usBuffer[iIndex];
}
if(iParamcount==2)
{
//Enter email subject
*pcOfemailsubject++ = usBuffer[iIndex];
}
}
iIndex++;
}
// '>' To maintain RFC 2821 format
*pcOfemailto++= '>';
*pcOfemailto++= '\0';
*pcOfemailsubject= '\0';
SlNetAppDestination_t destEmailAdd;
memcpy(destEmailAdd.Email,pcEmailto,strlen(pcEmailto)+1);
cStatus1 = sl_NetAppEmailSet(SL_NET_APP_EMAIL_ID,NETAPP_DEST_EMAIL, \
strlen(pcEmailto)+1, \
(unsigned char *)&destEmailAdd);
SlNetAppEmailSubject_t emailSubject;
memcpy(emailSubject.Value,pcEmailsubject,strlen(pcEmailsubject)+1);
cStatus2 = sl_NetAppEmailSet(SL_NET_APP_EMAIL_ID,NETAPP_SUBJECT, \
strlen(pcEmailsubject)+1, \
(unsigned char *)&emailSubject);
// Check for Error in setting the variables
if(cStatus1 == 0 && cStatus2 == 0)
{
DispatcherUartSendPacket((char*)pucUARTOKString, \
sizeof(pucUARTOKString));
}
else
{
DispatcherUartSendPacket((char*)putUARTErrorInputString, \
sizeof(putUARTErrorInputString));
}
break;
//**********************************************
// Case 04: Record email message
//**********************************************
case UART_COMMAND_EMAIL_MESSAGE:
pcOfemailmessage = &pcEmailmessage[0];
//Enter "Message"
iIndex =3;
while ((int)usBuffer[iIndex] != 0x0D && usBuffer[iIndex] != '\0')
{
if((int)usBuffer[iIndex] == 62)
{
iParamcount++;
}
else
{
if(iParamcount==0)
{
*pcOfemailmessage++ = usBuffer[iIndex];
}
}
iIndex++;
}
*pcOfemailmessage= '\0';
/* TODO here unsigned char is converting to char */
DispatcherUartSendPacket((char*)pucUARTOKString, \
sizeof(pucUARTOKString));
break;
//**********************************************
// Case 05: Send email message using configurations
//**********************************************
case UART_COMMAND_EMAIL_SEND:
{
// reset Orange LED state
GPIO_IF_LedOff(MCU_SENDING_DATA_IND);
// TODO: If no destination email given, default to hardcoded value
SlNetAppEmailOpt_t eMailServerSetting;
lRetVal = Network_IF_GetHostIP(GMAIL_HOST_NAME, &eMailServerSetting.Ip);
if(lRetVal >= 0)
{
eMailServerSetting.Family = AF_INET;
eMailServerSetting.Port = GMAIL_HOST_PORT;
eMailServerSetting.SecurityMethod = SL_SO_SEC_METHOD_SSLV3;
eMailServerSetting.SecurityCypher = SL_SEC_MASK_SSL_RSA_WITH_RC4_128_MD5;
lRetVal = sl_NetAppEmailSet(SL_NET_APP_EMAIL_ID, \
NETAPP_ADVANCED_OPT, \
sizeof(SlNetAppEmailOpt_t), \
(unsigned char*)&eMailServerSetting);
ASSERT_ON_ERROR(lRetVal);
}
else
{
UART_PRINT("Error:%d GetHostIP.", lRetVal);
return -1;
}
g_cConnectStatus = sl_NetAppEmailConnect();
// If return -1, throw connect error
if(g_cConnectStatus == -1)
{
DispatcherUartSendPacket((char*)pucUARTErrorSocketCreateString, \
sizeof(pucUARTErrorSocketCreateString));
}
// If return -2, throw socket option error
if(g_cConnectStatus == -2)
{
DispatcherUartSendPacket((char*)pucUARTErrorSocketOptionString, \
sizeof(pucUARTErrorSocketOptionString));
}
if(g_cConnectStatus == 0)
{
SlNetAppServerError_t sEmailErrorInfo;
long lRetCode = SL_EMAIL_ERROR_FAILED;
if((lRetCode = sl_NetAppEmailSend(pcEmailto,pcEmailsubject, \
pcEmailmessage, \
&sEmailErrorInfo)) == SL_EMAIL_ERROR_NONE)
{
// Blink LED7 to indicate email has been sent
for(iIndex=0 ;iIndex<5 ;iIndex++)
{
MAP_UtilsDelay(6000000);
GPIO_IF_LedOff(MCU_SENDING_DATA_IND);
MAP_UtilsDelay(6000000);
GPIO_IF_LedOn(MCU_SENDING_DATA_IND);
}
DispatcherUartSendPacket((char*)putUARTFinishString, \
sizeof(putUARTFinishString));
}
else
{
lRetVal = EmailHandleERROR(lRetCode,(char*)sEmailErrorInfo.Value);
ASSERT_ON_ERROR(lRetVal);
}
}
}
break;
case UART_COMMAND_SMART_CONFIG:
GPIO_IF_LedOff(MCU_IP_ALLOC_IND);
DispatcherUartSendPacket((char*)pucUARTSmartConfigString, \
sizeof(pucUARTSmartConfigString));
// Start LED blinking Timer
LedTimerConfigNStart();
//Reset the Network Status before Entering Smart Config
Network_IF_UnsetMCUMachineState(STATUS_BIT_CONNECTION);
Network_IF_UnsetMCUMachineState(STATUS_BIT_IP_AQUIRED);
// start smart config process
lRetVal = SmartConfigConnect();
ASSERT_ON_ERROR(lRetVal);
while (!(IS_CONNECTED(Network_IF_CurrentMCUState())) || \
!(IS_IP_ACQUIRED(Network_IF_CurrentMCUState())))
{
MAP_UtilsDelay(100);
}
LedTimerDeinitStop();
GPIO_IF_LedOn(MCU_IP_ALLOC_IND);
break;
default:
DispatcherUartSendPacket((char*)pucUARTErrorString, \
sizeof(pucUARTErrorString));
break;
}
return SUCCESS;
}
//****************************************************************************
//
//! \brief Configuring the Connection Policy
//!
//! This function configures different Connection Policy such as FAST,AUTO,OPEN
//!
//! \param[in] None
//!
//! \return 0 on success else error code
//!
//! \note
//
//****************************************************************************
static long SetConnectionPolicy()
{
unsigned char policyVal;
long lRetVal = -1;
/* Clear all stored profiles and reset the policies */
lRetVal = sl_WlanProfileDel(0xFF);
ASSERT_ON_ERROR(lRetVal);
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION, SL_CONNECTION_POLICY(0,0,0,0,0), 0, 0);
ASSERT_ON_ERROR(lRetVal);
//Add Profile
/* user needs to change SSID_NAME = "<Secured AP>"
SECURITY_TYPE = SL_SEC_TYPE_WPA
SECURITY_KEY = "<password>"
and set the priority as per requirement
to connect with a secured AP */
SlSecParams_t secParams;
secParams.Key = SECURITY_KEY;
secParams.KeyLen = strlen(SECURITY_KEY);
secParams.Type = SECURITY_TYPE;
lRetVal = sl_WlanProfileAdd(SSID_NAME,strlen(SSID_NAME),0,&secParams,0,1,0);
ASSERT_ON_ERROR(lRetVal);
//set AUTO policy
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,0),
&policyVal, 1 /*PolicyValLen*/);
ASSERT_ON_ERROR(lRetVal);
//wait until IP is acquired
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
_SlNonOsMainLoopTask();
}
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
//
// ****** Put breakpoint here ******
// If control comes here- means device connected to AP in auto mode
//
// Disconnect from AP
lRetVal = sl_WlanDisconnect();
if(0 == lRetVal)
{
// Wait
while(IS_CONNECTED(g_ulStatus))
{
#ifndef SL_PLATFORM_MULTI_THREADED
_SlNonOsMainLoopTask();
#endif
}
}
//delete profiles
lRetVal = sl_WlanProfileDel(0xFF);
ASSERT_ON_ERROR(lRetVal);
//set Auto SmartConfig policy
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(1,0,0,0,1),
&policyVal,0);
ASSERT_ON_ERROR(lRetVal);
// reset the NWP
lRetVal = ResetNwp();
ASSERT_ON_ERROR(lRetVal);
// wait for smart config to complete and device to connect to an AP
//wait until IP is acquired
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
_SlNonOsMainLoopTask();
}
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
//
// ****** Put breakpoint here ******
// If control comes here- means device connected to AP in smartconfig mode
//
/* Delete all profiles (0xFF) stored */
lRetVal = sl_WlanProfileDel(0xFF);
ASSERT_ON_ERROR(lRetVal);
// reset the NWP
lRetVal = ResetNwp();
ASSERT_ON_ERROR(lRetVal);
/* Set connection policy to Fast, Device will connect to last connected AP.
* This feature can be used to reconnect to AP */
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION , \
SL_CONNECTION_POLICY(1,1,0,0,0), 0, 0);
ASSERT_ON_ERROR(lRetVal);
/* Connect to the open AP */
lRetVal = sl_WlanConnect(SSID_NAME, strlen(SSID_NAME), 0, 0, 0);
ASSERT_ON_ERROR(lRetVal);
//wait until IP is acquired
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
_SlNonOsMainLoopTask();
}
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
// Add unsecured AP profile with priority 6 (7 is highest)
// Because of a limitation in SDK-0.5 which prevents the automatic addition
// of the profile (fast), the application is required to explicitly add it.
// The limitation shall be addressed in subsequent SDK release, and the below
// lines for adding the profile can be removed then...!
secParams.Key = "";
secParams.KeyLen = 0;
secParams.Type = SL_SEC_TYPE_OPEN;
lRetVal = sl_WlanProfileAdd((signed char*)SSID_NAME,
strlen(SSID_NAME), 0, &secParams, 0, 6, 0);
ASSERT_ON_ERROR(lRetVal);
// reset the NWP
lRetVal = ResetNwp();
ASSERT_ON_ERROR(lRetVal);
/* Wait for the connection to be established */
while((!IS_CONNECTED(g_ulStatus)) || (!IS_IP_ACQUIRED(g_ulStatus)))
{
_SlNonOsMainLoopTask();
}
//
// ****** Put breakpoint here ******
// If control comes here- means device connected to AP in FAST mode
//
//remove all policies
lRetVal = sl_WlanPolicySet(SL_POLICY_CONNECTION,
SL_CONNECTION_POLICY(0,0,0,0,0),
&policyVal,0);
ASSERT_ON_ERROR(lRetVal);
return SUCCESS;
}