/* settings_esp3d.cpp - settings esp3d functions class Copyright (c) 2014 Luc Lebosse. All rights reserved. This code 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 code 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 code; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include "../include/esp3d_config.h" #if defined (ESP_SAVE_SETTINGS) #include "settings_esp3d.h" #include "esp3doutput.h" #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM #include //EEPROM SIZE (Up to 4096) #define EEPROM_SIZE 2048 //max is 2048 #endif //SETTINGS_IN_EEPROM #if defined (WIFI_FEATURE) || defined(ETH_FEATURE) #include "../modules/network/netconfig.h" #if defined (WIFI_FEATURE) #include "../modules/wifi/wificonfig.h" #endif //WIFI_FEATURE #endif //WIFI_FEATURE || ETH_FEATURE #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES #include #define NAMESPACE "ESP3D" #endif // SETTINGS_IN_PREFERENCES //Current Settings Version #define CURRENT_SETTINGS_VERSION "ESP3D04" //boundaries #define MAX_DHT_INTERVAL 60000 #define MIN_DHT_INTERVAL 0 #define MAX_LOCAL_PASSWORD_LENGTH 20 #define MIN_LOCAL_PASSWORD_LENGTH 1 #define MAX_VERSION_LENGTH 7 //ESP3DXX #define MAX_BOOT_DELAY 40000 #define MIN_BOOT_DELAY 0 #define MIN_NOTIFICATION_TOKEN_LENGTH 0 #define MIN_NOTIFICATION_SETTINGS_LENGTH 0 #define MAX_NOTIFICATION_TOKEN_LENGTH 63 #define MAX_NOTIFICATION_SETTINGS_LENGTH 128 #define MAX_SERVER_ADDRESS_LENGTH 128 #define MIN_SERVER_ADDRESS_LENGTH 0 //default byte values #ifdef WIFI_FEATURE #if defined(STATION_WIFI_SSID) && defined(STATION_WIFI_PASSWORD) #define DEFAULT_ESP_RADIO_MODE ESP_WIFI_STA #else #define DEFAULT_ESP_RADIO_MODE ESP_WIFI_AP #endif //STATION_WIFI_SSID && STATION_WIFI_PASSWORD #else //WIFI_FEATURE #ifdef BLUETOOTH_FEATURE #define DEFAULT_ESP_RADIO_MODE ESP_BT #else //BLUETOOTH_FEATURE #ifdef ETH_FEATURE #define DEFAULT_ESP_RADIO_MODE ESP_ETH_STA #else //BLUETOOTH_FEATURE #define DEFAULT_ESP_RADIO_MODE NO_NETWORK #endif //ETH_FEATURE #endif //BLUETOOTH_FEATURE #endif //WIFI_FEATURE #ifdef BUZZER_DEVICE #define DEFAULT_BUZZER_STATE 1 #endif //BUZZER_DEVICE #ifdef TIMESTAMP_FEATURE #define DEFAULT_INTERNET_TIME 0 #endif //TIMESTAMP_FEATURE #define DEFAULT_ESP_BYTE 0 #define DEFAULT_ESP_STRING_SIZE 0 #if defined (WIFI_FEATURE) || defined (ETH_FEATURE) #define DEFAULT_STA_IP_MODE DHCP_MODE #endif //WIFI_FEATURE || ETH_FEATURE //#define DEFAULT_PHY_MODE WIFI_PHY_MODE_11G //#define DEFAULT_SLEEP_MODE WIFI_MODEM_SLEEP #define DEFAULT_AP_CHANNEL 11 #define DEFAULT_AUTH_TYPE AUTH_WPA_PSK #define DEFAULT_SSID_VISIBLE 1 #define DEFAULT_OUTPUT_FLAG ESP_ALL_CLIENTS #define DEFAULT_SDREADER_SPEED 4 #define DEFAULT_FW UNKNOWN_FW #define DEFAULT_TIME_ZONE 0 #define DEFAULT_TIME_DST 0 #define DEFAULT_SD_MOUNT ESP_SD_ROOT #define DEFAULT_DIRECT_SD_CHECK 0 #define DEFAULT_SD_CHECK_UPDATE_AT_BOOT 1 #define DEFAULT_DHT_TYPE NO_DHT_DEVICE #ifdef SD_DEVICE #define DEFAULT_SD_DEVICE_TYPE SD_DEVICE_CONNECTION #else #define DEFAULT_SD_DEVICE_TYPE ESP_NO_SD #endif //SD_DEVICE #define DEFAULT_HTTP_ON 1 #define DEFAULT_FTP_ON 1 #define DEFAULT_TELNET_ON 1 #define DEFAULT_WEBSOCKET_ON 1 #define DEFAULT_NOTIFICATION_TYPE 0 #define DEFAULT_NOTIFICATION_TOKEN1 "" #define DEFAULT_NOTIFICATION_TOKEN2 "" #define DEFAULT_NOTIFICATION_SETTINGS "" #define DEFAULT_AUTO_NOTIFICATION_STATE 1 //default int values #define DEFAULT_ESP_INT 0L #define DEFAULT_BAUD_RATE 115200L #define DEFAULT_HTTP_PORT 80L #define DEFAULT_FTP_CTRL_PORT 21L #define DEFAULT_FTP_ACTIVE_PORT 20L #define DEFAULT_FTP_PASSIVE_PORT 55600L #define DEFAULT_WEBSOCKET_PORT 8282L #define DEFAULT_CAMERA_PORT 9600L #define DEFAULT_TELNET_PORT 23L #define DEFAULT_DHT_INTERVAL 30000L #define DEFAULT_BOOT_DELAY 10000L #define DEFAULT_CALIBRATION_VALUE 0 #define DEFAULT_CALIBRATION_DONE 0 #ifdef WIFI_FEATURE //default string values const char DEFAULT_AP_SSID [] = "ESP3D"; const char DEFAULT_AP_PASSWORD [] = "12345678"; #if defined(STATION_WIFI_SSID) && defined(STATION_WIFI_PASSWORD) const char DEFAULT_STA_SSID [] = STATION_WIFI_SSID; const char DEFAULT_STA_PASSWORD [] = STATION_WIFI_PASSWORD; #else const char DEFAULT_STA_SSID [] = "ESP3D"; const char DEFAULT_STA_PASSWORD [] = "12345678"; #endif //STATION_WIFI_SSID && STATION_WIFI_PASSWORD #endif //WIFI_FEATURE #if defined (BLUETOOTH_FEATURE) || defined (WIFI_FEATURE) ||defined (ETH_FEATURE) const char DEFAULT_HOSTNAME [] = "esp3d"; #endif //BLUETOOTH_FEATURE ||WIFI_FEATURE || ETH_FEATURE const char DEFAULT_ESP_STRING [] = ""; #ifdef AUTHENTICATION_FEATURE const char DEFAULT_ADMIN_PWD [] = "admin"; const char DEFAULT_USER_PWD [] = "user"; #endif //AUTHENTICATION_FEATURE #ifdef TIMESTAMP_FEATURE const char DEFAULT_TIME_SERVER1 [] = "1.pool.ntp.org"; const char DEFAULT_TIME_SERVER2 [] = "2.pool.ntp.org"; const char DEFAULT_TIME_SERVER3 [] = "0.pool.ntp.org"; #endif //TIMESTAMP_FEATURE const char DEFAULT_SETTINGS_VERSION [] = "ESP3D"; #if defined (WIFI_FEATURE) ||defined (ETH_FEATURE) //default IP values const uint8_t DEFAULT_IP_VALUE[] = {192, 168, 0, 1}; const uint8_t DEFAULT_MASK_VALUE[] = {255, 255, 255, 0}; #define DEFAULT_GATEWAY_VALUE DEFAULT_IP_VALUE const uint8_t DEFAULT_ADDRESS_VALUE[] = {0, 0, 0, 0}; #endif //WIFI_FEATURE || ETH_FEATURE uint8_t Settings_ESP3D::_FirmwareTarget = UNKNOWN_FW; bool Settings_ESP3D::_SDdevice = ESP_NO_SD; bool Settings_ESP3D::begin() { if(GetSettingsVersion() == -1) { return false; } //get target FW Settings_ESP3D::GetFirmwareTarget(true); //get SD device if any Settings_ESP3D::GetSDDevice(true); return true; } uint8_t Settings_ESP3D::GetFirmwareTarget(bool fromsettings) { if(fromsettings) { _FirmwareTarget = read_byte (ESP_TARGET_FW); } return _FirmwareTarget; } uint8_t Settings_ESP3D::GetSDDevice(bool fromsettings) { if(fromsettings) { #ifdef SD_DEVICE _SDdevice = read_byte (ESP_SD_DEVICE_TYPE); #else // !SD_DEVICE _SDdevice = ESP_NO_SD; #endif //SD_DEVICE } return _SDdevice; } const char* Settings_ESP3D::GetFirmwareTargetShortName() { static String response; if ( _FirmwareTarget == REPETIER4DV) { response = F ("repetier4davinci"); } else if ( _FirmwareTarget == REPETIER) { response = F ("repetier"); } else if ( _FirmwareTarget == MARLIN) { response = F ("marlin"); } else if ( _FirmwareTarget == MARLINKIMBRA) { response = F ("marlinkimbra"); } else if ( _FirmwareTarget == SMOOTHIEWARE) { response = F ("smoothieware"); } else if ( _FirmwareTarget == GRBL) { response = F ("grbl"); } else { response = F ("unknown"); } return response.c_str(); } //Default value for a byte setting uint8_t Settings_ESP3D::get_default_byte_value(int pos) { uint8_t res; switch(pos) { case ESP_RADIO_MODE: res = DEFAULT_ESP_RADIO_MODE; break; #ifdef TIMESTAMP_FEATURE case ESP_INTERNET_TIME: res = DEFAULT_INTERNET_TIME; break; #endif //TIMESTAMP_FEATURE #ifdef BUZZER_DEVICE case ESP_BUZZER: res = DEFAULT_BUZZER_STATE; break; #endif //BUZZER_DEVICE #ifdef NOTIFICATION_FEATURE case ESP_NOTIFICATION_TYPE: res = DEFAULT_NOTIFICATION_TYPE; break; case ESP_AUTO_NOTIFICATION: res = DEFAULT_AUTO_NOTIFICATION_STATE; break; #endif //NOTIFICATION_FEATURE #if defined (WIFI_FEATURE) || defined (ETH_FEATURE) case ESP_STA_IP_MODE: res = DEFAULT_STA_IP_MODE; break; #endif //WIFI_FEATURE || ETH_FEATURE //case ESP_AP_PHY_MODE: //case ESP_STA_PHY_MODE: // res = DEFAULT_PHY_MODE; // break; //case ESP_SLEEP_MODE: // res = DEFAULT_SLEEP_MODE; // break; #if defined (WIFI_FEATURE) case ESP_AP_CHANNEL: res = DEFAULT_AP_CHANNEL; break; //case ESP_AP_AUTH_TYPE: // res = DEFAULT_AUTH_TYPE; // break; //case ESP_SSID_VISIBLE: // res = DEFAULT_SSID_VISIBLE; // break; #endif //WIFI_FEATURE case ESP_OUTPUT_FLAG: res = DEFAULT_OUTPUT_FLAG; break; #ifdef FTP_FEATURE case ESP_FTP_ON: res = DEFAULT_FTP_ON; break; #endif //FTP_FEATURE #ifdef HTTP_FEATURE case ESP_HTTP_ON: res = DEFAULT_HTTP_ON; break; #endif //HTTP_FEATURE #ifdef TELNET_FEATURE case ESP_TELNET_ON: res = DEFAULT_TELNET_ON; break; #endif //TELNET_FEATURE #ifdef WS_DATA_FEATURE case ESP_WEBSOCKET_ON: res = DEFAULT_WEBSOCKET_ON; break; #endif //WS_DATA_FEATURE #ifdef SD_DEVICE case ESP_SD_SPEED_DIV: res = DEFAULT_SDREADER_SPEED; break; case ESP_SD_MOUNT: res = DEFAULT_SD_MOUNT; break; case ESP_DIRECT_SD_CHECK: res = DEFAULT_DIRECT_SD_CHECK; break; case ESP_SD_CHECK_UPDATE_AT_BOOT: res = DEFAULT_SD_CHECK_UPDATE_AT_BOOT; break; case ESP_SD_DEVICE_TYPE: res = DEFAULT_SD_DEVICE_TYPE; break; #endif //SD_DEVICE case ESP_TARGET_FW: res = DEFAULT_FW; break; #ifdef TIMESTAMP_FEATURE case ESP_TIMEZONE: res = DEFAULT_TIME_ZONE; break; case ESP_TIME_IS_DST: res = DEFAULT_TIME_DST; break; #endif //TIMESTAMP_FEATURE #if defined(DHT_DEVICE) case ESP_DHT_TYPE: res = DEFAULT_DHT_TYPE; break; #endif //DHT_DEVICE #if defined(DISPLAY_DEVICE) && defined(DISPLAY_TOUCH_DRIVER) case ESP_CALIBRATION: res = DEFAULT_CALIBRATION_DONE; break; #endif // DISPLAY_DEVICE && DISPLAY_TOUCH_DRIVER default: res = DEFAULT_ESP_BYTE; } return res; } //Default value for a int32 setting uint32_t Settings_ESP3D::get_default_int32_value(int pos) { uint32_t res; switch(pos) { case ESP_BAUD_RATE: res = DEFAULT_BAUD_RATE; break; case ESP_BOOT_DELAY: res = DEFAULT_BOOT_DELAY; break; #if defined(DISPLAY_DEVICE) && defined(DISPLAY_TOUCH_DRIVER) case ESP_CALIBRATION_1: case ESP_CALIBRATION_2: case ESP_CALIBRATION_3: case ESP_CALIBRATION_4: case ESP_CALIBRATION_5: res = DEFAULT_CALIBRATION_VALUE; break; #endif // DISPLAY_DEVICE && DISPLAY_TOUCH_DRIVER #if defined (WIFI_FEATURE) || defined (ETH_FEATURE) case ESP_AP_IP_VALUE: case ESP_STA_IP_VALUE: res = IPAddress(DEFAULT_IP_VALUE); break; case ESP_STA_MASK_VALUE: res = IPAddress(DEFAULT_MASK_VALUE); break; case ESP_STA_GATEWAY_VALUE: res = IPAddress(DEFAULT_GATEWAY_VALUE); break; #endif //WIFI_FEATURE || ETH_FEATURE #ifdef FTP_FEATURE case ESP_FTP_CTRL_PORT: res = DEFAULT_FTP_CTRL_PORT; break; case ESP_FTP_DATA_ACTIVE_PORT: res = DEFAULT_FTP_ACTIVE_PORT; break; case ESP_FTP_DATA_PASSIVE_PORT: res = DEFAULT_FTP_PASSIVE_PORT; break; #endif //FTP_FEATURE #ifdef HTTP_FEATURE case ESP_HTTP_PORT: res = DEFAULT_HTTP_PORT; break; #endif //HTTP_FEATURE #ifdef TELNET_FEATURE case ESP_TELNET_PORT: res = DEFAULT_TELNET_PORT; break; #endif //TELNET_FEATURE #ifdef WS_DATA_FEATURE case ESP_WEBSOCKET_PORT: res = DEFAULT_WEBSOCKET_PORT; break; #endif //WS_DATA_FEATURE #ifdef CAMERA_DEVICE case ESP_CAMERA_PORT: res = DEFAULT_CAMERA_PORT; break; #endif //CAMERA_DEVICE #if defined(DHT_DEVICE) case ESP_DHT_INTERVAL: res = DEFAULT_DHT_INTERVAL; break; #endif //DHT_DEVICE default: res = DEFAULT_ESP_INT; } return res; } //Max value for a int32 setting uint32_t Settings_ESP3D::get_max_int32_value(int pos) { uint32_t res; switch(pos) { case ESP_BOOT_DELAY: res = MAX_BOOT_DELAY; break; #ifdef CAMERA_DEVICE case ESP_CAMERA_PORT: res = MAX_HTTP_PORT; break; #endif //CAMERA_DEVICE #ifdef FTP_FEATURE case ESP_FTP_CTRL_PORT: case ESP_FTP_DATA_ACTIVE_PORT: case ESP_FTP_DATA_PASSIVE_PORT: res = MAX_FTP_PORT; break; #endif //FTP_FEATURE #ifdef HTTP_FEATURE case ESP_HTTP_PORT: res = MAX_HTTP_PORT; break; #endif //HTTP_FEATURE #ifdef TELNET_FEATURE case ESP_TELNET_PORT: res = MAX_TELNET_PORT; break; #endif //TELNET_FEATURE #ifdef WS_DATA_FEATURE case ESP_WEBSOCKET_PORT: res = MAX_WEBSOCKET_PORT; break; #endif //WS_DATA_FEATURE #if defined(DHT_DEVICE) case ESP_DHT_INTERVAL: res = MAX_DHT_INTERVAL; break; #endif //DHT_DEVICE default: res = DEFAULT_ESP_INT; } return res; } //Min value for a int32 setting uint32_t Settings_ESP3D::get_min_int32_value(int pos) { uint32_t res; switch(pos) { case ESP_BOOT_DELAY: res = MIN_BOOT_DELAY; break; #ifdef CAMERA_DEVICE case ESP_CAMERA_PORT: res =MIN_HTTP_PORT; break; #endif //CAMERA_DEVICE #ifdef FTP_FEATURE case ESP_FTP_CTRL_PORT: case ESP_FTP_DATA_ACTIVE_PORT: case ESP_FTP_DATA_PASSIVE_PORT: res =MIN_FTP_PORT; break; #endif //FTP_FEATURE #ifdef HTTP_FEATURE case ESP_HTTP_PORT: res = MIN_HTTP_PORT; break; #endif //HTTP_FEATURE #ifdef TELNET_FEATURE case ESP_TELNET_PORT: res = MIN_TELNET_PORT; break; #endif //TELNET_FEATURE #ifdef WS_DATA_FEATURE case ESP_WEBSOCKET_PORT: res = MIN_WEBSOCKET_PORT; break; #endif //WS_DATA_FEATURE #if defined(DHT_DEVICE) case ESP_DHT_INTERVAL: res = MIN_DHT_INTERVAL; break; #endif //DHT_DEVICE default: res = DEFAULT_ESP_INT; } return res; } uint8_t Settings_ESP3D::get_max_byte(int pos) { uint8_t res; switch(pos) { #if defined (WIFI_FEATURE) case ESP_AP_CHANNEL: res = MAX_CHANNEL; break; #endif //WIFI_FEATURE #ifdef TIMESTAMP_FEATURE case ESP_TIMEZONE: res= 12; break; #endif //TIMESTAMP_FEATURE default: res = 255; } return res; } int8_t Settings_ESP3D::get_min_byte(int pos) { uint8_t res; switch(pos) { #if defined (WIFI_FEATURE) case ESP_AP_CHANNEL: res = MIN_CHANNEL; break; #endif //WIFI_FEATURE #ifdef TIMESTAMP_FEATURE case ESP_TIMEZONE: res= -12; break; #endif //TIMESTAMP_FEATURE default: res = 0; } return res; } //Default value for a ip setting uint32_t Settings_ESP3D::get_default_IP_value(int pos) { return get_default_int32_value(pos); } //Default value for a byte setting const String & Settings_ESP3D::get_default_string_value(int pos) { static String res; switch(pos) { #if defined (WIFI_FEATURE) || defined (ETH_FEATURE) || defined (BLUETOOTH_FEATURE) case ESP_HOSTNAME: res = DEFAULT_HOSTNAME; break; #endif //WIFI_FEATURE || ETH_FEATURE || defined (ETH_FEATURE) #ifdef TIMESTAMP_FEATURE case ESP_TIME_SERVER1: res = DEFAULT_TIME_SERVER1; break; case ESP_TIME_SERVER2: res = DEFAULT_TIME_SERVER2; break; case ESP_TIME_SERVER3: res = DEFAULT_TIME_SERVER3; break; #endif //TIMESTAMP_FEATURE #ifdef NOTIFICATION_FEATURE case ESP_NOTIFICATION_TOKEN1: res = DEFAULT_NOTIFICATION_TOKEN1; break; case ESP_NOTIFICATION_TOKEN2: res = DEFAULT_NOTIFICATION_TOKEN2; break; case ESP_NOTIFICATION_SETTINGS: res = DEFAULT_NOTIFICATION_SETTINGS; break; #endif //NOTIFICATION_FEATURE #if defined (WIFI_FEATURE) case ESP_STA_SSID: res = DEFAULT_STA_SSID; break; case ESP_AP_SSID: res = DEFAULT_AP_SSID; break; case ESP_STA_PASSWORD: res = DEFAULT_STA_PASSWORD; break; case ESP_AP_PASSWORD: res = DEFAULT_AP_PASSWORD; break; #endif //WIFI_FEATURE #ifdef AUTHENTICATION_FEATURE case ESP_ADMIN_PWD: res = DEFAULT_ADMIN_PWD; break; case ESP_USER_PWD: res = DEFAULT_USER_PWD; break; #endif //AUTHENTICATION_FEATURE case ESP_SETTINGS_VERSION: res = DEFAULT_SETTINGS_VERSION; break; default: res = DEFAULT_ESP_STRING; } return res; } //Max size of for a string setting uint8_t Settings_ESP3D::get_max_string_size(int pos) { uint8_t res; switch(pos) { #if defined (WIFI_FEATURE) || defined (ETH_FEATURE) || defined (BLUETOOTH_FEATURE) case ESP_HOSTNAME: res = MAX_HOSTNAME_LENGTH; break; #endif //WIFI_FEATURE || ETH_FEATURE || BLUETOOTH_FEATURE #ifdef TIMESTAMP_FEATURE case ESP_TIME_SERVER1: case ESP_TIME_SERVER2: case ESP_TIME_SERVER3: res = MAX_SERVER_ADDRESS_LENGTH; break; #endif //TIMESTAMP_FEATURE #ifdef NOTIFICATION_FEATURE case ESP_NOTIFICATION_TOKEN1: case ESP_NOTIFICATION_TOKEN2: res = MAX_NOTIFICATION_TOKEN_LENGTH; break; case ESP_NOTIFICATION_SETTINGS: res = MAX_NOTIFICATION_SETTINGS_LENGTH; break; #endif //NOTIFICATION_FEATURE #if defined (WIFI_FEATURE) case ESP_STA_SSID: case ESP_AP_SSID: res = MAX_SSID_LENGTH; break; case ESP_STA_PASSWORD: case ESP_AP_PASSWORD: res = MAX_PASSWORD_LENGTH; break; #endif //WIFI_FEATURE #ifdef AUTHENTICATION_FEATURE case ESP_ADMIN_PWD: case ESP_USER_PWD: res = MAX_LOCAL_PASSWORD_LENGTH; break; #endif //AUTHENTICATION_FEATURE case ESP_SETTINGS_VERSION: res = MAX_VERSION_LENGTH; break; default: res = DEFAULT_ESP_STRING_SIZE; } return res; } //Min size of for a string setting uint8_t Settings_ESP3D::get_min_string_size(int pos) { uint8_t res; switch(pos) { #if defined (WIFI_FEATURE) || defined (ETH_FEATURE) || defined (BLUETOOTH_FEATURE) case ESP_HOSTNAME: res = MIN_HOSTNAME_LENGTH; break; #endif //WIFI_FEATURE || ETH_FEATURE || BLUETOOTH_FEATURE #ifdef NOTIFICATION_FEATURE case ESP_NOTIFICATION_TOKEN1: case ESP_NOTIFICATION_TOKEN2: res = MIN_NOTIFICATION_TOKEN_LENGTH; break; case ESP_NOTIFICATION_SETTINGS: res = MIN_NOTIFICATION_SETTINGS_LENGTH; break; #endif //NOTIFICATION_FEATURE #ifdef TIMESTAMP_FEATURE case ESP_TIME_SERVER1: case ESP_TIME_SERVER2: case ESP_TIME_SERVER3: res = MIN_SERVER_ADDRESS_LENGTH; break; #endif //TIMESTAMP_FEATURE #if defined (WIFI_FEATURE) case ESP_STA_SSID: case ESP_AP_SSID: res = MIN_SSID_LENGTH; break; case ESP_STA_PASSWORD: case ESP_AP_PASSWORD: res = MIN_PASSWORD_LENGTH; break; #endif //WIFI_FEATURE #ifdef AUTHENTICATION_FEATURE case ESP_ADMIN_PWD: case ESP_USER_PWD: res = MIN_LOCAL_PASSWORD_LENGTH; break; #endif //AUTHENTICATION_FEATURE default: res = DEFAULT_ESP_STRING_SIZE; } return res; } uint8_t Settings_ESP3D::read_byte (int pos, bool * haserror) { if(haserror) { *haserror = true; } uint8_t value = get_default_byte_value(pos); #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM //check if parameters are acceptable if ((pos + 1 > EEPROM_SIZE) ) { log_esp3d("Error read byte %d", pos); return value; } //read byte EEPROM.begin (EEPROM_SIZE); value = EEPROM.read (pos); EEPROM.end(); #endif //SETTINGS_IN_EEPROM #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES Preferences prefs; if (!prefs.begin(NAMESPACE, true)) { log_esp3d("Error opening %s", NAMESPACE); return value; } String p = "P_" + String(pos); value = prefs.getChar(p.c_str(), get_default_byte_value(pos)); prefs.end(); #endif //SETTINGS_IN_PREFERENCES if(haserror) { *haserror = false; } return value; } //write a flag / byte bool Settings_ESP3D::write_byte (int pos, const uint8_t value) { #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM //check if parameters are acceptable if (pos + 1 > EEPROM_SIZE) { log_esp3d("Error read byte %d", pos); return false; } EEPROM.begin (EEPROM_SIZE); EEPROM.write (pos, value); if (!EEPROM.commit()) { log_esp3d("Error commit %d", pos); return false; } EEPROM.end(); #endif //SETTINGS_IN_EEPROM #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES Preferences prefs; if (!prefs.begin(NAMESPACE, false)) { log_esp3d("Error opening %s", NAMESPACE); return false; } String p = "P_" + String(pos); uint8_t r = prefs.putChar(p.c_str(), value); prefs.end(); if (r == 0) { log_esp3d("Error commit %s", p.c_str()); return false; } #endif //SETTINGS_IN_PREFERENCES return true; } bool Settings_ESP3D::is_string(const char * s, uint len) { for (uint p = 0; p < len; p++) { if (!isPrintable (char(s[p]))) { return false; } } return true; } //read a string //a string is multibyte + \0, this is won't work if 1 char is multibyte like chinese char const char * Settings_ESP3D::read_string (int pos, bool *haserror) { uint8_t size_max = get_max_string_size(pos); if (haserror) { *haserror = true; } if (size_max == 0) { log_esp3d("Error size string %d", pos); return DEFAULT_ESP_STRING; } #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM static char * byte_buffer = NULL; size_max++;//do not forget the 0x0 for the end if (byte_buffer) { free (byte_buffer); byte_buffer = NULL; } //check if parameters are acceptable if (pos + size_max + 1 > EEPROM_SIZE) { log_esp3d("Error read string %d", pos); return DEFAULT_ESP_STRING; } byte_buffer = (char *)malloc(size_max+1); if (!byte_buffer) { log_esp3d("Error mem read string %d", pos); return DEFAULT_ESP_STRING; } EEPROM.begin (EEPROM_SIZE); byte b = 1; // 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] = isPrintable (char(b))?b:0; i++; } // Be sure there is a 0 at the end. if (b != 0) { byte_buffer[i - 1] = 0x00; } EEPROM.end(); if (haserror) { *haserror = false; } return byte_buffer; #endif //SETTINGS_IN_EEPROM #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES Preferences prefs; static String res; if (!prefs.begin(NAMESPACE, true)) { log_esp3d("Error opening %s", NAMESPACE); return ""; } String p = "P_" + String(pos); res = prefs.getString(p.c_str(), get_default_string_value(pos)); prefs.end(); if (res.length() > size_max) { log_esp3d("String too long %d vs %d", res.length(), size_max); res = res.substring(0,size_max-1); } if (haserror) { *haserror = false; } return res.c_str(); #endif //SETTINGS_IN_PREFERENCES } //write a string (array of byte with a 0x00 at the end) bool Settings_ESP3D::write_string (int pos, const char * byte_buffer) { int size_buffer = strlen (byte_buffer); uint8_t size_max = get_max_string_size(pos); //check if parameters are acceptable if (size_max == 0) { log_esp3d("Error unknow entry %d", pos); return false; } if (size_max < size_buffer) { log_esp3d("Error string too long %d, %d", pos, size_buffer); return false; } #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM if ( pos + size_buffer + 1 > EEPROM_SIZE || byte_buffer == NULL) { log_esp3d("Error write string %d", pos); 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); if (!EEPROM.commit()) { log_esp3d("Error commit %d", pos); return false; } EEPROM.end(); #endif //SETTINGS_IN_EEPROM #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES Preferences prefs; if (!prefs.begin(NAMESPACE, false)) { log_esp3d("Error opening %s", NAMESPACE); return false; } String p = "P_" + String(pos); uint8_t r = prefs.putString(p.c_str(), byte_buffer); prefs.end(); if (r != size_buffer) { log_esp3d("Error commit %s", p.c_str()); return false; } #endif //SETTINGS_IN_PREFERENCES return true; } //read a uint32 uint32_t Settings_ESP3D::read_uint32(int pos, bool * haserror) { if (haserror) { *haserror = true; } uint32_t res = get_default_int32_value(pos); #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM //check if parameters are acceptable uint8_t size_buffer = sizeof(uint32_t); if ( pos + size_buffer > EEPROM_SIZE ) { log_esp3d("Error read int %d", pos); return res; } uint8_t i = 0; EEPROM.begin (EEPROM_SIZE); //read until max size is reached while (i < size_buffer ) { ((uint8_t *)(&res))[i] = EEPROM.read (pos + i); i++; } EEPROM.end(); #endif //SETTINGS_IN_EEPROM #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES Preferences prefs; if (!prefs.begin(NAMESPACE, true)) { log_esp3d("Error opening %s", NAMESPACE); return res; } String p = "P_" + String(pos); res = prefs.getUInt(p.c_str(), res); prefs.end(); #endif //SETTINGS_IN_PREFERENCES if (haserror) { *haserror = false; } return res; } //read an IP uint32_t Settings_ESP3D::read_IP(int pos, bool * haserror) { return read_uint32(pos,haserror); } //read an IP String Settings_ESP3D::read_IP_String(int pos, bool * haserror) { return IPtoString(read_uint32(pos,haserror)); } //write a uint32 bool Settings_ESP3D::write_uint32(int pos, const uint32_t value) { #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM uint8_t size_buffer = sizeof(uint32_t); //check if parameters are acceptable if (pos + size_buffer > EEPROM_SIZE) { log_esp3d("Error invalid entry %d", pos); return false; } EEPROM.begin (EEPROM_SIZE); //copy the value(s) for (int i = 0; i < size_buffer; i++) { EEPROM.write (pos + i, ((uint8_t *)(&value))[i]); } if (!EEPROM.commit()) { log_esp3d("Error commit %d", pos); return false; } EEPROM.end(); #endif //SETTINGS_IN_EEPROM #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES Preferences prefs; if (!prefs.begin(NAMESPACE, false)) { log_esp3d("Error opening %s", NAMESPACE); return false; } String p = "P_" + String(pos); uint8_t r = prefs.putUInt(p.c_str(), value); prefs.end(); if (r == 0) { log_esp3d("Error commit %s", p.c_str()); return false; } #endif //SETTINGS_IN_PREFERENCES return true; } //write a IP bool Settings_ESP3D::write_IP(int pos, const uint32_t value) { return write_uint32(pos, value); } //clear all entries bool Settings_ESP3D::reset() { bool res = true; log_esp3d("Reset Settings"); #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES log_esp3d("clear preferences"); Preferences prefs; if (!prefs.begin(NAMESPACE, false)) { return false; } res = prefs.clear(); prefs.end(); #endif //SETTINGS_IN_PREFERENCES //for EEPROM need to overwrite all settings #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM log_esp3d("clear EEPROM"); #if defined(DISPLAY_DEVICE) && defined(DISPLAY_TOUCH_DRIVER) //Calibration done (internal only) Settings_ESP3D::write_byte(ESP_CALIBRATION,Settings_ESP3D::get_default_byte_value(ESP_CALIBRATION)); //Calibration data (internal only) Settings_ESP3D::write_uint32 (ESP_CALIBRATION_1, Settings_ESP3D::get_default_int32_value(ESP_CALIBRATION_1)); Settings_ESP3D::write_uint32 (ESP_CALIBRATION_2, Settings_ESP3D::get_default_int32_value(ESP_CALIBRATION_2)); Settings_ESP3D::write_uint32 (ESP_CALIBRATION_3, Settings_ESP3D::get_default_int32_value(ESP_CALIBRATION_3)); Settings_ESP3D::write_uint32 (ESP_CALIBRATION_4, Settings_ESP3D::get_default_int32_value(ESP_CALIBRATION_4)); Settings_ESP3D::write_uint32 (ESP_CALIBRATION_5, Settings_ESP3D::get_default_int32_value(ESP_CALIBRATION_5)); #endif // DISPLAY_DEVICE && DISPLAY_TOUCH_DRIVER #ifdef BUZZER_DEVICE //Buzzer state Settings_ESP3D::write_byte(ESP_BUZZER,Settings_ESP3D::get_default_byte_value(ESP_BUZZER)); #endif //BUZZER_DEVICE #if defined (WIFI_FEATURE) || defined (BLUETOOTH_FEATURE) || defined (ETH_FEATURE) //Hostname Settings_ESP3D::write_string(ESP_HOSTNAME,Settings_ESP3D::get_default_string_value(ESP_HOSTNAME).c_str()); #endif //WIFI_FEATURE || BLUETOOTH_FEATURE || ETH_FEATURE #ifdef NOTIFICATION_FEATURE //Auto Notification Settings_ESP3D::write_byte(ESP_AUTO_NOTIFICATION,Settings_ESP3D::get_default_byte_value(ESP_AUTO_NOTIFICATION)); //Notification Type Settings_ESP3D::write_byte(ESP_NOTIFICATION_TYPE,Settings_ESP3D::get_default_byte_value(ESP_NOTIFICATION_TYPE)); //Notification Token1 Settings_ESP3D::write_string(ESP_NOTIFICATION_TOKEN1,Settings_ESP3D::get_default_string_value(ESP_NOTIFICATION_TOKEN1).c_str()); //Notification Token2 Settings_ESP3D::write_string(ESP_NOTIFICATION_TOKEN2,Settings_ESP3D::get_default_string_value(ESP_NOTIFICATION_TOKEN2).c_str()); //Notification Settings Settings_ESP3D::write_string(ESP_NOTIFICATION_SETTINGS,Settings_ESP3D::get_default_string_value(ESP_NOTIFICATION_SETTINGS).c_str()); #endif //NOTIFICATION_FEATURE //radio mode Settings_ESP3D::write_byte(ESP_RADIO_MODE,Settings_ESP3D::get_default_byte_value(ESP_RADIO_MODE)); #if defined (WIFI_FEATURE) //STA SSID Settings_ESP3D::write_string(ESP_STA_SSID,Settings_ESP3D::get_default_string_value(ESP_STA_SSID).c_str()); //STA pwd Settings_ESP3D::write_string(ESP_STA_PASSWORD,Settings_ESP3D::get_default_string_value(ESP_STA_PASSWORD).c_str()); //AP SSID Settings_ESP3D::write_string(ESP_AP_SSID,Settings_ESP3D::get_default_string_value(ESP_AP_SSID).c_str()); //AP password Settings_ESP3D::write_string(ESP_AP_PASSWORD,Settings_ESP3D::get_default_string_value(ESP_AP_PASSWORD).c_str()); //AP static IP Settings_ESP3D::write_IP(ESP_AP_IP_VALUE, Settings_ESP3D::get_default_IP_value(ESP_AP_IP_VALUE)); //AP Channel Settings_ESP3D::write_byte(ESP_AP_CHANNEL,Settings_ESP3D::get_default_byte_value(ESP_AP_CHANNEL)); //AP Network Mode (PHY) //Settings_ESP3D::write_byte(ESP_AP_PHY_MODE,Settings_ESP3D::get_default_byte_value(ESP_AP_PHY_MODE)); //AP Authentication //Settings_ESP3D::write_byte(ESP_AP_AUTH_TYPE,Settings_ESP3D::get_default_byte_value(ESP_AP_AUTH_TYPE)); //AP SSID visibility //Settings_ESP3D::write_byte(ESP_SSID_VISIBLE,Settings_ESP3D::get_default_byte_value(ESP_SSID_VISIBLE)); #endif //WIFI_FEATURE #if defined (WIFI_FEATURE) || defined (ETH_FEATURE) //STA Network Mode //Settings_ESP3D::write_byte(ESP_STA_PHY_MODE,Settings_ESP3D::get_default_byte_value(ESP_STA_PHY_MODE)); //STA IP mode Settings_ESP3D::write_byte(ESP_STA_IP_MODE,Settings_ESP3D::get_default_byte_value(ESP_STA_IP_MODE)); //STA static IP Settings_ESP3D::write_IP(ESP_STA_IP_VALUE, Settings_ESP3D::get_default_IP_value(ESP_STA_IP_VALUE)); //STA static Gateway Settings_ESP3D::write_IP(ESP_STA_GATEWAY_VALUE, Settings_ESP3D::get_default_IP_value(ESP_STA_GATEWAY_VALUE)); //STA static Mask Settings_ESP3D::write_IP(ESP_STA_MASK_VALUE, Settings_ESP3D::get_default_IP_value(ESP_STA_MASK_VALUE)); #endif //WIFI_FEATURE || ETH_FEATURE #ifdef FTP_FEATURE //FTP On Settings_ESP3D::write_byte(ESP_FTP_ON,Settings_ESP3D::get_default_byte_value(ESP_FTP_ON)); //FTP Ctrl Port Settings_ESP3D::write_uint32 (ESP_FTP_CTRL_PORT, Settings_ESP3D::get_default_int32_value(ESP_FTP_CTRL_PORT)); //FTP Active data Port Settings_ESP3D::write_uint32 (ESP_FTP_DATA_ACTIVE_PORT, Settings_ESP3D::get_default_int32_value(ESP_FTP_DATA_ACTIVE_PORT)); //FTP Pasive data Port Settings_ESP3D::write_uint32 (ESP_FTP_DATA_PASSIVE_PORT, Settings_ESP3D::get_default_int32_value(ESP_FTP_DATA_PASSIVE_PORT)); #endif //FTP_FEATURE #ifdef HTTP_FEATURE //HTTP On Settings_ESP3D::write_byte(ESP_HTTP_ON,Settings_ESP3D::get_default_byte_value(ESP_HTTP_ON)); //HTTP Port Settings_ESP3D::write_uint32 (ESP_HTTP_PORT, Settings_ESP3D::get_default_int32_value(ESP_HTTP_PORT)); #endif //HTTP_FEATURE #ifdef TELNET_FEATURE //TELNET On Settings_ESP3D::write_byte(ESP_TELNET_ON,Settings_ESP3D::get_default_byte_value(ESP_TELNET_ON)); //TELNET Port Settings_ESP3D::write_uint32 (ESP_TELNET_PORT, Settings_ESP3D::get_default_int32_value(ESP_TELNET_PORT)); #endif //TELNET #ifdef CAMERA_DEVICE //Camera Port Settings_ESP3D::write_uint32 (ESP_CAMERA_PORT, Settings_ESP3D::get_default_int32_value(ESP_CAMERA_PORT)); #endif //CAMERA_DEVICE #ifdef WS_DATA_FEATURE //Websocket On Settings_ESP3D::write_byte(ESP_WEBSOCKET_ON,Settings_ESP3D::get_default_byte_value(ESP_WEBSOCKET_ON)); //Websocket Port Settings_ESP3D::write_uint32 (ESP_WEBSOCKET_PORT, Settings_ESP3D::get_default_int32_value(ESP_WEBSOCKET_PORT)); #endif //WS_DATA_FEATURE #ifdef AUTHENTICATION_FEATURE //Admin password Settings_ESP3D::write_string(ESP_ADMIN_PWD,Settings_ESP3D::get_default_string_value(ESP_ADMIN_PWD).c_str()); //User password Settings_ESP3D::write_string(ESP_USER_PWD,Settings_ESP3D::get_default_string_value(ESP_USER_PWD).c_str()); #endif //AUTHENTICATION_FEATURE //Target FW Settings_ESP3D::write_byte(ESP_TARGET_FW,Settings_ESP3D::get_default_byte_value(ESP_TARGET_FW)); //Output flag Settings_ESP3D::write_byte(ESP_OUTPUT_FLAG,Settings_ESP3D::get_default_byte_value(ESP_OUTPUT_FLAG)); #ifdef SD_DEVICE //Direct SD Settings_ESP3D::write_byte(ESP_SD_DEVICE_TYPE,Settings_ESP3D::get_default_byte_value(ESP_SD_DEVICE_TYPE)); //SPI SD Divider Settings_ESP3D::write_byte(ESP_SD_SPEED_DIV,Settings_ESP3D::get_default_byte_value(ESP_SD_SPEED_DIV)); #endif //SD_DEVICE #ifdef TIMESTAMP_FEATURE //Internet time Settings_ESP3D::write_byte(ESP_INTERNET_TIME,Settings_ESP3D::get_default_byte_value(ESP_INTERNET_TIME)); //Time Zone Settings_ESP3D::write_byte(ESP_TIMEZONE,Settings_ESP3D::get_default_byte_value(ESP_TIMEZONE)); //Is DST Time Zone Settings_ESP3D::write_byte(ESP_TIME_IS_DST,Settings_ESP3D::get_default_byte_value(ESP_TIME_IS_DST)); //Time Server 1 address Settings_ESP3D::write_string(ESP_TIME_SERVER1, Settings_ESP3D::get_default_string_value(ESP_TIME_SERVER1).c_str()); //Time Server 2 address Settings_ESP3D::write_string(ESP_TIME_SERVER2, Settings_ESP3D::get_default_string_value(ESP_TIME_SERVER2).c_str()); //Time Server 3 address Settings_ESP3D::write_string(ESP_TIME_SERVER3, Settings_ESP3D::get_default_string_value(ESP_TIME_SERVER3).c_str()); #endif //TIMESTAMP_FEATURE #ifdef DHT_DEVICE //DHT device Settings_ESP3D::write_byte(ESP_DHT_TYPE,Settings_ESP3D::get_default_byte_value(ESP_DHT_TYPE)); //DHT query interval Settings_ESP3D::write_uint32 (ESP_DHT_INTERVAL, Settings_ESP3D::get_default_int32_value(ESP_DHT_INTERVAL)); #endif //DHT_DEVICE //Start Delay Settings_ESP3D::write_uint32 (ESP_BOOT_DELAY, Settings_ESP3D::get_default_int32_value(ESP_BOOT_DELAY)); #endif //SETTINGS_IN_EEPROM //set version in settings if (res) { log_esp3d("Reset Setting Version"); //Settings version (internal only) res = Settings_ESP3D::write_string(ESP_SETTINGS_VERSION, CURRENT_SETTINGS_VERSION); } return res; } //Get Settings Version // * -1 means no version detected // * 00 / 01 Not used // * 03 and up is version int8_t Settings_ESP3D::GetSettingsVersion() { int8_t v = -1; String version = Settings_ESP3D::read_string(ESP_SETTINGS_VERSION); if ((version == "ESP3D") ||( version.length() != 7) || (version.indexOf("ESP3D")!=0)) { log_esp3d("Invalid Settings Version %s",version.c_str()); return v; } v = version.substring(5).toInt(); log_esp3d("Settings Version %d", v); return v; } //write a IP from string bool Settings_ESP3D::write_IP_String(int pos, const char * value) { return write_uint32(pos, StringtoIP(value)); } //Helper to convert IP string to int uint32_t Settings_ESP3D::StringtoIP(const char *s) { uint32_t ip_int = 0; IPAddress ipaddr; if (ipaddr.fromString(s)) { ip_int = ipaddr; } return ip_int; } // Helper to convert int to IP string String Settings_ESP3D::IPtoString(uint32_t ip_int) { static IPAddress ipaddr; ipaddr = ip_int; return ipaddr.toString(); } const char * Settings_ESP3D::TargetBoard() { #ifdef ARDUINO_ARCH_ESP32 return "ESP32"; #endif //ARDUINO_ARCH_ESP32 #ifdef ARDUINO_ARCH_ESP8266 return "ESP82XX"; #endif //ARDUINO_ARCH_ESP8266 } bool Settings_ESP3D::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 (uint8_t i = 0; i < strlen (password); i++) { c = password[i]; if (c == ' ') { return false; } } return true; } #endif //ESP_SAVE_SETTINGS