void setup_wifi_st_mode(void) { // wifi_set_opmode((wifi_get_opmode()|STATION_MODE)&STATIONAP_MODE); wifi_set_opmode(wifi_get_opmode() | STATION_MODE); struct station_config stconfig; wifi_station_disconnect(); wifi_station_dhcpc_stop(); if(wifi_station_get_config(&stconfig)) { memset(stconfig.ssid, 0, sizeof(stconfig.ssid)); memset(stconfig.password, 0, sizeof(stconfig.password)); os_sprintf(stconfig.ssid, "%s", sysCfg.sta_ssid); os_sprintf(stconfig.password, "%s", sysCfg.sta_pwd); if(!wifi_station_set_config(&stconfig)) { #ifdef PLATFORM_DEBUG INFO("ESP8266 not set station config!\r\n"); #endif } } wifi_station_connect(); wifi_station_dhcpc_start(); wifi_station_set_auto_connect(1); #ifdef PLATFORM_DEBUG INFO("ESP8266 in STA mode configured.\r\n"); #endif }
void ICACHE_FLASH_ATTR station_connect_status_check_timercb(void* _timer) { ETSTimer* timer = (ETSTimer*)_timer; os_printf("wifi_station_dhcpc_status: [%d]\n", wifi_station_dhcpc_status()); if(wifi_station_dhcpc_status() == DHCP_STOPPED && !wifi_station_dhcpc_start()) { os_printf("wifi_station_dhcpc_start error\n"); } os_printf("wifi station connect status: [%d]\n", wifi_station_get_connect_status()); if(wifi_station_get_connect_status() == STATION_GOT_IP && client_status != STATUS_CONNECTED) { os_printf("Connected to ROUTER, connecting to cloud\n"); connect_to_cloud(); client_status = STATUS_CONNECTING; } //连接成功后停止定时器 if(client_status == STATUS_CONNECTED) { os_timer_disarm(timer); } //如果系统模式非station模式,则停止 if(wifi_get_opmode() != STATION_MODE) { os_timer_disarm(timer); } }
void ICACHE_FLASH_ATTR setup_station(char ssid[], char password[]) { // Stop previous connection wifi_station_disconnect(); wifi_station_dhcpc_stop(); // Create config struct struct station_config staConfig; wifi_station_get_config(&staConfig); // Set SSID in struct os_memset(staConfig.ssid, 0, sizeof(staConfig.ssid)); os_memcpy(staConfig.ssid, ssid, os_strlen(ssid)); // Set Password in struct os_memset(staConfig.password, 0, sizeof(staConfig.password)); os_memcpy(staConfig.password, password, os_strlen(password)); // Use config struct wifi_station_set_config(&staConfig); //print("Set Station info"); wifi_station_connect(); wifi_station_dhcpc_start(); wifi_station_set_auto_connect(1); connection_status = CONNECTION_CONNECTING; }
static void ICACHE_FLASH_ATTR client_connection_setup(void) { wifi_set_opmode(STATIONAP_MODE); wifi_station_set_reconnect_policy(true); wifi_station_set_config(&s_station_config); wifi_station_dhcpc_start(); }
// applies only to ClientNetwork void STC_FLASHMEM IP::configureDHCP(WiFi::Network network) { if (network == WiFi::ClientNetwork) { Critical critical; wifi_station_dhcpc_start(); } }
int ESP8266WiFiClass::begin() { ETS_UART_INTR_DISABLE(); wifi_station_connect(); ETS_UART_INTR_ENABLE(); if(!_useStaticIp) wifi_station_dhcpc_start(); return status(); }
int ESP8266WiFiClass::begin(const char* ssid, const char *passphrase, int32_t channel, uint8_t bssid[6]){ _useClientMode = true; if(_useApMode) { // turn on AP+STA mode mode(WIFI_AP_STA); } else { // turn on STA mode mode(WIFI_STA); } if(!ssid || *ssid == 0x00 || strlen(ssid) > 31) { // fail SSID to long or missing! return WL_CONNECT_FAILED; } if(passphrase && strlen(passphrase) > 63) { // fail passphrase to long! return WL_CONNECT_FAILED; } struct station_config conf; strcpy(reinterpret_cast<char*>(conf.ssid), ssid); if (passphrase) { strcpy(reinterpret_cast<char*>(conf.password), passphrase); } else { *conf.password = 0; } if (bssid) { conf.bssid_set = 1; memcpy((void *) &conf.bssid[0], (void *) bssid, 6); } else { conf.bssid_set = 0; } ETS_UART_INTR_DISABLE(); wifi_station_set_config(&conf); wifi_station_connect(); ETS_UART_INTR_ENABLE(); if(channel > 0 && channel <= 13) { wifi_set_channel(channel); } if(!_useStaticIp) wifi_station_dhcpc_start(); return status(); }
/** * Use to connect to SDK config. * @return wl_status_t */ wl_status_t ESP31BWiFiSTAClass::begin() { if(!WiFi.enableSTA(true)) { // enable STA failed return WL_CONNECT_FAILED; } wifi_station_connect(); if(!_useStaticIp) { wifi_station_dhcpc_start(); } return status(); }
/** * Use to connect to SDK config. * @return wl_status_t */ wl_status_t ESP8266WiFiSTAClass::begin() { if(!WiFi.enableSTA(true)) { // enable STA failed return WL_CONNECT_FAILED; } ETS_UART_INTR_DISABLE(); wifi_station_connect(); ETS_UART_INTR_ENABLE(); if(!_useStaticIp) { wifi_station_dhcpc_start(); } return status(); }
//Init function void ICACHE_FLASH_ATTR user_init() { char ssid[32] = "MY_SSID"; char password[64] = "MY_PASS"; struct station_config stationConf; os_printf("Init a\n\r"); uart_init(BIT_RATE_115200, BIT_RATE_115200); gpio16_output_conf(); gpio16_output_set(0); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13); PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTMS_U, FUNC_GPIO14); gpio_output_set(0, BIT12|BIT13|BIT14, BIT12|BIT13|BIT14, 0); //Set station mode //wifi_set_macaddr(uint8 if_index, uint8 *macaddr) wifi_set_opmode_current( STATION_MODE ); os_memcpy(&stationConf.ssid, ssid, 32); os_memcpy(&stationConf.password, password, 64); stationConf.bssid_set = 0; wifi_station_set_config_current(&stationConf); // wifi_status_led_install (16, uint32 gpio_name, FUNC_GPIO16) os_printf("Init Ok! %d\n\r", wifi_station_get_connect_status()); wifi_station_set_auto_connect(1); wifi_station_connect(); wifi_station_dhcpc_start(); user_server_init(8888); //Start os task system_os_task(loop, user_procTaskPrio,user_procTaskQueue, user_procTaskQueueLen); // system_os_post(user_procTaskPrio, 0, 0 ); }
// ---------------------------------------------------------------------------- // Set up and connect for STA Mode // ---------------------------------------------------------------------------- void connect_st_mode(void) { struct station_config stconfig; wifi_set_opmode(STATION_MODE); wifi_station_disconnect(); // just in case wifi_station_dhcpc_stop(); if(wifi_station_get_config(&stconfig)) { os_memset(stconfig.ssid, 0, sizeof(stconfig.ssid)); os_memset(stconfig.password, 0, sizeof(stconfig.password)); os_sprintf((char *)stconfig.ssid, "%s", WIFI_CLIENTSSID); os_sprintf((char *)stconfig.password, "%s", WIFI_CLIENTPASSWORD); if(!wifi_station_set_config(&stconfig)) { os_printf("ESP8266 not set station config!\n"); } } wifi_station_connect(); wifi_station_dhcpc_start(); os_printf("ESP8266 in STA mode configured.\n"); }
LOCAL void ICACHE_FLASH_ATTR setup_wifi_st_mode(void) { wifi_set_opmode(STATION_MODE); struct station_config stconfig; wifi_station_disconnect(); wifi_station_dhcpc_stop(); if(wifi_station_get_config(&stconfig)) { os_memcpy(&stconfig.ssid, WIFI_CLIENTSSID, sizeof(WIFI_CLIENTSSID)); os_memcpy(&stconfig.password, WIFI_CLIENTPASSWORD, sizeof(WIFI_CLIENTPASSWORD)); wifi_station_set_config(&stconfig); ets_uart_printf("SSID: %s\n",stconfig.ssid); stringDraw(2, 1, (char*)stconfig.ssid); } wifi_station_connect(); wifi_station_dhcpc_start(); wifi_station_set_auto_connect(1); ets_uart_printf("STA mode\n"); }
void ICACHE_FLASH_ATTR reset_wifi_configs(){ DPRINT("Resetting WiFi config..."); wifi_set_opmode(STATION_MODE); struct station_config stconfig; wifi_station_disconnect(); wifi_station_dhcpc_stop(); if(wifi_station_get_config(&stconfig)) { DPRINT("Setting config..."); os_memset(stconfig.ssid, 0, sizeof(stconfig.ssid)); os_memset(stconfig.password, 0, sizeof(stconfig.password)); os_sprintf((char*)stconfig.ssid, "%s", WIFI_CLIENTSSID); os_sprintf((char*)stconfig.password, "%s", WIFI_CLIENTPASS); Config::I().wifi_configured(wifi_station_set_config(&stconfig)); DPRINT("Config setting %s",Config::I().wifi_configured()?"success":"failed"); } wifi_station_connect(); wifi_station_dhcpc_start(); wifi_station_set_auto_connect(1); DPRINT("ESP8266 in STA mode configured."); }
// configure Wifi, specifically DHCP vs static IP address based on flash config void ICACHE_FLASH_ATTR configWifiIP() { if (flashConfig.staticip == 0) { // let's DHCP! wifi_station_set_hostname(flashConfig.hostname); if (wifi_station_dhcpc_status() == DHCP_STARTED) wifi_station_dhcpc_stop(); wifi_station_dhcpc_start(); DBG("Wifi uses DHCP, hostname=%s\n", flashConfig.hostname); } else { // no DHCP, we got static network config! wifi_station_dhcpc_stop(); struct ip_info ipi; ipi.ip.addr = flashConfig.staticip; ipi.netmask.addr = flashConfig.netmask; ipi.gw.addr = flashConfig.gateway; wifi_set_ip_info(0, &ipi); DBG("Wifi uses static IP %d.%d.%d.%d\n", IP2STR(&ipi.ip.addr)); } #ifdef DEBUGIP debugIP(); #endif }
LOCAL void ICACHE_FLASH_ATTR setup_wifi_st_mode(void) { wifi_set_opmode(STATION_MODE); struct station_config stconfig; wifi_station_disconnect(); wifi_station_dhcpc_stop(); if(wifi_station_get_config(&stconfig)) { os_memset(stconfig.ssid, 0, sizeof(stconfig.ssid)); os_memset(stconfig.password, 0, sizeof(stconfig.password)); os_sprintf(stconfig.ssid, "%s", WIFI_CLIENTSSID); os_sprintf(stconfig.password, "%s", WIFI_CLIENTPASSWORD); if(!wifi_station_set_config(&stconfig)) { DHT22_DEBUG("ESP8266 not set station config!\r\n"); } } wifi_station_connect(); wifi_station_dhcpc_start(); wifi_station_set_auto_connect(1); DHT22_DEBUG("ESP8266 in STA mode configured.\r\n"); }
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 ICACHE_FLASH_ATTR setup_wifi_st_mode(void) { wifi_set_opmode(STATION_MODE); struct station_config stconfig; wifi_station_disconnect(); wifi_station_dhcpc_stop(); if(wifi_station_get_config(&stconfig)) { os_memset(stconfig.ssid, 0, sizeof(stconfig.ssid)); os_memset(stconfig.password, 0, sizeof(stconfig.password)); os_sprintf(stconfig.ssid, "%s", configs.hwSettings.wifi.SSID); os_sprintf(stconfig.password, "%s", configs.hwSettings.wifi.SSID_PASS); ets_uart_printf("\r\nSTA SSID:%s", configs.hwSettings.wifi.SSID); ets_uart_printf("\r\nSTA SSIDPAS:%s\r\n", configs.hwSettings.wifi.SSID_PASS); if(!wifi_station_set_config(&stconfig)) { ets_uart_printf("ESP8266 not set station config!\r\n"); } } wifi_station_connect(); wifi_station_dhcpc_start(); wifi_station_set_auto_connect(1); ets_uart_printf("ESP8266 in STA mode configured.\r\n"); }
/** * Start Wifi connection * if passphrase is set the most secure supported mode will be automatically selected * @param ssid const char* Pointer to the SSID string. * @param passphrase const char * Optional. Passphrase. Valid characters in a passphrase must be between ASCII 32-126 (decimal). * @param bssid uint8_t[6] Optional. BSSID / MAC of AP * @param channel Optional. Channel of AP * @param connect Optional. call connect * @return */ wl_status_t ESP8266WiFiSTAClass::begin(const char* ssid, const char *passphrase, int32_t channel, const uint8_t* bssid, bool connect) { if(!WiFi.enableSTA(true)) { // enable STA failed return WL_CONNECT_FAILED; } if(!ssid || *ssid == 0x00 || strlen(ssid) > 32) { // fail SSID too long or missing! return WL_CONNECT_FAILED; } int passphraseLen = passphrase == nullptr ? 0 : strlen(passphrase); if(passphraseLen > 64) { // fail passphrase too long! return WL_CONNECT_FAILED; } struct station_config conf; conf.threshold.authmode = (passphraseLen == 0) ? AUTH_OPEN : (_useInsecureWEP ? AUTH_WEP : AUTH_WPA_PSK); if(strlen(ssid) == 32) memcpy(reinterpret_cast<char*>(conf.ssid), ssid, 32); //copied in without null term else strcpy(reinterpret_cast<char*>(conf.ssid), ssid); if(passphrase) { if (passphraseLen == 64) // it's not a passphrase, is the PSK, which is copied into conf.password without null term memcpy(reinterpret_cast<char*>(conf.password), passphrase, 64); else strcpy(reinterpret_cast<char*>(conf.password), passphrase); } else { *conf.password = 0; } conf.threshold.rssi = -127; conf.open_and_wep_mode_disable = !(_useInsecureWEP || *conf.password == 0); if(bssid) { conf.bssid_set = 1; memcpy((void *) &conf.bssid[0], (void *) bssid, 6); } else { conf.bssid_set = 0; } struct station_config conf_compare; if(WiFi._persistent){ wifi_station_get_config_default(&conf_compare); } else { wifi_station_get_config(&conf_compare); } if(sta_config_equal(conf_compare, conf)) { DEBUGV("sta config unchanged"); } else { ETS_UART_INTR_DISABLE(); if(WiFi._persistent) { wifi_station_set_config(&conf); } else { wifi_station_set_config_current(&conf); } ETS_UART_INTR_ENABLE(); } ETS_UART_INTR_DISABLE(); if(connect) { wifi_station_connect(); } ETS_UART_INTR_ENABLE(); if(channel > 0 && channel <= 13) { wifi_set_channel(channel); } if(!_useStaticIp) { wifi_station_dhcpc_start(); } return status(); }
/** * Start Wifi connection * if passphrase is set the most secure supported mode will be automatically selected * @param ssid const char* Pointer to the SSID string. * @param passphrase const char * Optional. Passphrase. Valid characters in a passphrase must be between ASCII 32-126 (decimal). * @param bssid uint8_t[6] Optional. BSSID / MAC of AP * @param channel Optional. Channel of AP * @param connect Optional. call connect * @return */ wl_status_t ESP8266WiFiSTAClass::begin(const char* ssid, const char *passphrase, int32_t channel, const uint8_t* bssid, bool connect) { if(!WiFi.enableSTA(true)) { // enable STA failed return WL_CONNECT_FAILED; } if(!ssid || *ssid == 0x00 || strlen(ssid) > 31) { // fail SSID too long or missing! return WL_CONNECT_FAILED; } if(passphrase && strlen(passphrase) > 64) { // fail passphrase too long! return WL_CONNECT_FAILED; } struct station_config conf; strcpy(reinterpret_cast<char*>(conf.ssid), ssid); if(passphrase) { if (strlen(passphrase) == 64) // it's not a passphrase, is the PSK, which is copied into conf.password without null term memcpy(reinterpret_cast<char*>(conf.password), passphrase, 64); else strcpy(reinterpret_cast<char*>(conf.password), passphrase); } else { *conf.password = 0; } conf.threshold.rssi = -127; // TODO(#909): set authmode to AUTH_WPA_PSK if passphrase is provided conf.threshold.authmode = AUTH_OPEN; if(bssid) { conf.bssid_set = 1; memcpy((void *) &conf.bssid[0], (void *) bssid, 6); } else { conf.bssid_set = 0; } struct station_config conf_compare; if(WiFi._persistent){ wifi_station_get_config_default(&conf_compare); } else { wifi_station_get_config(&conf_compare); } if(sta_config_equal(conf_compare, conf)) { DEBUGV("sta config unchanged"); } else { ETS_UART_INTR_DISABLE(); if(WiFi._persistent) { wifi_station_set_config(&conf); } else { wifi_station_set_config_current(&conf); } ETS_UART_INTR_ENABLE(); } ETS_UART_INTR_DISABLE(); if(connect) { wifi_station_connect(); } ETS_UART_INTR_ENABLE(); if(channel > 0 && channel <= 13) { wifi_set_channel(channel); } if(!_useStaticIp) { wifi_station_dhcpc_start(); } return status(); }
/****************************************************************************** * 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); }
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(); } }
/** * Start Wifi connection * if passphrase is set the most secure supported mode will be automatically selected * @param ssid const char* Pointer to the SSID string. * @param passphrase const char * Optional. Passphrase. Valid characters in a passphrase must be between ASCII 32-126 (decimal). * @param bssid uint8_t[6] Optional. BSSID / MAC of AP * @param channel Optional. Channel of AP * @param connect Optional. call connect * @return */ wl_status_t ESP8266WiFiSTAClass::begin(const char* ssid, const char *passphrase, int32_t channel, const uint8_t* bssid, bool connect) { if(!WiFi.enableSTA(true)) { // enable STA failed return WL_CONNECT_FAILED; } if(!ssid || *ssid == 0x00 || strlen(ssid) > 31) { // fail SSID too long or missing! return WL_CONNECT_FAILED; } if(passphrase && strlen(passphrase) > 63) { // fail passphrase too long! return WL_CONNECT_FAILED; } struct station_config conf; strcpy(reinterpret_cast<char*>(conf.ssid), ssid); if(passphrase) { strcpy(reinterpret_cast<char*>(conf.password), passphrase); } else { *conf.password = 0; } if(bssid) { conf.bssid_set = 1; memcpy((void *) &conf.bssid[0], (void *) bssid, 6); } else { conf.bssid_set = 0; } struct station_config current_conf; wifi_station_get_config(¤t_conf); if(sta_config_equal(current_conf, conf)) { DEBUGV("sta config unchanged"); return status(); } ETS_UART_INTR_DISABLE(); if(WiFi._persistent) { wifi_station_set_config(&conf); } else { wifi_station_set_config_current(&conf); } if(connect) { wifi_station_connect(); } ETS_UART_INTR_ENABLE(); if(channel > 0 && channel <= 13) { wifi_set_channel(channel); } if(!_useStaticIp) { wifi_station_dhcpc_start(); } return status(); }
/** * Change IP configuration settings disabling the dhcp client * @param local_ip Static ip configuration * @param gateway Static gateway configuration * @param subnet Static Subnet mask * @param dns1 Static DNS server 1 * @param dns2 Static DNS server 2 */ bool ESP8266WiFiSTAClass::config(IPAddress local_ip, IPAddress arg1, IPAddress arg2, IPAddress arg3, IPAddress dns2) { if(!WiFi.enableSTA(true)) { return false; } //ESP argument order is: ip, gateway, subnet, dns1 //Arduino arg order is: ip, dns, gateway, subnet. //first, check whether dhcp should be used, which is when ip == 0 && gateway == 0 && subnet == 0. bool espOrderUseDHCP = (local_ip == 0U && arg1 == 0U && arg2 == 0U); bool arduinoOrderUseDHCP = (local_ip == 0U && arg2 == 0U && arg3 == 0U); if (espOrderUseDHCP || arduinoOrderUseDHCP) { _useStaticIp = false; wifi_station_dhcpc_start(); return true; } //To allow compatibility, check first octet of 3rd arg. If 255, interpret as ESP order, otherwise Arduino order. IPAddress gateway = arg1; IPAddress subnet = arg2; IPAddress dns1 = arg3; if(subnet[0] != 255) { //octet is not 255 => interpret as Arduino order gateway = arg2; subnet = arg3[0] == 0 ? IPAddress(255,255,255,0) : arg3; //arg order is arduino and 4th arg not given => assign it arduino default dns1 = arg1; } // check whether all is IPv4 (or gateway not set) if (!(local_ip.isV4() && subnet.isV4() && (!gateway.isSet() || gateway.isV4()))) { return false; } //ip and gateway must be in the same subnet if((local_ip.v4() & subnet.v4()) != (gateway.v4() & subnet.v4())) { return false; } struct ip_info info; info.ip.addr = local_ip.v4(); info.gw.addr = gateway.v4(); info.netmask.addr = subnet.v4(); wifi_station_dhcpc_stop(); if(wifi_set_ip_info(STATION_IF, &info)) { _useStaticIp = true; } else { return false; } if(dns1.isSet()) { // Set DNS1-Server dns_setserver(0, dns1); } if(dns2.isSet()) { // Set DNS2-Server dns_setserver(1, dns2); } return true; }
void ICACHE_FLASH_ATTR settings_apply( userSettings_t *settings ) { //Description if (!((settings->magic==0x42)&&(settings->version==SETTINGS_VERSION))) { os_printf("<ERROR: CAN NOT APPLY CORRUPT SETTINGS!>\n\r"); return; } if (settings->connection_successful) { ap_stop(); } else { ap_start(); } //Device information wifi_station_set_hostname(settings->name); //Network struct station_config stationConf; wifi_station_get_config( &stationConf ); stationConf.bssid_set = 0; os_memcpy( &stationConf.ssid, settings->ssid, 32 ); os_memcpy( &stationConf.password, settings->password, 64 ); wifi_station_set_config_current( &stationConf ); os_printf("########################## Wifi config set to SSID '%s' and PASSWORD '%s'.\n\r", settings->ssid, settings->password); if (settings->enable_dhcp) { wifi_station_dhcpc_start(); } else { wifi_station_dhcpc_stop(); struct ip_info dhcpc_ip_info; IP4_ADDR(&dhcpc_ip_info.ip, settings->static_ip_1, settings->static_ip_2, settings->static_ip_3, settings->static_ip_4); IP4_ADDR(&dhcpc_ip_info.gw, settings->static_gateway_1, settings->static_gateway_2, settings->static_gateway_3, settings->static_gateway_4); IP4_ADDR(&dhcpc_ip_info.netmask, settings->static_netmask_1, settings->static_netmask_2, settings->static_netmask_3, settings->static_netmask_4); wifi_set_ip_info(STATION_IF, &dhcpc_ip_info); } wifi_station_disconnect(); //MDNS if (settings->enable_mdns) { /*wifi_set_broadcast_if(STATIONAP_MODE); struct mdns_info *info = (struct mdns_info *) os_zalloc(sizeof(struct mdns_info)); info->host_name = settings->mdns_hostname; info->ipAddr = station_ipconfig.ip.addr; //ESP8266 station IP info->server_name = "FirmwaRe MDNS"; info->server_port = 80; info->txt_data[0] = “version = now”; info->txt_data[1] = “user1 = data1”; info->txt_data[2] = “user2 = data2”; espconn_mdns_init(info);*/ } //NTP if (settings->enable_ntp) { //settings->ntpserver //settings->timezone //settings->enable_summertime } //Security /* settings->password; */ //Digital outputs #if OUTPUT1>-1 if (settings->bootstate&1){ board_setOutput(OUTPUT1, true); } else { board_setOutput(OUTPUT1, false); } #endif #if OUTPUT2>-1 if (settings->bootstate&2) { board_setOutput(OUTPUT2, true); } else { board_setOutput(OUTPUT2, false); } #endif #if OUTPUT3>-1 if (settings->bootstate&4) { board_setOutput(OUTPUT3, true); } else { board_setOutput(OUTPUT3, false); } #endif #if OUTPUT4>-1 if (settings->bootstate&8) { board_setOutput(OUTPUT4, true); } else { board_setOutput(OUTPUT4, false); } #endif #if OUTPUT5>-1 if (settings->bootstate&16) { board_setOutput(OUTPUT5, true); } else { board_setOutput(OUTPUT5, false); } #endif #if OUTPUT6>-1 if (settings->bootstate&32) { board_setOutput(OUTPUT6, true); } else { board_setOutput(OUTPUT6, false); } #endif #if OUTPUT7>-1 if (settings->bootstate&64) { board_setOutput(OUTPUT7, true); } else { board_setOutput(OUTPUT7, false); } #endif #if OUTPUT8>-1 if (settings->bootstate&128) { board_setOutput(OUTPUT8, true); } else { board_setOutput(OUTPUT8, false); } #endif //ESPLight setPWM(settings->bootstate_R, settings->bootstate_G, settings->bootstate_B); //settings->ledstrip_type; //settings->ledstrip_length; //PKA /* settings->pka_wb settings->pka_wb_time */ }