//--tested, working--//
int8_t WiFiClass::scanNetworks()
{
if (!_initialized) {
init();
}
const int WLAN_SCAN_COUNT = 20;
int iRet;
unsigned char ucpolicyOpt;
union
{
unsigned char ucPolicy[4];
unsigned int uiPolicyLen;
}policyVal;
//
// make sure the connection policy is not set (so no scan is run in the background)
//
ucpolicyOpt = SL_CONNECTION_POLICY(0, 0, 0, 0, 0);
iRet = sl_WlanPolicySet(SL_POLICY_CONNECTION , ucpolicyOpt, NULL, 0);
if(iRet != 0)
{
sl_WlanPolicySet(SL_POLICY_CONNECTION , SL_CONNECTION_POLICY(1,1,0,0,0), 0, 0);
return 0;
}
//
// set the scan policy for ten seconds. This starts the scan.
//
policyVal.uiPolicyLen = 10;
iRet = sl_WlanPolicySet(SL_POLICY_SCAN , SL_SCAN_POLICY(1), (unsigned char *)(policyVal.ucPolicy), sizeof(policyVal));
if(iRet != 0)
{
sl_WlanPolicySet(SL_POLICY_CONNECTION , SL_CONNECTION_POLICY(1,1,0,0,0), 0, 0);
return 0;
}
delay(300);
//
// get scan results - all 20 entries in one transaction
// this array isn't actually used, but you have to do this to get the count
//
Sl_WlanNetworkEntry_t found_networks[WLAN_SCAN_COUNT];
network_count = sl_WlanGetNetworkList(0, (unsigned char)WLAN_SCAN_COUNT, found_networks);
//
// disable scan
//
ucpolicyOpt = SL_SCAN_POLICY(0);
sl_WlanPolicySet(SL_POLICY_SCAN , ucpolicyOpt, NULL, 0);
sl_WlanPolicySet(SL_POLICY_CONNECTION , SL_CONNECTION_POLICY(1,1,0,0,0), 0, 0);
return network_count;
}
int sj_wifi_scan(sj_wifi_scan_cb_t cb) {
const char *ssids[21];
Sl_WlanNetworkEntry_t info[20];
int i, n = sl_WlanGetNetworkList(0, 20, info);
if (n < 0) return 0;
for (i = 0; i < n; i++) {
ssids[i] = (char *) info[i].ssid;
}
ssids[i] = NULL;
cb(ssids);
return 1;
}
STATIC mp_obj_t wlan_scan(mp_obj_t self_in) {
STATIC const qstr wlan_scan_info_fields[] = {
MP_QSTR_ssid, MP_QSTR_bssid, MP_QSTR_sec, MP_QSTR_channel, MP_QSTR_rssi
};
// check for correct wlan mode
if (wlan_obj.mode == ROLE_AP) {
mp_raise_OSError(MP_EPERM);
}
Sl_WlanNetworkEntry_t wlanEntry;
mp_obj_t nets = mp_obj_new_list(0, NULL);
uint8_t _index = 0;
// trigger a new network scan
uint32_t scanSeconds = MODWLAN_SCAN_PERIOD_S;
ASSERT_ON_ERROR(sl_WlanPolicySet(SL_POLICY_SCAN , MODWLAN_SL_SCAN_ENABLE, (_u8 *)&scanSeconds, sizeof(scanSeconds)));
// wait for the scan to complete
mp_hal_delay_ms(MODWLAN_WAIT_FOR_SCAN_MS);
do {
if (sl_WlanGetNetworkList(_index++, 1, &wlanEntry) <= 0) {
break;
}
// we must skip any duplicated results
if (!wlan_scan_result_is_unique(nets, wlanEntry.bssid)) {
continue;
}
mp_obj_t tuple[5];
tuple[0] = mp_obj_new_str((const char *)wlanEntry.ssid, wlanEntry.ssid_len, false);
tuple[1] = mp_obj_new_bytes((const byte *)wlanEntry.bssid, SL_BSSID_LENGTH);
// 'normalize' the security type
if (wlanEntry.sec_type > 2) {
wlanEntry.sec_type = 2;
}
tuple[2] = mp_obj_new_int(wlanEntry.sec_type);
tuple[3] = mp_const_none;
tuple[4] = mp_obj_new_int(wlanEntry.rssi);
// add the network to the list
mp_obj_list_append(nets, mp_obj_new_attrtuple(wlan_scan_info_fields, 5, tuple));
} while (_index < MODWLAN_SL_MAX_NETWORKS);
return nets;
}
void miot_wifi_scan(miot_wifi_scan_cb_t cb, void *arg) {
const char *ssids[21];
const char **res = NULL;
int i, n;
Sl_WlanNetworkEntry_t info[20];
if (!ensure_role_sta()) goto out;
n = sl_WlanGetNetworkList(0, 20, info);
if (n < 0) goto out;
for (i = 0; i < n; i++) {
ssids[i] = (char *) info[i].ssid;
}
ssids[i] = NULL;
res = ssids;
out:
cb(res, arg);
}
static void wlan_scan()
{
unsigned char ucpolicyOpt;
union {
unsigned char ucPolicy[4];
unsigned int uiPolicyLen;
} policyVal;
ucpolicyOpt = SL_CONNECTION_POLICY(0, 0, 0, 0,0);
sl_WlanPolicySet(SL_POLICY_CONNECTION , ucpolicyOpt, NULL, 0);
ucpolicyOpt = SL_SCAN_POLICY(1);
policyVal.uiPolicyLen = 10;
sl_WlanPolicySet(SL_POLICY_SCAN , ucpolicyOpt, (unsigned char*)(policyVal.ucPolicy), sizeof(policyVal));
MAP_UtilsDelay(8000000);
Sl_WlanNetworkEntry_t netEntries[10];
_i16 resultsCount = sl_WlanGetNetworkList(0,10,&netEntries[0]);
for (int i=0; i< resultsCount; i++)
UART_PRINT("ssid: %s\trssi: %d\tsec-t: %u\r\n",netEntries[i].ssid, netEntries[i].rssi, netEntries[i].sec_type);
}
//--tested, working--//
int32_t WiFiClass::RSSI(uint8_t networkItem)
{
if (!_initialized) {
init();
}
//
//get the network list and pull out the security type of the requested item
//
if (networkItem >= network_count) {
return 0;
}
//
//fetch all 20 items. For some reason, fetching a single item doesn't work
//
Sl_WlanNetworkEntry_t netInfo[network_count];
memset(&netInfo, 0, sizeof(netInfo));
sl_WlanGetNetworkList(0, network_count, (Sl_WlanNetworkEntry_t*)&netInfo);
return (int32_t)netInfo[networkItem].rssi;
}
//--tested, working--//
uint8_t WiFiClass::encryptionType(uint8_t networkItem)
{
if (!_initialized) {
init();
}
//
//get the network list and pull out the security type of the requested item
//
if (networkItem >= network_count) {
return 0;
}
//
//fetch all 20 items. For some reason, fetching a signle item doesn't work
//
Sl_WlanNetworkEntry_t netInfo[network_count];
memset(&netInfo, 0, sizeof(netInfo));
sl_WlanGetNetworkList(0, network_count, (Sl_WlanNetworkEntry_t*)&netInfo);
uint8_t security = netInfo[networkItem].sec_type;
//
//the security type returned by simplelink has to be matched
//to the security type that would be returned by arduino
//TKIP (WPA) = 2, WEP = 5, NONE = 7, AUTO = 8
//
if (security == SL_SEC_TYPE_WPA) {
return 2;
} else if (security == SL_SEC_TYPE_WEP) {
return 5;
} else if (security == SL_SEC_TYPE_OPEN) {
return 7;
} else if (security == SL_SEC_TYPE_WPS_PBC){
return 2;
} else if (security == SL_SEC_TYPE_WPS_PIN){
return 2;
} else {
return 8;
}
}
//--tested, working--//
char* WiFiClass::SSID(uint8_t networkItem)
{
if (!_initialized) {
init();
}
//
//get the network list and return the ssid of the requested index
//
if (networkItem >= network_count) {
return NULL;
}
//
//fetch all 20 items. For some reason, fetching a single item doesn't work
//
Sl_WlanNetworkEntry_t netInfo[network_count];
memset(&netInfo, 0, sizeof(netInfo));
sl_WlanGetNetworkList(0, network_count, (Sl_WlanNetworkEntry_t*)&netInfo);
strcpy(string_output_buffer, (const char*)netInfo[networkItem].ssid);
return string_output_buffer;
}
//*****************************************************************************
//
//! \brief This function Get the Scan Result
//!
//! \param[in] none
//!
//! \return Size of Scan Result Array
//!
//! \note
//!
//
//*****************************************************************************
int GetScanResult(Sl_WlanNetworkEntry_t* netEntries )
{
UINT8 policyOpt;
UINT32 IntervalVal = 60;
int retVal;
policyOpt = SL_CONNECTION_POLICY(0, 0, 0, 0, 0);
retVal = sl_WlanPolicySet(SL_POLICY_CONNECTION , policyOpt, NULL, 0);
if(retVal < 0)
{
/* Error */
}
// enable scan
policyOpt = SL_SCAN_POLICY(1);
// set scan policy - this starts the scan
retVal = sl_WlanPolicySet(SL_POLICY_SCAN , policyOpt,
(UINT8 *)(IntervalVal), sizeof(IntervalVal));
// delay 1 second to verify scan is started
osi_Sleep(1000);
// retVal indicates the valid number of entries
// The scan results are occupied in netEntries[]
retVal = sl_WlanGetNetworkList(0, SCAN_TABLE_SIZE, netEntries);
// Disable scan
policyOpt = SL_SCAN_POLICY(0);
// set scan policy - this stops the scan
sl_WlanPolicySet(SL_POLICY_SCAN , policyOpt,
(UINT8 *)(IntervalVal), sizeof(IntervalVal));
return retVal;
}
void Task_WifiScan(void* params)
{
(void)params; //avoid unused error
long retval;
unsigned char policy;
unsigned int policy_len;
LOG(LOG_VERBOSE, "Starting WiFi network scan...");
SetLEDBlink(LED_1, LED_BLINK_PATTERN_WIFI_SCANNING);
if(WifiDefaultSettings() == RET_FAILURE) {
goto error;
}
retval = sl_Start(0,0,0);
if(retval<0) {
goto error;
}
//first, delete current connection policy
policy = SL_CONNECTION_POLICY(0,0,0,0,0);
retval = sl_WlanPolicySet(SL_POLICY_CONNECTION, policy, NULL, 0);
if(retval<0) {
goto error;
}
//make scan policy
policy = SL_SCAN_POLICY(1);
policy_len = WIFI_SCAN_TIME_S;
retval = sl_WlanPolicySet(SL_POLICY_SCAN, policy, (unsigned char*)&policy_len, sizeof(policy_len));
if(retval<0) {
goto error;
}
//wait for the scan to complete
const TickType_t delay = (1100*WIFI_SCAN_TIME_S) / portTICK_PERIOD_MS;
vTaskDelay(delay);
//get the results back
unsigned char index = 0;
retval = sl_WlanGetNetworkList(index, (unsigned char)WIFI_NUM_NETWORKS, &(wifi_state.networks[index]));
//retval holds the number of networks now, and they are saved in the state.
//disable the scan
policy = SL_SCAN_POLICY(0);
retval = sl_WlanPolicySet(SL_POLICY_SCAN, policy, NULL, 0);
if(retval<0) {
goto error;
}
//disable SimpleLink altogether
retval = sl_Stop(SL_STOP_TIMEOUT);
if(retval<0) {
goto error;
}
LOG(LOG_VERBOSE, "WiFi network scan complete.");
ClearLED(LED_1);
#ifdef DO_STACK_CHECK
wifi_state.stack_watermark = uxTaskGetStackHighWaterMark(NULL);
#endif
//exit (delete this task)
WifiTaskEndCallback(&Task_WifiScan);
vTaskDelete(NULL);
return;
error:
SetLEDBlink(LED_1, LED_BLINK_PATTERN_WIFI_FAILED);
TASK_RETURN_ERROR(ERROR_UNKNOWN, "WIFI scan fail");
return;
}
//****************************************************************************
//
//! \brief Opening a TCP server side socket and receiving data
//!
//! This function opens a TCP socket in Listen mode and waits for an incoming
//! TCP connection.
//! If a socket connection is established then the function will try to read
//! 1000 TCP packets from the connected client.
//!
//! \param[in] port number on which the server will be listening on
//!
//! \return 0 on success, -1 on error.
//!
//! \note This function will wait for an incoming connection till
//! one is established
//
//****************************************************************************
int BsdTcpServer(unsigned short usPort)
{
SlSockAddrIn_t sAddr;
SlSockAddrIn_t sLocalAddr;
int iCounter;
int iAddrSize;
int iSockID;
int iStatus;
int iNewSockID;
unsigned long lLoopCount = 0;
long lBytesSent = 0;
long lNonBlocking = 1;
int iTestBufLen;
// filling the buffer
for (iCounter=0 ; iCounter<BUF_SIZE ; iCounter++)
{
g_cBsdBuf[iCounter] = (char)(iCounter % 10) + '0';
}
iTestBufLen = BUF_SIZE;
//filling the TCP server socket address
sLocalAddr.sin_family = SL_AF_INET;
sLocalAddr.sin_port = sl_Htons((unsigned short)usPort);
sLocalAddr.sin_addr.s_addr = 0;
// sLocalAddr.sin_port = usPort;
// sLocalAddr.sin_addr.s_addr = SL_IPV4_VAL(192,168,1,101);
// creating a TCP socket
iSockID = sl_Socket(SL_AF_INET,SL_SOCK_STREAM, 0);
if( iSockID < 0 )
{
UART_PRINT("error at creating a TCP socket ! \n\r");
// error
return -1;
}
UART_PRINT("iSockID :");
Z_NumDispaly(iSockID, 2);
iAddrSize = sizeof(SlSockAddrIn_t);
// binding the TCP socket to the TCP server address
iStatus = sl_Bind(iSockID, (SlSockAddr_t *)&sLocalAddr, iAddrSize);
if( iStatus < 0 )
{
UART_PRINT("error at binding the TCP socket to the TCP server address ! \n\r");
// error
return -1;
}
UART_PRINT("binding the TCP socket to the TCP server address ok! \n\r");
// putting the socket for listening to the incoming TCP connection
iStatus = sl_Listen(iSockID, 0);
if( iStatus < 0 )
{
UART_PRINT("error at putting the socket for listening to the incoming TCP connection ! \n\r");
return -1;
}
UART_PRINT("listen end! \n\r");
// setting socket option to make the socket as non blocking
iStatus = sl_SetSockOpt(iSockID, SL_SOL_SOCKET, SL_SO_NONBLOCKING, &lNonBlocking, sizeof(lNonBlocking));
iNewSockID = SL_EAGAIN;
UART_PRINT(" waiting for an incoming TCP connection! \n\r");
// waiting for an incoming TCP connection
while( iNewSockID < 0 )
{
// accepts a connection form a TCP client, if there is any
// otherwise returns SL_EAGAIN
iNewSockID = sl_Accept(iSockID, ( struct SlSockAddr_t *)&sAddr, (SlSocklen_t*)&iAddrSize);
if( iNewSockID == SL_EAGAIN )
{
UtilsDelay(10000);
// UART_PRINT(" iNewSockID == SL_EAGAIN! \n\r");
}
else if( iNewSockID < 0 )
{
// error
UART_PRINT(" iNewSockID < 0! \n\r");
return -1;
}
}
UART_PRINT("connect succeed the new iSockID :");
Z_NumDispaly(iSockID, 5);
unsigned long the_client_ip = sl_BIGtoLITTLE_l( (unsigned long)sAddr.sin_addr.s_addr );
UART_PRINT("the client ip is :");
Z_IPDispaly(&the_client_ip);
unsigned short the_client_port = sl_BIGtoLITTLE_S( (unsigned short)sAddr.sin_port );
UART_PRINT("the client port is :");
Z_NumDispaly( (unsigned long)the_client_port,5);
/*
UART_PRINT(" waits for 1000 packets from the connected TCP client! \n\r");
// waits for 1000 packets from the connected TCP client
while (lLoopCount < 1000)
{
iStatus = sl_Recv(iNewSockID, g_cBsdBuf, iTestBufLen, 0);
if( iStatus <= 0 )
{
// error
return -1;
}
lLoopCount++;
lBytesSent += iStatus;
}
*/
// sending 3 packets to the TCP server
while (lLoopCount < 3)
{
// sending packet
// iStatus = sl_Send(iNewSockID, g_cBsdBuf, iTestBufLen, 0 );
char *send_buffer = "hellow i am cc3200 , welcome to wifi world !\n\r";
iStatus = sl_Send(iNewSockID, send_buffer, strlen(send_buffer), 0 );
if( iStatus <= 0 )
{
UART_PRINT("error at sending packet\n\r");
Z_NumDispaly(lLoopCount,5);
// error
return -1;
}
lLoopCount++;
lBytesSent += iStatus;
}
Sl_WlanNetworkEntry_t netEntries[20];
char message[80];
unsigned long intervalInSeconds = 10;
sl_WlanPolicySet(SL_POLICY_SCAN,SL_SCAN_POLICY_EN(1), (unsigned char *)&intervalInSeconds,sizeof(intervalInSeconds));
while(1){
//Get Scan Result
UINT8 Index = sl_WlanGetNetworkList(0,20,&netEntries[0]);
for(UINT8 i=0; i< Index; i++)
{
snprintf(message, 60, "%d) SSID %s RSSI %d \n\r",i,netEntries[i].ssid,netEntries[i].rssi);
UART_PRINT(message);
sl_Send(iNewSockID, message, strlen(message), 0 );
}
Z_DelayS(3);
}
// close the connected socket after receiving from connected TCP client
sl_Close(iNewSockID);
// close the listening socket
sl_Close(iSockID);
return 0;
}
