void setup_wifi_ap_mode(void)
{
wifi_set_opmode((wifi_get_opmode()|SOFTAP_MODE)&STATIONAP_MODE);
struct softap_config apconfig;
if(wifi_softap_get_config(&apconfig))
{
wifi_softap_dhcps_stop();
memset(apconfig.ssid, 0, sizeof(apconfig.ssid));
memset(apconfig.password, 0, sizeof(apconfig.password));
apconfig.ssid_len = os_sprintf(apconfig.ssid, WIFI_AP_NAME);
os_sprintf(apconfig.password, "%s", WIFI_AP_PASSWORD);
apconfig.authmode = AUTH_WPA_WPA2_PSK;
apconfig.ssid_hidden = 0;
apconfig.channel = 7;
apconfig.max_connection = 4;
if(!wifi_softap_set_config(&apconfig))
{
#ifdef PLATFORM_DEBUG
os_printf("ESP8266 not set AP config!\r\n");
#endif
};
struct ip_info ipinfo;
wifi_get_ip_info(SOFTAP_IF, &ipinfo);
IP4_ADDR(&ipinfo.ip, 192, 168, 4, 1);
IP4_ADDR(&ipinfo.gw, 192, 168, 4, 1);
IP4_ADDR(&ipinfo.netmask, 255, 255, 255, 0);
wifi_set_ip_info(SOFTAP_IF, &ipinfo);
wifi_softap_dhcps_start();
}
#ifdef PLATFORM_DEBUG
os_printf("ESP8266 in AP mode configured.\r\n");
#endif
}
void user_init(void) {
char * ap = "SKUNKWILLEM";
char * pass = "******";
uart_init(BIT_RATE_115200, uart_receive, false);
system_set_os_print(1);
os_printf("\nUart init done... \n");
wifi_softap_get_config(&apconf);
memset(apconf.ssid, 0, 32);
memset(apconf.password, 0, 64);
os_strncpy((char*)apconf.ssid, ap, 32);
os_strncpy((char*)apconf.password, pass, 64);
apconf.authmode = AUTH_WPA_WPA2_PSK;
apconf.max_connection = 5;
apconf.ssid_hidden = 0;
wifi_softap_set_config(&apconf);
IP4_ADDR(&IpInfo.gw, 192, 168, 10, 1);
IP4_ADDR(&IpInfo.ip, 192, 168, 10, 1);
IP4_ADDR(&IpInfo.netmask, 255, 255, 255, 0);
wifi_softap_dhcps_stop();
dhcps_start(&IpInfo);
wifi_set_ip_info(0x01, &IpInfo);
os_timer_disarm(&waitTimer);
os_timer_setfn(&waitTimer, init_udp, NULL);
os_timer_arm(&waitTimer, 2000, 0);
}
void ICACHE_FLASH_ATTR config_wifi_new(void){
wifi_softap_dhcps_stop();
//vTaskDelay( xDelay );
wifi_set_opmode(NULL_MODE);
//vTaskDelay( xDelay );
wifi_set_opmode(SOFTAP_MODE);
//vTaskDelay( xDelay );
struct softap_config apConfig;
char ssid[8];
wifi_set_event_handler_cb(wifi_event_cb);
//mode_info();
memset(apConfig.ssid, 0, sizeof(apConfig.ssid));
sprintf(ssid, "%s\0", WIFI_APSSID);
memcpy(apConfig.ssid, ssid, strlen(ssid));
printf("SSID %s\n",apConfig.ssid);
apConfig.authmode = AUTH_OPEN;
apConfig.channel = 5;
apConfig.ssid_len=strlen(ssid);
apConfig.max_connection = 255;
apConfig.ssid_hidden = 0;
wifi_softap_set_config(&apConfig);
//vTaskDelay( xDelay );
wifi_softap_dhcps_start();
//vTaskDelay( xDelay*10 );
coap_restart(0);
}
/**
* Initializes DHCP server
*/
LOCAL void ICACHE_FLASH_ATTR esp_wifi_setup_dhcp_server( void )
{
struct dhcps_lease admin_dhcp_config;
uint8_t dhcp_server = 0x01;
uint8_t dhcp_start_ip[ 4 ] = { WIFI_DHCP_SERVER_START_IP };
uint8_t dhcp_end_ip[ 4 ] = { WIFI_DHCP_SERVER_END_IP };
// check if parameters don't exist
/* if( esp_flash_read_parameter( ESP_WIFI_APMODE_DHCP_ENABLE_ID, &dhcp_server ) == 0x00 )
{
// save defaults in flash
esp_flash_save_parameter( ESP_WIFI_APMODE_DHCP_ENABLE_ID, &dhcp_server, 0x01 );
esp_flash_save_parameter( ESP_WIFI_APMODE_DHCP_START_IP_ID, dhcp_start_ip, 0x04 );
esp_flash_save_parameter( ESP_WIFI_APMODE_DHCP_END_IP_ID, dhcp_end_ip, 0x04 );
} else {*/
// stop the DHCP
if( wifi_softap_dhcps_status() == DHCP_STARTED )
wifi_softap_dhcps_stop();
// check if DHCP is enabled
// if( dhcp_server == 0x01 )
// {
// read configuration details
//esp_flash_read_parameter( ESP_WIFI_APMODE_DHCP_START_IP_ID, dhcp_start_ip );
// esp_flash_read_parameter( ESP_WIFI_APMODE_DHCP_END_IP_ID, dhcp_end_ip );
// configure and turn on DHCP
IP4_ADDR( &admin_dhcp_config.start_ip, dhcp_start_ip[ 0 ], dhcp_start_ip[ 1 ], dhcp_start_ip[ 2 ], dhcp_start_ip[ 3 ] );
IP4_ADDR( &admin_dhcp_config.end_ip, dhcp_end_ip[ 0 ], dhcp_end_ip[ 1 ], dhcp_end_ip[ 2 ], dhcp_end_ip[ 3 ] );
wifi_softap_set_dhcps_lease( &admin_dhcp_config );
wifi_softap_dhcps_start();
// }
// }
}
void setup_ap(void) {
int off = 0;
struct ip_info info;
struct softap_config cfg;
wifi_set_opmode_current(SOFTAP_MODE);
memset(&cfg, 0, sizeof(cfg));
strcpy((char *) cfg.ssid, AP_SSID);
strcpy((char *) cfg.password, AP_PASS);
cfg.ssid_len = strlen((const char *) cfg.ssid);
cfg.authmode =
strlen((const char *) cfg.password) ? AUTH_WPA2_PSK : AUTH_OPEN;
cfg.channel = AP_CHAN;
cfg.ssid_hidden = 0;
cfg.max_connection = 10;
cfg.beacon_interval = 100; /* ms */
printf("Setting up AP '%s' on channel %d\n", cfg.ssid, cfg.channel);
wifi_softap_set_config_current(&cfg);
wifi_softap_dhcps_stop();
wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &off);
wifi_softap_dhcps_start();
wifi_get_ip_info(SOFTAP_IF, &info);
printf("WiFi AP: SSID %s, channel %d, IP " IPSTR "\n", cfg.ssid, cfg.channel,
IP2STR(&info.ip));
}
void user_init()
{
#ifdef ESP8266_GDBSTUB
gdbstub_init();
#endif
//Uncomment the line below if you want to step through the initialization function in the debugger without getting a reset from a watchdog.
//system_soft_wdt_stop();
struct ip_info info;
struct softap_config cfg;
wifi_softap_get_config(&cfg);
strcpy((char *)cfg.ssid, "$$com.sysprogs.esp8266.http.ssid$$");
cfg.ssid_len = strlen((char*)cfg.ssid);
wifi_softap_set_config_current(&cfg);
wifi_set_opmode(SOFTAP_MODE);
wifi_softap_dhcps_stop();
IP4_ADDR(&info.ip, 192, 168, $$com.sysprogs.esp8266.http.subnet$$, 1);
IP4_ADDR(&info.gw, 192, 168, $$com.sysprogs.esp8266.http.subnet$$, 1);
IP4_ADDR(&info.netmask, 255, 255, 255, 0);
wifi_set_ip_info(SOFTAP_IF, &info);
dhcps_lease_test();
wifi_softap_dhcps_start();
static struct espconn httpdConn;
static esp_tcp httpdTcp;
httpdConn.type = ESPCONN_TCP;
httpdConn.state = ESPCONN_NONE;
httpdTcp.local_port = 80;
httpdConn.proto.tcp = &httpdTcp;
espconn_regist_connectcb(&httpdConn, httpdConnectCb);
espconn_accept(&httpdConn);
}
//============================================================================================================================
void setup_wifi_ap_mode(void)
{
wifi_set_opmode((wifi_get_opmode()|STATIONAP_MODE)&STATIONAP_MODE);
struct softap_config apconfig;
if(wifi_softap_get_config(&apconfig))
{
wifi_softap_dhcps_stop();
os_memset(apconfig.ssid, 0, sizeof(apconfig.ssid));
os_memset(apconfig.password, 0, sizeof(apconfig.password));
apconfig.ssid_len = os_sprintf(apconfig.ssid, configs.hwSettings.wifi.SSID);//"HA-HA-HA");
os_sprintf(apconfig.password, "%s", configs.hwSettings.wifi.SSID_PASS);//"qwertyuiop");
apconfig.authmode = configs.hwSettings.wifi.auth;//AUTH_OPEN;//AUTH_WPA_WPA2_PSK;
apconfig.ssid_hidden = 0;
apconfig.channel = 7;
apconfig.max_connection = 4;
if(!wifi_softap_set_config(&apconfig))
{
//#if DEBUG_LEVEL > 0
ets_uart_printf("ESP8266 not set AP config!\r\n");
//#endif
};
struct ip_info ipinfo;
wifi_get_ip_info(SOFTAP_IF, &ipinfo);
IP4_ADDR(&ipinfo.ip, 192, 168, 4, 100);
IP4_ADDR(&ipinfo.gw, 192, 168, 4, 100);
IP4_ADDR(&ipinfo.netmask, 255, 255, 255, 0);
wifi_set_ip_info(SOFTAP_IF, &ipinfo);
wifi_softap_dhcps_start();
}
//#if DEBUG_LEVEL > 0
ets_uart_printf("ESP8266 in AP mode configured.\r\n");
//#endif
}
// Lua: ip = wifi.ap.dhcp.config()
static int wifi_ap_dhcp_config( lua_State* L )
{
if (!lua_istable(L, 1))
return luaL_error( L, "wrong arg type" );
struct dhcps_lease lease;
uint32_t ip;
ip = parse_key(L, "start");
if (ip == 0)
return luaL_error( L, "wrong arg type" );
lease.start_ip = ip;
NODE_DBG(IPSTR, IP2STR(&lease.start_ip));
NODE_DBG("\n");
// use configured max_connection to determine end
struct softap_config config;
wifi_softap_get_config(&config);
lease.end_ip = lease.start_ip;
ip4_addr4(&lease.end_ip) += config.max_connection - 1;
char temp[64];
c_sprintf(temp, IPSTR, IP2STR(&lease.start_ip));
lua_pushstring(L, temp);
c_sprintf(temp, IPSTR, IP2STR(&lease.end_ip));
lua_pushstring(L, temp);
// note: DHCP max range = 101 from start_ip to end_ip
wifi_softap_dhcps_stop();
wifi_softap_set_dhcps_lease(&lease);
wifi_softap_dhcps_start();
return 2;
}
// Lua: ip = wifi.xx.setip()
static int wifi_setip( lua_State* L, uint8_t mode )
{
struct ip_info pTempIp;
wifi_get_ip_info(mode, &pTempIp);
if (!lua_istable(L, 1))
return luaL_error( L, "wrong arg type" );
uint32_t ip = parse_key(L, "ip");
if(ip!=0)
pTempIp.ip.addr = ip;
ip = parse_key(L, "netmask");
if(ip!=0)
pTempIp.netmask.addr = ip;
ip = parse_key(L, "gateway");
if(mode==SOFTAP_IF || ip!=0)
pTempIp.gw.addr = ip;
if(STATION_IF == mode)
{
wifi_station_dhcpc_stop();
lua_pushboolean(L,wifi_set_ip_info(mode, &pTempIp));
}
else
{
wifi_softap_dhcps_stop();
lua_pushboolean(L,wifi_set_ip_info(mode, &pTempIp));
wifi_softap_dhcps_start();
}
return 1;
}
void ESP8266WiFiClass::softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet)
{
struct ip_info info;
info.ip.addr = static_cast<uint32_t>(local_ip);
info.gw.addr = static_cast<uint32_t>(gateway);
info.netmask.addr = static_cast<uint32_t>(subnet);
wifi_softap_dhcps_stop();
wifi_set_ip_info(SOFTAP_IF, &info);
wifi_softap_dhcps_start();
}
void STC_FLASHMEM IP::configureStatic(WiFi::Network network, char const *IP, char const *netmask, char const *gateway) {
ip_info info;
info.ip.addr = ipaddr_addr(APtr<char>(f_strdup(IP)).get());
info.netmask.addr = ipaddr_addr(APtr<char>(f_strdup(netmask)).get());
info.gw.addr = ipaddr_addr(APtr<char>(f_strdup(gateway)).get());
Critical critical;
wifi_station_dhcpc_stop();
wifi_softap_dhcps_stop();
wifi_set_ip_info(network, &info);
}
// warn: each IP in the range requires memory!
void STC_FLASHMEM DHCPServer::configure(char const *startIP, char const *endIP) {
wifi_softap_dhcps_stop();
dhcps_lease lease;
lease.start_ip = IPAddress(startIP).get_ip_addr_t();
lease.end_ip = IPAddress(endIP).get_ip_addr_t();
wifi_softap_set_dhcps_lease(&lease);
uint8_t mode = 1;
wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &mode);
wifi_softap_dhcps_start();
}
/*
* This is entry point for user code
*/
void ICACHE_FLASH_ATTR user_init(void)
{
uart_div_modify(UART0, UART_CLK_FREQ / (BIT_RATE_115200));
show_free_mem(0);
wifi_softap_dhcps_stop();
show_free_mem(1);
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0); // GPIO 0
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2); // GPIO 2
xTaskCreate(jerry_task, "jerry", JERRY_STACK_SIZE, NULL, 2, NULL);
}
// Access point IP setup
void ICACHE_FLASH_ATTR setup_ap_ip() {
struct ip_info ipinfo;
wifi_softap_dhcps_stop();
//wifi_get_ip_info(SOFTAP_IF, &ipinfo);
IP4_ADDR(&ipinfo.ip, 10, 10, 10, 1); // Self IP
IP4_ADDR(&ipinfo.gw, 10, 10, 10, 1); // Gateway IP (also self)
IP4_ADDR(&ipinfo.netmask, 255, 255, 255, 0); // Netmask (class C /24)
//IP4_ADDR(&dhcp_lease.start_ip, 10, 10, 10, 10);
//IP4_ADDR(&dhcp_lease.end_ip, 10, 10, 10, 100);
//wifi_softap_set_dhcps_lease(&dhcp_lease);
wifi_set_ip_info(SOFTAP_IF, &ipinfo);
wifi_softap_dhcps_start();
//print("Set IP info");
}
LOCAL void ICACHE_FLASH_ATTR setup_ap_mode() {
wifi_station_disconnect();
wifi_station_dhcpc_stop();
wifi_set_opmode(SOFTAP_MODE);
struct softap_config apconfig;
if (wifi_softap_get_config(&apconfig)) {
wifi_softap_dhcps_stop();
char macaddr[6];
wifi_get_macaddr(SOFTAP_IF, macaddr);
os_memset(apconfig.ssid, 0, sizeof(apconfig.ssid));
os_memset(apconfig.password, 0, sizeof(apconfig.password));
apconfig.ssid_len = os_sprintf(apconfig.ssid, "MacGyver-IoT_%02x%02x%02x%02x%02x%02x", MAC2STR(macaddr));
//os_sprintf(apconfig.password, "%02x%02x%02x%02x%02x%02x", MAC2STR(macaddr)); // 18fe349bc6b6
//os_sprintf(apconfig.password, "test"); // 18fe349bc6b6
//apconfig.authmode = AUTH_WPA_WPA2_PSK; // AUTH_OPEN
apconfig.authmode = AUTH_OPEN;
apconfig.ssid_hidden = 0;
apconfig.channel = 7;
apconfig.max_connection = 10;
if (!wifi_softap_set_config(&apconfig)) {
// CTRL not set AP config!
}
struct ip_info ipinfo;
if (wifi_get_ip_info(SOFTAP_IF, &ipinfo)) {
IP4_ADDR(&ipinfo.ip, 192, 168, 4, 1);
IP4_ADDR(&ipinfo.gw, 192, 168, 4, 1);
IP4_ADDR(&ipinfo.netmask, 255, 255, 255, 0);
if (!wifi_set_ip_info(SOFTAP_IF, &ipinfo)) {
// CTRL not set IP config!
}
}
wifi_softap_dhcps_start();
}
if (wifi_get_phy_mode() != PHY_MODE_11N)
wifi_set_phy_mode(PHY_MODE_11N);
}
bool AccessPointClass::setIP(IPAddress address)
{
/*
if (System.isReady())
{
debugf("IP can be changed only in init() method");
return false;
}
*/
wifi_softap_dhcps_stop();
struct ip_info ipinfo;
wifi_get_ip_info(SOFTAP_IF, &ipinfo);
ipinfo.ip = address;
ipinfo.gw = address;
IP4_ADDR(&ipinfo.netmask, 255, 255, 255, 0);
wifi_set_ip_info(SOFTAP_IF, &ipinfo);
wifi_softap_dhcps_start();
return true;
}
void setup_wifi_ap_mode(void)
{
wifi_set_opmode((wifi_get_opmode() | SOFTAP_MODE));
//wifi_set_opmode(STATIONAP_MODE);
struct softap_config apconfig;
if(wifi_softap_get_config(&apconfig))
{
INFO("In softw AP Setup\r\n");
wifi_softap_dhcps_stop();
memset(apconfig.ssid, 0, sizeof(apconfig.ssid));
memset(apconfig.password, 0, sizeof(apconfig.password));
apconfig.ssid_len = os_sprintf(apconfig.ssid, WIFI_AP_NAME);
os_sprintf(apconfig.password, "%s", WIFI_AP_PASSWORD);
apconfig.authmode = AUTH_OPEN; // AUTH_WPA_WPA2_PSK - for protected AP
apconfig.ssid_hidden = 0;
apconfig.channel = 7;
apconfig.max_connection = 4;
if(!wifi_softap_set_config(&apconfig))
{
INFO("\r\n === ESP8266 not set AP config!\r\n");
}
else
INFO("\r == ESP Set to AP Mode for Setup - 192.168.4.1\r");
struct ip_info ipinfo;
wifi_get_ip_info(SOFTAP_IF, &ipinfo);
IP4_ADDR(&ipinfo.ip, 192, 168, 4, 1);
IP4_ADDR(&ipinfo.gw, 192, 168, 4, 1);
IP4_ADDR(&ipinfo.netmask, 255, 255, 255, 0);
wifi_set_ip_info(SOFTAP_IF, &ipinfo);
wifi_softap_dhcps_start();
}
else
{
INFO("\r\n === Problems setting AP Mode\r\n");
}
INFO("\r\n === ESP8266 in AP mode configured.\r\n");
}
void AccessPointClass::onSystemReady()
{
if (runConfig != NULL)
{
noInterrupts();
bool enabled = isEnabled();
enable(true);
wifi_softap_dhcps_stop();
if(!wifi_softap_set_config(runConfig))
debugf("Can't set AP config on system ready event!");
else
debugf("AP configuration was updated on system ready event");
delete runConfig;
runConfig = NULL;
wifi_softap_dhcps_start();
enable(enabled);
interrupts();
}
}
LOCAL void ICACHE_FLASH_ATTR setup_wifi_ap_mode(void)
{
ets_uart_printf("\n\nMudando Wifi para modo AP\n");
wifi_set_opmode(SOFTAP_MODE);
struct softap_config apconfig;
wifi_softap_dhcps_stop();
if(wifi_softap_get_config(&apconfig))
{
apconfig.authmode = AUTH_WPA_PSK;
os_memcpy(&apconfig.ssid, WIFI_CLIENTSSID_AP, sizeof(WIFI_CLIENTSSID));
os_memcpy(&apconfig.password, WIFI_CLIENTPASSWORD_AP, sizeof(WIFI_CLIENTPASSWORD));
wifi_softap_set_config(&apconfig);
ets_uart_printf("SSID: %s\n",apconfig.ssid);
stringDraw(2, 1, (char*)apconfig.ssid);
ets_uart_printf("Password: %s\n",apconfig.password);
}
wifi_softap_dhcps_start();
}
void ICACHE_FLASH_ATTR configure(void){
restartActive=0;
struct station_config st_config;
memset(st_config.ssid, 0, sizeof(st_config.ssid));
memcpy(st_config.ssid, ssid_name, strlen(ssid_name));
//st_config.ssid_len=strlen(ssid_name);
memset(st_config.password, 0, sizeof(st_config.password));
memcpy(st_config.password, password, strlen(password));
// if(!isnew){
memset(user_config.ssid, 0, sizeof(user_config.ssid));
memcpy(user_config.ssid, ssid_name, strlen(ssid_name));
memset(user_config.pwd, 0, sizeof(user_config.pwd));
memcpy(user_config.pwd, password, strlen(password));
// }
printf("STA config: SSID: %s, PASSWORD: %s\r\n",st_config.ssid,st_config.password );
printf("info: SSID: %s, PASSWORD: %s\r\n",ssid_name,password );
int ch;
wifi_softap_dhcps_stop();
wifi_set_event_handler_cb(wifi_event_cb);
//vTaskDelay( xDelay );
wifi_set_opmode(NULL_MODE);
vTaskDelay( xDelay );
//save_user_config(&user_config);
wifi_set_opmode(STATION_MODE);
//vTaskDelay( xDelay );
wifi_station_set_config_current(&st_config);
// int ret = wifi_station_set_auto_connect(1);
//vTaskDelay( xDelay );
wifi_station_connect();
//vTaskDelay( xDelay );
wifi_station_dhcpc_start();
//vTaskDelay( 100 );
//vTaskDelay( 100 );
coap_restart(1);
}
void RAMFUNC user_init(void)
{
#ifdef ESP32_GDBSTUB
gdbstub_init();
#endif
struct ip_info info;
struct softap_config cfg;
wifi_softap_get_config(&cfg);
strcpy((char *)cfg.ssid, "$$com.sysprogs.esp32.http.ssid$$");
cfg.ssid_len = strlen((char*)cfg.ssid);
wifi_softap_set_config_current(&cfg);
wifi_set_opmode(SOFTAP_MODE);
wifi_softap_dhcps_stop();
IP4_ADDR(&info.ip, 192, 168, $$com.sysprogs.esp32.http.subnet$$, 1);
IP4_ADDR(&info.gw, 192, 168, $$com.sysprogs.esp32.http.subnet$$, 1);
IP4_ADDR(&info.netmask, 255, 255, 255, 0);
wifi_set_ip_info(SOFTAP_IF, &info);
dhcps_lease_test();
wifi_softap_dhcps_start();
xTaskCreate(ServerTask, "Server", 256, NULL, 2, NULL);
}
// Lua: wifi.ap.dhcp.stop()
static int wifi_ap_dhcp_stop( lua_State* L )
{
lua_pushboolean(L, wifi_softap_dhcps_stop());
return 1;
}
/******************************************************************************
* FunctionName : udp_test_port_recv
* Returns : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
udp_test_port_recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, ip_addr_t *addr, u16_t port)
{
uint8 usrdata[32];
if (p == NULL) return;
if(p->tot_len < 2) {
pbuf_free(p);
return;
}
uint16 length = mMIN(p->tot_len, sizeof(usrdata)-1);
#if DEBUGSOO > 0
os_printf("udp " IPSTR ":%u [%d]\n", IP2STR(addr), port, p->tot_len);
#endif
length = pbuf_copy_partial(p, usrdata, length, 0);
pbuf_free(p);
uint8 *pudpbuf = (uint8 *)os_zalloc(udpbufsize+1);
if(pudpbuf == NULL) return;
uint16 udpbuflen = 0;
int x = 0;
if(length>2) x = atoi((char *)&usrdata[2]);
if ((length>1)&&(usrdata[1]=='?')) switch(usrdata[0])
{
case 'M':
system_print_meminfo();
case 'A':
{
udp_puts("\nChip_id: %08x Flash_id: %08x\nsys_time:%08x ADC:%d\n", system_get_chip_id(), spi_flash_get_id(), system_get_time(), system_adc_read());
struct softap_config wiconfig;
wifi_softap_get_config(&wiconfig);
udp_puts("OPMode:%u SSID:'%s' Pwd:'%s' Ch:%u Authmode:%u MaxCon:%u Phu:%u ACon:%u\n", wifi_get_opmode(), wiconfig.ssid, wiconfig.password, wiconfig.channel, wiconfig.authmode, wiconfig.max_connection, wifi_get_phy_mode(), wifi_station_get_auto_connect());
udp_puts("Connect status:%u\n", wifi_station_get_connect_status());
};
case 'I':
udp_puts("heapsize: %d\n", system_get_free_heap_size() + udpbufsize);
udpbuflen += print_udp_psc(pudpbuf+udpbuflen, udpbufsize-udpbuflen);
udpbuflen += print_tcp_psc(pudpbuf+udpbuflen, udpbufsize-udpbuflen);
udpbuflen += chow_tcp_connection_info(pudpbuf+udpbuflen, udpbufsize-udpbuflen);
break;
case 'H':
udp_puts("heapsize: %d\n", system_get_free_heap_size() + udpbufsize);
break;
case 'U':
udp_puts("heapsize: %d\n", system_get_free_heap_size() + udpbufsize);
udpbuflen += print_udp_psc(pudpbuf+udpbuflen, udpbufsize-udpbuflen);
break;
case 'T':
udp_puts("heapsize: %d\n", system_get_free_heap_size() + udpbufsize);
udpbuflen += print_tcp_psc(pudpbuf+udpbuflen, udpbufsize-udpbuflen);
break;
#ifdef USE_SRV_WEB_PORT
case 'S':
udp_puts("heapsize: %d\n", system_get_free_heap_size() + udpbufsize);
udpbuflen += chow_tcp_connection_info(pudpbuf+udpbuflen, udpbufsize-udpbuflen);
break;
#endif
case 'R':
system_restart();
break;
case 'P':
udp_puts("system_set_os_print(%u)\n", x);
system_set_os_print(x);
break;
case 'O':
udp_puts("wifi_set_opmode(%u):%u\n", x, wifi_set_opmode(x));
break;
case 'B':
udp_puts("wifi_station_set_auto_connect(%u):%u\n", x, wifi_station_set_auto_connect(x));
break;
case 'D':
switch(x) {
case 0:
udp_puts("wifi_station_dhcpc_start:%u\n", wifi_station_dhcpc_start());
break;
case 1:
udp_puts("wifi_station_dhcpc_stop:%u\n", wifi_station_dhcpc_stop());
break;
case 2:
udp_puts("wifi_softap_dhcps_start:%u\n",wifi_softap_dhcps_start());
break;
case 3:
udp_puts("wifi_softap_dhcps_stop:%u\n", wifi_softap_dhcps_stop());
break;
default:
udp_puts("D(%u)?\n", x);
}
break;
case 'F':
if(flashchip != NULL) {
udp_puts("FlashID: 0x%08x\nChip size: %d\nBlock size: %d\nSector size: %d\nPage size: %d\nStatus mask: 0x%08x\n", flashchip->deviceId, flashchip->chip_size, flashchip->block_size, flashchip->sector_size, flashchip->page_size, flashchip->status_mask );
udp_puts("Real Flash size: %u\n", spi_flash_real_size());
}
else udp_puts("Unknown Flash type!\n");
break;
case 'E':
udp_puts("wifi_set_sleep_type(%d):%u\n", x, wifi_set_sleep_type(x));
break;
case 'G':
udp_puts("g_ic = %p\n", &g_ic);
break;
default:
udp_puts("???\n");
}
if(udpbuflen) {
struct pbuf *z = pbuf_alloc(PBUF_TRANSPORT, udpbuflen, PBUF_RAM);
if(z != NULL) {
err_t err = pbuf_take(z, pudpbuf, udpbuflen);
os_free(pudpbuf);
if(err == ERR_OK) {
udp_sendto(upcb, z, addr, port);
}
pbuf_free(z);
return;
}
}
os_free(pudpbuf);
}
bool AccessPointClass::config(String ssid, String password, AUTH_MODE mode, bool hidden /* = false*/, int channel /* = 7*/, int beaconInterval /* = 200*/)
{
softap_config config = {0};
if (mode == AUTH_WEP) return false; // Not supported!
if (mode == AUTH_OPEN)
password = "";
bool enabled = isEnabled();
enable(true);
wifi_softap_dhcps_stop();
wifi_softap_get_config(&config);
config.channel = channel;
config.ssid_hidden = hidden;
memset(config.ssid, 0, sizeof(config.ssid));
memset(config.password, 0, sizeof(config.password));
strcpy((char*)config.ssid, ssid.c_str());
strcpy((char*)config.password, password.c_str());
config.ssid_len = ssid.length();
config.authmode = mode;
config.max_connection = 4; // max 4
config.beacon_interval = beaconInterval;
// RTOS TODO Check Systemready procedure including sotsp setup
noInterrupts();
if (!wifi_softap_set_config(&config))
{
interrupts();
wifi_softap_dhcps_start();
enable(enabled);
debugf("Can't set AP configuration!");
return false;
}
interrupts();
debugf("AP configuration was updated");
/*
if (System.isReady())
{
noInterrupts();
if (!wifi_softap_set_config(&config))
{
interrupts();
wifi_softap_dhcps_start();
enable(enabled);
debugf("Can't set AP configuration!");
return false;
}
interrupts();
debugf("AP configuration was updated");
}
else
{
debugf("Set AP configuration in background");
if (runConfig != NULL)
delete runConfig;
runConfig = new softap_config();
memcpy(runConfig, &config, sizeof(softap_config));
}
*/
wifi_softap_dhcps_start();
enable(enabled);
return true;
}
//---------------------------------------------------------------------------------
//-- Read MavLink message from GCS
bool
MavESP8266GCS::_readMessage()
{
bool msgReceived = false;
int udp_count = _udp.parsePacket();
if(udp_count > 0)
{
mavlink_status_t gcs_status;
while(udp_count--)
{
int result = _udp.read();
if (result >= 0)
{
// Parsing
msgReceived = mavlink_parse_char(MAVLINK_COMM_2, result, &_message, &gcs_status);
if(msgReceived) {
//-- We no longer need to broadcast
_status.packets_received++;
if(_ip[3] == 255) {
_ip = _udp.remoteIP();
getWorld()->getLogger()->log("Response from GCS. Setting GCS IP to: %s\n", _ip.toString().c_str());
}
//-- First packets
if(!_heard_from) {
if(_message.msgid == MAVLINK_MSG_ID_HEARTBEAT) {
//-- We no longer need DHCP
if(getWorld()->getParameters()->getWifiMode() == WIFI_MODE_AP) {
wifi_softap_dhcps_stop();
}
_heard_from = true;
_system_id = _message.sysid;
_component_id = _message.compid;
_seq_expected = _message.seq + 1;
_last_heartbeat = millis();
}
} else {
if(_message.msgid == MAVLINK_MSG_ID_HEARTBEAT)
_last_heartbeat = millis();
_checkLinkErrors(&_message);
}
//-- Check for message we might be interested
if(getWorld()->getComponent()->handleMessage(this, &_message)){
//-- Eat message (don't send it to FC)
memset(&_message, 0, sizeof(_message));
msgReceived = false;
continue;
}
//-- Got message, leave
break;
}
}
}
}
if(!msgReceived) {
if(_heard_from && (millis() - _last_heartbeat) > HEARTBEAT_TIMEOUT) {
//-- Restart DHCP and start broadcasting again
if(getWorld()->getParameters()->getWifiMode() == WIFI_MODE_AP) {
wifi_softap_dhcps_start();
}
_heard_from = false;
_ip[3] = 255;
getWorld()->getLogger()->log("Heartbeat timeout from GCS\n");
}
}
return msgReceived;
}
int sj_wifi_setup_ap(const struct sys_config_wifi_ap *cfg) {
struct softap_config ap_cfg;
struct ip_info info;
struct dhcps_lease dhcps;
size_t pass_len = strlen(cfg->pass);
size_t ssid_len = strlen(cfg->ssid);
if (ssid_len > sizeof(ap_cfg.ssid) || pass_len > sizeof(ap_cfg.password)) {
LOG(LL_ERROR, ("AP SSID or PASS too long"));
return 0;
}
if (pass_len != 0 && pass_len < 8) {
/*
* If we don't check pwd len here and it will be less than 8 chars
* esp will setup _open_ wifi with name ESP_<mac address here>
*/
LOG(LL_ERROR, ("AP password too short"));
return 0;
}
/* If in STA-only mode, switch to AP. If in AP or AP+STA, keep it. */
if (wifi_get_opmode() == STATION_MODE) {
wifi_set_opmode_current(SOFTAP_MODE);
}
memset(&ap_cfg, 0, sizeof(ap_cfg));
strncpy((char *) ap_cfg.ssid, cfg->ssid, sizeof(ap_cfg.ssid));
strncpy((char *) ap_cfg.password, cfg->pass, sizeof(ap_cfg.password));
ap_cfg.ssid_len = ssid_len;
if (pass_len != 0) {
ap_cfg.authmode = AUTH_WPA2_PSK;
}
ap_cfg.channel = cfg->channel;
ap_cfg.ssid_hidden = (cfg->hidden != 0);
ap_cfg.max_connection = cfg->max_connections;
ap_cfg.beacon_interval = 100; /* ms */
LOG(LL_DEBUG, ("Setting up %s on channel %d", ap_cfg.ssid, ap_cfg.channel));
wifi_softap_set_config_current(&ap_cfg);
LOG(LL_DEBUG, ("Restarting DHCP server"));
wifi_softap_dhcps_stop();
/*
* We have to set ESP's IP address explicitly also, GW IP has to be the
* same. Using ap_dhcp_start as IP address for ESP
*/
info.netmask.addr = ipaddr_addr(cfg->netmask);
info.ip.addr = ipaddr_addr(cfg->ip);
info.gw.addr = ipaddr_addr(cfg->gw);
wifi_set_ip_info(SOFTAP_IF, &info);
dhcps.enable = 1;
dhcps.start_ip.addr = ipaddr_addr(cfg->dhcp_start);
dhcps.end_ip.addr = ipaddr_addr(cfg->dhcp_end);
wifi_softap_set_dhcps_lease(&dhcps);
/* Do not offer self as a router, we're not one. */
{
int off = 0;
wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &off);
}
wifi_softap_dhcps_start();
wifi_get_ip_info(SOFTAP_IF, &info);
LOG(LL_INFO, ("WiFi AP: SSID %s, channel %d, IP " IPSTR "", ap_cfg.ssid,
ap_cfg.channel, IP2STR(&info.ip)));
return 1;
}
void wifi_init() {
wifi_set_opmode(NULL_MODE); //Next time start up in NULL mode
wifi_set_opmode_current(NULL_MODE);
//Initialize station config parameters
struct station_config stconf;
memset(&stconf, 0, sizeof(stconf));
strncpy((char *)stconf.ssid, szWifiSsid, sizeof(stconf.ssid));
strncpy((char *)stconf.password, szWifiPassword, sizeof(stconf.password));
stconf.ssid[sizeof(stconf.ssid)-1]='\0';
stconf.password[sizeof(stconf.password)-1]='\0';
//Initialize AP config parameters
struct softap_config apconf;
memset(&apconf, 0, sizeof(apconf));
// SSID
strncpy((char *)apconf.ssid, szWifiSsid, sizeof(apconf.ssid));
apconf.ssid[sizeof(apconf.ssid)-1]='\0';
// Password & encryption
strncpy((char *)apconf.password, szWifiPassword, sizeof(apconf.password));
apconf.password[sizeof(apconf.password)-1]='\0';
if (strlen(szWifiPassword) >= 8) {
apconf.authmode = AUTH_WPA_WPA2_PSK;
} else {
// if password <8 characters, don't use password.
apconf.authmode = AUTH_WEP;
memset(apconf.password, 0, sizeof(apconf.password));
}
apconf.max_connection = 255;
apconf.beacon_interval = 100;
wifi_set_opmode_current(nWifiMode);
wifi_softap_set_config_current(&apconf);
wifi_station_set_config_current(&stconf);
struct ip_info ipinfo;
memset(&ipinfo, 0, sizeof(ipinfo));
ipinfo.ip.addr = aIP;
ipinfo.netmask.addr = aNetmask;
ipinfo.gw.addr = aGateway;
if (nWifiMode == STATION_MODE) {
wifi_station_dhcpc_stop();
wifi_station_set_hostname(szHostname);
if (bUseDhcp) {
wifi_station_dhcpc_start();
} else {
wifi_set_ip_info(STATION_IF, &ipinfo);
}
} else {
// DHCP Server should be stopped to change IP information
wifi_softap_dhcps_stop();
wifi_set_ip_info(SOFTAP_IF, &ipinfo);
uint32_t aFirstIp = (aIP & aNetmask) | 1;
uint32_t aLastIp = (aIP & aNetmask) | (-1 & ~aNetmask);
struct dhcps_lease leases;
memset(&leases, 0, sizeof(leases));
// Determine whether the range before or after our IP is bigger
if (aIP - aFirstIp > aLastIp - aIP) {
leases.start_ip.addr = aFirstIp;
leases.end_ip.addr = aIP - 1;
} else {
leases.start_ip.addr = aIP + 1;
leases.end_ip.addr = aLastIp;
}
wifi_softap_set_dhcps_lease(&leases);
uint8_t offer_router = 0;
wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &offer_router);
wifi_softap_dhcps_start();
}
}
/**
* Configure access point
* @param local_ip access point IP
* @param gateway gateway IP
* @param subnet subnet mask
*/
bool ESP8266WiFiAPClass::softAPConfig(IPAddress local_ip, IPAddress gateway, IPAddress subnet) {
DEBUG_WIFI("[APConfig] local_ip: %s gateway: %s subnet: %s\n", local_ip.toString().c_str(), gateway.toString().c_str(), subnet.toString().c_str());
if(!WiFi.enableAP(true)) {
// enable AP failed
DEBUG_WIFI("[APConfig] enableAP failed!\n");
return false;
}
bool ret = true;
struct ip_info info;
info.ip.addr = static_cast<uint32_t>(local_ip);
info.gw.addr = static_cast<uint32_t>(gateway);
info.netmask.addr = static_cast<uint32_t>(subnet);
if(!wifi_softap_dhcps_stop()) {
DEBUG_WIFI("[APConfig] wifi_softap_dhcps_stop failed!\n");
}
if(!wifi_set_ip_info(SOFTAP_IF, &info)) {
DEBUG_WIFI("[APConfig] wifi_set_ip_info failed!\n");
ret = false;
}
struct dhcps_lease dhcp_lease;
IPAddress ip = local_ip;
ip[3] += 99;
dhcp_lease.start_ip.addr = static_cast<uint32_t>(ip);
DEBUG_WIFI("[APConfig] DHCP IP start: %s\n", ip.toString().c_str());
ip[3] += 100;
dhcp_lease.end_ip.addr = static_cast<uint32_t>(ip);
DEBUG_WIFI("[APConfig] DHCP IP end: %s\n", ip.toString().c_str());
if(!wifi_softap_set_dhcps_lease(&dhcp_lease)) {
DEBUG_WIFI("[APConfig] wifi_set_ip_info failed!\n");
ret = false;
}
// set lease time to 720min --> 12h
if(!wifi_softap_set_dhcps_lease_time(720)) {
DEBUG_WIFI("[APConfig] wifi_softap_set_dhcps_lease_time failed!\n");
ret = false;
}
uint8 mode = 1;
if(!wifi_softap_set_dhcps_offer_option(OFFER_ROUTER, &mode)) {
DEBUG_WIFI("[APConfig] wifi_softap_set_dhcps_offer_option failed!\n");
ret = false;
}
if(!wifi_softap_dhcps_start()) {
DEBUG_WIFI("[APConfig] wifi_softap_dhcps_start failed!\n");
ret = false;
}
// check config
if(wifi_get_ip_info(SOFTAP_IF, &info)) {
if(info.ip.addr == 0x00000000) {
DEBUG_WIFI("[APConfig] IP config Invalid?!\n");
ret = false;
} else if(local_ip != info.ip.addr) {
ip = info.ip.addr;
DEBUG_WIFI("[APConfig] IP config not set correct?! new IP: %s\n", ip.toString().c_str());
ret = false;
}
} else {
DEBUG_WIFI("[APConfig] wifi_get_ip_info failed!\n");
ret = false;
}
return ret;
}
