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 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;
}
}
/**
* @brief Transparent data through ip.
* @param arg: no used
* @retval None
*/
void ICACHE_FLASH_ATTR
at_japChack(void *arg)
{
static uint8_t chackTime = 0;
uint8_t japState;
os_timer_disarm(&at_japDelayChack);
chackTime++;
japState = wifi_station_get_connect_status();
if(japState == STATION_GOT_IP)
{
chackTime = 0;
at_backOk;
specialAtState = TRUE;
at_state = at_statIdle;
return;
}
else if(chackTime >= 7)
{
wifi_station_disconnect();
chackTime = 0;
uart0_sendStr("\r\nFAIL\r\n");
specialAtState = TRUE;
at_state = at_statIdle;
return;
}
os_timer_arm(&at_japDelayChack, 2000, 0);
}
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 tcp_disconnected( void *arg )
{
struct espconn *conn = arg;
os_printf( "%s\n", __FUNCTION__ );
wifi_station_disconnect();
}
/******************************************************************************
* FunctionName : esptouch_FailCb
* Description : esp-touch fail callback
*******************************************************************************/
void ICACHE_FLASH_ATTR
esptouch_FailCb(void* data)
{
wifi_station_disconnect();
smartconfig_stop();
//wifi_set_opmode(STATIONAP_MODE);
SC_INFO("ESP-TOUCH FAIL \r\n");
os_timer_disarm(&esptouch_tout_t);
#if LIGHT_DEVICE
light_shadeStart(HINT_RED,2000,0,1,NULL);
#endif
SC_INFO("ENABLE LIGHT ACTION(ESP-NOW)");
os_printf("debug: channel:%d\r\n",wifi_get_channel());
#if ESP_NOW_SUPPORT
light_EspnowInit();
#endif
#if ESP_MESH_SUPPORT
SC_INFO("RESTART MESH NOW...\r\n");
#if LIGHT_DEVICE
light_hint_stop(HINT_RED);
#endif
//user_MeshStart();
wifi_RestartMeshScan(5000);
#else
SC_INFO("ESP-TOUCH FAIL, OPEN WEBSERVER NOW");
mesh_SetSoftap();//check
#endif
}
static int do_wifi(const struct sys_config *cfg) {
int result = 1;
int gpio = cfg->wifi.ap.trigger_on_gpio;
int trigger_ap = 0;
wifi_set_opmode_current(STATION_MODE);
wifi_station_set_auto_connect(0);
wifi_station_disconnect();
if (gpio >= 0) {
sj_gpio_set_mode(gpio, GPIO_MODE_INPUT, GPIO_PULL_PULLUP);
trigger_ap = sj_gpio_read(gpio) == GPIO_LEVEL_HIGH;
}
if (!trigger_ap && cfg->wifi.ap.mode == 2 && cfg->wifi.sta.enable) {
wifi_set_opmode_current(STATIONAP_MODE);
result =
sj_wifi_setup_ap(&cfg->wifi.ap) ? sj_wifi_setup_sta(&cfg->wifi.sta) : 0;
} else if (!trigger_ap && cfg->wifi.sta.enable) {
wifi_set_opmode_current(STATION_MODE);
result = sj_wifi_setup_sta(&cfg->wifi.sta);
} else if (trigger_ap || cfg->wifi.ap.mode > 0) {
wifi_set_opmode_current(SOFTAP_MODE);
result = sj_wifi_setup_ap(&cfg->wifi.ap);
} else {
LOG(LL_WARN, ("No wifi mode specified"));
}
return result;
}
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 restoreFactorySettings() {
wifi_station_disconnect();
wifi_set_opmode(0x3); //reset to STA+AP mode
struct softap_config apConfig;
wifi_softap_get_config(&apConfig);
os_strncpy((char*)apConfig.ssid, "smartswitch", 18);
apConfig.authmode = 0; //Disable security
wifi_softap_set_config(&apConfig);
struct station_config stconf;
os_strncpy((char*)stconf.ssid, "", 2);
os_strncpy((char*)stconf.password, "", 2);
wifi_station_set_config(&stconf);
OLED_CLS();
OLED_Print(2, 0, "RESET", 1);
os_printf("Reset completed. Restarting system...\n");
ioOutput(0, GPIO_OUTPUT1);
ioOutput(0, GPIO_OUTPUT2);
while (!GPIO_INPUT_GET(GPIO_BUTTON1)) { os_printf("."); };
while (!GPIO_INPUT_GET(GPIO_BUTTON2)) { os_printf("."); };
system_restart();
}
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
}
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();
}
/**
* @brief Initialize the CPU, the board and the peripherals
*
* This function is called by ESP8266 SDK when all system initializations
* has been finished.
*/
void system_init(void)
{
LOG_INFO("\nStarting ESP8266 CPU with ID: %08x", system_get_chip_id());
LOG_INFO("\nSDK Version %s\n\n", system_get_sdk_version());
/* avoid reconnection all the time */
wifi_station_disconnect();
/* set exception handlers */
init_exceptions ();
/* init random number generator */
srand(hwrand());
/* init flash drive */
extern void flash_drive_init (void);
flash_drive_init();
/* trigger static peripheral initialization */
periph_init();
/* trigger board initialization */
board_init();
/* print the board config */
board_print_config();
}
static void reset_slave() {
init_slave = 0;
chackTime = 0;
ip_connected = 0;
wifi_station_disconnect();
os_timer_disarm(&at_japDelayChack);
}
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;
}
/**
* @brief Transparent data through ip.
* @param arg: no used
* @retval None
*/
static void ICACHE_FLASH_ATTR
at_japChack(void *arg)
{
uint8_t japState;
char temp[32];
os_printf("Checking if we have ip...\r\n");
os_timer_disarm(&at_japDelayChack);
chackTime++;
japState = wifi_station_get_connect_status();
if(japState == STATION_GOT_IP)
{
os_printf("YEAHHH we have ip...\r\n");
chackTime = 0;
connect_attempts = 0;
if(ip_connected == 0) {
initer_slave();
ip_connected = 1;
}
}
else if(chackTime >= 10)
{
ip_connected = 0;
wifi_station_disconnect();
os_sprintf(temp,"+CWJAP:%d\r\n",japState);
os_printf(temp);
os_printf("\r\nFAIL\r\n");
reset_slave();
return;
}
//scan_slave();
os_timer_arm(&at_japDelayChack, 2000, 0);
os_printf("ip check done\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);
}
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;
}
/**
* @brief Execution commad of quit wifi ap.
* @param id: commad id number
* @retval None
*/
void ICACHE_FLASH_ATTR
at_exeCmdCwqap(uint8_t id)
{
wifi_station_disconnect();
mdState = m_wdact;
at_backOk;
}
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
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;
}
}
// 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 ESP8266WiFiClass::disconnect(bool wifioff)
{
struct station_config conf;
*conf.ssid = 0;
*conf.password = 0;
ETS_UART_INTR_DISABLE();
if (_persistent)
wifi_station_set_config(&conf);
else
wifi_station_set_config_current(&conf);
wifi_station_disconnect();
ETS_UART_INTR_ENABLE();
if(wifioff) {
_useClientMode = false;
if(_useApMode) {
// turn on AP
_mode(WIFI_AP);
} else {
// turn wifi off
_mode(WIFI_OFF);
}
}
return 0;
}
void dns_done( const char *name, ip_addr_t *ipaddr, void *arg )
{
struct espconn *conn = arg;
os_printf( "%s\n", __FUNCTION__ );
if ( ipaddr == NULL)
{
os_printf("DNS lookup failed\n");
wifi_station_disconnect();
}
else
{
os_printf("Connecting...\n" );
conn->type = ESPCONN_TCP;
conn->state = ESPCONN_NONE;
conn->proto.tcp=&threatbutt_tcp;
conn->proto.tcp->local_port = espconn_port();
conn->proto.tcp->remote_port = 1234;
os_memcpy(conn->proto.tcp->remote_ip, &ipaddr->addr, 4 );
espconn_regist_connectcb( conn, tcp_connected );
//espconn_regist_disconcb( conn, tcp_disconnected );
espconn_connect( conn );
}
}
ICACHE_FLASH_ATTR static v7_val_t Wifi_disconnect(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_disconnect());
}
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();
}
/**
* 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 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();
}
// 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();
}
void ICACHE_FLASH_ATTR user_init(void) {
stdout_init();
gpio_init();
wifi_station_disconnect();
wifi_station_set_auto_connect(false);
wifi_station_set_reconnect_policy(false);
system_init_done_cb(&initDone_cb);
}
// 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);
}
