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();
}
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;
}
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 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);
}
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();
}
static void wifi_connect() {
struct station_config conf;
wifi_station_set_auto_connect(FALSE);
wifi_set_event_handler_cb(wifi_change_cb);
strcpy((char *) conf.ssid, NETWORK_SSID);
strcpy((char *) conf.password, NETWORK_PWD);
printf("connecting to %s\n", conf.ssid);
conf.bssid_set = 0;
wifi_set_opmode_current(STATION_MODE);
wifi_station_disconnect();
wifi_station_set_config_current(&conf);
wifi_station_connect();
}
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_current(STATION_MODE);
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_current(&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_connect();
}
//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 );
}
/**
* Disconnect from the network
* @param wifioff
* @return one value of wl_status_t enum
*/
bool ESP31BWiFiSTAClass::disconnect(bool wifioff) {
bool ret;
struct station_config conf;
*conf.ssid = 0;
*conf.password = 0;
if(WiFi._persistent) {
wifi_station_set_config(&conf);
} else {
wifi_station_set_config_current(&conf);
}
ret = wifi_station_disconnect();
if(wifioff) {
WiFi.enableSTA(false);
}
return ret;
}
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);
}
/**
* 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();
}
static void _esp_wifi_setup(void)
{
esp_wifi_netdev_t* dev = &_esp_wifi_dev;
ESP_WIFI_DEBUG("%p", dev);
if (dev->netdev.driver) {
ESP_WIFI_DEBUG("early returning previously initialized device");
return;
}
/* initialize netdev data structure */
dev->rx_len = 0;
dev->state = ESP_WIFI_DISCONNECTED;
dev->event = EVENT_MAX;
/* set the netdev driver */
dev->netdev.driver = &_esp_wifi_driver;
#ifndef MODULE_ESP_NOW
/* set the WiFi interface mode */
if (!wifi_set_opmode_current(ESP_WIFI_MODE)) {
ESP_WIFI_LOG_ERROR("could not set WiFi working mode");
return;
}
/* set the WiFi SoftAP configuration */
if (!wifi_softap_set_config_current((struct softap_config *)&softap_cfg)) {
ESP_WIFI_LOG_ERROR("could not set WiFi configuration");
return;
}
#endif
/* set the WiFi station configuration */
if (!wifi_station_set_config_current((struct station_config *)&station_cfg)) {
ESP_WIFI_LOG_ERROR("could not set WiFi configuration");
return;
}
/* get station mac address and store it in device address */
if (!wifi_get_macaddr(ESP_WIFI_STATION_IF, dev->mac)) {
ESP_WIFI_LOG_ERROR("could not get MAC address of WiFi interface");
return;
}
ESP_WIFI_DEBUG("own MAC addr is " MAC_STR, MAC_STR_ARG(dev->mac));
/* set auto reconnect policy */
wifi_station_set_reconnect_policy(true);
wifi_station_set_auto_connect(true);
/* register callbacks */
wifi_set_event_handler_cb(_esp_wifi_handle_event_cb);
/* reconnect timer initialization */
_esp_wifi_reconnect_timer.callback = &_esp_wifi_reconnect_timer_cb;
_esp_wifi_reconnect_timer.arg = dev;
/* set the the reconnect timer */
xtimer_set(&_esp_wifi_reconnect_timer, ESP_WIFI_RECONNECT_TIME);
/* avoid the WiFi modem going into sleep mode */
wifi_set_sleep_type(NONE_SLEEP_T);
/* connect */
wifi_station_connect();
_esp_wifi_dev.state = ESP_WIFI_CONNECTING;
return;
}
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) > 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();
}
void ICACHE_FLASH_ATTR network_connect(void) {
wifi_set_opmode_current(STATION_MODE);
wifi_station_set_config_current(&station_config);
wifi_station_connect();
}
int ESP8266WiFiClass::begin_internal(const char* ssid, const char *passphrase, int32_t channel, const uint8_t* bssid)
{
_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 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 (_persistent)
wifi_station_set_config(&conf);
else
wifi_station_set_config_current(&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();
}
/**
* 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();
}
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 */
}
