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;
}
}
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;
}
// Init function
void ICACHE_FLASH_ATTR user_init()
{
struct station_config station_conf;
// Enable GPIO
gpio_init();
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO2_U, FUNC_GPIO2);
PIN_FUNC_SELECT(PERIPHS_IO_MUX_GPIO0_U, FUNC_GPIO0);
gpio_output_set(0, 0, (1<<ELGPIO), 0);
// Set station mode
wifi_set_opmode_current(STATION_MODE);
// Set AP settings
os_memcpy(&station_conf.ssid, SSID, 32);
os_memcpy(&station_conf.password, SSID_PASSWORD, 64);
wifi_station_set_config(&station_conf);
// Set an event handler for WiFi events
wifi_set_event_handler_cb(wifi_callback);
// Setup poll and EL timers, but don't start them yet
os_timer_disarm(&poll_timer);
os_timer_setfn(&poll_timer, poll_timer_callback, NULL);
os_timer_disarm(&el_timer);
os_timer_setfn(&el_timer, el_timer_callback, NULL);
os_printf("user_init() complete!\n\r");
}
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 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;
}
}
// 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;
}
/**
* @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);
}
void user_init()
{
struct station_config conf;
// This is used to setup the serial communication
uart_div_modify(0, UART_CLK_FREQ / 115200);
wifi_set_opmode(STATION_MODE);
// os_bzero ( &conf, sizeof(struct station_config) );
os_memset ( &conf, 0, sizeof(struct station_config) );
os_memcpy (&conf.ssid, ssid, 32);
os_memcpy (&conf.password, pass, 64 );
wifi_station_set_config (&conf);
// And this is used to print some information
os_printf("\n");
os_printf("SDK version:%s\n", system_get_sdk_version());
system_print_meminfo();
os_delay_us ( 1 );
os_printf ( "CPU Hz = %d\n", system_get_cpu_freq() );
show_mac ();
show_ip ();
/* set a callback for wifi events */
wifi_set_event_handler_cb ( wifi_event );
}
/******************************************************************************
* FunctionName : user_set_station_config
* Description : set the router info which ESP8266 station will connect to
* Parameters : none
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_set_station_config(void)
{
// Wifi configuration
///char ssid[32] = SSID;
///char password[64] = PASSWORD;
char ssid[32] = "2701";
char password[64] = "liuming123";
struct station_config stationConf;
os_memset(stationConf.ssid, 0, 32);
os_memset(stationConf.password, 0, 64);
//need not mac address
stationConf.bssid_set = 0;
//Set ap settings
os_memcpy(&stationConf.ssid, ssid, 32);
os_memcpy(&stationConf.password, password, 64);
wifi_station_set_config(&stationConf);
//set a timer to check whether got ip from router succeed or not.
os_timer_disarm(&test_timer);
os_timer_setfn(&test_timer, (os_timer_func_t *)v_user_esp_platform_check_ip, NULL);
os_timer_arm(&test_timer, 100, 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 ICACHE_FLASH_ATTR dhconnector_init(dhconnector_command_json_cb cb) {
dhrequest_load_settings();
mCommandCallback = cb;
mConnectionState = CS_DISCONNECT;
dhrequest_create_info(&mInfoRequest);
dhrequest_create_register(&mRegisterRequest);
mPollRequest.len = mPollRequest.data[0] = 0;
wifi_set_opmode(STATION_MODE);
wifi_station_set_auto_connect(1);
wifi_station_set_reconnect_policy(true);
struct station_config stationConfig;
wifi_station_get_config(&stationConfig);
wifi_set_phy_mode(PHY_MODE_11N);
os_memset(stationConfig.ssid, 0, sizeof(stationConfig.ssid));
os_memset(stationConfig.password, 0, sizeof(stationConfig.password));
snprintf(stationConfig.ssid, sizeof(stationConfig.ssid), "%s", dhsettings_get_wifi_ssid());
snprintf(stationConfig.password, sizeof(stationConfig.password), "%s", dhsettings_get_wifi_password());
wifi_station_set_config(&stationConfig);
static esp_tcp tcp;
os_memset(&tcp, 0, sizeof(tcp));
os_memset(&mDHConnector, 0, sizeof(mDHConnector));
mDHConnector.type = ESPCONN_TCP;
mDHConnector.state = ESPCONN_NONE;
mDHConnector.proto.tcp = &tcp;
mDHConnector.proto.tcp->local_port = espconn_port();
wifi_set_event_handler_cb(wifi_state_cb);
}
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();
}
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;
}
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
}
/******************************************************************************
* FunctionName : user_set_station_config
* Description : set the router info which ESP8266 station will connect to
* Parameters : none
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_set_station_config(void)
{
// Wifi configuration
char ssid[32] = SSID;
char password[64] = PASSWORD;
struct station_config stationConf;
//need not mac address
stationConf.bssid_set = 0;
//Set ap settings
os_memcpy(&stationConf.ssid, ssid, 32);
os_memcpy(&stationConf.password, password, 64);
wifi_station_set_config(&stationConf);
//set a timer to check whether got ip from router succeed or not.
os_timer_disarm(&test_timer);
os_timer_setfn(&test_timer, (os_timer_func_t *)user_check_ip, NULL);
os_timer_arm(&test_timer, 100, 0);
//set send command timer
os_timer_disarm(&send_timer);
os_timer_setfn(&send_timer, (os_timer_func_t *)user_udp_send, NULL);
}
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();
}
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();
}
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();
}
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();
}
// 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
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();
}
// 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);
}
void ICACHE_FLASH_ATTR set_wifi()
{
wifi_set_opmode(0x01);
char myssid[32] = "";
char mypasswd[64] = "";
struct station_config my_wifi;
os_memcpy(&my_wifi.ssid, myssid, 32);
os_memcpy(&my_wifi.password, mypasswd, 64);
wifi_station_set_config(&my_wifi);
wifi_station_set_config_current(&my_wifi);
}
static ICACHE_FLASH_ATTR int
configure(void)
{
char ch;
int ret;
static struct station_config st_config;
wifi_station_get_config(&st_config);
do
{
printf("\r\nConfiguration:\r\n");
printf("1: Wifi SSID [%s]\r\n", st_config.ssid);
printf("2: Wifi Password [%s]\r\n", st_config.password);
printf("3: HTTP host[%s]\r\n", user_config.host);
printf("4: HTTP port[%d]\r\n", user_config.port);
printf("5: HTTP path/query [%s]\r\n", user_config.get_cmd);
printf("0: Exit configuration\r\n");
// ch = uart_getchar();
xQueueReceive(xUARTQueue, &ch, -1);
switch (ch)
{
case '1':
printf("Enter Wifi SSID: ");
uart_gets(&xUARTQueue, st_config.ssid, 32);
break;
case '2':
printf("Enter Wifi Password: "******"Enter HTTP host: ");
uart_gets(&xUARTQueue, user_config.host, HOST_LEN+1);
break;
case '4':
printf("Enter HTTP port: ");
char buf[6];
uart_gets(&xUARTQueue, buf, 6);
user_config.port = atoi(buf);
break;
case '5':
printf("Enter HTTP path and query string: ");
uart_gets(&xUARTQueue, user_config.get_cmd, GET_LEN+1);
break;
case '0':
DBG("setting config [%s] [%s]\n", st_config.ssid, st_config.password);
wifi_station_set_config(&st_config);
save_user_config(&user_config);
break;
default:
printf("Invalid choice\r\n");
}
} while (ch != '0');
printf("System will now restart\r\n");
system_restart();
}
int ESP8266WiFiClass::disconnect()
{
struct station_config conf;
*conf.ssid = 0;
*conf.password = 0;
ETS_UART_INTR_DISABLE();
wifi_station_set_config(&conf);
wifi_station_disconnect();
ETS_UART_INTR_ENABLE();
return 0;
}
/*
* 函数：user_set_station_config
* 参数：u8* ssid - WiFi的名称
* u8 password - WiFi的密码
*/
void ICACHE_FLASH_ATTR
user_set_station_config(u8* ssid, u8* password)
{
//u8 ssid[32] = "your ssid";
//u8 password[64] = "your password";
struct station_config stationConf;
stationConf.bssid_set = 0; //need not check MAC address of AP
os_memcpy(&stationConf.ssid, ssid, 32);
os_memcpy(&stationConf.password, password, 64);
wifi_station_set_config(&stationConf);
}
/******************************************************************************
* FunctionName : user_init
* Description : entry of user application, init user function here
* Parameters : none
* Returns : none
*******************************************************************************/
void ICACHE_FLASH_ATTR
user_init(void)
{
printf("SDK version:%d.%d.%d\n",
SDK_VERSION_MAJOR,
SDK_VERSION_MINOR,
SDK_VERSION_REVISION);
/* need to set opmode before you set config */
wifi_set_opmode(STATIONAP_MODE);
{
struct station_config *config = (struct station_config *)zalloc(sizeof(struct station_config));
sprintf(config->ssid, "CVR100W_T");
sprintf(config->password, "justfortest");
/* need to sure that you are in station mode first,
* otherwise it will be failed. */
wifi_station_set_config(config);
free(config);
}
{
struct ip_info ipinfo;
ipinfo.gw.addr = ipaddr_addr("192.168.145.253");
ipinfo.ip.addr = ipaddr_addr("192.168.145.253");
ipinfo.netmask.addr = ipaddr_addr("255.255.255.0");
wifi_set_ip_info(SOFTAP_IF, &ipinfo);
}
{
struct dhcp_info *pdhcp_info = NULL;
pdhcp_info = (struct dhcp_info *)zalloc(sizeof(struct dhcp_info));
pdhcp_info->start_ip = ipaddr_addr("192.168.145.100");
pdhcp_info->end_ip = ipaddr_addr("192.168.145.110"); // don't set the range too large, because it will cost memory.
pdhcp_info->max_leases = 10;
pdhcp_info->auto_time = 60;
pdhcp_info->decline_time = 60;
pdhcp_info->conflict_time = 60;
pdhcp_info->offer_time = 60;
pdhcp_info->min_lease_sec = 60;
dhcp_set_info(pdhcp_info);
free(pdhcp_info);
}
udhcpd_start();
xTaskCreate(task2, "tsk2", 256, NULL, 2, NULL);
xTaskCreate(task3, "tsk3", 256, NULL, 2, NULL);
}
void WifiStation::config(char* SSID, char* PWD)
{
struct station_config *config = (struct station_config *)zalloc(sizeof(struct station_config));
sprintf((char*)config->ssid, SSID);
sprintf((char*)config->password,PWD);
/* need to sure that you are in station mode first,
* otherwise it will be failed. */
wifi_station_set_config(config);
free(config);
}
