void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent)
{
UART_PRINT("SimpleLinkWlanEventHandler\r\n");
switch(pWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'slWlanConnectAsyncResponse_t'-Applications
// can use it if required
//
// slWlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
//
UART_PRINT("[WLAN EVENT] STA Connected to the AP: %s\n\r",
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_name);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;
// If the user has initiated 'Disconnect' request,
//'reason_code' is SL_USER_INITIATED_DISCONNECTION
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
UART_PRINT("[WLAN EVENT]Device disconnected from the AP: %s\r\n",
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_name);
}
else
{
UART_PRINT("[WLAN ERROR]Device disconnected from the AP AP: %s\r\n",
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_name);
}
}
break;
default:
{
UART_PRINT("[WLAN EVENT] Unexpected event [0x%x]\n\r",
pWlanEvent->Event);
}
break;
}
}
/*!
\brief This function handles WLAN events
\param[in] pWlanEvent is the event passed to the handler
\return None
\note
\warning
*/
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent)
{
if(pWlanEvent == NULL)
{
CLI_Write((_u8 *)" [WLAN EVENT] NULL Pointer Error \n\r");
return;
}
switch(pWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
/*
* Information about the connected AP (like name, MAC etc) will be
* available in 'slWlanConnectAsyncResponse_t' - Applications
* can use it if required
*
* slWlanConnectAsyncResponse_t *pEventData = NULL;
* pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
*
*/
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_Status, STATUS_BIT_IP_ACQUIRED);
pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;
/* If the user has initiated 'Disconnect' request, 'reason_code' is SL_USER_INITIATED_DISCONNECTION */
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
CLI_Write((_u8 *)" Device disconnected from the AP on application's request \n\r");
}
else
{
CLI_Write((_u8 *)" Device disconnected from the AP on an ERROR..!! \n\r");
}
}
break;
default:
{
CLI_Write((_u8 *)" [WLAN EVENT] Unexpected event \n\r");
}
break;
}
}
/*!
\brief This function handles WLAN events
\param[in] pWlanEvent is the event passed to the handler
*/
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent) {
if(pWlanEvent == NULL) {
CLI_Write((_u8 *)"[WLAN EVENT] NULL Pointer Error \n");
return;
}
switch(pWlanEvent->Event) {
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(_status, STATUS_BIT_CONNECTION);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(_status, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(_status, STATUS_BIT_IP_ACQUIRED);
pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
CLI_Write((_u8 *)"Device disconnected from the AP on application's request \n");
else
CLI_Write((_u8 *)"Device disconnected from the AP on an ERROR..!! \n");
}
break;
case SL_WLAN_STA_CONNECTED_EVENT:
{
SET_STATUS_BIT(_status, STATUS_BIT_STA_CONNECTED);
}
break;
case SL_WLAN_STA_DISCONNECTED_EVENT:
{
CLR_STATUS_BIT(_status, STATUS_BIT_STA_CONNECTED);
CLR_STATUS_BIT(_status, STATUS_BIT_IP_LEASED);
}
break;
default:
{
CLI_Write((_u8 *)"[WLAN EVENT] Unexpected event \n");
}
break;
}
}
static void net_ping(const char *host)
{
SlPingStartCommand_t pingParams = {0};
SlPingReport_t pingReport = {0};
unsigned long ulIpAddr = 0;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_PING_DONE);
// Set the ping parameters
pingParams.PingIntervalTime = 1000;
pingParams.PingSize = 20;
pingParams.PingRequestTimeout = 3000;
pingParams.TotalNumberOfAttempts = 3;
pingParams.Flags = 0;
pingParams.Ip = g_ulGatewayIP;
UART_PRINT("ping host: %s\r\n", host);
sl_NetAppDnsGetHostByName((signed char*)host, strlen(host), &ulIpAddr, SL_AF_INET);
UART_PRINT("host ip: 0x%08X\r\n", host);
pingParams.Ip = ulIpAddr;
sl_NetAppPingStart((SlPingStartCommand_t*)&pingParams, SL_AF_INET, (SlPingReport_t*)&pingReport, SimpleLinkPingReport);
while (!IS_PING_DONE(g_ulStatus))
_SlNonOsMainLoopTask();
}
/*!
\brief This function checks the LAN connection by pinging the AP's gateway
\param[in] None
\return 0 on success, negative error-code on error
*/
static _i32 checkLanConnection()
{
SlPingStartCommand_t pingParams = {0};
SlPingReport_t pingReport = {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 LAN connection */
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 LAN connection */
ASSERT_ON_ERROR(LAN_CONNECTION_FAILED);
}
/* LAN connection is successful */
return SUCCESS;
}
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent) {
switch (pWlanEvent->Event) {
case SL_WLAN_CONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
memset(g_ConnectionSSID, 0, sizeof(g_ConnectionSSID));
memset(g_ConnectionBSSID, 0, sizeof(g_ConnectionBSSID));
memcpy(g_ConnectionSSID, pEventData->ssid_name, pEventData->ssid_len);
memcpy(g_ConnectionBSSID, pEventData->bssid, SL_BSSID_LENGTH);
UART_PRINT("[QuickStart] Connected to : %s (%x:%x:%x:%x:%x:%x)\r\n",
g_ConnectionSSID,
g_ConnectionBSSID[0], g_ConnectionBSSID[1],
g_ConnectionBSSID[2], g_ConnectionBSSID[3],
g_ConnectionBSSID[4], g_ConnectionBSSID[5]);
SET_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
CLR_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_Status, STATUS_BIT_IP_AQUIRED);
slWlanConnectAsyncResponse_t* pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;
UART_PRINT("[QuickStart] Disconnected from : %s (%x:%x:%x:%x:%x:%x)\r\n",
g_ConnectionSSID,
g_ConnectionBSSID[0], g_ConnectionBSSID[1],
g_ConnectionBSSID[2], g_ConnectionBSSID[3],
g_ConnectionBSSID[4], g_ConnectionBSSID[5]);
if (SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code) {
UART_PRINT(" Reason : user request\r\n");
} else {
UART_PRINT(" Error : %d\r\n", pEventData->reason_code);
}
memset(g_ConnectionSSID, 0, sizeof(g_ConnectionSSID));
memset(g_ConnectionBSSID, 0, sizeof(g_ConnectionBSSID));
}
break;
default:
break;
}
}
//*****************************************************************************
//
//! \brief The Function Handles WLAN Events
//!
//! \param[in] pWlanEvent - Pointer to WLAN Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent)
{
if(!pWlanEvent)
{
return;
}
switch(pWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'slWlanConnectAsyncResponse_t'-Applications
// can use it if required
//
// slWlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
//
// Copy new connection SSID and BSSID to global parameters
memcpy(g_ucConnectionSSID,pWlanEvent->EventData.
STAandP2PModeWlanConnected.ssid_name,
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_len);
memcpy(g_ucConnectionBSSID,
pWlanEvent->EventData.STAandP2PModeWlanConnected.bssid,
SL_BSSID_LENGTH);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
memset(g_ucConnectionSSID,0,sizeof(g_ucConnectionSSID));
memset(g_ucConnectionBSSID,0,sizeof(g_ucConnectionBSSID));
}
break;
}
}
//*****************************************************************************
//! \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;
// Get external host IP address
lRetVal = sl_NetAppDnsGetHostByName((signed char*)HOST_NAME, sizeof(HOST_NAME),
&ulIpAddr, SL_AF_INET);
ASSERT_ON_ERROR(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(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
ASSERT_ON_ERROR(INTERNET_CONNECTION_FAILED);
}
// Internet connection is successful
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 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;
}
//*****************************************************************************
//
//! 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;
}
//*****************************************************************************
//
//! \brief The Function Handles WLAN Events
//!
//! \param[in] pWlanEvent - Pointer to WLAN Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent) {
if (!pWlanEvent) {
return;
}
switch(pWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
//slWlanConnectAsyncResponse_t *pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
// copy the new connection data
//memcpy(wlan_obj.bssid, pEventData->bssid, SL_BSSID_LENGTH);
//memcpy(wlan_obj.ssid_o, pEventData->ssid_name, pEventData->ssid_len);
//wlan_obj.ssid_o[pEventData->ssid_len] = '\0';
SET_STATUS_BIT(wlan_obj.status, STATUS_BIT_CONNECTION);
#if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
// we must reset the servers in case that the last connection
// was lost without any notification being received
servers_reset();
#endif
}
break;
case SL_WLAN_DISCONNECT_EVENT:
CLR_STATUS_BIT(wlan_obj.status, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(wlan_obj.status, STATUS_BIT_IP_ACQUIRED);
#if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
servers_reset();
servers_wlan_cycle_power();
#endif
break;
case SL_WLAN_STA_CONNECTED_EVENT:
{
//slPeerInfoAsyncResponse_t *pEventData = &pWlanEvent->EventData.APModeStaConnected;
// get the mac address and name of the connected device
//memcpy(wlan_obj.bssid, pEventData->mac, SL_BSSID_LENGTH);
//memcpy(wlan_obj.ssid_o, pEventData->go_peer_device_name, pEventData->go_peer_device_name_len);
//wlan_obj.ssid_o[pEventData->go_peer_device_name_len] = '\0';
SET_STATUS_BIT(wlan_obj.status, STATUS_BIT_CONNECTION);
#if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
// we must reset the servers in case that the last connection
// was lost without any notification being received
servers_reset();
#endif
}
break;
case SL_WLAN_STA_DISCONNECTED_EVENT:
CLR_STATUS_BIT(wlan_obj.status, STATUS_BIT_CONNECTION);
#if (MICROPY_PORT_HAS_TELNET || MICROPY_PORT_HAS_FTP)
servers_reset();
servers_wlan_cycle_power();
#endif
break;
case SL_WLAN_P2P_DEV_FOUND_EVENT:
// TODO
break;
case SL_WLAN_P2P_NEG_REQ_RECEIVED_EVENT:
// TODO
break;
case SL_WLAN_CONNECTION_FAILED_EVENT:
// TODO
break;
default:
break;
}
}
/*!
* \brief Start the device in STA mode
*
* 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
*/
_i32 startAP(void){
SlPingStartCommand_t PingParams = {0};
SlPingReport_t Report = {0};
_u8 SecType = 0;
_i32 mode = ROLE_STA;
_i32 retVal = configureSimpleLinkToDefaultState();
if(retVal < 0)
{
if (DEVICE_NOT_IN_STATION_MODE == retVal)
CLI_Write((_u8 *)" Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
CLI_Write((_u8 *)" 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
*/
mode = sl_Start(0, 0, 0);
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(); }
}
else
{
/* Configure CC3100 to start in AP mode */
retVal = sl_WlanSetMode(ROLE_AP);
if(retVal < 0)
LOOP_FOREVER();
/* Configure the SSID of the CC3100 */
retVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_SSID,
pal_Strlen(SSID_AP_MODE), (_u8 *)SSID_AP_MODE);
if(retVal < 0)
LOOP_FOREVER();
SecType = SEC_TYPE_AP_MODE;
/* Configure the Security parameter the AP mode */
retVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_SECURITY_TYPE, 1,
(_u8 *)&SecType);
if(retVal < 0)
LOOP_FOREVER();
retVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_PASSWORD, pal_Strlen(PASSWORD_AP_MODE),
(_u8 *)PASSWORD_AP_MODE);
if(retVal < 0)
LOOP_FOREVER();
retVal = sl_Stop(SL_STOP_TIMEOUT);
if(retVal < 0)
LOOP_FOREVER();
CLR_STATUS_BIT(g_Status, STATUS_BIT_IP_ACQUIRED);
mode = sl_Start(0, 0, 0);
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(); }
}
else
{
CLI_Write((_u8 *)" Device couldn't be configured in AP mode \n\r");
LOOP_FOREVER();
}
}
CLI_Write((_u8 *)" Device started as Access Point\n\r");
/* Wait */
CLI_Write((_u8 *)" Waiting for clients to connect...!\n\r");
while((!IS_IP_LEASED(g_Status)) || (!IS_STA_CONNECTED(g_Status))) { _SlNonOsMainLoopTask(); }
CLI_Write((_u8 *)" Client connected to the device \n\r");
CLI_Write((_u8 *)" Pinging...! \n\r");
/* 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_StationIP; /* Fill the station IP address connected to CC3100 */
/* Ping client connected to CC3100 */
retVal = sl_NetAppPingStart((SlPingStartCommand_t*)&PingParams, SL_AF_INET,
(SlPingReport_t*)&Report, SimpleLinkPingReport);
if(retVal < 0)
LOOP_FOREVER();
/* Wait */
// while(!IS_PING_DONE(g_Status)) { _SlNonOsMainLoopTask(); }
//
// if (0 == g_PingPacketsRecv)
// {
// CLI_Write((_u8 *)" A STATION couldn't connect to the device \n\r");
// ASSERT_ON_ERROR(LAN_CONNECTION_FAILED);
// }
CLI_Write((_u8 *)" Device and the station are successfully connected \n\r");
return SUCCESS;
}
/*!
\brief This function handles WLAN events
\param[in] pWlanEvent is the event passed to the handler
\return None
\note
\warning
*/
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent)
{
if(pWlanEvent == NULL)
CLI_Write(" [WLAN EVENT] NULL Pointer Error \n\r");
switch(pWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
/*
* Information about the connected AP (like name, MAC etc) will be
* available in 'slWlanConnectAsyncResponse_t' - Applications
* can use it if required
*
* slWlanConnectAsyncResponse_t *pEventData = NULL;
* pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
*
*/
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_Status, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_Status, STATUS_BIT_IP_ACQUIRED );
pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;
/* If the user has initiated 'Disconnect' request, 'reason_code' is
* SL_USER_INITIATED_DISCONNECTION */
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
CLI_Write(" Device disconnected from the AP on application's request \n\r");
}
else
{
CLI_Write(" Device disconnected from the AP on an ERROR..!! \n\r");
}
}
break;
case SL_WLAN_SMART_CONFIG_COMPLETE_EVENT:
/** SmartConfig operation finished
* The new SSID that was acquired is:
* pWlanEventHandler->EventData.smartConfigStartResponse.ssid
* We have the possibility that also a private token was sent to the Host:
* if(pWlanEventHandler->EventData.smartConfigStartResponse.private_token_len)
* then the private token is populated:
* pWlanEventHandler->EventData.smartConfigStartResponse.private_token
*/
SET_STATUS_BIT(g_Status, STATUS_BIT_SMARTCONFIG_DONE);
SET_STATUS_BIT(g_Status, STATUS_BIT_SMARTCONFIG_STOPPED);
break;
case SL_WLAN_SMART_CONFIG_STOP_EVENT:
/* SmartConfig stop operation was completed */
SET_STATUS_BIT(g_Status, STATUS_BIT_SMARTCONFIG_STOPPED);
CLR_STATUS_BIT(g_Status, STATUS_BIT_SMARTCONFIG_DONE);
default:
{
/* Unexpected Event */
}
break;
}
}
//*****************************************************************************
//
//! \brief The Function Handles WLAN Events
//!
//! \param[in] pWlanEvent pointer indicating Event type
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pSlWlanEvent)
{
switch(pSlWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION_FAILED);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'sl_protocol_wlanConnectAsyncResponse_t' - Applications
// can use it if required
//
// sl_protocol_wlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.STAandP2PModeWlanConnected;
//
//
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
sl_protocol_wlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
pEventData = &pSlWlanEvent->EventData.STAandP2PModeDisconnected;
// If the user has initiated 'Disconnect' request, 'reason_code'
// is SL_USER_INITIATED_DISCONNECTION
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
UART_PRINT("Device disconnected from the AP on application's"
"request \n\r");
}
else
{
UART_PRINT("Device disconnected from the AP on an ERROR..!! \n\r");
}
}
break;
case SL_WLAN_STA_CONNECTED_EVENT:
{
// when device is in AP mode and any client connects to device cc3xxx
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION_FAILED);
//
// Information about the connected client (like SSID, MAC etc) will
// be available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModeStaConnected;
//
}
break;
case SL_WLAN_STA_DISCONNECTED_EVENT:
{
// when client disconnects from device (AP)
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
//
// Information about the connected client (like SSID, MAC etc) will
// be available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModestaDisconnected;
//
}
break;
case SL_WLAN_P2P_DEV_FOUND_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_P2P_DEV_FOUND);
//
// Information about P2P config details (like Peer device name, own
// SSID etc) will be available in 'slPeerInfoAsyncResponse_t' -
// Applications can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.P2PModeDevFound;
//
}
break;
case SL_WLAN_P2P_NEG_REQ_RECEIVED_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_P2P_REQ_RECEIVED);
memset(g_p2p_dev, '\0', MAXIMAL_SSID_LENGTH + 1);
memcpy(g_p2p_dev,pSlWlanEvent->EventData.P2PModeNegReqReceived.go_peer_device_name,
pSlWlanEvent->EventData.P2PModeNegReqReceived.go_peer_device_name_len);
//
// Information about P2P Negotiation req details (like Peer device
// name, own SSID etc) will be available in
// 'slPeerInfoAsyncResponse_t' - Applications can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.P2PModeNegReqReceived;
//
}
break;
case SL_WLAN_CONNECTION_FAILED_EVENT:
{
// If device gets any connection failed event
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION_FAILED);
}
break;
default:
{
UART_PRINT("[WLAN EVENT] Unexpected event \n\r");
}
break;
}
}
//*****************************************************************************
//
//! \brief This function handles network events such as IP acquisition, IP
//! leased, IP released etc.
//!
//! \param pNetAppEvent - Pointer indicating device acquired IP
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *pNetAppEvent)
{
switch(pNetAppEvent->Event)
{
case SL_NETAPP_IPV4_ACQUIRED:
case SL_NETAPP_IPV6_ACQUIRED:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
//
// Information about the IPv4 & IPv6 details (like IP, gateway,dns
// etc) will be available in 'SlNetAppEventData_u' - Applications
// can use it if required
//
// For IPv4:
//
// SlNetAppEventData_u *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipAcquiredV4;
//
// For IPv6:
//
// SlNetAppEventData_u *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipAcquiredV6;
//
}
break;
case SL_NETAPP_IP_LEASED:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
//
// Information about the IP-Leased details(like IP-Leased,lease-time,
// mac etc) will be available in 'SlIpLeasedAsync_t' - Applications
// can use it if required
//
// SlIpLeasedAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipLeased;
//
SlIpLeasedAsync_t *pEventData = NULL;
pEventData = &pNetAppEvent->EventData.ipLeased;
g_ulStaIp = pEventData->ip_address;
}
break;
case SL_NETAPP_IP_RELEASED:
{
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
//
// Information about the IP-Released details (like IP-address, mac
// etc) will be available in 'SlIpReleasedAsync_t' - Applications
// can use it if required
//
// SlIpReleasedAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipReleased;
//
}
break;
case SL_NETAPP_SOCKET_TX_FAILED:
{
UART_PRINT("[NETAPP EVENT] Socket Error # %d \n\r",
pNetAppEvent->EventData.sd);
}
break;
default:
{
UART_PRINT("[NETAPP EVENT] Unexpected event \n\r");
}
break;
}
}
//*****************************************************************************
//
//! On Successful completion of Wlan Connect, This function triggers Connection
//! status to be set.
//!
//! \param pSlWlanEvent pointer indicating Event type
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pSlWlanEvent)
{
switch(pSlWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'sl_protocol_wlanConnectAsyncResponse_t'-Applications
// can use it if required
//
// sl_protocol_wlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
//
//
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
sl_protocol_wlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
pEventData = &pSlWlanEvent->EventData.STAandP2PModeDisconnected;
// If the user has initiated 'Disconnect' request,
//'reason_code' is SL_USER_INITIATED_DISCONNECTION
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
UART_PRINT("Device disconnected from the AP on application's "
"request \n\r");
}
else
{
UART_PRINT("Device disconnected from the AP on an ERROR..!! \n\r");
}
}
break;
case SL_WLAN_STA_CONNECTED_EVENT:
{
// when device is in AP mode and any client connects to device cc3xxx
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected client (like SSID, MAC etc) will be
// available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModeStaConnected;
//
}
break;
case SL_WLAN_STA_DISCONNECTED_EVENT:
{
// when client disconnects from device (AP)
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
//
// Information about the connected client (like SSID, MAC etc) will
// be available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModestaDisconnected;
//
}
break;
default:
{
UART_PRINT("[WLAN EVENT] Unexpected event \n\r");
}
break;
}
}
//*****************************************************************************
//
//! 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;
}
//*****************************************************************************
//
//! \brief The Function Handles WLAN Events
//!
//! \param[in] pSlWlanEvent - Pointer to WLAN Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pSlWlanEvent)
{
if(pSlWlanEvent == NULL)
{
return;
}
switch(((SlWlanEvent_t*)pSlWlanEvent)->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION_FAILED);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'slWlanConnectAsyncResponse_t'-Applications
// can use it if required
//
// slWlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.STAandP2PModeWlanConnected;
//
// Copy new connection SSID and BSSID to global parameters
memcpy(g_ucConnectionSSID,pSlWlanEvent->EventData.
STAandP2PModeWlanConnected.ssid_name,
pSlWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_len);
memcpy(g_ucConnectionBSSID,
pSlWlanEvent->EventData.STAandP2PModeWlanConnected.bssid,
SL_BSSID_LENGTH);
UART_PRINT("[WLAN EVENT] STA Connected to the AP: %s , BSSID: "
"%x:%x:%x:%x:%x:%x\n\r", g_ucConnectionSSID,
g_ucConnectionBSSID[0], g_ucConnectionBSSID[1],
g_ucConnectionBSSID[2], g_ucConnectionBSSID[3],
g_ucConnectionBSSID[4], g_ucConnectionBSSID[5]);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
pEventData = &pSlWlanEvent->EventData.STAandP2PModeDisconnected;
// If the user has initiated 'Disconnect' request,
//'reason_code' is SL_USER_INITIATED_DISCONNECTION
if(SL_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
UART_PRINT("[WLAN EVENT]Device disconnected from the AP: %s, "
"BSSID: %x:%x:%x:%x:%x:%x on application's request "
"\n\r", g_ucConnectionSSID,g_ucConnectionBSSID[0],
g_ucConnectionBSSID[1],g_ucConnectionBSSID[2],
g_ucConnectionBSSID[3],g_ucConnectionBSSID[4],
g_ucConnectionBSSID[5]);
}
else
{
UART_PRINT("[WLAN ERROR]Device disconnected from the AP AP: %s,"
" BSSID: %x:%x:%x:%x:%x:%x on an ERROR..!! \n\r",
g_ucConnectionSSID,g_ucConnectionBSSID[0],
g_ucConnectionBSSID[1],g_ucConnectionBSSID[2],
g_ucConnectionBSSID[3],g_ucConnectionBSSID[4],
g_ucConnectionBSSID[5]);
}
memset(g_ucConnectionSSID,0,sizeof(g_ucConnectionSSID));
memset(g_ucConnectionBSSID,0,sizeof(g_ucConnectionBSSID));
}
break;
case SL_WLAN_STA_CONNECTED_EVENT:
{
// when device is in AP mode and any client connects to device cc3xxx
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION_FAILED);
//
// Information about the connected client (like SSID, MAC etc) will
// be available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModeStaConnected;
//
}
break;
case SL_WLAN_STA_DISCONNECTED_EVENT:
{
// when client disconnects from device (AP)
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
//
// Information about the connected client (like SSID, MAC etc) will
// be available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModestaDisconnected;
//
}
break;
case SL_WLAN_SMART_CONFIG_COMPLETE_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_SMARTCONFIG_START);
//
// Information about the SmartConfig details (like Status, SSID,
// Token etc) will be available in 'slSmartConfigStartAsyncResponse_t'
// - Applications can use it if required
//
// slSmartConfigStartAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.smartConfigStartResponse;
//
}
break;
case SL_WLAN_SMART_CONFIG_STOP_EVENT:
{
// SmartConfig operation finished
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_SMARTCONFIG_START);
//
// Information about the SmartConfig details (like Status, padding
// etc) will be available in 'slSmartConfigStopAsyncResponse_t' -
// Applications can use it if required
//
// slSmartConfigStopAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.smartConfigStopResponse;
//
}
break;
case SL_WLAN_P2P_DEV_FOUND_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_P2P_DEV_FOUND);
//
// Information about P2P config details (like Peer device name, own
// SSID etc) will be available in 'slPeerInfoAsyncResponse_t' -
// Applications can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.P2PModeDevFound;
//
}
break;
case SL_WLAN_P2P_NEG_REQ_RECEIVED_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_P2P_REQ_RECEIVED);
//
// Information about P2P Negotiation req details (like Peer device
// name, own SSID etc) will be available in 'slPeerInfoAsyncResponse_t'
// - Applications can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.P2PModeNegReqReceived;
//
}
break;
case SL_WLAN_CONNECTION_FAILED_EVENT:
{
// If device gets any connection failed event
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION_FAILED);
}
break;
default:
{
UART_PRINT("[WLAN EVENT] Unexpected event \n\r");
}
break;
}
}
//*****************************************************************************
//
//! \brief The Function Handles WLAN Events
//!
//! \param[in] pSlWlanEvent - Pointer to WLAN Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pSlWlanEvent)
{
switch(((SlWlanEvent_t*)pSlWlanEvent)->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'slWlanConnectAsyncResponse_t'-Applications
// can use it if required
//
// slWlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.STAandP2PModeWlanConnected;
//
// Copy new connection SSID and BSSID to global parameters
memcpy(g_ucConnectionSSID,pSlWlanEvent->EventData.
STAandP2PModeWlanConnected.ssid_name,
pSlWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_len);
memcpy(g_ucConnectionBSSID,
pSlWlanEvent->EventData.STAandP2PModeWlanConnected.bssid,
SL_BSSID_LENGTH);
UART_PRINT("[WLAN EVENT] STA Connected to the AP: %s , BSSID: "
"%x:%x:%x:%x:%x:%x\n\r", g_ucConnectionSSID,
g_ucConnectionBSSID[0], g_ucConnectionBSSID[1],
g_ucConnectionBSSID[2], g_ucConnectionBSSID[3],
g_ucConnectionBSSID[4], g_ucConnectionBSSID[5]);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
pEventData = &pSlWlanEvent->EventData.STAandP2PModeDisconnected;
// If the user has initiated 'Disconnect' request,
//'reason_code' is SL_WLAN_DISCONNECT_USER_INITIATED_DISCONNECTION
if(SL_WLAN_DISCONNECT_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
UART_PRINT("[WLAN EVENT]Device disconnected from the AP: %s, "
"BSSID: %x:%x:%x:%x:%x:%x on application's request "
"\n\r", g_ucConnectionSSID,g_ucConnectionBSSID[0],
g_ucConnectionBSSID[1],g_ucConnectionBSSID[2],
g_ucConnectionBSSID[3],g_ucConnectionBSSID[4],
g_ucConnectionBSSID[5]);
}
else
{
UART_PRINT("[WLAN ERROR]Device disconnected from the AP AP: %s,"
" BSSID: %x:%x:%x:%x:%x:%x on an ERROR..!! \n\r",
g_ucConnectionSSID,g_ucConnectionBSSID[0],
g_ucConnectionBSSID[1],g_ucConnectionBSSID[2],
g_ucConnectionBSSID[3],g_ucConnectionBSSID[4],
g_ucConnectionBSSID[5]);
}
memset(g_ucConnectionSSID,0,sizeof(g_ucConnectionSSID));
memset(g_ucConnectionBSSID,0,sizeof(g_ucConnectionBSSID));
}
break;
case SL_WLAN_STA_CONNECTED_EVENT:
{
// when device is in AP mode and any client connects to device cc3xxx
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected client (like SSID, MAC etc) will
// be available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModeStaConnected;
//
}
break;
case SL_WLAN_STA_DISCONNECTED_EVENT:
{
// when client disconnects from device (AP)
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected client (like SSID, MAC etc) will
// be available in 'slPeerInfoAsyncResponse_t' - Applications
// can use it if required
//
// slPeerInfoAsyncResponse_t *pEventData = NULL;
// pEventData = &pSlWlanEvent->EventData.APModestaDisconnected;
//
}
break;
default:
{
UART_PRINT("[WLAN EVENT] Unexpected event \n\r");
}
break;
}
}
//*****************************************************************************
//
//! \brief Unsets a state from the state machine
//!
//! \param cStat Status of State Machine defined in e_StatusBits
//!
//! \return none
//!
//*****************************************************************************
void
Network_IF_UnsetMCUMachineState(char cStat)
{
CLR_STATUS_BIT(g_ulStatus, cStat);
}
//*****************************************************************************
//
//! \brief This function handles network events such as IP acquisition, IP
//! leased, IP released etc.
//!
//! \param[in] pNetAppEvent - Pointer to NetApp Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *pNetAppEvent)
{
if(pNetAppEvent == NULL)
{
UART_PRINT("Null pointer\n\r");
LOOP_FOREVER();
}
switch(pNetAppEvent->Event)
{
case SL_NETAPP_IPV4_IPACQUIRED_EVENT:
{
SlIpV4AcquiredAsync_t *pEventData = NULL;
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
//Ip Acquired Event Data
pEventData = &pNetAppEvent->EventData.ipAcquiredV4;
UART_PRINT("[NETAPP EVENT] IP Acquired: IP=%d.%d.%d.%d , "
"Gateway=%d.%d.%d.%d\n\r",
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip,3),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip,2),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip,1),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.ip,0),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway,3),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway,2),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway,1),
SL_IPV4_BYTE(pNetAppEvent->EventData.ipAcquiredV4.gateway,0));
UNUSED(pEventData);
}
break;
case SL_NETAPP_IP_LEASED_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
//
// Information about the IP-Leased details(like IP-Leased,lease-time,
// mac etc) will be available in 'SlIpLeasedAsync_t' - Applications
// can use it if required
//
// SlIpLeasedAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipLeased;
//
}
break;
case SL_NETAPP_IP_RELEASED_EVENT:
{
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
//
// Information about the IP-Released details (like IP-address, mac
// etc) will be available in 'SlIpReleasedAsync_t' - Applications
// can use it if required
//
// SlIpReleasedAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipReleased;
//
}
break;
default:
{
UART_PRINT("[NETAPP EVENT] Unexpected event [0x%x] \n\r",
pNetAppEvent->Event);
}
break;
}
}
//*****************************************************************************
//
//! \brief This function handles network events such as IP acquisition, IP
//! leased, IP released etc.
//!
//! \param pNetAppEvent - Pointer indicating device acquired IP
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkNetAppEventHandler(SlNetAppEvent_t *pNetAppEvent)
{
if(pNetAppEvent == NULL)
{
return;
}
switch(pNetAppEvent->Event)
{
case SL_NETAPP_IPV4_IPACQUIRED_EVENT:
case SL_NETAPP_IPV6_IPACQUIRED_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
UART_PRINT("[NETAPP EVENT] IP acquired by the device\n\r");
//
// Information about the IPv4 & IPv6 details (like IP, gateway,dns
// etc) will be available in 'SlIpV4AcquiredAsync_t /
// SlIpV6AcquiredAsync_t' - Applications can use it if required
//
// For IPv4:
//
// SlIpV4AcquiredAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipAcquiredV4;
//
// For IPv6:
//
// SlIpV6AcquiredAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipAcquiredV6;
//
}
break;
case SL_NETAPP_IP_LEASED_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
UART_PRINT("[NETAPP EVENT] IP leased to a client\n\r");
//
// Information about the IP-Leased details(like IP-Leased,lease-time,
// mac etc) will be available in 'SlIpLeasedAsync_t' - Applications
// can use it if required
//
// SlIpLeasedAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipLeased;
//
SlIpLeasedAsync_t *pEventData = NULL;
pEventData = &pNetAppEvent->EventData.ipLeased;
g_ulStaIp = pEventData->ip_address;
}
break;
case SL_NETAPP_IP_RELEASED_EVENT:
{
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_LEASED);
UART_PRINT("[NETAPP EVENT] IP released from a client\n\r");
//
// Information about the IP-Released details (like IP-address, mac
// etc) will be available in 'SlIpReleasedAsync_t' - Applications
// can use it if required
//
// SlIpReleasedAsync_t *pEventData = NULL;
// pEventData = &pNetAppEvent->EventData.ipReleased;
//
}
break;
default:
{
UART_PRINT("[NETAPP EVENT] Unexpected event \n\r");
}
break;
}
}
//****************************************************************************
//
//! \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;
}
//*****************************************************************************
//
//! \brief The Function Handles WLAN Events
//!
//! \param[in] pWlanEvent - Pointer to WLAN Event Info
//!
//! \return None
//!
//*****************************************************************************
void SimpleLinkWlanEventHandler(SlWlanEvent_t *pWlanEvent)
{
if(!pWlanEvent)
{
return;
}
switch(pWlanEvent->Event)
{
case SL_WLAN_CONNECT_EVENT:
{
SET_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
//
// Information about the connected AP (like name, MAC etc) will be
// available in 'slWlanConnectAsyncResponse_t'.
// Applications can use it if required
//
// slWlanConnectAsyncResponse_t *pEventData = NULL;
// pEventData = &pWlanEvent->EventData.STAandP2PModeWlanConnected;
//
// Copy new connection SSID and BSSID to global parameters
memcpy(g_ucConnectionSSID,pWlanEvent->EventData.
STAandP2PModeWlanConnected.ssid_name,
pWlanEvent->EventData.STAandP2PModeWlanConnected.ssid_len);
memcpy(g_ucConnectionBSSID,
pWlanEvent->EventData.STAandP2PModeWlanConnected.bssid,
SL_BSSID_LENGTH);
UART_PRINT("[WLAN EVENT] STA Connected to the AP: %s , "
"BSSID: %x:%x:%x:%x:%x:%x\n\r",
g_ucConnectionSSID,g_ucConnectionBSSID[0],
g_ucConnectionBSSID[1],g_ucConnectionBSSID[2],
g_ucConnectionBSSID[3],g_ucConnectionBSSID[4],
g_ucConnectionBSSID[5]);
}
break;
case SL_WLAN_DISCONNECT_EVENT:
{
slWlanConnectAsyncResponse_t* pEventData = NULL;
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_CONNECTION);
CLR_STATUS_BIT(g_ulStatus, STATUS_BIT_IP_AQUIRED);
pEventData = &pWlanEvent->EventData.STAandP2PModeDisconnected;
// If the user has initiated 'Disconnect' request,
//'reason_code' is SL_WLAN_DISCONNECT_USER_INITIATED_DISCONNECTION
if(SL_WLAN_DISCONNECT_USER_INITIATED_DISCONNECTION == pEventData->reason_code)
{
UART_PRINT("[WLAN EVENT]Device disconnected from the AP: %s,"
"BSSID: %x:%x:%x:%x:%x:%x on application's request \n\r",
g_ucConnectionSSID,g_ucConnectionBSSID[0],
g_ucConnectionBSSID[1],g_ucConnectionBSSID[2],
g_ucConnectionBSSID[3],g_ucConnectionBSSID[4],
g_ucConnectionBSSID[5]);
}
else
{
UART_PRINT("[WLAN ERROR]Device disconnected from the AP AP: %s, "
"BSSID: %x:%x:%x:%x:%x:%x on an ERROR..!! \n\r",
g_ucConnectionSSID,g_ucConnectionBSSID[0],
g_ucConnectionBSSID[1],g_ucConnectionBSSID[2],
g_ucConnectionBSSID[3],g_ucConnectionBSSID[4],
g_ucConnectionBSSID[5]);
}
memset(g_ucConnectionSSID,0,sizeof(g_ucConnectionSSID));
memset(g_ucConnectionBSSID,0,sizeof(g_ucConnectionBSSID));
}
break;
default:
{
UART_PRINT("[WLAN EVENT] Unexpected event [0x%x]\n\r",
pWlanEvent->Event);
}
break;
}
}
/*
* Application's entry point
*/
int main(int argc, char** argv)
{
SlPingStartCommand_t PingParams = {0};
SlPingReport_t Report = {0};
_u8 SecType = 0;
_i32 mode = ROLE_STA;
_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();
CLR_STATUS_BIT(g_Status, STATUS_BIT_PING_DONE);
g_PingPacketsRecv = 0;
/*
* 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((_u8 *)" Failed to configure the device in its default state \n\r");
LOOP_FOREVER();
}
CLI_Write((_u8 *)" 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
*/
mode = sl_Start(0, 0, 0);
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(); }
}
else
{
/* Configure CC3100 to start in AP mode */
retVal = sl_WlanSetMode(ROLE_AP);
if(retVal < 0)
LOOP_FOREVER();
/* Configure the SSID of the CC3100 */
retVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_SSID,
pal_Strlen(SSID_AP_MODE), (_u8 *)SSID_AP_MODE);
if(retVal < 0)
LOOP_FOREVER();
SecType = SEC_TYPE_AP_MODE;
/* Configure the Security parameter the AP mode */
retVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_SECURITY_TYPE, 1,
(_u8 *)&SecType);
if(retVal < 0)
LOOP_FOREVER();
retVal = sl_WlanSet(SL_WLAN_CFG_AP_ID, WLAN_AP_OPT_PASSWORD, pal_Strlen(PASSWORD_AP_MODE),
(_u8 *)PASSWORD_AP_MODE);
if(retVal < 0)
LOOP_FOREVER();
retVal = sl_Stop(SL_STOP_TIMEOUT);
if(retVal < 0)
LOOP_FOREVER();
CLR_STATUS_BIT(g_Status, STATUS_BIT_IP_ACQUIRED);
mode = sl_Start(0, 0, 0);
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(); }
}
else
{
CLI_Write((_u8 *)" Device couldn't be configured in AP mode \n\r");
LOOP_FOREVER();
}
}
CLI_Write((_u8 *)" Device started as Access Point\n\r");
while(1){
/* Wait */
CLI_Write((_u8 *)" Waiting for clients to connect...!\n\r");
while((!IS_IP_LEASED(g_Status)) || (!IS_STA_CONNECTED(g_Status))) { _SlNonOsMainLoopTask(); }
CLI_Write((_u8 *)" Client connected to the device \n\r");
CLI_Write((_u8 *)" Pinging...! \n\r");
/* Set the ping parameters */
PingParams.PingIntervalTime = PING_INTERVAL;
PingParams.PingSize = PING_SIZE;
PingParams.PingRequestTimeout = PING_REQUEST_TIMEOUT;
PingParams.TotalNumberOfAttempts = PING_ATTEMPT;
PingParams.Flags = 0;
PingParams.Ip = g_StationIP; /* Fill the station IP address connected to CC3100 */
/* Ping client connected to CC3100 */
retVal = sl_NetAppPingStart((SlPingStartCommand_t*)&PingParams, SL_AF_INET,
(SlPingReport_t*)&Report, SimpleLinkPingReport);
if(retVal < 0)
LOOP_FOREVER();
/* Wait */
while(!IS_PING_DONE(g_Status)) { _SlNonOsMainLoopTask(); }
if (0 == g_PingPacketsRecv)
{
CLI_Write((_u8 *)" A STATION couldn't connect to the device \n\r");
ASSERT_ON_ERROR(LAN_CONNECTION_FAILED);
}
CLI_Write((_u8 *)" Device and the station are successfully connected \n\r");
}
return SUCCESS;
}
