mirror of
https://github.com/drasko/open-ameba.git
synced 2024-11-24 23:14:17 +00:00
836 lines
23 KiB
C
836 lines
23 KiB
C
/*
|
|
* wifi_api.c
|
|
*
|
|
* Created on: 01/11/2017
|
|
* Author: pvvx
|
|
*/
|
|
#include "FreeRTOS.h"
|
|
#include <autoconf.h>
|
|
#include "main.h"
|
|
|
|
#include <platform_opts.h>
|
|
|
|
#if CONFIG_EXAMPLE_WLAN_FAST_CONNECT
|
|
#error "Udnef CONFIG_EXAMPLE_WLAN_FAST_CONNECT!"
|
|
#endif
|
|
#ifndef USE_FLASH_EEP
|
|
#error "Define USE_FLASH_EEP!"
|
|
#endif
|
|
|
|
#include "task.h"
|
|
#include <platform/platform_stdlib.h>
|
|
#include <wifi/wifi_conf.h>
|
|
#include "flash_api.h"
|
|
#include <lwip_netconf.h>
|
|
#include "dhcp/dhcps.h"
|
|
#include "ethernetif.h"
|
|
#if CONFIG_ETHERNET
|
|
#include "ethernet_mii/ethernet_mii.h"
|
|
#endif
|
|
|
|
#include "wlan_lib.h"
|
|
|
|
#include "flash_eep.h"
|
|
#include "feep_config.h"
|
|
|
|
#include "wifi_api.h"
|
|
#include "wifi_user_set.h"
|
|
|
|
//=========================================
|
|
//--- Wlan Config Init-------------------
|
|
WIFI_CONFIG wifi_cfg = {
|
|
.mode = DEF_WIFI_MODE, // rtw_mode_t
|
|
.sleep = DEF_WIFI_ST_SLEEP,
|
|
.country_code = DEF_WIFI_COUNTRY,// rtw_country_code_t
|
|
.tx_pwr = DEF_WIFI_TX_PWR, // rtw_tx_pwr_percentage_t
|
|
.bgn = DEF_WIFI_BGN, // rtw_network_mode_t
|
|
.load_flg = DEF_LOAD_CFG,
|
|
.save_flg = DEF_SAVE_CFG
|
|
};
|
|
//---- Interface 0 - wlan0 - AP - init ---
|
|
SOFTAP_CONFIG wifi_ap_cfg = {
|
|
.ssid = DEF_AP_SSID,
|
|
.password = DEF_AP_PASSWORD,
|
|
.security_type = DEF_AP_SECURITY,
|
|
.beacon_interval = DEF_AP_BEACON,
|
|
.channel = DEF_AP_CHANNEL,
|
|
.ssid_hidden = 0,
|
|
.max_sta = DEF_WIFI_AP_STATIONS // Max number of STAs, should be 1..3, default is 3
|
|
};
|
|
DHCP_CONFIG wifi_ap_dhcp = {
|
|
.ip = DEF_AP_IP,
|
|
.mask = DEF_AP_MSK,
|
|
.gw = DEF_AP_GW,
|
|
.mode = 2
|
|
};
|
|
//---- Interface 1 - wlan1 - ST - init ---
|
|
STATION_CONFIG wifi_st_cfg = {
|
|
.ssid = DEF_ST_SSID,
|
|
.password = DEF_ST_PASSWORD,
|
|
.bssid = DEF_ST_BSSID,
|
|
.security_type = DEF_ST_SECURITY,
|
|
.autoreconnect = DEF_ST_AUTORECONNECT,
|
|
.reconnect_pause = DEF_ST_RECONNECT_PAUSE
|
|
};
|
|
DHCP_CONFIG wifi_st_dhcp = {
|
|
.ip = DEF_ST_IP,
|
|
.mask = DEF_ST_MSK,
|
|
.gw = DEF_ST_GW,
|
|
.mode = 1
|
|
};
|
|
|
|
rtw_mode_t wifi_run_mode = RTW_MODE_NONE;
|
|
|
|
typedef struct _feep_element {
|
|
uint16 id;
|
|
uint16 size;
|
|
void * obj;
|
|
} FEEP_ELEMENT, *PFEEP_ELEMENT;
|
|
|
|
FEEP_ELEMENT feep_tab[] = {
|
|
{ FEEP_ID_WIFI_AP_CFG, sizeof(wifi_ap_cfg), &wifi_ap_cfg }, // Bit0
|
|
{ FEEP_ID_WIFI_ST_CFG, sizeof(wifi_st_cfg), &wifi_st_cfg }, // Bit1
|
|
{ FEEP_ID_AP_DHCP_CFG, sizeof(wifi_ap_dhcp), &wifi_ap_dhcp }, // Bit2
|
|
{ FEEP_ID_ST_DHCP_CFG, sizeof(wifi_st_dhcp), &wifi_st_dhcp }, // Bit3
|
|
{ FEEP_ID_WIFI_CFG, sizeof(wifi_cfg), &wifi_cfg }, // Bit4
|
|
// { FEEP_ID_LWIP_CFG, sizeof(lwip_conn_info), &lwip_conn_info }, // Bit5
|
|
{ 0, 0, NULL }
|
|
};
|
|
|
|
uint32 read_wifi_cfg(uint32 flg)
|
|
{
|
|
uint32 ret = 0;
|
|
PFEEP_ELEMENT p = feep_tab;
|
|
for(int m = 1; m && p->id != 0; m <<= 1, p++) {
|
|
if((flg & m)
|
|
&& flash_read_cfg(p->obj, p->id, p->size) < p->size) {
|
|
ret |= m;
|
|
};
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
uint32 write_wifi_cfg(uint32 flg)
|
|
{
|
|
uint32 ret = 0;
|
|
PFEEP_ELEMENT p = feep_tab;
|
|
for(int m = 1; m && p->id != 0; m <<= 1, p++) {
|
|
if((flg & m)
|
|
&& flash_write_cfg(p->obj, p->id, p->size) < p->size) {
|
|
ret |= m;
|
|
};
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
typedef int (*wlan_init_done_ptr)(void);
|
|
typedef int (*write_reconnect_ptr)(uint8_t *data, uint32_t len);
|
|
//Function
|
|
#if CONFIG_AUTO_RECONNECT
|
|
extern void (*p_wlan_autoreconnect_hdl)(rtw_security_t, char*, int, char*, int,
|
|
int);
|
|
#endif
|
|
extern wlan_init_done_ptr p_wlan_init_done_callback;
|
|
extern write_reconnect_ptr p_write_reconnect_ptr;
|
|
extern struct netif xnetif[NET_IF_NUM];
|
|
|
|
_WEAK void connect_start(void)
|
|
{
|
|
info_printf("\%s: Time at start %d ms.\n", __func__, xTaskGetTickCount());
|
|
}
|
|
|
|
_WEAK void connect_close(void)
|
|
{
|
|
info_printf("\%s: Time at start %d ms.\n", __func__, xTaskGetTickCount());
|
|
}
|
|
|
|
_WEAK void user_start(void)
|
|
{
|
|
info_printf("\%s: Time at start %d ms.\n", __func__, xTaskGetTickCount());
|
|
}
|
|
|
|
int wlan_init_done_callback(void) {
|
|
info_printf("WiFi Init after %d ms\n", xTaskGetTickCount());
|
|
return 0;
|
|
}
|
|
|
|
//char wlan_st_name[] = WLAN0_NAME;
|
|
char wlan_st_name[] = WLAN0_NAME;
|
|
char wlan_ap_name[] = WLAN1_NAME;
|
|
char wlan_st_netifn = 0;
|
|
char wlan_ap_netifn = 1;
|
|
extern rtw_mode_t wifi_mode; // новый режим работы
|
|
|
|
uint8 chk_ap_netif_num(void)
|
|
{
|
|
if (wifi_mode == RTW_MODE_AP) {
|
|
wlan_st_name[4] = '1';
|
|
wlan_ap_name[4] = '0';
|
|
wlan_st_netifn = 1;
|
|
wlan_ap_netifn = 0;
|
|
}
|
|
else { // if (wifi_mode == RTW_MODE_STA) {
|
|
wlan_st_name[4] = '0';
|
|
wlan_ap_name[4] = '1';
|
|
wlan_st_netifn = 0;
|
|
wlan_ap_netifn = 1;
|
|
}
|
|
return wlan_ap_netifn;
|
|
}
|
|
|
|
rtw_result_t wifi_run_ap(void) {
|
|
chk_ap_netif_num();
|
|
|
|
rtw_result_t ret = RTW_NOTAP;
|
|
if( (wifi_mode == RTW_MODE_AP) || (wifi_mode == RTW_MODE_STA_AP) ){
|
|
info_printf("Starting AP (%s, netif%d)...\n", wlan_ap_name, wlan_ap_netifn);
|
|
netif_set_addr(&xnetif[WLAN_AP_NETIF_NUM], &wifi_ap_dhcp.ip,
|
|
&wifi_ap_dhcp.mask, &wifi_ap_dhcp.gw);
|
|
if(wext_set_sta_num(wifi_ap_cfg.max_sta) != 0) { // Max number of STAs, should be 1..3, default is 3
|
|
error_printf("AP not set max connections %d!\n", wifi_ap_cfg.max_sta);
|
|
};
|
|
ret = wifi_start_ap(wifi_ap_cfg.ssid, //char *ssid,
|
|
wifi_ap_cfg.security_type, //rtw_security_t ecurity_type,
|
|
wifi_ap_cfg.password, //char *password,
|
|
strlen(wifi_ap_cfg.ssid), //int ssid_len,
|
|
strlen(wifi_ap_cfg.password), //int password_len,
|
|
wifi_ap_cfg.channel); //int channel
|
|
wifi_run_mode |= RTW_MODE_AP;
|
|
if (ret != RTW_SUCCESS) {
|
|
error_printf("Error(%d): Start AP failed!\n\n", ret);;
|
|
} else {
|
|
int timeout = 10000 / 200;
|
|
while (1) {
|
|
char essid[33];
|
|
if (wext_get_ssid(wlan_ap_name, (unsigned char *) essid) > 0) {
|
|
if (strcmp((const char * ) essid,
|
|
(const char * )wifi_ap_cfg.ssid)
|
|
== 0) {
|
|
#ifdef CONFIG_DONT_CARE_TP
|
|
pnetiff->flags |= NETIF_FLAG_IPSWITCH;
|
|
#endif
|
|
dhcps_ip4addr_pool_start = DEF_AP_DHCP_START;
|
|
dhcps_ip4addr_pool_end = DEF_AP_DHCP_STOP;
|
|
dhcps_init(&xnetif[WLAN_AP_NETIF_NUM]);
|
|
info_printf("AP '%s' started after %d ms\n",
|
|
wifi_ap_cfg.ssid, xTaskGetTickCount());
|
|
show_wifi_ap_ip();
|
|
if(wifi_cfg.save_flg & (BID_WIFI_AP_CFG | BID_AP_DHCP_CFG))
|
|
write_wifi_cfg(wifi_cfg.save_flg & (BID_WIFI_AP_CFG | BID_AP_DHCP_CFG));
|
|
ret = RTW_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
if (timeout == 0) {
|
|
error_printf("Start AP timeout!\n");
|
|
ret = RTW_TIMEOUT;
|
|
break;
|
|
}
|
|
vTaskDelay(200 / portTICK_RATE_MS);
|
|
timeout--;
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
rtw_result_t StartStDHCPClient(void)
|
|
{
|
|
debug_printf("Start DHCPClient...\n");
|
|
int ret = RTW_SUCCESS;
|
|
struct netif * pnetif = &xnetif[WLAN_ST_NETIF_NUM];
|
|
DHCP_CONFIG *p = (dhcp_cfg *)&wifi_st_dhcp;
|
|
unsigned char mode = p->mode;
|
|
if((mode == 3)
|
|
&& (p->ip == IP4ADDR(255,255,255,255)
|
|
|| p->ip == IP4ADDR(0,0,0,0))) {
|
|
mode = 2;
|
|
}
|
|
else mode = 1;
|
|
if(mode == 2) {
|
|
netif_set_addr(pnetif, (ip_addr_t *)&p->ip, (ip_addr_t *)&p->mask, (ip_addr_t *)&p->gw);
|
|
// dhcps_init(pnetif);
|
|
}
|
|
else if(mode) {
|
|
UBaseType_t savePriority = uxTaskPriorityGet(NULL);
|
|
/* If not rise priority, LwIP DHCP may timeout */
|
|
vTaskPrioritySet(NULL, tskIDLE_PRIORITY + 3);
|
|
/* Start DHCP Client */
|
|
ret = LwIP_DHCP(WLAN_ST_NETIF_NUM, DHCP_START);
|
|
vTaskPrioritySet(NULL, savePriority);
|
|
if (ret == DHCP_ADDRESS_ASSIGNED) {
|
|
p->ip = pnetif->ip_addr.addr;
|
|
p->gw = pnetif->gw.addr;
|
|
p->mask = pnetif->netmask.addr;
|
|
if(p->mode == 3) {
|
|
p->mode = 2;
|
|
write_wifi_cfg(BID_ST_DHCP_CFG);
|
|
}
|
|
ret = RTW_SUCCESS;
|
|
}
|
|
else {
|
|
debug_printf("LwIP_DHCP ret=%d\n", ret);
|
|
ret = RTW_ERROR;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
rtw_result_t wifi_run_st(void) {
|
|
rtw_result_t ret = RTW_SUCCESS;
|
|
chk_ap_netif_num();
|
|
if((wifi_mode == RTW_MODE_STA) || (wifi_mode == RTW_MODE_STA_AP)) {
|
|
#if CONFIG_AUTO_RECONNECT
|
|
// p_wlan_autoreconnect_hdl = NULL;
|
|
if (wifi_st_cfg.autoreconnect) {
|
|
ret = wifi_config_autoreconnect(1, wifi_st_cfg.autoreconnect,
|
|
wifi_st_cfg.reconnect_pause);
|
|
if (ret != RTW_SUCCESS)
|
|
warning_printf("ERROR: Operation failed! Error=%d\n", ret);
|
|
}
|
|
#endif
|
|
info_printf("Connected to AP (%s, netif%d)...\n", wlan_st_name, wlan_st_netifn);
|
|
ret = wifi_connect(wifi_st_cfg.ssid, wifi_st_cfg.security_type,
|
|
wifi_st_cfg.password, strlen(wifi_st_cfg.ssid),
|
|
strlen(wifi_st_cfg.password), -1, NULL);
|
|
wifi_run_mode |= RTW_MODE_STA;
|
|
if (ret != RTW_SUCCESS) {
|
|
error_printf("%s: Operation failed! Error(%d)\n", __func__, ret);
|
|
} else {
|
|
if(wifi_cfg.save_flg & BID_WIFI_ST_CFG)
|
|
write_wifi_cfg(BID_WIFI_ST_CFG);
|
|
// Start DHCPClient
|
|
ret = StartStDHCPClient();
|
|
if(ret == RTW_SUCCESS) {
|
|
show_wifi_st_ip();
|
|
#if CONFIG_WLAN_CONNECT_CB
|
|
// extern void connect_start(void);
|
|
connect_start();
|
|
#endif
|
|
}
|
|
}
|
|
};
|
|
return ret;
|
|
}
|
|
|
|
int _wifi_on(rtw_mode_t mode) {
|
|
int ret = 0;
|
|
uint32 timeout = xTaskGetTickCount();
|
|
uint8 devnum;
|
|
|
|
if (rltk_wlan_running(WLAN0_IDX)) {
|
|
warning_printf("WIFI is already running\n");
|
|
return 0;
|
|
}
|
|
|
|
static int event_init = 0;
|
|
if (event_init == 0) {
|
|
init_event_callback_list();
|
|
event_init = 1;
|
|
}
|
|
wifi_mode = mode;
|
|
info_printf("Initializing WIFI...\n");
|
|
// set wifi mib
|
|
// adaptivity
|
|
wext_set_adaptivity(RTW_ADAPTIVITY_DISABLE);
|
|
// wext_set_adaptivity(RTW_ADAPTIVITY_NORMAL);
|
|
// wext_set_adaptivity(RTW_ADAPTIVITY_CARRIER_SENSE);
|
|
|
|
devnum = (mode == RTW_MODE_STA_AP);
|
|
|
|
ret = rltk_wlan_init(0, mode);
|
|
if (ret < 0) return ret;
|
|
if(devnum) {
|
|
ret = rltk_wlan_init(1, mode);
|
|
if (ret < 0) return ret;
|
|
}
|
|
rltk_wlan_start(0);
|
|
if(devnum) rltk_wlan_start(1);
|
|
while (1) {
|
|
if (rltk_wlan_running(0) &&
|
|
rltk_wlan_running(devnum) ) {
|
|
#if CONFIG_DEBUG_LOG > 2
|
|
printf("WIFI initialized (%d ms)\n", xTaskGetTickCount() - timeout);
|
|
#endif
|
|
break;
|
|
}
|
|
if(xTaskGetTickCount() - timeout > wifi_test_timeout_ms/portTICK_RATE_MS) {
|
|
error_printf("WIFI init timeout!\n");
|
|
break;
|
|
}
|
|
vTaskDelay(wifi_test_timeout_step_ms / portTICK_RATE_MS);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
extern int lwip_init_done;
|
|
|
|
void _LwIP_Init(void)
|
|
{
|
|
if(!lwip_init_done) {
|
|
int idx;
|
|
debug_printf("LwIP Init (%d)\n", wifi_mode);
|
|
/* Create tcp_ip stack thread */
|
|
tcpip_init( NULL, NULL );
|
|
|
|
chk_ap_netif_num(); // Исполняется после _wifi_on()
|
|
for(idx = 0; idx < NET_IF_NUM; idx++) {
|
|
xnetif[idx].name[0] = 'r';
|
|
xnetif[idx].name[1] = '0' + idx;
|
|
}
|
|
netif_add(&xnetif[WLAN_ST_NETIF_NUM], (struct netif *)&wifi_st_dhcp.ip, (struct netif *)&wifi_st_dhcp.mask, (struct netif *)&wifi_st_dhcp.gw, NULL, ðernetif_init, &tcpip_input);
|
|
netif_add(&xnetif[WLAN_AP_NETIF_NUM], (struct netif *)&wifi_ap_dhcp.ip, (struct netif *)&wifi_ap_dhcp.mask, (struct netif *)&wifi_ap_dhcp.gw, NULL, ðernetif_init, &tcpip_input);
|
|
#if CONFIG_ETHERNET // && NET_IF_NUM > 2
|
|
{
|
|
struct ip_addr ipaddr;
|
|
struct ip_addr netmask;
|
|
struct ip_addr gw;
|
|
ipaddr.addr = DEF_EH_IP;
|
|
netmask.addr = DEF_EH_MSK;
|
|
gw.addr = DEF_EH_GW;
|
|
netif_add(&xnetif[2], &ipaddr, &netmask, &gw, NULL, ðernetif_mii_init, &tcpip_input);
|
|
}
|
|
#endif
|
|
/* Registers the default network interface. */
|
|
netif_set_default(&xnetif[0]);
|
|
/* When the netif is fully configured this function must be called.*/
|
|
for(idx = 0; idx < NET_IF_NUM; idx++) {
|
|
netif_set_up(&xnetif[idx]);
|
|
}
|
|
info_printf("interface %d is initialized\n", idx);
|
|
wifi_mode = 0;
|
|
lwip_init_done = 1;
|
|
}
|
|
}
|
|
|
|
int wifi_run(rtw_mode_t mode) {
|
|
int ret = 0;
|
|
#if CONFIG_DEBUG_LOG > 4
|
|
debug_printf("\n%s(%d), %d\n", __func__, mode, wifi_run_mode);
|
|
#endif
|
|
if(mode != RTW_MODE_NONE) {
|
|
_LwIP_Init();
|
|
};
|
|
if(wifi_run_mode & RTW_MODE_AP) {
|
|
info_printf("Deinit old AP...\n");
|
|
LwIP_DHCP(WLAN_AP_NETIF_NUM, DHCP_STOP);
|
|
#if CONFIG_DEBUG_LOG > 4
|
|
debug_printf("dhcps_deinit()\n");
|
|
#endif
|
|
dhcps_deinit();
|
|
wifi_run_mode &= ~RTW_MODE_AP;
|
|
};
|
|
if(wifi_run_mode & RTW_MODE_STA) {
|
|
info_printf("Deinit old ST...\n");
|
|
LwIP_DHCP(WLAN_ST_NETIF_NUM, DHCP_STOP);
|
|
wifi_run_mode &= ~RTW_MODE_STA;
|
|
};
|
|
// if(mode != wifi_mode)
|
|
// wifi_mode = mode;
|
|
// chk_ap_netif_num();
|
|
if (mode != RTW_MODE_NONE) {
|
|
if(mode != (volatile)wifi_mode) {
|
|
info_printf("Deinitializing WIFI ...\n");
|
|
wifi_off();
|
|
vTaskDelay(30);
|
|
debug_printf("WiFi_on(%d)\n", mode);
|
|
if (_wifi_on(mode) < 0) {
|
|
error_printf("Wifi On failed!\n");
|
|
goto error_end;
|
|
};
|
|
wifi_mode = mode;
|
|
};
|
|
if(wifi_set_country(wifi_cfg.country_code) != RTW_SUCCESS) {
|
|
error_printf("Error set tx country_code (%d)!", wifi_cfg.country_code);
|
|
};
|
|
// extern uint8_t rtw_power_percentage_idx;
|
|
if(rtw_power_percentage_idx != wifi_cfg.tx_pwr) {
|
|
if(rltk_set_tx_power_percentage(wifi_cfg.tx_pwr) != RTW_SUCCESS) {
|
|
error_printf("Error set tx power (%d)!", wifi_cfg.tx_pwr);
|
|
};
|
|
}
|
|
debug_printf("mode == wifi_mode? (%d == %d?)\n", mode, wifi_mode);
|
|
// if(mode == wifi_mode)
|
|
{
|
|
if((wifi_mode == RTW_MODE_AP) || (wifi_mode == RTW_MODE_STA_AP)) {
|
|
wifi_run_ap();
|
|
};
|
|
if((wifi_mode == RTW_MODE_STA) || (wifi_mode == RTW_MODE_STA_AP)) {
|
|
wifi_run_st();
|
|
};
|
|
#if CONFIG_INTERACTIVE_MODE
|
|
/* Initial uart rx swmaphore*/
|
|
vSemaphoreCreateBinary(uart_rx_interrupt_sema);
|
|
xSemaphoreTake(uart_rx_interrupt_sema, 1/portTICK_RATE_MS);
|
|
start_interactive_mode();
|
|
#endif
|
|
// if(wifi_run_mode == wifi_cfg.mode)
|
|
ret = 1;
|
|
};
|
|
} else {
|
|
ret = 1;
|
|
error_end:
|
|
#if CONFIG_WLAN_CONNECT_CB
|
|
connect_close();
|
|
#endif
|
|
wifi_off();
|
|
};
|
|
chk_ap_netif_num();
|
|
return ret;
|
|
}
|
|
|
|
void wifi_init_thrd(void) {
|
|
debug_printf("\nLoad Config\n");
|
|
read_wifi_cfg(DEF_LOAD_CFG);
|
|
// Call back from wlan driver after wlan init done
|
|
p_wlan_init_done_callback = wlan_init_done_callback;
|
|
// Call back from application layer after wifi_connection success
|
|
// p_write_reconnect_ptr = wlan_write_reconnect_data_to_flash;
|
|
p_wlan_autoreconnect_hdl = NULL;
|
|
if (wifi_cfg.mode != RTW_MODE_NONE) {
|
|
wifi_mode = wifi_cfg.mode;
|
|
#if CONFIG_WIFI_IND_USE_THREAD
|
|
wifi_manager_init();
|
|
#endif
|
|
wifi_run(wifi_cfg.mode);
|
|
user_start();
|
|
}
|
|
/* Initilaize the console stack */
|
|
console_init();
|
|
/* Kill init thread after all init tasks done */
|
|
vTaskDelete(NULL);
|
|
}
|
|
|
|
rtw_security_t translate_rtw_security(u8 security_type)
|
|
{
|
|
rtw_security_t security_mode = RTW_SECURITY_OPEN;
|
|
|
|
switch (security_type) {
|
|
// case RTW_ENCRYPTION_OPEN:
|
|
// security_mode = RTW_SECURITY_OPEN;
|
|
// break;
|
|
case RTW_ENCRYPTION_WEP40:
|
|
case RTW_ENCRYPTION_WEP104:
|
|
security_mode = RTW_SECURITY_WEP_PSK;
|
|
break;
|
|
case RTW_ENCRYPTION_WPA_TKIP:
|
|
case RTW_ENCRYPTION_WPA_AES:
|
|
case RTW_ENCRYPTION_WPA2_TKIP:
|
|
case RTW_ENCRYPTION_WPA2_AES:
|
|
case RTW_ENCRYPTION_WPA2_MIXED:
|
|
security_mode = RTW_SECURITY_WPA2_AES_PSK;
|
|
break;
|
|
// case RTW_ENCRYPTION_UNKNOWN:
|
|
// case RTW_ENCRYPTION_UNDEF:
|
|
// default:
|
|
//security_mode = RTW_SECURITY_OPEN;
|
|
}
|
|
return security_mode;
|
|
}
|
|
|
|
void show_wifi_ap_ip(void) {
|
|
printf("SoftAP ip: " IPSTR "\n", IP2STR(&xnetif[WLAN_AP_NETIF_NUM].ip_addr));
|
|
}
|
|
void show_wifi_st_ip(void) {
|
|
printf("Station ip: " IPSTR "\n", IP2STR(&xnetif[WLAN_ST_NETIF_NUM].ip_addr));
|
|
}
|
|
|
|
void show_wifi_st_cfg(void) {
|
|
printf("\tSSID: '%s'\n", wifi_st_cfg.ssid);
|
|
printf("\tPassword: '%s'\n", wifi_st_cfg.password);
|
|
printf("\tSecurity type: %p\n", wifi_st_cfg.security_type);
|
|
printf("\tAuto-reconnect: %d\n", wifi_st_cfg.autoreconnect);
|
|
printf("\tReconnect pause: %d\n", wifi_st_cfg.reconnect_pause);
|
|
}
|
|
|
|
void show_wifi_ap_cfg(void) {
|
|
printf("\tSSID: '%s'\n", wifi_ap_cfg.ssid);
|
|
printf("\tSSID hidden: %d\n", wifi_ap_cfg.ssid_hidden);
|
|
printf("\tPassword: '%s'\n", wifi_ap_cfg.password);
|
|
printf("\tSecurity type: %p\n", wifi_ap_cfg.security_type);
|
|
printf("\tChannel: %d\n", wifi_ap_cfg.channel);
|
|
printf("\tBeacon interval: %d ms\n", wifi_ap_cfg.beacon_interval);
|
|
printf("\tMax connections: %d\n", wifi_ap_cfg.max_sta);
|
|
}
|
|
|
|
void show_wifi_cfg(void) {
|
|
printf("\tStart mode: %p\n", wifi_cfg.mode);
|
|
printf("\tCountry code: %d\n", wifi_cfg.country_code);
|
|
printf("\tSleep mode: %p\n", wifi_cfg.sleep);
|
|
printf("\tNetwork mode: %d\n", wifi_cfg.bgn);
|
|
printf("\tTx power: %d\n", wifi_cfg.tx_pwr);
|
|
printf("\tLoad flags: %p\n", wifi_cfg.load_flg);
|
|
printf("\tSave flags: %p\n", wifi_cfg.save_flg);
|
|
}
|
|
|
|
//==========================================================
|
|
//--- CONSOLE --------------------------
|
|
#include "section_config.h"
|
|
#include "hal_diag.h"
|
|
|
|
// ATPN=<SSID>[,password[,encryption[,auto reconnect[,reconnect pause]]]: WIFI Connect to AP
|
|
void fATPN(int argc, char *argv[]){
|
|
if(argc > 1) {
|
|
if(argv[1][0] == '?') {
|
|
show_wifi_st_cfg();
|
|
}
|
|
else {
|
|
strncpy(wifi_st_cfg.ssid, argv[1], NDIS_802_11_LENGTH_SSID);
|
|
if(argc > 2) {
|
|
strncpy(wifi_st_cfg.password, argv[2], NDIS_802_11_LENGTH_SSID);
|
|
int i = strlen(wifi_st_cfg.password);
|
|
if(i > 7) {
|
|
wifi_st_cfg.security_type = RTW_SECURITY_WPA2_AES_PSK;
|
|
}
|
|
else if(!i) {
|
|
wifi_st_cfg.security_type = RTW_SECURITY_OPEN;
|
|
}
|
|
else {
|
|
printf("password len < 8!\n");
|
|
wifi_st_cfg.security_type = RTW_SECURITY_OPEN;
|
|
}
|
|
}
|
|
else {
|
|
wifi_st_cfg.password[0] = 0;
|
|
wifi_st_cfg.security_type = RTW_SECURITY_OPEN;
|
|
}
|
|
if(argc > 3) {
|
|
wifi_st_cfg.security_type = translate_rtw_security(atoi(argv[3]));
|
|
}
|
|
if(argc > 4) {
|
|
wifi_st_cfg.autoreconnect = atoi(argv[3]);
|
|
}
|
|
else wifi_st_cfg.autoreconnect = 0;
|
|
if(argc > 5) {
|
|
wifi_st_cfg.reconnect_pause = atoi(argv[3]);
|
|
}
|
|
else wifi_st_cfg.reconnect_pause = 5;
|
|
show_wifi_st_cfg();
|
|
wifi_run(wifi_run_mode | RTW_MODE_STA);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ATPA=<SSID>[,password[,encryption[,channel[,hidden[,max connections]]]]]: Start WIFI AP
|
|
void fATPA(int argc, char *argv[]){
|
|
if(argc > 1) {
|
|
if(argv[1][0] == '?') {
|
|
show_wifi_ap_cfg();
|
|
}
|
|
else {
|
|
strncpy(wifi_ap_cfg.ssid, argv[1], NDIS_802_11_LENGTH_SSID);
|
|
if(argc > 2) {
|
|
strncpy(wifi_ap_cfg.password, argv[2], NDIS_802_11_LENGTH_SSID);
|
|
int i = strlen(wifi_ap_cfg.password);
|
|
if(i > 7) {
|
|
wifi_ap_cfg.security_type = RTW_SECURITY_WPA2_AES_PSK;
|
|
}
|
|
else if(i == 0) {
|
|
wifi_ap_cfg.security_type = RTW_SECURITY_OPEN;
|
|
}
|
|
else {
|
|
printf("password len < 8!\n");
|
|
wifi_ap_cfg.security_type = RTW_SECURITY_OPEN;
|
|
}
|
|
}
|
|
else {
|
|
wifi_ap_cfg.password[0] = 0;
|
|
wifi_ap_cfg.security_type = RTW_SECURITY_OPEN;
|
|
}
|
|
if(argc > 3) {
|
|
wifi_ap_cfg.security_type = translate_rtw_security(atoi(argv[3]));
|
|
}
|
|
if(argc > 4) {
|
|
wifi_ap_cfg.channel = atoi(argv[4]);
|
|
}
|
|
else wifi_ap_cfg.channel = 1;
|
|
if(argc > 5) {
|
|
wifi_ap_cfg.ssid_hidden = atoi(argv[5]);
|
|
}
|
|
else wifi_ap_cfg.ssid_hidden = 0;
|
|
|
|
if(argc > 6) {
|
|
wifi_ap_cfg.max_sta = atoi(argv[6]);
|
|
}
|
|
else wifi_ap_cfg.max_sta = 3;
|
|
|
|
show_wifi_ap_cfg();
|
|
wifi_run(wifi_run_mode | RTW_MODE_AP);
|
|
}
|
|
}
|
|
}
|
|
|
|
// WIFI Connect, Disconnect
|
|
void fATWR(int argc, char *argv[]){
|
|
rtw_mode_t mode = RTW_MODE_NONE;
|
|
if(argc > 1) mode = atoi(argv[1]);
|
|
wifi_run(mode);
|
|
}
|
|
|
|
// Close connections
|
|
void fATOF(int argc, char *argv[]){
|
|
connect_close();
|
|
}
|
|
|
|
// Open connections
|
|
void fATON(int argc, char *argv[]){
|
|
connect_start();
|
|
}
|
|
|
|
void fATWI(int argc, char *argv[]) {
|
|
rtw_wifi_setting_t Setting;
|
|
if((wifi_run_mode & RTW_MODE_AP)
|
|
&& wifi_get_setting(wlan_ap_name, &Setting) == 0) {
|
|
wifi_show_setting(wlan_ap_name, &Setting);
|
|
// show_wifi_ap_ip();
|
|
printf("\tIP: " IPSTR "\n", IP2STR(&xnetif[WLAN_AP_NETIF_NUM].ip_addr));
|
|
}
|
|
if((wifi_run_mode & RTW_MODE_STA)
|
|
&& wifi_get_setting(wlan_st_name, &Setting) == 0) {
|
|
wifi_show_setting(wlan_st_name, &Setting);
|
|
// show_wifi_st_ip();
|
|
printf("\tIP: " IPSTR "\n", IP2STR(&xnetif[WLAN_ST_NETIF_NUM].ip_addr));
|
|
}
|
|
printf("\nWIFI config:\n");
|
|
printf(&str_rom_57ch3Dch0A[25]); // "================================\n"
|
|
show_wifi_cfg();
|
|
printf("\nWIFI AP config:\n");
|
|
printf(&str_rom_57ch3Dch0A[25]); // "================================\n"
|
|
show_wifi_ap_cfg();
|
|
printf("\nWIFI ST config:\n");
|
|
printf(&str_rom_57ch3Dch0A[25]); // "================================\n"
|
|
show_wifi_st_cfg();
|
|
printf("\n");
|
|
if(argc > 2
|
|
&& (argv[1][0] == 's'
|
|
|| argv[1][0] == 'S')) {
|
|
int i = atoi(argv[2]);
|
|
printf("Save configs(%d)..\n", i);
|
|
write_wifi_cfg(atoi(argv[2]));
|
|
}
|
|
}
|
|
|
|
void fATWT(int argc, char *argv[]) {
|
|
if(argc > 1) {
|
|
int txpwr = atoi(argv[1]);
|
|
debug_printf("set tx power (%d)...\n", txpwr);
|
|
if(rltk_set_tx_power_percentage(txpwr) != RTW_SUCCESS) {
|
|
error_printf("Error set tx power (%d)!", wifi_cfg.tx_pwr);
|
|
}
|
|
}
|
|
printf("TX power = %d\n", rtw_power_percentage_idx);
|
|
}
|
|
|
|
//-- Test tsf (64-bits counts, 1 us step) ---
|
|
|
|
#include "hal_com_reg.h"
|
|
|
|
#define ReadTSF_Lo32() (*((volatile unsigned int *)(WIFI_REG_BASE + REG_TSFTR)))
|
|
#define ReadTSF_Hi32() (*((volatile unsigned int *)(WIFI_REG_BASE + REG_TSFTR1)))
|
|
|
|
LOCAL uint64_t get_tsf(void)
|
|
{
|
|
return *((uint64_t *)(WIFI_REG_BASE + REG_TSFTR));
|
|
}
|
|
|
|
void fATSF(int argc, char *argv[])
|
|
{
|
|
uint64_t tsf = get_tsf();
|
|
printf("\nTSF: %08x%08x\n", (uint32_t)(tsf>>32), (uint32_t)(tsf));
|
|
}
|
|
|
|
/* -------- WiFi Scan ------------------------------- */
|
|
unsigned char *tab_txt_rtw_secyrity[] = {
|
|
"OPEN ",
|
|
"WEP ",
|
|
"WPA TKIP",
|
|
"WPA AES",
|
|
"WPA2 AES",
|
|
"WPA2 TKIP",
|
|
"WPA2 Mixed",
|
|
"WPA/WPA2 AES",
|
|
"Unknown"
|
|
};
|
|
unsigned int *tab_code_rtw_secyrity[] = {
|
|
RTW_SECURITY_OPEN,
|
|
RTW_SECURITY_WEP_PSK,
|
|
RTW_SECURITY_WPA_TKIP_PSK,
|
|
RTW_SECURITY_WPA_AES_PSK,
|
|
RTW_SECURITY_WPA2_AES_PSK,
|
|
RTW_SECURITY_WPA2_TKIP_PSK,
|
|
RTW_SECURITY_WPA2_MIXED_PSK,
|
|
RTW_SECURITY_WPA_WPA2_MIXED,
|
|
RTW_SECURITY_UNKNOWN
|
|
};
|
|
|
|
volatile uint8_t scan_end;
|
|
|
|
/* -------- WiFi Scan ------------------------------- */
|
|
static rtw_result_t _scan_result_handler( rtw_scan_handler_result_t* malloced_scan_result )
|
|
{
|
|
if (malloced_scan_result->scan_complete != RTW_TRUE) {
|
|
rtw_scan_result_t* record = &malloced_scan_result->ap_details;
|
|
record->SSID.val[record->SSID.len] = 0; /* Ensure the SSID is null terminated */
|
|
if(scan_end == 1) {
|
|
printf("\nScan networks:\n\n");
|
|
printf("N\tType\tMAC\t\t\tSignal\tCh\tWPS\tSecyrity\tSSID\n\n");
|
|
};
|
|
printf("%d\t", scan_end++);
|
|
printf("%s\t", (record->bss_type == RTW_BSS_TYPE_ADHOC)? "Adhoc": "Infra");
|
|
printf(MAC_FMT, MAC_ARG(record->BSSID.octet));
|
|
printf("\t%d\t", record->signal_strength);
|
|
printf("%d\t", record->channel);
|
|
printf("%d\t", record->wps_type);
|
|
int i = 0;
|
|
for(; record->security != tab_code_rtw_secyrity[i] && tab_code_rtw_secyrity[i] != RTW_SECURITY_UNKNOWN; i++);
|
|
printf("%s \t", tab_txt_rtw_secyrity[i]);
|
|
printf("%s\n", record->SSID.val);
|
|
} else {
|
|
scan_end = 0;
|
|
printf("\n");
|
|
}
|
|
return RTW_SUCCESS;
|
|
}
|
|
/* -------- WiFi Scan ------------------------------- */
|
|
#define scan_channels 14
|
|
void fATSN(int argc, char *argv[])
|
|
{
|
|
int i;
|
|
u8 *channel_list = (u8*)pvPortMalloc(scan_channels*2);
|
|
if(channel_list) {
|
|
scan_end = 1;
|
|
u8 * pscan_config = &channel_list[scan_channels];
|
|
//parse command channel list
|
|
for(i = 1; i <= scan_channels; i++){
|
|
*(channel_list + i - 1) = i;
|
|
*(pscan_config + i - 1) = PSCAN_ENABLE;
|
|
};
|
|
if(wifi_set_pscan_chan(channel_list, pscan_config, scan_channels) < 0){
|
|
printf("ERROR: wifi set partial scan channel fail\n");
|
|
} else if(wifi_scan_networks(_scan_result_handler, NULL ) != RTW_SUCCESS){
|
|
printf("ERROR: wifi scan failed\n");
|
|
} else {
|
|
i = 300;
|
|
while(i-- && scan_end) {
|
|
vTaskDelay(10);
|
|
};
|
|
};
|
|
vPortFree(channel_list);
|
|
} else {
|
|
printf(" ERROR: Can't malloc memory for channel list\n");
|
|
};
|
|
}
|
|
|
|
MON_RAM_TAB_SECTION COMMAND_TABLE console_cmd_wifi_api[] = {
|
|
{"ATPN", 1, fATPN, "=<SSID>[,password[,encryption[,auto-reconnect[,reconnect pause]]]: WIFI Connect to AP"},
|
|
{"ATPA", 1, fATPA, "=<SSID>[,password[,encryption[,channel[,hidden[,max connections]]]]]: Start WIFI AP"},
|
|
{"ATWR", 0, fATWR, ": WIFI Connect, Disconnect"},
|
|
{"ATON", 0, fATON, ": Open connections"},
|
|
{"ATOF", 0, fATOF, ": Close connections"},
|
|
{"ATWI", 0, fATWI, ": WiFi Info"},
|
|
#if CONFIG_DEBUG_LOG > 3
|
|
{"ATWT", 1, fATWT, "=<tx_power>: WiFi tx power: 0 - 100%, 1 - 75%, 2 - 50%, 3 - 25%, 4 - 12.5%"},
|
|
{"ATSF", 0, fATSF, ": Test TSF value"},
|
|
#endif
|
|
{"ATSN", 0, fATSN, ": Scan networks"}
|
|
};
|