static void ICACHE_FLASH_ATTR wifi_check_ip(void *arg)
{
struct ip_info ipConfig;
os_timer_disarm(&WiFiLinker);
wifi_get_ip_info(STATION_IF, &ipConfig);
wifiStatus = wifi_station_get_connect_status();
if (wifiStatus == STATION_GOT_IP && ipConfig.ip.addr != 0)
{
os_timer_setfn(&WiFiLinker, (os_timer_func_t *)wifi_check_ip, NULL);
os_timer_arm(&WiFiLinker, 2000, 0);
}
else
{
if(wifi_station_get_connect_status() == STATION_WRONG_PASSWORD)
{
INFO("STATION_WRONG_PASSWORD\r\n");
wifi_station_connect();
}
else if(wifi_station_get_connect_status() == STATION_NO_AP_FOUND)
{
INFO("STATION_NO_AP_FOUND\r\n");
wifi_station_connect();
}
else if(wifi_station_get_connect_status() == STATION_CONNECT_FAIL)
{
INFO("STATION_CONNECT_FAIL\r\n");
wifi_station_connect();
}
else
{
INFO("STATION_IDLE\r\n");
}
os_timer_setfn(&WiFiLinker, (os_timer_func_t *)wifi_check_ip, NULL);
os_timer_arm(&WiFiLinker, 500, 0);
}
if(wifiStatus != lastWifiStatus){
lastWifiStatus = wifiStatus;
if(wifiCb)
wifiCb(wifiStatus);
}
}
void ICACHE_FLASH_ATTR
smartconfig_done(sc_status status, void *pdata)
{
switch(status) {
case SC_STATUS_WAIT:
printf("SC_STATUS_WAIT\n");
break;
case SC_STATUS_FIND_CHANNEL:
printf("SC_STATUS_FIND_CHANNEL\n");
break;
case SC_STATUS_GETTING_SSID_PSWD:
printf("SC_STATUS_GETTING_SSID_PSWD\n");
break;
case SC_STATUS_LINK:
printf("SC_STATUS_LINK\n");
struct station_config *sta_conf = pdata;
wifi_station_set_config(sta_conf);
wifi_station_disconnect();
wifi_station_connect();
break;
case SC_STATUS_LINK_OVER:
printf("SC_STATUS_LINK_OVER\n");
if (SC_Type == SC_TYPE_ESPTOUCH) {
uint8 phone_ip[4] = {0};
memcpy(phone_ip, (uint8*)pdata, 4);
printf("Phone ip: %d.%d.%d.%d\n",phone_ip[0],phone_ip[1],phone_ip[2],phone_ip[3]);
}
smartconfig_stop();
break;
}
}
ICACHE_FLASH_ATTR static v7_val_t Wifi_connect(struct v7 *v7, v7_val_t this_obj,
v7_val_t args) {
(void) v7;
(void) this_obj;
(void) args;
return v7_create_boolean(wifi_station_connect());
}
void ICACHE_FLASH_ATTR smartConfig_done(sc_status status, void *pdata) {
switch (status) {
case SC_STATUS_WAIT:
os_printf("SC_STATUS_WAIT\n");
break;
case SC_STATUS_FIND_CHANNEL:
os_printf("SC_STATUS_FIND_CHANNEL\n");
break;
case SC_STATUS_GETTING_SSID_PSWD:
os_printf("SC_STATUS_GETTING_SSID_PSWD\n");
break;
case SC_STATUS_LINK:
os_printf("SC_STATUS_LINK\n");
struct station_config *sta_conf = pdata;
wifi_station_set_config(sta_conf);
INFOP("Connected to %s (%s) %d", sta_conf->ssid, sta_conf->password, sta_conf->bssid_set);
strcpy(sysCfg.sta_ssid, sta_conf->ssid);
strcpy(sysCfg.sta_pwd, sta_conf->password);
wifi_station_disconnect();
wifi_station_connect();
break;
case SC_STATUS_LINK_OVER:
os_printf("SC_STATUS_LINK_OVER\n");
smartconfig_stop();
checkSmartConfig(SC_HAS_STOPPED);
sysCfg.sta_ssid;
break;
}
}
void ICACHE_FLASH_ATTR WIFI_Connect(WifiCallback cb)
{
struct station_config stationConf;
struct ip_info info;
INFO("WIFI_INIT\r\n");
os_timer_disarm(&WiFiLinker);
//wifi_set_opmode(STATION_MODE);
wifi_station_set_auto_connect(FALSE);
wifiCb = cb;
os_memset(&stationConf, 0, sizeof(struct station_config));
os_sprintf((char *)stationConf.ssid, "%s", sysCfg.sta_ssid);
os_sprintf((char *)stationConf.password, "%s", sysCfg.sta_pass);
wifi_get_ip_info(STATION_IF, &info);
char *dhcp = (char *)sysCfg.sta_mode;
char *ip, *mask, *gw;
if (!dhcp || os_strcmp(dhcp, "dhcp") != 0)
{
ip = (char *)sysCfg.sta_ip;
mask = (char *)sysCfg.sta_mask;
gw = (char *)sysCfg.sta_gw;
if (ip)
info.ip.addr = ipaddr_addr(ip);
if (mask)
info.netmask.addr = ipaddr_addr(mask);
if (gw)
info.gw.addr = ipaddr_addr(gw);
wifi_set_ip_info(STATION_IF, &info);
}
wifi_get_ip_info(SOFTAP_IF, &info);
ip = (char *)sysCfg.ap_ip;
mask = (char *)sysCfg.ap_mask;
gw = (char *)sysCfg.ap_gw;
if (ip)
info.ip.addr = ipaddr_addr(ip);
if (mask)
info.netmask.addr = ipaddr_addr(mask);
if (gw)
info.gw.addr = ipaddr_addr(gw);
if (wifi_get_opmode() != STATION_MODE)
wifi_set_ip_info(SOFTAP_IF, &info);
wifi_station_set_config(&stationConf);
os_timer_disarm(&WiFiLinker);
os_timer_setfn(&WiFiLinker, (os_timer_func_t *)wifi_check_ip, NULL);
os_timer_arm(&WiFiLinker, 1000, 0);
wifi_station_set_auto_connect(TRUE);
wifi_station_connect();
}
bool StationClass::setIP(IPAddress address, IPAddress netmask, IPAddress gateway)
{
if (System.isReady())
{
debugf("IP can be changed only in init() method");
return false;
}
wifi_station_disconnect();
// wifi_station_dhcpc_stop();
struct ip_info ipinfo;
wifi_get_ip_info(STATION_IF, &ipinfo);
ipinfo.ip = address;
ipinfo.netmask = netmask;
ipinfo.gw = gateway;
if (wifi_set_ip_info(STATION_IF, &ipinfo))
debugf("AP IP succesfully updated");
else
{
debugf("AP IP can't be updated");
enableDHCP(true);
}
wifi_station_connect();
//wifi_station_dhcpc_start();
return true;
}
bool ICACHE_FLASH_ATTR checkSmartConfig(enum SmartConfigAction action) {
static doingSmartConfig = false;
switch (action) {
case SC_CHECK:
break;
case SC_HAS_STOPPED:
os_printf("Finished smartConfig\n");
stopFlash();
doingSmartConfig = false;
MQTT_Connect(&mqttClient);
break;
case SC_TOGGLE:
if (doingSmartConfig) {
os_printf("Stop smartConfig\n");
stopFlash();
smartconfig_stop();
doingSmartConfig = false;
wifi_station_disconnect();
wifi_station_connect();
} else {
os_printf("Start smartConfig\n");
MQTT_Disconnect(&mqttClient);
mqttConnected = false;
startFlash(100, true);
doingSmartConfig = true;
smartconfig_start(smartConfig_done, true);
}
break;
}
return doingSmartConfig;
}
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;
}
int sj_wifi_setup_sta(const struct sys_config_wifi_sta *cfg) {
int res;
struct station_config sta_cfg;
/* If in AP-only mode, switch to station. If in STA or AP+STA, keep it. */
if (wifi_get_opmode() == SOFTAP_MODE) {
wifi_set_opmode_current(STATION_MODE);
}
wifi_station_disconnect();
memset(&sta_cfg, 0, sizeof(sta_cfg));
sta_cfg.bssid_set = 0;
strncpy((char *) &sta_cfg.ssid, cfg->ssid, 32);
strncpy((char *) &sta_cfg.password, cfg->pass, 64);
res = wifi_station_set_config_current(&sta_cfg);
if (!res) {
LOG(LL_ERROR, ("Failed to set station config"));
return 0;
}
if (cfg->ip != NULL && cfg->netmask != NULL) {
struct ip_info info;
memset(&info, 0, sizeof(info));
info.ip.addr = ipaddr_addr(cfg->ip);
info.netmask.addr = ipaddr_addr(cfg->netmask);
if (cfg->gw != NULL) info.gw.addr = ipaddr_addr(cfg->gw);
wifi_station_dhcpc_stop();
wifi_set_ip_info(STATION_IF, &info);
LOG(LL_INFO, ("WiFi STA IP config: %s %s %s", cfg->ip, cfg->netmask,
(cfg->gw ? cfg->ip : "")));
}
LOG(LL_INFO, ("WiFi STA: Joining %s", sta_cfg.ssid));
return wifi_station_connect();
}
void ICACHE_FLASH_ATTR user_init(void) {
uart_div_modify(0, UART_CLK_FREQ / BAUD);
wifi_set_opmode(STATION_MODE);
wifi_station_connect();
/*** I²C init ***/
i2c_master_gpio_init();
mpu9250_init();
ak8963_init();
os_delay_us(10000);
i2c_scanbus();
/*** LCD Init ***/
ssd1306_init(0);
ssd1306_text_small(10, 10, "Init...");
ssd1306_flip();
// ~Charge input
PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTCK_U, FUNC_GPIO13);
gpio_output_set(0, 0, 0, BIT13);
// Button inputs
buttons_init();
ak8963_calibration_start(10000, on_ak8963_calibration);
os_printf("Startup\r\n");
}
/**
* @brief Setup commad of join to wifi ap.
* @param id: commad id number
* @param pPara: AT input param
* @retval None
*/
static void ICACHE_FLASH_ATTR wifi_connect(char * ssid, char * password, char * bssid)
{
char temp[64];
struct station_config stationConf;
int8_t len;
connect_attempts++;
//wifi_station_get_config(&stationConf);
os_bzero(&stationConf, sizeof(struct station_config));
os_memcpy(&stationConf.ssid, ssid, os_strlen(ssid));
//os_memcpy(&stationConf.password, password, os_strlen(password));
os_memcpy(&stationConf.bssid, bssid, 6);
stationConf.bssid_set = 1;
wifi_station_disconnect();
os_printf("stationConf.ssid: -%s-\r\n", stationConf.ssid);
os_printf("stationConf.password: -%s-\r\n", stationConf.password);
ETS_UART_INTR_DISABLE();
wifi_station_set_config(&stationConf);
ETS_UART_INTR_ENABLE();
wifi_station_connect();
os_timer_disarm(&at_japDelayChack);
os_timer_setfn(&at_japDelayChack, (os_timer_func_t *)at_japChack, NULL);
os_timer_arm(&at_japDelayChack, 3000, 0);
}
ICACHE_FLASH_ATTR static v7_val_t Wifi_setup(struct v7 *v7, v7_val_t this_obj,
v7_val_t args) {
struct station_config stationConf;
v7_val_t ssidv = v7_array_get(v7, args, 0);
v7_val_t passv = v7_array_get(v7, args, 1);
const char *ssid, *pass;
size_t ssid_len, pass_len;
int res;
if (!v7_is_string(ssidv) || !v7_is_string(passv)) {
printf("ssid/pass are not strings\n");
return v7_create_undefined();
}
wifi_station_disconnect();
ssid = v7_to_string(v7, &ssidv, &ssid_len);
pass = v7_to_string(v7, &passv, &pass_len);
stationConf.bssid_set = 0;
strncpy((char *) &stationConf.ssid, ssid, 32);
strncpy((char *) &stationConf.password, pass, 64);
res = v7_create_boolean(wifi_station_set_config(&stationConf));
if (!res) {
printf("Failed to set station config\n");
return v7_create_boolean(0);
}
return v7_create_boolean(wifi_station_connect());
}
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
WIFI_Connect(uint8_t* ssid, uint8_t* pass, WifiCallback cb)
{
struct station_config stationConf;
INFO("WIFI_INIT\r\n");
wifi_set_opmode(STATIONAP_MODE);//
if(cb){
wifiCb = cb;
}else{
wifiCb = WIFI_ConnectCb;
}
os_memset(&stationConf, 0, sizeof(struct station_config));
os_sprintf(stationConf.ssid, "%s", ssid);
os_sprintf(stationConf.password, "%s", pass);
wifi_station_set_config(&stationConf);
os_timer_disarm(&WiFiLinker);
os_timer_setfn(&WiFiLinker, (os_timer_func_t *)WIFI_CheckIp, NULL);
os_timer_arm(&WiFiLinker, 1000, 0);
wifi_station_connect();
}
/**
* WPS callback
* @param status wps_cb_status
*/
void wifi_wps_status_cb(wps_cb_status status) {
DEBUGV("wps cb status: %d\r\n", status);
switch(status) {
case WPS_CB_ST_SUCCESS:
if(!wifi_wps_disable()) {
DEBUGV("wps disable failed\n");
}
wifi_station_connect();
break;
case WPS_CB_ST_FAILED:
DEBUGV("wps FAILED\n");
break;
case WPS_CB_ST_TIMEOUT:
DEBUGV("wps TIMEOUT\n");
break;
case WPS_CB_ST_WEP:
DEBUGV("wps WEP\n");
break;
case WPS_CB_ST_UNK:
DEBUGV("wps UNKNOWN\n");
if(!wifi_wps_disable()) {
DEBUGV("wps disable failed\n");
}
break;
}
// TODO user function to get status
esp_schedule(); // resume the beginWPSConfig function
}
// Lua: wifi.sta.config(ssid, password)
static int wifi_station_config( lua_State* L )
{
size_t sl, pl;
struct station_config sta_conf;
int i;
const char *ssid = luaL_checklstring( L, 1, &sl );
if (sl>32 || ssid == NULL)
return luaL_error( L, "ssid:<32" );
const char *password = luaL_checklstring( L, 2, &pl );
if (pl>64 || password == NULL)
return luaL_error( L, "pwd:<64" );
c_memset(sta_conf.ssid, 0, 32);
c_memset(sta_conf.password, 0, 64);
c_memset(sta_conf.bssid, 0, 6);
c_memcpy(sta_conf.ssid, ssid, sl);
c_memcpy(sta_conf.password, password, pl);
sta_conf.bssid_set = 0;
NODE_DBG(sta_conf.ssid);
NODE_DBG(" %d\n", sl);
NODE_DBG(sta_conf.password);
NODE_DBG(" %d\n", pl);
wifi_station_set_config(&sta_conf);
wifi_station_set_auto_connect(true);
wifi_station_disconnect();
wifi_station_connect();
// station_check_connect(0);
return 0;
}
int sj_wifi_setup_sta(const char *ssid, const char *pass) {
int res;
struct station_config stationConf;
/* Switch to station mode if not already in it. */
if (wifi_get_opmode() != 0x1) {
wifi_set_opmode_current(0x1);
}
wifi_station_disconnect();
stationConf.bssid_set = 0;
strncpy((char *) &stationConf.ssid, ssid, 32);
strncpy((char *) &stationConf.password, pass, 64);
res = wifi_station_set_config_current(&stationConf);
if (!res) {
fprintf(stderr, "Failed to set station config\n");
return 0;
}
res = wifi_station_connect();
if (res) {
wifi_setting_up = 1;
}
return 1;
}
void wifiConnectTimerCb(void *arg)
{
/* Do we have an IP already? */
int status = wifi_station_get_connect_status();
if( status != STATION_GOT_IP)
{
/* No, then connect to the WiFi station */
wifi_station_disconnect();
os_printf("Trying to connect to %s\n", stconf.ssid );
/* connect to a WiFi station */
wifi_station_connect();
}
else
{
/* yes, then disable the timer WiFi setup timer*/
os_timer_disarm(&wifi_setup_timer);
/* enable POST timer in periodic mode */
os_timer_disarm((ETSTimer*)&post_timer);
os_timer_setfn((ETSTimer*)&post_timer, (os_timer_func_t *) startHttpRequestTimerCallback, NULL);
os_timer_arm((ETSTimer*)&post_timer, 10000, 0); // thingspeak needs minimum 15 sec delay between updates
}
}
void ICACHE_FLASH_ATTR WIFI_999_Connect(uint8_t* ssid, uint8_t* pass, WifiCallback cb)
{
struct station_config stationConf;
INFO("WIFI_INIT\r\n");
wifi_set_opmode(STATION_MODE);
wifi_station_set_auto_connect(FALSE);
wifiCb = cb;
os_memset(&stationConf, 0, sizeof(struct station_config));
os_sprintf(stationConf.ssid, "%s", ssid);
os_sprintf(stationConf.password, "%s", pass);
wifi_station_set_config(&stationConf);
os_timer_disarm(&WiFiLinker);
os_timer_setfn(&WiFiLinker, (os_timer_func_t *)wifi_check_ip, NULL);
os_timer_arm(&WiFiLinker, 1000, 0);
wifi_station_set_auto_connect(TRUE);
/*
* Reconnect is only in SDK 1.2 and newer. :-(
*
* wifi_station_set_reconnect_policy(TRUE); // After a hint from Pete Scargill.
*/
wifi_station_connect();
}
/**
* will force a disconnect an then start reconnecting to AP
* @return ok
*/
bool ESP8266WiFiSTAClass::reconnect() {
if((WiFi.getMode() & WIFI_STA) != 0) {
if(wifi_station_disconnect()) {
return wifi_station_connect();
}
}
return false;
}
void ESP8266WiFiClass::_smartConfigDone(void* result)
{
station_config* sta_conf = reinterpret_cast<station_config*>(result);
wifi_station_set_config(sta_conf);
wifi_station_disconnect();
wifi_station_connect();
}
void ICACHE_FLASH_ATTR
smartconfig_done(void *data)
{
struct station_config *sta_conf = data;
wifi_station_set_config(sta_conf);
wifi_station_disconnect();
wifi_station_connect();
}
LOCAL void initDone() {
wifi_set_opmode_current(STATION_MODE);
struct station_config stationConfig;
strncpy(stationConfig.ssid, "ur_ssid", 32);
strncpy(stationConfig.password, "ur_password", 64);
wifi_station_set_config(&stationConfig);
wifi_station_connect();
}
// setMode must be called with Client or ClientAndAccessPoint
void STC_FLASHMEM WiFi::configureClient(char const *SSID, char const *securityKey) {
station_config config = {0};
f_strcpy((char *)config.ssid, SSID);
f_strcpy((char *)config.password, securityKey);
Critical critical;
wifi_station_disconnect();
wifi_station_set_config(&config);
wifi_station_connect();
}
int ESP8266WiFiClass::begin()
{
ETS_UART_INTR_DISABLE();
wifi_station_connect();
ETS_UART_INTR_ENABLE();
if(!_useStaticIp)
wifi_station_dhcpc_start();
return status();
}
bool StationClass::config(String ssid, String password, bool autoConnectOnStartup /* = true*/)
{
station_config config = {0};
if (ssid.length() >= sizeof(config.ssid)) return false;
if (password.length() >= sizeof(config.password)) return false;
bool enabled = isEnabled();
bool dhcp = isEnabledDHCP();
enable(true); // Power on for configuration
wifi_station_disconnect();
if (dhcp) enableDHCP(false);
bool cfgreaded = wifi_station_get_config(&config);
if (!cfgreaded) debugf("Can't read station configuration!");
memset(config.ssid, 0, sizeof(config.ssid));
memset(config.password, 0, sizeof(config.password));
config.bssid_set = false;
strcpy((char*)config.ssid, ssid.c_str());
strcpy((char*)config.password, password.c_str());
noInterrupts();
if(!wifi_station_set_config(&config))
{
interrupts();
debugf("Can't set station configuration!");
wifi_station_connect();
enableDHCP(dhcp);
enable(enabled);
return false;
}
debugf("Station configuration was updated to: %s", ssid.c_str());
interrupts();
wifi_station_connect();
enableDHCP(dhcp);
enable(enabled);
wifi_station_set_auto_connect(autoConnectOnStartup);
return true;
}
// Function that will run after initialization is done, contains information to connect to the WIFI and SNTP settings
LOCAL ICACHE_FLASH_ATTR void initDone()
{
wifi_set_opmode_current(STATION_MODE);
struct station_config stationConfig;
strncpy(stationConfig.ssid, ur_ssid, 32);
strncpy(stationConfig.password, ur_ssid_password, 64);
wifi_station_set_config(&stationConfig);
wifi_station_connect();
my_sntp_init(); // This will setup the sntp and it seems to take some time.
}
// Callback actually doing reassociation
static void ICACHE_FLASH_ATTR reassTimerCb(void *arg) {
os_printf("Wifi changing association\n");
wifi_station_disconnect();
wifi_station_set_config(&stconf);
wifi_station_connect();
// Schedule check
os_timer_disarm(&resetTimer);
os_timer_setfn(&resetTimer, resetTimerCb, NULL);
os_timer_arm(&resetTimer, RESET_TIMEOUT, 0);
}
LOCAL void initDone() {
os_printf("Initialized! \n");
struct station_config config;
strncpy(config.ssid, SSID, 32);
strncpy(config.password, SSID_PASSWORD, 64);
wifi_set_opmode_current(STATION_MODE);
wifi_station_set_config_current(&config);
wifi_station_connect();
}
/**
* wake up WiFi Modem
* @return ok
*/
bool ESP8266WiFiGenericClass::forceSleepWake() {
wifi_fpm_do_wakeup();
wifi_fpm_close();
// restore last mode
if(mode(_forceSleepLastMode)) {
if((_forceSleepLastMode & WIFI_STA) != 0){
wifi_station_connect();
}
return true;
}
return false;
}
