自学教程：C++ wifi_station_disconnect函数代码示例

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_ATTRat_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_ATTRat_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_ATTRat_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_ATTRsmartconfig_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_ATTRsmartconfig_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 ClientAndAccessPointvoid 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 reassociationstatic 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);}