ESP3D/esp3d/config.cpp
Luc 1cf2744bad Add Notifications
Add EEPROM version Check
Update embedded page content and build process
Move check sum ESP commands from ESP6XX to ESP5XX to let Notifications use ESP6XX
Update command.txt with latest commands
2019-06-07 11:52:57 +02:00

1942 lines
57 KiB
C++

/*
config.cpp- ESP3D configuration class
Copyright (c) 2014 Luc Lebosse. All rights reserved.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#include <EEPROM.h>
#ifndef FS_NO_GLOBALS
#define FS_NO_GLOBALS
#endif
#include <FS.h>
#include <WiFiUdp.h>
#include "wificonf.h"
#ifdef ARDUINO_ARCH_ESP8266
extern "C" {
#include "user_interface.h"
}
#else
#include "Update.h"
#include "esp_wifi.h"
#endif
#include "espcom.h"
#ifdef TIMESTAMP_FEATURE
#include <time.h>
#endif
#ifdef DHT_FEATURE
#include "DHTesp.h"
extern DHTesp dht;
#endif
#ifdef NOTIFICATION_FEATURE
#include "notifications_service.h"
#endif
uint8_t CONFIG::FirmwareTarget = UNKNOWN_FW;
byte CONFIG::output_flag = DEFAULT_OUTPUT_FLAG;
#ifdef DHT_FEATURE
byte CONFIG::DHT_type = DEFAULT_DHT_TYPE;
int CONFIG::DHT_interval = DEFAULT_DHT_INTERVAL;
#endif
//Watchdog feeder
void CONFIG::wdtFeed()
{
#ifdef ARDUINO_ARCH_ESP8266
ESP.wdtFeed();
#else
void esp_task_wdt_feed();
#endif
}
void CONFIG::wait (uint32_t milliseconds)
{
#if defined(ASYNCWEBSERVER)
uint32_t timeout = millis();
while ( (millis() - timeout) < milliseconds) {
wdtFeed();
}
#else
delay(milliseconds);
#endif
}
bool CONFIG::SetFirmwareTarget (uint8_t fw)
{
if ( fw <= MAX_FW_ID) {
FirmwareTarget = fw;
return true;
} else {
return false;
}
}
uint8_t CONFIG::GetFirmwareTarget()
{
return FirmwareTarget;
}
const char* CONFIG::GetFirmwareTargetName()
{
static String response;
if ( CONFIG::FirmwareTarget == REPETIER4DV) {
response = F ("Repetier for Davinci");
} else if ( CONFIG::FirmwareTarget == REPETIER) {
response = F ("Repetier");
} else if ( CONFIG::FirmwareTarget == MARLIN) {
response = F ("Marlin");
} else if ( CONFIG::FirmwareTarget == MARLINKIMBRA) {
response = F ("MarlinKimbra");
} else if ( CONFIG::FirmwareTarget == SMOOTHIEWARE) {
response = F ("Smoothieware");
} else if ( CONFIG::FirmwareTarget == GRBL) {
response = F ("Grbl");
} else {
response = F ("???");
}
return response.c_str();
}
const char* CONFIG::GetFirmwareTargetShortName()
{
static String response;
if ( CONFIG::FirmwareTarget == REPETIER4DV) {
response = F ("repetier4davinci");
} else if ( CONFIG::FirmwareTarget == REPETIER) {
response = F ("repetier");
} else if ( CONFIG::FirmwareTarget == MARLIN) {
response = F ("marlin");
} else if ( CONFIG::FirmwareTarget == MARLINKIMBRA) {
response = F ("marlinkimbra");
} else if ( CONFIG::FirmwareTarget == SMOOTHIEWARE) {
response = F ("smoothieware");
} else if ( CONFIG::FirmwareTarget == GRBL) {
response = F ("grbl");
} else {
response = F ("???");
}
return response.c_str();
}
void CONFIG::InitFirmwareTarget()
{
uint8_t b = UNKNOWN_FW;
if (!CONFIG::read_byte (EP_TARGET_FW, &b ) ) {
b = UNKNOWN_FW;
}
if (!SetFirmwareTarget (b) ) {
SetFirmwareTarget (UNKNOWN_FW) ;
}
}
void CONFIG::InitOutput(){
byte bflag = 0;
if (!CONFIG::read_byte (EP_OUTPUT_FLAG, &bflag ) ) {
bflag = 0;
}
CONFIG::output_flag = bflag;
}
bool CONFIG::is_locked(byte flag){
return ((CONFIG::output_flag & flag) == flag);
}
void CONFIG::InitDirectSD()
{
CONFIG::is_direct_sd = false;
}
bool CONFIG::InitBaudrate(long value)
{
long baud_rate = 0;
if (value > 0)baud_rate = value;
else {
if ( !CONFIG::read_buffer (EP_BAUD_RATE, (byte *) &baud_rate, INTEGER_LENGTH) ) {
return false;
}
}
if ( ! (baud_rate == 9600 || baud_rate == 19200 || baud_rate == 38400 || baud_rate == 57600 || baud_rate == 115200 || baud_rate == 230400 || baud_rate == 250000 || baud_rate == 500000 || baud_rate == 921600 ) ) {
return false;
}
//setup serial
//TODO define baudrate for each Serial
#ifdef USE_SERIAL_0
if (Serial.baudRate() != baud_rate) {
#ifdef ARDUINO_ARCH_ESP8266
Serial.begin (baud_rate);
#else
Serial.begin (baud_rate, ESP_SERIAL_PARAM, ESP_RX_PIN, ESP_TX_PIN);
#endif
}
#endif
#ifdef USE_SERIAL_1
if (Serial1.baudRate() != baud_rate) {
#ifdef ARDUINO_ARCH_ESP8266
Serial1.begin (baud_rate);
#else
Serial1.begin (baud_rate, ESP_SERIAL_PARAM, ESP_RX_PIN, ESP_TX_PIN);
#endif
}
#endif
#ifdef USE_SERIAL_2
if (Serial2.baudRate() != baud_rate) {
#ifdef ARDUINO_ARCH_ESP8266
Serial2.begin (baud_rate);
#else
Serial2.begin (baud_rate, ESP_SERIAL_PARAM, ESP_RX_PIN, ESP_TX_PIN);
#endif
}
#endif
//only Serial for ESP8266
#ifdef ARDUINO_ARCH_ESP8266
Serial.setRxBufferSize (SERIAL_RX_BUFFER_SIZE);
#endif
wifi_config.baud_rate = baud_rate;
delay (100);
return true;
}
bool CONFIG::InitExternalPorts()
{
if (!CONFIG::read_buffer (EP_WEB_PORT, (byte *) & (wifi_config.iweb_port), INTEGER_LENGTH) || !CONFIG::read_buffer (EP_DATA_PORT, (byte *) & (wifi_config.idata_port), INTEGER_LENGTH) ) {
return false;
}
if (wifi_config.iweb_port < DEFAULT_MIN_WEB_PORT || wifi_config.iweb_port > DEFAULT_MAX_WEB_PORT || wifi_config.idata_port < DEFAULT_MIN_DATA_PORT || wifi_config.idata_port > DEFAULT_MAX_DATA_PORT) {
return false;
}
return true;
}
//warning if using from async function with async param
//restart will work but reason will be wrong
//better to use "web_interface->restartmodule = true;" instead
void CONFIG::esp_restart (bool async)
{
LOG ("Restarting\r\n")
ESPCOM::flush (DEFAULT_PRINTER_PIPE);
SPIFFS.end();
if (!async) {
delay (1000);
}
#ifdef ARDUINO_ARCH_ESP8266
//ESP8266 has only serial
Serial.swap();
#endif
ESP.restart();
while (1) {
if (!async) {
delay (1);
}
};
}
#ifdef DHT_FEATURE
void CONFIG::InitDHT(bool refresh) {
if (!refresh) {
byte bflag = DEFAULT_DHT_TYPE;
int ibuf = DEFAULT_DHT_INTERVAL;
if (!CONFIG::read_byte (EP_DHT_TYPE, &bflag ) ) {
bflag = DEFAULT_DHT_TYPE;
}
CONFIG::DHT_type = bflag;
if (!CONFIG::read_buffer (EP_DHT_INTERVAL, (byte *) &ibuf, INTEGER_LENGTH) ) {
ibuf = DEFAULT_DHT_INTERVAL;
}
CONFIG::DHT_interval = ibuf;
}
if (CONFIG::DHT_type != 255) dht.setup(ESP_DHT_PIN,(DHTesp::DHT_MODEL_t)CONFIG::DHT_type); // Connect DHT sensor to GPIO ESP_DHT_PIN
}
#endif
void CONFIG::InitPins()
{
#ifdef RECOVERY_FEATURE
pinMode (RESET_CONFIG_PIN, INPUT);
#endif
#ifdef DHT_FEATURE
CONFIG::InitDHT();
#endif
}
#if defined(TIMESTAMP_FEATURE)
void CONFIG::init_time_client()
{
String s1, s2, s3;
int8_t t1;
byte d1;
if (!CONFIG::read_string (EP_TIME_SERVER1, s1, MAX_DATA_LENGTH) ) {
s1 = FPSTR (DEFAULT_TIME_SERVER1);
}
if (!CONFIG::read_string (EP_TIME_SERVER2, s2, MAX_DATA_LENGTH) ) {
s2 = FPSTR (DEFAULT_TIME_SERVER2);
}
if (!CONFIG::read_string (EP_TIME_SERVER3, s3, MAX_DATA_LENGTH) ) {
s3 = FPSTR (DEFAULT_TIME_SERVER3);
}
if (!CONFIG::read_byte (EP_TIMEZONE, (byte *) &t1 ) ) {
t1 = DEFAULT_TIME_ZONE;
}
if (!CONFIG::read_byte (EP_TIME_ISDST, &d1 ) ) {
d1 = DEFAULT_TIME_DST;
}
configTime (3600 * (t1), d1 * 3600, s1.c_str(), s2.c_str(), s3.c_str() );
time_t now = time(nullptr);
if (WiFi.getMode() == WIFI_STA) {
int nb = 0;
while ((now < 8 * 3600 * 2) && (nb < 6)) {
wait(500);
nb++;
now = time(nullptr);
}
}
}
#endif
bool CONFIG::is_direct_sd = false;
bool CONFIG::isHostnameValid (const char * hostname)
{
//limited size
char c;
if (strlen (hostname) > MAX_HOSTNAME_LENGTH || strlen (hostname) < MIN_HOSTNAME_LENGTH) {
return false;
}
//only letter and digit
for (int i = 0; i < strlen (hostname); i++) {
c = hostname[i];
if (! (isdigit (c) || isalpha (c) || c == '_') ) {
return false;
}
if (c == ' ') {
return false;
}
}
return true;
}
bool CONFIG::isSSIDValid (const char * ssid)
{
//limited size
//char c;
if (strlen (ssid) > MAX_SSID_LENGTH || strlen (ssid) < MIN_SSID_LENGTH) {
return false;
}
//only printable
for (int i = 0; i < strlen (ssid); i++) {
if (!isPrintable (ssid[i]) ) {
return false;
}
}
return true;
}
bool CONFIG::isPasswordValid (const char * password)
{
//limited size
if (strlen (password) > MAX_PASSWORD_LENGTH) {
return false;
}
#if MIN_PASSWORD_LENGTH > 0
if (strlen (password) < MIN_PASSWORD_LENGTH) {
) return false;
}
#endif
//no space allowed
for (int i = 0; i < strlen (password); i++)
if (password[i] == ' ') {
return false;
}
return true;
}
bool CONFIG::isLocalPasswordValid (const char * password)
{
char c;
//limited size
if ( (strlen (password) > MAX_LOCAL_PASSWORD_LENGTH) || (strlen (password) < MIN_LOCAL_PASSWORD_LENGTH) ) {
return false;
}
//no space allowed
for (int i = 0; i < strlen (password); i++) {
c = password[i];
if (c == ' ') {
return false;
}
}
return true;
}
bool CONFIG::isIPValid (const char * IP)
{
//limited size
int internalcount = 0;
int dotcount = 0;
bool previouswasdot = false;
char c;
if (strlen (IP) > 15 || strlen (IP) == 0) {
return false;
}
//cannot start with .
if (IP[0] == '.') {
return false;
}
//only letter and digit
for (int i = 0; i < strlen (IP); i++) {
c = IP[i];
if (isdigit (c) ) {
//only 3 digit at once
internalcount++;
previouswasdot = false;
if (internalcount > 3) {
return false;
}
} else if (c == '.') {
//cannot have 2 dots side by side
if (previouswasdot) {
return false;
}
previouswasdot = true;
internalcount = 0;
dotcount++;
}//if not a dot neither a digit it is wrong
else {
return false;
}
}
//if not 3 dots then it is wrong
if (dotcount != 3) {
return false;
}
//cannot have the last dot as last char
if (IP[strlen (IP) - 1] == '.') {
return false;
}
return true;
}
char * CONFIG::intTostr (int value)
{
static char result [12];
sprintf (result, "%d", value);
return result;
}
String CONFIG::formatBytes (uint64_t bytes)
{
if (bytes < 1024) {
return String ((uint16_t)bytes) + " B";
} else if (bytes < (1024 * 1024) ) {
return String ((float)(bytes / 1024.0)) + " KB";
} else if (bytes < (1024 * 1024 * 1024) ) {
return String ((float)(bytes / 1024.0 / 1024.0)) + " MB";
} else {
return String ((float)(bytes / 1024.0 / 1024.0 / 1024.0)) + " GB";
}
}
//helper to convert string to IP
//do not use IPAddress.fromString() because lack of check point and error result
//return number of parts
byte CONFIG::split_ip (const char * ptr, byte * part)
{
if (strlen (ptr) > 15 || strlen (ptr) < 7) {
part[0] = 0;
part[1] = 0;
part[2] = 0;
part[3] = 0;
return 0;
}
char pstart [16];
char * ptr2;
strcpy (pstart, ptr);
ptr2 = pstart;
byte i = strlen (pstart);
byte pos = 0;
for (byte j = 0; j < i; j++) {
if (pstart[j] == '.') {
if (pos == 4) {
part[0] = 0;
part[1] = 0;
part[2] = 0;
part[3] = 0;
return 0;
}
pstart[j] = 0x0;
part[pos] = atoi (ptr2);
pos++;
ptr2 = &pstart[j + 1];
}
}
part[pos] = atoi (ptr2);
return pos + 1;
}
//just simple helper to convert mac address to string
char * CONFIG::mac2str (uint8_t mac [WL_MAC_ADDR_LENGTH])
{
static char macstr [18];
if (0 > sprintf (macstr, "%02X:%02X:%02X:%02X:%02X:%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]) ) {
strcpy (macstr, "00:00:00:00:00:00");
}
return macstr;
}
bool CONFIG::set_EEPROM_version(uint8_t v){
byte byte_buffer[6];
byte_buffer[0]='E';
byte_buffer[1]='S';
byte_buffer[2]='P';
byte_buffer[3]='3';
byte_buffer[4]='D';
byte_buffer[5]=v;
return CONFIG::write_buffer (EP_EEPROM_VERSION, byte_buffer, 6);
}
uint8_t CONFIG::get_EEPROM_version(){
byte byte_buffer[6];
long baud_rate;
if (!CONFIG::read_buffer (EP_EEPROM_VERSION, byte_buffer, 6)) return EEPROM_V0;
if ((byte_buffer[0]=='E') && (byte_buffer[1]=='S') && (byte_buffer[2]=='P')&& (byte_buffer[3]=='3') && (byte_buffer[4]=='D')){
return byte_buffer[5];
}
if ( !CONFIG::read_buffer (EP_BAUD_RATE, (byte *) &baud_rate, INTEGER_LENGTH) ) {
return EEPROM_V0;
}
if ((baud_rate == 9600 || baud_rate == 19200 || baud_rate == 38400 || baud_rate == 57600 || baud_rate == 115200 || baud_rate == 230400 || baud_rate == 250000 || baud_rate == 500000 || baud_rate == 921600 ) ) {
return EEPROM_V1;
}
return EEPROM_V0;
}
bool CONFIG::adjust_EEPROM_settings(){
uint8_t v = get_EEPROM_version();
bool bdone =false;
if (v == EEPROM_CURRENT_VERSION) return true;
if (v == 1) {
bdone =true;
#ifdef SDCARD_FEATURE
if (!CONFIG::write_byte (EP_SD_SPEED_DIV, DEFAULT_SDREADER_SPEED) ) {
bdone =false;
}
#endif
#ifdef DHT_FEATURE
if (!CONFIG::write_buffer (EP_DHT_INTERVAL, (const byte *) &DEFAULT_DHT_INTERVAL, INTEGER_LENGTH) ) {
bdone =false;
}
if (!CONFIG::write_byte (EP_DHT_TYPE, DEFAULT_DHT_TYPE) ) {
bdone =false;
}
#endif
if (!CONFIG::write_byte (EP_OUTPUT_FLAG, DEFAULT_OUTPUT_FLAG) ) {
bdone =false;
}
}
if (bdone){
set_EEPROM_version(EEPROM_CURRENT_VERSION);
}
return bdone;
}
//read a string
//a string is multibyte + \0, this is won't work if 1 char is multibyte like chinese char
bool CONFIG::read_string (int pos, char byte_buffer[], int size_max)
{
//check if parameters are acceptable
if (size_max == 0 || pos + size_max + 1 > EEPROM_SIZE || byte_buffer == NULL) {
LOG ("Error read string\r\n")
return false;
}
EEPROM.begin (EEPROM_SIZE);
byte b = 13; // non zero for the while loop below
int i = 0;
//read until max size is reached or \0 is found
while (i < size_max && b != 0) {
b = EEPROM.read (pos + i);
byte_buffer[i] = b;
i++;
}
// Be sure there is a 0 at the end.
if (b != 0) {
byte_buffer[i - 1] = 0x00;
}
EEPROM.end();
return true;
}
bool CONFIG::read_string (int pos, String & sbuffer, int size_max)
{
//check if parameters are acceptable
if (size_max == 0 || pos + size_max + 1 > EEPROM_SIZE ) {
LOG ("Error read string\r\n")
return false;
}
byte b = 13; // non zero for the while loop below
int i = 0;
sbuffer = "";
EEPROM.begin (EEPROM_SIZE);
//read until max size is reached or \0 is found
while (i < size_max && b != 0) {
b = EEPROM.read (pos + i);
if (b != 0) {
sbuffer += char (b);
}
i++;
}
EEPROM.end();
return true;
}
//read a buffer of size_buffer
bool CONFIG::read_buffer (int pos, byte byte_buffer[], int size_buffer)
{
//check if parameters are acceptable
if (size_buffer == 0 || pos + size_buffer > EEPROM_SIZE || byte_buffer == NULL) {
LOG ("Error read buffer\r\n")
return false;
}
int i = 0;
EEPROM.begin (EEPROM_SIZE);
//read until max size is reached
while (i < size_buffer ) {
byte_buffer[i] = EEPROM.read (pos + i);
i++;
}
EEPROM.end();
return true;
}
//read a flag / byte
bool CONFIG::read_byte (int pos, byte * value)
{
//check if parameters are acceptable
if (pos + 1 > EEPROM_SIZE) {
LOG ("Error read byte\r\n")
return false;
}
EEPROM.begin (EEPROM_SIZE);
value[0] = EEPROM.read (pos);
EEPROM.end();
return true;
}
bool CONFIG::write_string (int pos, const __FlashStringHelper *str)
{
String stmp = str;
return write_string (pos, stmp.c_str() );
}
//write a string (array of byte with a 0x00 at the end)
bool CONFIG::write_string (int pos, const char * byte_buffer)
{
int size_buffer;
int maxsize = EEPROM_SIZE;
size_buffer = strlen (byte_buffer);
//check if parameters are acceptable
switch (pos) {
case EP_ADMIN_PWD:
case EP_USER_PWD:
maxsize = MAX_LOCAL_PASSWORD_LENGTH;
break;
case EP_AP_SSID:
case EP_STA_SSID:
maxsize = MAX_SSID_LENGTH;
break;
case EP_AP_PASSWORD:
case EP_STA_PASSWORD:
maxsize = MAX_PASSWORD_LENGTH;
break;
case EP_HOSTNAME:
maxsize = MAX_HOSTNAME_LENGTH;
break;
case EP_TIME_SERVER1:
case EP_TIME_SERVER2:
case EP_TIME_SERVER3:
maxsize = MAX_DATA_LENGTH;
break;
case ESP_NOTIFICATION_TOKEN1:
case ESP_NOTIFICATION_TOKEN2:
maxsize = MAX_NOTIFICATION_TOKEN_LENGTH;
break;
case ESP_NOTIFICATION_SETTINGS:
maxsize = MAX_NOTIFICATION_SETTINGS_LENGTH;
break;
default:
maxsize = EEPROM_SIZE;
break;
}
if ( (size_buffer == 0 ) || pos + size_buffer + 1 > EEPROM_SIZE || size_buffer > maxsize || byte_buffer == NULL) {
LOG ("Error write string\r\n")
return false;
}
//copy the value(s)
EEPROM.begin (EEPROM_SIZE);
for (int i = 0; i < size_buffer; i++) {
EEPROM.write (pos + i, byte_buffer[i]);
}
//0 terminal
EEPROM.write (pos + size_buffer, 0x00);
EEPROM.commit();
EEPROM.end();
return true;
}
//write a buffer
bool CONFIG::write_buffer (int pos, const byte * byte_buffer, int size_buffer)
{
//check if parameters are acceptable
if (size_buffer == 0 || pos + size_buffer > EEPROM_SIZE || byte_buffer == NULL) {
LOG ("Error write buffer\r\n")
return false;
}
EEPROM.begin (EEPROM_SIZE);
//copy the value(s)
for (int i = 0; i < size_buffer; i++) {
EEPROM.write (pos + i, byte_buffer[i]);
}
EEPROM.commit();
EEPROM.end();
return true;
}
//read a flag / byte
bool CONFIG::write_byte (int pos, const byte value)
{
//check if parameters are acceptable
if (pos + 1 > EEPROM_SIZE) {
LOG ("Error write byte\r\n")
return false;
}
EEPROM.begin (EEPROM_SIZE);
EEPROM.write (pos, value);
EEPROM.commit();
EEPROM.end();
return true;
}
bool CONFIG::reset_config()
{
if (!CONFIG::write_byte (EP_WIFI_MODE, DEFAULT_WIFI_MODE) ) {
return false;
}
if (!CONFIG::write_buffer (EP_BAUD_RATE, (const byte *) &DEFAULT_BAUD_RATE, INTEGER_LENGTH) ) {
return false;
}
if (!CONFIG::write_string (EP_AP_SSID, FPSTR (DEFAULT_AP_SSID) ) ) {
return false;
}
if (!CONFIG::write_string (EP_AP_PASSWORD, FPSTR (DEFAULT_AP_PASSWORD) ) ) {
return false;
}
if (!CONFIG::write_string (EP_STA_SSID, FPSTR (DEFAULT_STA_SSID) ) ) {
return false;
}
if (!CONFIG::write_string (EP_STA_PASSWORD, FPSTR (DEFAULT_STA_PASSWORD) ) ) {
return false;
}
if (!CONFIG::write_byte (EP_AP_IP_MODE, DEFAULT_AP_IP_MODE) ) {
return false;
}
if (!CONFIG::write_byte (EP_STA_IP_MODE, DEFAULT_STA_IP_MODE) ) {
return false;
}
if (!CONFIG::write_buffer (EP_STA_IP_VALUE, DEFAULT_IP_VALUE, IP_LENGTH) ) {
return false;
}
if (!CONFIG::write_buffer (EP_STA_MASK_VALUE, DEFAULT_MASK_VALUE, IP_LENGTH) ) {
return false;
}
if (!CONFIG::write_buffer (EP_STA_GATEWAY_VALUE, DEFAULT_GATEWAY_VALUE, IP_LENGTH) ) {
return false;
}
if (!CONFIG::write_byte (EP_STA_PHY_MODE, DEFAULT_PHY_MODE) ) {
return false;
}
if (!CONFIG::write_buffer (EP_AP_IP_VALUE, DEFAULT_IP_VALUE, IP_LENGTH) ) {
return false;
}
if (!CONFIG::write_buffer (EP_AP_MASK_VALUE, DEFAULT_MASK_VALUE, IP_LENGTH) ) {
return false;
}
if (!CONFIG::write_buffer (EP_AP_GATEWAY_VALUE, DEFAULT_GATEWAY_VALUE, IP_LENGTH) ) {
return false;
}
if (!CONFIG::write_byte (EP_AP_PHY_MODE, DEFAULT_PHY_MODE) ) {
return false;
}
if (!CONFIG::write_byte (EP_SLEEP_MODE, DEFAULT_SLEEP_MODE) ) {
return false;
}
if (!CONFIG::write_byte (EP_CHANNEL, DEFAULT_CHANNEL) ) {
return false;
}
if (!CONFIG::write_byte (EP_AUTH_TYPE, DEFAULT_AUTH_TYPE) ) {
return false;
}
if (!CONFIG::write_byte (EP_SSID_VISIBLE, DEFAULT_SSID_VISIBLE) ) {
return false;
}
if (!CONFIG::write_buffer (EP_WEB_PORT, (const byte *) &DEFAULT_WEB_PORT, INTEGER_LENGTH) ) {
return false;
}
if (!CONFIG::write_buffer (EP_DATA_PORT, (const byte *) &DEFAULT_DATA_PORT, INTEGER_LENGTH) ) {
return false;
}
if (!CONFIG::write_string (EP_HOSTNAME, wifi_config.get_default_hostname() ) ) {
return false;
}
if (!CONFIG::write_string (EP_ADMIN_PWD, FPSTR (DEFAULT_ADMIN_PWD) ) ) {
return false;
}
if (!CONFIG::write_string (EP_USER_PWD, FPSTR (DEFAULT_USER_PWD) ) ) {
return false;
}
if (!CONFIG::write_byte (EP_TARGET_FW, UNKNOWN_FW) ) {
return false;
}
#if defined(TIMESTAMP_FEATURE)
if (!CONFIG::write_byte (EP_TIMEZONE, DEFAULT_TIME_ZONE) ) {
return false;
}
if (!CONFIG::write_byte (EP_TIME_ISDST, DEFAULT_TIME_DST) ) {
return false;
}
if (!CONFIG::write_string (EP_TIME_SERVER1, FPSTR (DEFAULT_TIME_SERVER1) ) ) {
return false;
}
if (!CONFIG::write_string (EP_TIME_SERVER2, FPSTR (DEFAULT_TIME_SERVER2) ) ) {
return false;
}
if (!CONFIG::write_string (EP_TIME_SERVER3, FPSTR (DEFAULT_TIME_SERVER3) ) ) {
return false;
}
#endif
if (!CONFIG::write_byte (EP_OUTPUT_FLAG, DEFAULT_OUTPUT_FLAG) ) {
return false;
}
#ifdef DHT_FEATURE
if (!CONFIG::write_buffer (EP_DHT_INTERVAL, (const byte *) &DEFAULT_DHT_INTERVAL, INTEGER_LENGTH) ) {
return false;
}
if (!CONFIG::write_byte (EP_DHT_TYPE, DEFAULT_DHT_TYPE) ) {
return false;
}
#endif
#ifdef NOTIFICATION_FEATURE
if (!CONFIG::write_byte (ESP_NOTIFICATION_TYPE, DEFAULT_NOTIFICATION_TYPE) ) {
return false;
}
if (!CONFIG::write_string (ESP_NOTIFICATION_TOKEN1, DEFAULT_NOTIFICATION_TOKEN1 ) ) {
return false;
}
if (!CONFIG::write_string (ESP_NOTIFICATION_TOKEN2, DEFAULT_NOTIFICATION_TOKEN2 ) ) {
return false;
}
if (!CONFIG::write_string (ESP_NOTIFICATION_SETTINGS, DEFAULT_NOTIFICATION_SETTINGS ) ) {
return false;
}
#endif
return set_EEPROM_version(EEPROM_CURRENT_VERSION);
}
void CONFIG::print_config (tpipe output, bool plaintext, ESPResponseStream *espresponse)
{
if (!plaintext) {
ESPCOM::print (F ("{\"chip_id\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Chip ID: "), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP8266
ESPCOM::print (String (ESP.getChipId() ).c_str(), output, espresponse);
#else
ESPCOM::print (String ( (uint16_t) (ESP.getEfuseMac() >> 32) ).c_str(), output, espresponse);
#endif
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"cpu\":\""), output, espresponse);
} else {
ESPCOM::print (F ("CPU Frequency: "), output, espresponse);
}
ESPCOM::print (String (ESP.getCpuFreqMHz() ).c_str(), output, espresponse);
if (plaintext) {
ESPCOM::print (F ("Mhz"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
if (!plaintext) {
ESPCOM::print (F ("\"cpu_temp\":\""), output, espresponse);
} else {
ESPCOM::print (F ("CPU Temperature: "), output, espresponse);
}
ESPCOM::print (String (temperatureRead(), 1).c_str(), output, espresponse);
if (plaintext) {
ESPCOM::print (F ("C"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
#endif
if (!plaintext) {
ESPCOM::print (F ("\"freemem\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Free memory: "), output, espresponse);
}
ESPCOM::print (formatBytes (ESP.getFreeHeap() ).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\""), output, espresponse);
}
ESPCOM::print (F ("SDK"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\":\""), output, espresponse);
} else {
ESPCOM::print (F (": "), output, espresponse);
}
ESPCOM::print (ESP.getSdkVersion(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"flash_size\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Flash Size: "), output, espresponse);
}
ESPCOM::print (formatBytes (ESP.getFlashChipSize() ).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP8266
if (!plaintext) {
ESPCOM::print (F ("\"update_size\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Available Size for update: "), output, espresponse);
}
uint32_t flashsize = ESP.getFlashChipSize();
fs::FSInfo info;
SPIFFS.info (info);
//if higher than 1MB take out SPIFFS
if (flashsize > 1024 * 1024) {
flashsize = (1024 * 1024)-ESP.getSketchSize()-1024;
}
else {
flashsize = flashsize - ESP.getSketchSize()-info.totalBytes-1024;
}
ESPCOM::print(formatBytes(flashsize).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
if (flashsize > ( ESP.getSketchSize())) {
ESPCOM::println(F("(Ok)"), output, espresponse);
} else {
ESPCOM::println(F ("(Not enough)"), output, espresponse);
}
}
if (!plaintext) {
ESPCOM::print (F ("\"spiffs_size\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Available Size for SPIFFS: "), output, espresponse);
}
ESPCOM::print (formatBytes (info.totalBytes).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
#else
if (!plaintext) {
ESPCOM::print (F ("\"update_size\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Available Size for update: "), output, espresponse);
}
uint32_t flashsize = ESP.getFlashChipSize();
//Not OTA on 2Mb board per spec
if (flashsize > 0x20000) {
flashsize = 0x140000;
} else {
flashsize = 0x0;
}
ESPCOM::print (formatBytes (flashsize).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
if (flashsize > 0x0) {
ESPCOM::println (F ("(Ok)"), output, espresponse);
} else {
ESPCOM::print (F ("(Not enough)"), output, espresponse);
}
}
if (!plaintext) {
ESPCOM::print (F ("\"spiffs_size\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Available Size for SPIFFS: "), output, espresponse);
}
ESPCOM::print (formatBytes (SPIFFS.totalBytes() ).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
#endif
if (!plaintext) {
ESPCOM::print (F ("\"baud_rate\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Baud rate: "), output, espresponse);
}
uint32_t br = ESPCOM::baudRate(DEFAULT_PRINTER_PIPE);
ESPCOM::print (String (br).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"sleep_mode\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Sleep mode: "), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
wifi_ps_type_t ps_type;
esp_wifi_get_ps (&ps_type);
#else
WiFiSleepType_t ps_type;
ps_type = WiFi.getSleepMode();
#endif
if (ps_type == WIFI_NONE_SLEEP) {
ESPCOM::print (F ("None"), output, espresponse);
} else if (ps_type == WIFI_LIGHT_SLEEP) {
ESPCOM::print (F ("Light"), output, espresponse);
} else if (ps_type == WIFI_MODEM_SLEEP) {
ESPCOM::print (F ("Modem"), output, espresponse);
} else {
ESPCOM::print (F ("???"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"channel\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Channel: "), output, espresponse);
}
ESPCOM::print (String (WiFi.channel() ).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
uint8_t PhyMode;
if (WiFi.getMode() == WIFI_STA) {
esp_wifi_get_protocol (ESP_IF_WIFI_STA, &PhyMode);
} else {
esp_wifi_get_protocol (ESP_IF_WIFI_AP, &PhyMode);
}
#else
WiFiPhyMode_t PhyMode = WiFi.getPhyMode();
#endif
if (!plaintext) {
ESPCOM::print (F ("\"phy_mode\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Phy Mode: "), output, espresponse);
}
if (PhyMode == (WIFI_PHY_MODE_11G) ) {
ESPCOM::print (F ("11g"), output, espresponse);
} else if (PhyMode == (WIFI_PHY_MODE_11B) ) {
ESPCOM::print (F ("11b"), output, espresponse);
} else if (PhyMode == (WIFI_PHY_MODE_11N) ) {
ESPCOM::print (F ("11n"), output, espresponse);
} else {
ESPCOM::print (F ("???"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"web_port\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Web port: "), output, espresponse);
}
ESPCOM::print (String (wifi_config.iweb_port).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"data_port\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Data port: "), output, espresponse);
}
#ifdef TCP_IP_DATA_FEATURE
ESPCOM::print (String (wifi_config.idata_port).c_str(), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (WiFi.getMode() == WIFI_STA || WiFi.getMode() == WIFI_AP_STA) {
if (!plaintext) {
ESPCOM::print (F ("\"hostname\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Hostname: "), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
ESPCOM::print (WiFi.getHostname(), output, espresponse);
#else
ESPCOM::print (WiFi.hostname().c_str(), output, espresponse);
#endif
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
}
if (!plaintext) {
ESPCOM::print (F ("\"active_mode\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Active Mode: "), output, espresponse);
}
if (WiFi.getMode() == WIFI_STA) {
ESPCOM::print (F ("STA ("), output, espresponse);
ESPCOM::print (WiFi.macAddress().c_str(), output, espresponse);
ESPCOM::print (F (")"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (WiFi.isConnected() ) {
if (!plaintext) {
ESPCOM::print (F ("\"connected_ssid\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Connected to: "), output, espresponse);
}
ESPCOM::print (WiFi.SSID().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"connected_signal\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Signal: "), output, espresponse);
}
ESPCOM::print (String (wifi_config.getSignal (WiFi.RSSI() ) ).c_str(), output, espresponse);
ESPCOM::print (F ("%"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
} else {
if (!plaintext) {
ESPCOM::print (F ("\"connection_status\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Connection Status: "), output, espresponse);
}
ESPCOM::print (F ("Connection Status: "), output, espresponse);
if (WiFi.status() == WL_DISCONNECTED) {
ESPCOM::print (F ("Disconnected"), output, espresponse);
} else if (WiFi.status() == WL_CONNECTION_LOST) {
ESPCOM::print (F ("Connection lost"), output, espresponse);
} else if (WiFi.status() == WL_CONNECT_FAILED) {
ESPCOM::print (F ("Connection failed"), output, espresponse);
} else if (WiFi.status() == WL_NO_SSID_AVAIL) {
ESPCOM::print (F ("No connection"), output, espresponse);
} else if (WiFi.status() == WL_IDLE_STATUS ) {
ESPCOM::print (F ("Idle"), output, espresponse);
} else {
ESPCOM::print (F ("Unknown"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
}
if (!plaintext) {
ESPCOM::print (F ("\"ip_mode\":\""), output, espresponse);
} else {
ESPCOM::print (F ("IP Mode: "), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
tcpip_adapter_dhcp_status_t dhcp_status;
tcpip_adapter_dhcpc_get_status (TCPIP_ADAPTER_IF_STA, &dhcp_status);
if (dhcp_status == TCPIP_ADAPTER_DHCP_STARTED)
#else
if (wifi_station_dhcpc_status() == DHCP_STARTED)
#endif
{
ESPCOM::print (F ("DHCP"), output, espresponse);
} else {
ESPCOM::print (F ("Static"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"ip\":\""), output, espresponse);
} else {
ESPCOM::print (F ("IP: "), output, espresponse);
}
ESPCOM::print (WiFi.localIP().toString().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"gw\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Gateway: "), output, espresponse);
}
ESPCOM::print (WiFi.gatewayIP().toString().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"msk\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Mask: "), output, espresponse);
}
ESPCOM::print (WiFi.subnetMask().toString().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"dns\":\""), output, espresponse);
} else {
ESPCOM::print (F ("DNS: "), output, espresponse);
}
ESPCOM::print (WiFi.dnsIP().toString().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"disabled_mode\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Disabled Mode: "), output, espresponse);
}
ESPCOM::print (F ("AP ("), output, espresponse);
ESPCOM::print (WiFi.softAPmacAddress().c_str(), output, espresponse);
ESPCOM::print (F (")"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
} else if (WiFi.getMode() == WIFI_AP) {
ESPCOM::print (F ("AP ("), output, espresponse);
ESPCOM::print (WiFi.softAPmacAddress().c_str(), output, espresponse);
ESPCOM::print (F (")"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
//get current config
#ifdef ARDUINO_ARCH_ESP32
wifi_ap_config_t apconfig;
wifi_config_t conf;
esp_wifi_get_config (ESP_IF_WIFI_AP, &conf);
apconfig.ssid_hidden = conf.ap.ssid_hidden;
apconfig.authmode = conf.ap.authmode;
apconfig.max_connection = conf.ap.max_connection;
#else
struct softap_config apconfig;
wifi_softap_get_config (&apconfig);
#endif
if (!plaintext) {
ESPCOM::print (F ("\"ap_ssid\":\""), output, espresponse);
} else {
ESPCOM::print (F ("SSID: "), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
ESPCOM::print ( (const char*) conf.ap.ssid, output, espresponse);
#else
ESPCOM::print ( (const char*) apconfig.ssid, output, espresponse);
#endif
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"ssid_visible\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Visible: "), output, espresponse);
}
ESPCOM::print ( (apconfig.ssid_hidden == 0) ? F ("Yes") : F ("No"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"ssid_authentication\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Authentication: "), output, espresponse);
}
if (apconfig.authmode == AUTH_OPEN) {
ESPCOM::print (F ("None"), output, espresponse);
} else if (apconfig.authmode == AUTH_WEP) {
ESPCOM::print (F ("WEP"), output, espresponse);
} else if (apconfig.authmode == AUTH_WPA_PSK) {
ESPCOM::print (F ("WPA"), output, espresponse);
} else if (apconfig.authmode == AUTH_WPA2_PSK) {
ESPCOM::print (F ("WPA2"), output, espresponse);
} else {
ESPCOM::print (F ("WPA/WPA2"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"ssid_max_connections\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Max Connections: "), output, espresponse);
}
ESPCOM::print (String (apconfig.max_connection).c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"ssid_dhcp\":\""), output, espresponse);
} else {
ESPCOM::print (F ("DHCP Server: "), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
tcpip_adapter_dhcp_status_t dhcp_status;
tcpip_adapter_dhcps_get_status (TCPIP_ADAPTER_IF_AP, &dhcp_status);
if (dhcp_status == TCPIP_ADAPTER_DHCP_STARTED)
#else
if (wifi_softap_dhcps_status() == DHCP_STARTED)
#endif
{
ESPCOM::print (F ("Started"), output, espresponse);
} else {
ESPCOM::print (F ("Stopped"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"ip\":\""), output, espresponse);
} else {
ESPCOM::print (F ("IP: "), output, espresponse);
}
ESPCOM::print (WiFi.softAPIP().toString().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
#ifdef ARDUINO_ARCH_ESP32
tcpip_adapter_ip_info_t ip;
tcpip_adapter_get_ip_info (TCPIP_ADAPTER_IF_AP, &ip);
#else
struct ip_info ip;
wifi_get_ip_info (SOFTAP_IF, &ip);
#endif
if (!plaintext) {
ESPCOM::print (F ("\"gw\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Gateway: "), output, espresponse);
}
ESPCOM::print (IPAddress (ip.gw.addr).toString().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"msk\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Mask: "), output, espresponse);
}
ESPCOM::print (IPAddress (ip.netmask.addr).toString().c_str(), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"connected_clients\":["), output, espresponse);
} else {
ESPCOM::print (F ("Connected clients: "), output, espresponse);
}
int client_counter = 0;
#ifdef ARDUINO_ARCH_ESP32
wifi_sta_list_t station;
tcpip_adapter_sta_list_t tcpip_sta_list;
esp_wifi_ap_get_sta_list (&station);
tcpip_adapter_get_sta_list (&station, &tcpip_sta_list);
#else
struct station_info * station;
station = wifi_softap_get_station_info();
#endif
String stmp = "";
#ifdef ARDUINO_ARCH_ESP32
for (int i = 0; i < station.num; i++) {
#else
while (station) {
#endif
if (stmp.length() > 0) {
if (!plaintext) {
stmp += F (",");
} else {
stmp += F ("\n");
}
}
if (!plaintext) {
stmp += F ("{\"bssid\":\"");
}
//BSSID
#ifdef ARDUINO_ARCH_ESP32
stmp += CONFIG::mac2str (tcpip_sta_list.sta[i].mac);
#else
stmp += CONFIG::mac2str (station->bssid);
#endif
if (!plaintext) {
stmp += F ("\",\"ip\":\"");
} else {
stmp += F (" ");
}
//IP
#ifdef ARDUINO_ARCH_ESP32
stmp += IPAddress (tcpip_sta_list.sta[i].ip.addr).toString().c_str();
#else
stmp += IPAddress ( (const uint8_t *) &station->ip).toString().c_str();
#endif
if (!plaintext) {
stmp += F ("\"}");
}
//increment counter
client_counter++;
#ifdef ARDUINO_ARCH_ESP32
}
#else
//go next record
station = STAILQ_NEXT (station, next);
}
wifi_softap_free_station_info();
#endif
if (!plaintext) {
ESPCOM::print (stmp.c_str(), output, espresponse);
ESPCOM::print (F ("],"), output, espresponse);
} else {
//display number of client
ESPCOM::println (String (client_counter).c_str(), output, espresponse);
//display list if any
if (stmp.length() > 0) {
ESPCOM::println (stmp.c_str(), output, espresponse);
}
}
if (!plaintext) {
ESPCOM::print (F ("\"disabled_mode\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Disabled Mode: "), output, espresponse);
}
ESPCOM::print (F ("STA ("), output, espresponse);
ESPCOM::print (WiFi.macAddress().c_str(), output, espresponse);
ESPCOM::print (F (") is disabled"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
} else if (WiFi.getMode() == WIFI_AP_STA)
{
ESPCOM::print (F ("Mixed"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext) {
ESPCOM::print (F ("\"active_mode\":\""), output, espresponse);
} else {
ESPCOM::print (F ("Active Mode: "), output, espresponse);
}
ESPCOM::print (F ("AP ("), output, espresponse);
ESPCOM::print (WiFi.softAPmacAddress().c_str(), output, espresponse);
ESPCOM::println (F (")"), output, espresponse);
ESPCOM::print (F ("STA ("), output, espresponse);
ESPCOM::print (WiFi.macAddress().c_str(), output, espresponse);
ESPCOM::print (F (")"), output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
} else
{
ESPCOM::print ("Wifi Off", output, espresponse);
if (!plaintext) {
ESPCOM::print (F ("\","), output, espresponse);
} else {
ESPCOM::print (F ("\n"), output, espresponse);
}
}
if (!plaintext)
{
ESPCOM::print (F ("\"captive_portal\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Captive portal: "), output, espresponse);
}
#ifdef CAPTIVE_PORTAL_FEATURE
ESPCOM::print (F ("Enabled"), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\"ssdp\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("SSDP: "), output, espresponse);
}
#ifdef SSDP_FEATURE
ESPCOM::print (F ("Enabled"), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\"netbios\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("NetBios: "), output, espresponse);
}
#ifdef NETBIOS_FEATURE
ESPCOM::print (F ("Enabled"), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\"mdns\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("mDNS: "), output, espresponse);
}
#ifdef MDNS_FEATURE
ESPCOM::print (F ("Enabled"), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\"web_update\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Web Update: "), output, espresponse);
}
#ifdef WEB_UPDATE_FEATURE
ESPCOM::print (F ("Enabled"), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\"pin recovery\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Pin Recovery: "), output, espresponse);
}
#ifdef RECOVERY_FEATURE
ESPCOM::print (F ("Enabled"), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\"autentication\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Authentication: "), output, espresponse);
}
#ifdef AUTHENTICATION_FEATURE
ESPCOM::print (F ("Enabled"), output, espresponse);
#else
ESPCOM::print (F ("Disabled"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\"target_fw\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Target Firmware: "), output, espresponse);
}
ESPCOM::print (CONFIG::GetFirmwareTargetName(), output, espresponse);
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
//flag M117
if (!plaintext)
{
ESPCOM::print (F ("\"M117_output\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("M117 output: "), output, espresponse);
}
if (!CONFIG::is_locked(FLAG_BLOCK_M117))
{
ESPCOM::print (F ("Enabled"), output, espresponse);
} else
{
ESPCOM::print (F ("Disabled"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
#ifdef NOTIFICATION_FEATURE
if (!plaintext)
{
ESPCOM::print (F ("\"Notifications\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Notifications: "), output, espresponse);
}
if (notificationsservice.started())
{
ESPCOM::print (notificationsservice.getTypeString(), output, espresponse);
} else
{
ESPCOM::print (F ("Disabled"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
#endif
//Flag Oled
#ifdef ESP_OLED_FEATURE
if (!plaintext)
{
ESPCOM::print (F ("\"Oled_output\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Oled output: "), output, espresponse);
}
if (!CONFIG::is_locked(FLAG_BLOCK_OLED))
{
ESPCOM::print (F ("Enabled"), output, espresponse);
} else
{
ESPCOM::print (F ("Disabled"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
#endif
//flag serial
if (!plaintext)
{
ESPCOM::print (F ("\"Serial_output\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Serial output: "), output, espresponse);
}
if (!CONFIG::is_locked(FLAG_BLOCK_SERIAL))
{
ESPCOM::print (F ("Enabled"), output, espresponse);
} else
{
ESPCOM::print (F ("Disabled"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
#ifdef WS_DATA_FEATURE
//flag websocket
if (!plaintext)
{
ESPCOM::print (F ("\"Websocket_output\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Web socket output: "), output, espresponse);
}
if (!CONFIG::is_locked(FLAG_BLOCK_WSOCKET))
{
ESPCOM::print (F ("Enabled"), output, espresponse);
} else
{
ESPCOM::print (F ("Disabled"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
#endif
#ifdef TCP_IP_DATA_FEATURE
//flag tcp
if (!plaintext)
{
ESPCOM::print (F ("\"TCP_output\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("TCP output: "), output, espresponse);
}
if (!CONFIG::is_locked(FLAG_BLOCK_TCP))
{
ESPCOM::print (F ("Enabled"), output, espresponse);
} else
{
ESPCOM::print (F ("Disabled"), output, espresponse);
}
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
#endif
#ifdef DEBUG_ESP3D
if (!plaintext)
{
ESPCOM::print (F ("\"debug\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("Debug: "), output, espresponse);
}
ESPCOM::print (F ("Debug Enabled :"), output, espresponse);
#ifdef DEBUG_OUTPUT_SPIFFS
ESPCOM::print (F ("SPIFFS"), output, espresponse);
#endif
#ifdef DEBUG_OUTPUT_SD
ESPCOM::print (F ("SD"), output, espresponse);
#endif
#ifdef DEBUG_OUTPUT_SERIAL
ESPCOM::print (F ("serial"), output, espresponse);
#endif
#ifdef DEBUG_OUTPUT_TCP
ESPCOM::print (F ("TCP"), output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\","), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
#endif
if (!plaintext)
{
ESPCOM::print (F ("\"fw\":\""), output, espresponse);
} else
{
ESPCOM::print (F ("FW version: "), output, espresponse);
}
ESPCOM::print (FW_VERSION, output, espresponse);
#ifdef ARDUINO_ARCH_ESP8266
ESPCOM::print (" ESP8266/8586", output, espresponse);
#else
ESPCOM::print (" ESP32", output, espresponse);
#endif
if (!plaintext)
{
ESPCOM::print (F ("\"}"), output, espresponse);
} else
{
ESPCOM::print (F ("\n"), output, espresponse);
}
}