diff --git a/docs/espXXX.md b/docs/espXXX.md index 94537c32..7e763949 100644 --- a/docs/espXXX.md +++ b/docs/espXXX.md @@ -1552,132 +1552,180 @@ the admin password if authentication is enabled +++ archetype = "section" -title = "[ESP800]" +title = "[ESP400]" weight = 800 +++ -Get FW capabilities +Get full ESP3D settings ## Input - -`[ESP800] json= pwd=` +`[ESP400] json= pwd=` * json=no -the output format -can be in JSON or plain text - -* time= -to set ESP3D time using ISO 8601 format : `YYYY`-`MM`-`DD`T`HH`:`minutes`:`seconds` - -* tzone= -to set ESP3D time zone using ISO 8601 format : `+`/`-` `HH`:`minutes` +the output format +can be in JSON or plain text * pwd= the admin password if authentication is enabled -* version -version of webUI -* setup flag -Enable / Disable the setup flag ## Output -- In json format +Passwords are not displayed and replaced by `********` -```json -{ - "cmd":"800", - "status":"ok", - "data":{ - "FWVersion":"bugfix-2.0.x-3.0.0.a200", - "FWTarget":"marlin", - "FWTargetID":"30", - "Setup":"Enabled", - "SDConnection":"shared", - "SerialProtocol":"Socket", - "Authentication":"Disabled", - "WebCommunication":"Synchronous", - "WebSocketIP":"192.168.2.117", - "WebSocketPort":"81", - "Hostname":"esp3d", - "WiFiMode":"STA", - "WebUpdate":"Enabled", - "FlashFileSystem":"LittleFS", - "HostPath":"www", - "Time":"none" - } -} + * if json + ```json + {"cmd":"400","status":"ok","data":[ +{"F":"network/network","P":"130","T":"S","R":"1","V":"esp3d","H":"hostname" ,"S":"32", "M":"1"}, +{"F":"network/network","P":"0","T":"B","R":"1","V":"1","H":"radio mode","O":[{"none":"0"}, +{"sta":"1"}, +{"ap":"2"}, +{"setup":"5"}]}, +{"F":"network/network","P":"1034","T":"B","R":"1","V":"1","H":"radio_boot","O":[{"no":"0"}, +{"yes":"1"}]}, +{"F":"network/sta","P":"1","T":"S","V":"Luc-Lab","S":"32","H":"SSID","M":"1"}, +{"F":"network/sta","P":"34","T":"S","N":"1","MS":"0","R":"1","V":"********","S":"64","H":"pwd","M":"8"}, +{"F":"network/sta","P":"99","T":"B","R":"1","V":"1","H":"ip mode","O":[{"dhcp":"1"}, +{"static":"0"}]}, +{"F":"network/sta","P":"100","T":"A","R":"1","V":"192.168.0.1","H":"ip"}, +{"F":"network/sta","P":"108","T":"A","R":"1","V":"192.168.0.1","H":"gw"}, +{"F":"network/sta","P":"104","T":"A","R":"1","V":"255.255.255.0","H":"msk"}, +{"F":"network/sta","P":"1029","T":"A","R":"1","V":"192.168.0.1","H":"DNS"}, +{"F":"network/sta","P":"1035","T":"B","R":"0","V":"5","H":"sta fallback mode","O":[{"none":"0"}, +{"setup":"5"}]}, +{"F":"network/ap","P":"218","T":"S","R":"1","V":"ESP3D","S":"32","H":"SSID","M":"1"}, +{"F":"network/ap","P":"251","T":"S","N":"1","MS":"0","R":"1","V":"********","S":"64","H":"pwd","M":"8"}, +{"F":"network/ap","P":"316","T":"A","R":"1","V":"192.168.0.1","H":"ip"}, +{"F":"network/ap","P":"118","T":"B","R":"1","V":"11","H":"channel","O":[{"1":"1"}, +{"2":"2"}, +{"3":"3"}, +{"4":"4"}, +{"5":"5"}, +{"6":"6"}, +{"7":"7"}, +{"8":"8"}, +{"9":"9"}, +{"10":"10"}, +{"11":"11"}, +{"12":"12"}, +{"13":"13"}, +{"14":"14"}]}, +{"F":"service/http","P":"328","T":"B","R":"1","V":"1","H":"enable","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"service/http","P":"121","T":"I","R":"1","V":"8181","H":"port","S":"65001","M":"1"}, +{"F":"service/telnetp","P":"329","T":"B","R":"1","V":"1","H":"enable","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"service/telnetp","P":"125","T":"I","R":"1","V":"23","H":"port","S":"65001","M":"1"}, +{"F":"service/webdavp","P":"1024","T":"B","R":"1","V":"1","H":"enable","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"service/webdavp","P":"1025","T":"I","R":"1","V":"80","H":"port","S":"65001","M":"1"}, +{"F":"service/time","P":"120","T":"B","V":"1","H":"i-time","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"service/time","P":"1042","T":"S","R":"1","V":"+08:00","H":"tzone","O":[{"-12:00":"-12:00"}, +{"-11:00":"-11:00"}, +{"-10:00":"-10:00"}, +{"-09:00":"-09:00"}, +{"-08:00":"-08:00"}, +{"-07:00":"-07:00"}, +{"-06:00":"-06:00"}, +{"-05:00":"-05:00"}, +{"-04:00":"-04:00"}, +{"-03:30":"-03:30"}, +{"-03:00":"-03:00"}, +{"-02:00":"-02:00"}, +{"-01:00":"-01:00"}, +{"+00:00":"+00:00"}, +{"+01:00":"+01:00"}, +{"+02:00":"+02:00"}, +{"+03:00":"+03:00"}, +{"+03:30":"+03:30"}, +{"+04:00":"+04:00"}, +{"+04:30":"+04:30"}, +{"+05:00":"+05:00"}, +{"+05:30":"+05:30"}, +{"+05:45":"+05:45"}, +{"+06:00":"+06:00"}, +{"+06:30":"+06:30"}, +{"+07:00":"+07:00"}, +{"+08:00":"+08:00"}, +{"+08:45":"+08:45"}, +{"+09:00":"+09:00"}, +{"+09:30":"+09:30"}, +{"+10:00":"+10:00"}, +{"+10:30":"+10:30"}, +{"+11:00":"+11:00"}, +{"+12:00":"+12:00"}, +{"+12:45":"+12:45"}, +{"+13:00":"+13:00"}, +{"+14:00":"+14:00"}]}, +{"F":"service/time","P":"464","T":"S","R":"1","V":"time.windows.com","S":"128","H":"t-server","M":"0"}, +{"F":"service/time","P":"593","T":"S","R":"1","V":"time.google.com","S":"128","H":"t-server","M":"0"}, +{"F":"service/time","P":"722","T":"S","R":"1","V":"0.pool.ntp.org","S":"128","H":"t-server","M":"0"}, +{"F":"service/notification","P":"1022","T":"B","R":"1","V":"1","H":"auto notif","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"service/notification","P":"116","T":"B","R":"1","V":"0","H":"notification","O":[{"none":"0"}, +{"pushover":"1"}, +{"email":"2"}, +{"line":"3"}, +{"telegram":"4"}, +{"IFTTT":"5"}]}, +{"F":"service/notification","P":"332","T":"S","R":"1","V":"********","S":"63","H":"t1","M":"0"}, +{"F":"service/notification","P":"396","T":"S","R":"1","V":"********","S":"63","H":"t2","M":"0"}, +{"F":"service/notification","P":"856","T":"S","R":"1","V":" ","S":"128","H":"ts","M":"0"}, +{"F":"system/system","P":"461","T":"B","V":"0","H":"targetfw","O":[{"repetier":"50"}, +{"marlin":"20"}, +{"smoothieware":"40"}, +{"grbl":"10"}, +{"unknown":"0"}]}, +{"F":"system/system","P":"112","T":"I","V":"115200","H":"baud","O":[{"9600":"9600"}, +{"19200":"19200"}, +{"38400":"38400"}, +{"57600":"57600"}, +{"74880":"74880"}, +{"115200":"115200"}, +{"230400":"230400"}, +{"250000":"250000"}, +{"500000":"500000"}, +{"921600":"921600"}, +{"1958400":"1958400"}]}, +{"F":"system/boot","P":"320","T":"I","V":"100","H":"bootdelay","S":"40000","M":"0"}, +{"F":"system/boot","P":"1023","T":"B","V":"0","H":"verbose","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"system/outputmsg","P":"129","T":"B","V":"1","H":"serial","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"system/outputmsg","P":"851","T":"B","V":"1","H":"M117","O":[{"no":"0"},{"yes":"1"}]}, +{"F":"system/outputmsg","P":"1006","T":"B","V":"1","H":"telnet","O":[{"no":"0"},{"yes":"1"}] +}]} + ``` + +1 - key : `Settings` +2 - value: array of data formated like this +{"F":"network/network","P":"130","T":"S","V":"esp3d","H":"hostname","S":"32","M":"1"} +or +{"F":"service/notification","P":"1004","T":"B","V":"1","H":"auto notif","O":[{"no":"0"},{"yes":"1"}]} + + - F: is filter formated as section/sub-section, if section is same as sub-section, it means no sub-section + - P: is id (also position reference so it is unique) + - T: is type of data which can be: + - S: for string + - I: for integer + - B: for Byte + - A: for IP address / Mask + - F: for float (only grblHAL) + - M: for bits mask (only grblHAL) + - X: for exclusive bitsfield (only grblHAL) + - V: is current value, if type is string and value is `********`, (8 stars) then it is a password + - E: is integer for exactess / precision of float/double value (only grblHAL) + - U: is text unit of value (only grblHAL) + - H: is text label of value + - S: is max size if type is string, and max possible value if value is number (byte, integer) + - M: is min size if type is string, and min possible value if value is number (byte, integer) + - MS: is additionnal min size if type is string (e.g for password can be 0 or 8, so need additional min size), M should be the more minimal value + so MS value must be between M and S + - O: is an array of {label:value} used for possible values in selection or bits labels list + - R: need restart to be applied + +Note: if Type `M` and `X` use `O` entry to define the label / position, if `O` is `[]` then axis label are used according need `X`, `Y`, `Z`, `A`, `B`, `C` +Note2 : the 2.1 Flag type is no more used, several entries are used instead grouped by sub-section + +If no json the list is limited to a list of `: ` + +```text + +Settings: +network/network/hostname: esp3d +network/network/mdns: 1 ``` -* `cmd` -Id of requested command, should be `800` - -* `status` -status of command, should be `ok` - -* `data` -content of response: -* `FWVersion` -Version of ESP3D firmware or targeted FW (Marlin with ESP3DLib / grblHal) -* `FWTarget` -name of targeted Firmware -* `FWTargetID` -numerical ID of targeted FW as same name can have several Ids -* `Setup` -Should be `Enabled` or `Disabled` according flag in EEPROM/Preferences, this allows to WedUI to start wizard automaticaly (or not) - -* `SDConnection` -This is SD capability, SD can be - * `shared` - ESP does share access to SD card reader with main board or Firmware (Marlin with ESP3Dlib, ESP3D with hardware SD share solution) - * `direct` - ESP does have direct access to SD card reader (e.g: ESP3D, grblHal) - * `none` - ESP does not have direct access to SD card reader, (e.g: ESP3D with only serial connection) -* `SerialProtocol` -It define how ESP3D FW communicate with main FW - * `Socket` - ESP and main FW use same FW (e.g: Marlin with ESP3DLib, grblHal) - * `Raw` - Classic serial connection - * `MKS` - Serial connection using MKS protocol -* `Authentication` -Can be `Enabled` or `Disabled` -* `WebCommunication` - currently only `Synchronous`, because `Asychronous` has been put in hold -* `WebSocketIP` -Ip address for the websocket terminal `192.168.2.117` -* `WebSocketPort` -Port for the web socket terminal `81` -* `Hostname` - Hostname of ESP3D or main Baord `esp3d` -* `WiFiMode` -Current wiFi mode in use can be `AP` or `STA` -* `WebUpdate` -Inform webUI the feature is available or not, can be `Enabled` or `Disabled` -* `FlashFileSystem` (currently `FileSystem`, to be updated soon ) -The file system used by ESP board can be `LittleFS`, `SPIFFS`, `Fat`, `none` -* `HostPath` -Path where the preferences.json and index.html.gz are stored and can be updated (e.g: `www`) -* `Time` -Type of time support - * `none` - Time is not supported - * `Auto` - Board use internet to sync time and it is successful - * `Failed to set` - Board use internet to sync time and it is failed - * `Manual` - Board use time of ESP800 to set the time and it is successful - * `Not set` - Board use time of ESP800 to set the time and command did not sent it (time may have been set by previous command) -* `CameraID` -if ESP has camera it contain the camera ID -* `CameraName` -if ESP has camera it contain the camera name -* `Axisletters` -Currently only used for grbHAL -can be : - - XYZABC - - XYZUVZ (supported soon) - - XYZABCUVZ (supported soon) diff --git a/docs/pagespliter.py b/docs/pagespliter.py new file mode 100644 index 00000000..a401acd8 --- /dev/null +++ b/docs/pagespliter.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 + +import os + +input_file = "espXXX.md" +output_file_head = "esp" +output_ext = ".md" + + + +f = open(input_file, "r") +lines = f.readlines() +#parse each lines +head = "" +have_command = False +fo=0 +count = 0 +for line in lines: + if not have_command: + count=0 + head+=line + if line.startswith("title ="): + have_command = True + num = line.split("ESP")[1].split("]")[0] + fo = open(output_file_head+num+output_ext, "w") + fo.write(head) + have_command = True + else: + if line.startswith("+++"): + count+=1 + if count==2: + fo.close() + have_command = False + head = line + print("close file "+output_file_head+num+output_ext) + else: + fo.write(line) + else: + fo.write(line) + +f.close() \ No newline at end of file diff --git a/esp3d/src/core/commands.cpp b/esp3d/src/core/commands.cpp index 5a9f89d0..7f13147a 100644 --- a/esp3d/src/core/commands.cpp +++ b/esp3d/src/core/commands.cpp @@ -809,3 +809,161 @@ bool Commands::execute_internal_command(int cmd, const char *cmd_params, } return response; } + +bool Commands::_dispatchSetting( + bool json, const char *filter, ESP3DSettingIndex index, const char *help, + const char **optionValues, const char **optionLabels, uint32_t maxsize, + uint32_t minsize, uint32_t minsize2, uint8_t precision, const char *unit, + bool needRestart, ESP3DOutput *output, bool isFirst) { + String tmpstr; + String value; + char out_str[255]; + tmpstr.reserve( + 350); // to save time and avoid several memories allocation delay + const ESP3DSettingDescription *elementSetting = + Settings_ESP3D::getSettingPtr(index); + if (!elementSetting) { + return false; + } + switch (elementSetting->type) { + case ESP3DSettingType::byte_t: + value = String(Settings_ESP3D::read_byte(index)); + break; + case ESP3DSettingType::integer_t: + value = String(Settings_ESP3D::read_uint32(index)); + break; + case ESP3DSettingType::ip_t: + value = Settings_ESP3D::read_IP_String(index); + break; + case ESP3DSettingType::float_t: + // TODO Add float support ? + value = "Not supported"; + log_esp3d_e("Float not supported"); + return false; + break; + case ESP3DSettingType::mask: + // TODO Add Mask support ? + value = "Not supported"; + log_esp3d_e("Mask not supported"); + return false; + break; + case ESP3DSettingType::bitsfield: + // TODO Add bitfield support ? + value = "Not supported"; + log_esp3d_e("Bitsfield not supported"); + return false; + break; + case ESP3DSettingType::string_t: + // String + if (index == ESP_AP_PASSWORD || index == ESP_STA_PASSWORD || +#ifdef NOTIFICATION_FEATURE + index == ESP_NOTIFICATION_TOKEN1 || + index == ESP_NOTIFICATION_TOKEN2 || +#endif // NOTIFICATION_FEATURE + + index == ESP_USER_PWD || index == ESP_ADMIN_PWD) { // hide passwords + // using ******** + value = HIDDEN_PASSWORD; + } else { + value = Settings_ESP3D::read_string(index); + } + break; + default: + value = "Not supported"; + log_esp3d_e("Type not supported"); + return false; + break; + } + if (json) { + if (!isFirst) { + tmpstr += ","; + } + tmpstr += "{\"F\":\""; + tmpstr += filter; + tmpstr += "\",\"P\":\""; + tmpstr += String(static_cast(index)); + tmpstr += "\",\"T\":\""; + // Limited support already done for above so even not supported we can + // define it once will be enabled + switch (elementSetting->type) { + case ESP3DSettingType::byte_t: + tmpstr += "B"; + break; + case ESP3DSettingType::integer_t: + tmpstr += "I"; + break; + case ESP3DSettingType::ip_t: + tmpstr += "A"; + break; + case ESP3DSettingType::float_t: + tmpstr += "F"; + break; + case ESP3DSettingType::mask: + tmpstr += "M"; + break; + case ESP3DSettingType::bitsfield: + tmpstr += "X"; + break; + default: + tmpstr += "S"; + } + tmpstr += "\",\"V\":\""; + tmpstr += value; + tmpstr += "\",\"H\":\""; + tmpstr += help; + tmpstr += "\""; + if (needRestart) { + tmpstr += ",\"R\":\"1\""; + } + if (optionValues && optionLabels) { + tmpstr += ",\"O\":["; + for (uint8_t i = 0; i < maxsize; i++) { + if (i > 0) { + tmpstr += ","; + } + tmpstr += "{\""; + // be sure we have same size for both array to avoid overflow + tmpstr += optionLabels[i]; + tmpstr += "\":\""; + tmpstr += optionValues[i]; + tmpstr += "\"}"; + } + tmpstr += "]"; + } + if (unit) { + tmpstr += ",\"R\":\""; + tmpstr += unit; + tmpstr += "\""; + } + if (precision != ((uint8_t)-1)) { + tmpstr += ",\"E\":\""; + tmpstr += String(precision); + tmpstr += "\""; + } + if (maxsize != (uint32_t)-1 && !optionValues) { + tmpstr += ",\"S\":\""; + tmpstr += String(maxsize); + tmpstr += "\""; + } + if (minsize != (uint32_t)-1) { + tmpstr += ",\"M\":\""; + tmpstr += String(minsize); + tmpstr += "\""; + } + if (minsize2 != (uint32_t)-1) { + tmpstr += ",\"MS\":\""; + tmpstr += String(minsize2); + tmpstr += "\""; + } + tmpstr += "}"; + } else { + tmpstr = filter; + tmpstr += "/"; + tmpstr += help; + tmpstr += ": "; + tmpstr += value; + tmpstr += "\n"; + } + output->print(tmpstr.c_str()); + return true; +} \ No newline at end of file diff --git a/esp3d/src/core/commands.h b/esp3d/src/core/commands.h index d12ee3e1..379c36d6 100644 --- a/esp3d/src/core/commands.h +++ b/esp3d/src/core/commands.h @@ -21,159 +21,244 @@ #ifndef COMMANDS_H #define COMMANDS_H #include + #include "../modules/authentication/authentication_service.h" + class ESP3DOutput; -class Commands -{ -public: - Commands(); - ~Commands(); - void process(uint8_t * sbuf, size_t len, ESP3DOutput * output, level_authenticate_type auth = LEVEL_GUEST, ESP3DOutput * outputonly = nullptr, uint8_t outputignore = 0); - bool is_esp_command(uint8_t * sbuf, size_t len); - bool execute_internal_command(int cmd, const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - int get_space_pos(const char * string, uint from = 0); - const char* get_param (const char * cmd_params, const char * label); - const char* get_label (const char * cmd_params, const char * labelseparator, uint8_t startindex = 0); - const char * clean_param (const char * cmd_params); - const char * format_response(uint cmdID, bool isjson = false, bool isok=true, const char * message=""); - bool has_tag (const char * cmd_params, const char * tag); - bool ESP0(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#if defined (WIFI_FEATURE) - bool ESP100(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP101(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE -#if defined (WIFI_FEATURE) || defined (ETH_FEATURE) - bool ESP102(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP103(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE ||ETH_FEATURE -#if defined( WIFI_FEATURE) || defined( BLUETOOTH_FEATURE) || defined (ETH_FEATURE) - bool ESP104(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE || BLUETOOTH_FEATURE || ETH_FEATURE -#if defined (WIFI_FEATURE) - bool ESP105(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP106(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP107(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP108(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE -#if defined( WIFI_FEATURE) || defined( BLUETOOTH_FEATURE) || defined (ETH_FEATURE) - bool ESP110(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE || BLUETOOTH_FEATURE || ETH_FEATURE -#if defined( WIFI_FEATURE) || defined (ETH_FEATURE) - bool ESP111(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE || ETH_FEATURE +class Commands { + public: + Commands(); + ~Commands(); + void process(uint8_t* sbuf, size_t len, ESP3DOutput* output, + level_authenticate_type auth = LEVEL_GUEST, + ESP3DOutput* outputonly = nullptr, uint8_t outputignore = 0); + bool is_esp_command(uint8_t* sbuf, size_t len); + bool execute_internal_command(int cmd, const char* cmd_params, + level_authenticate_type auth_level, + ESP3DOutput* output); + int get_space_pos(const char* string, uint from = 0); + const char* get_param(const char* cmd_params, const char* label); + const char* get_label(const char* cmd_params, const char* labelseparator, + uint8_t startindex = 0); + const char* clean_param(const char* cmd_params); + const char* format_response(uint cmdID, bool isjson = false, bool isok = true, + const char* message = ""); + bool has_tag(const char* cmd_params, const char* tag); + bool ESP0(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#if defined(WIFI_FEATURE) + bool ESP100(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP101(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE +#if defined(WIFI_FEATURE) || defined(ETH_FEATURE) + bool ESP102(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP103(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE ||ETH_FEATURE +#if defined(WIFI_FEATURE) || defined(BLUETOOTH_FEATURE) || defined(ETH_FEATURE) + bool ESP104(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE || BLUETOOTH_FEATURE || ETH_FEATURE +#if defined(WIFI_FEATURE) + bool ESP105(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP106(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP107(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP108(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE +#if defined(WIFI_FEATURE) || defined(BLUETOOTH_FEATURE) || defined(ETH_FEATURE) + bool ESP110(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE || BLUETOOTH_FEATURE || ETH_FEATURE +#if defined(WIFI_FEATURE) || defined(ETH_FEATURE) + bool ESP111(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE || ETH_FEATURE #if defined(WIFI_FEATURE) || defined(ETH_FEATURE) || defined(BT_FEATURE) - bool ESP112(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP114(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP115(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE || BLUETOOTH_FEATURE || ETH_FEATURE + bool ESP112(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP114(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP115(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE || BLUETOOTH_FEATURE || ETH_FEATURE #if defined(HTTP_FEATURE) - bool ESP120(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP121(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //HTTP_FEATURE + bool ESP120(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP121(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // HTTP_FEATURE #if defined(TELNET_FEATURE) - bool ESP130(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP131(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //TELNET_FEATURE + bool ESP130(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP131(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // TELNET_FEATURE #if defined(TIMESTAMP_FEATURE) - bool ESP140(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //TIMESTAMP_FEATURE - bool ESP150(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); + bool ESP140(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // TIMESTAMP_FEATURE + bool ESP150(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); #if defined(WS_DATA_FEATURE) - bool ESP160(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP161(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WS_DATA_FEATURE + bool ESP160(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP161(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WS_DATA_FEATURE #if defined(CAMERA_DEVICE) - bool ESP170(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP171(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //CAMERA_DEVICE + bool ESP170(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP171(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // CAMERA_DEVICE #if defined(FTP_FEATURE) - bool ESP180(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP181(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //FTP_FEATURE + bool ESP180(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP181(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // FTP_FEATURE #if defined(WEBDAV_FEATURE) - bool ESP190(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP191(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WEBDAV_FEATURE -#if defined (SD_DEVICE) - bool ESP200(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); + bool ESP190(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP191(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WEBDAV_FEATURE +#if defined(SD_DEVICE) + bool ESP200(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); #if SD_DEVICE != ESP_SDIO - bool ESP202(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //SD_DEVICE != ESP_SDIO + bool ESP202(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // SD_DEVICE != ESP_SDIO #ifdef SD_UPDATE_FEATURE - bool ESP402(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //SD_UPDATE_FEATURE -#endif //SD_DEVICE + bool ESP402(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // SD_UPDATE_FEATURE +#endif // SD_DEVICE #ifdef DIRECT_PIN_FEATURE - bool ESP201(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //DIRECT_PIN_FEATURE -#if defined (DISPLAY_DEVICE) - bool ESP214(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); + bool ESP201(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // DIRECT_PIN_FEATURE +#if defined(DISPLAY_DEVICE) + bool ESP214(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); #if defined(DISPLAY_TOUCH_DRIVER) - bool ESP215(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //DISPLAY_TOUCH_DRIVER -#endif //DISPLAY_DEVICE + bool ESP215(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // DISPLAY_TOUCH_DRIVER +#endif // DISPLAY_DEVICE #ifdef SENSOR_DEVICE - bool ESP210(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //SENSOR_DEVICE - bool ESP220(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP290(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP400(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP401(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#if defined (WIFI_FEATURE) - bool ESP410(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //WIFI_FEATURE - bool ESP420(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP444(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); + bool ESP210(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // SENSOR_DEVICE + bool ESP220(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP290(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP400(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP401(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#if defined(WIFI_FEATURE) + bool ESP410(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // WIFI_FEATURE + bool ESP420(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP444(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); #ifdef MDNS_FEATURE - bool ESP450(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //MDNS_FEATURE -#if defined (AUTHENTICATION_FEATURE) - bool ESP550(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP555(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //AUTHENTICATION_FEATURE + bool ESP450(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // MDNS_FEATURE +#if defined(AUTHENTICATION_FEATURE) + bool ESP550(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP555(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // AUTHENTICATION_FEATURE #if defined(NOTIFICATION_FEATURE) - bool ESP600(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP610(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP620(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //NOTIFICATION_FEATURE + bool ESP600(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP610(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP620(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // NOTIFICATION_FEATURE #if defined(GCODE_HOST_FEATURE) - bool ESP700(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP701(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //GCODE_HOST_FEATURE + bool ESP700(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP701(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // GCODE_HOST_FEATURE #if defined(FILESYSTEM_FEATURE) - bool ESP710(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP720(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP730(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //FILESYSTEM_FEATURE -#if defined (SD_DEVICE) - bool ESP715(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP750(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP740(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //SD_DEVICE -#if defined (GLOBAL_FILESYSTEM_FEATURE) - bool ESP780(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP790(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //GLOBAL_FILESYSTEM_FEATURE - bool ESP800(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); + bool ESP710(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP720(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP730(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // FILESYSTEM_FEATURE +#if defined(SD_DEVICE) + bool ESP715(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP750(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP740(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // SD_DEVICE +#if defined(GLOBAL_FILESYSTEM_FEATURE) + bool ESP780(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP790(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // GLOBAL_FILESYSTEM_FEATURE + bool ESP800(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); #if COMMUNICATION_PROTOCOL != SOCKET_SERIAL - bool ESP900(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP901(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //COMMUNICATION_PROTOCOL != SOCKET_SERIAL - bool ESP920(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#if defined (ESP_SERIAL_BRIDGE_OUTPUT) - bool ESP930(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP931(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //defined (ESP_SERIAL_BRIDGE_OUTPUT) + bool ESP900(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP901(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // COMMUNICATION_PROTOCOL != SOCKET_SERIAL + bool ESP920(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#if defined(ESP_SERIAL_BRIDGE_OUTPUT) + bool ESP930(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP931(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // defined (ESP_SERIAL_BRIDGE_OUTPUT) #ifdef BUZZER_DEVICE - bool ESP910(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); - bool ESP250(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //BUZZER_DEVICE -#if defined(ARDUINO_ARCH_ESP32) && (CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32S2 || CONFIG_IDF_TARGET_ESP32C3) - bool ESP999(const char* cmd_params, level_authenticate_type auth_level, ESP3DOutput * output); -#endif //ARDUINO_ARCH_ESP32 + bool ESP910(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); + bool ESP250(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // BUZZER_DEVICE +#if defined(ARDUINO_ARCH_ESP32) && \ + (CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32S2 || \ + CONFIG_IDF_TARGET_ESP32C3) + bool ESP999(const char* cmd_params, level_authenticate_type auth_level, + ESP3DOutput* output); +#endif // ARDUINO_ARCH_ESP32 + + private: + bool _dispatchSetting(bool json, const char* filter, ESP3DSettingIndex index, + const char* help, const char** optionValues, + const char** optionLabels, uint32_t maxsize, + uint32_t minsize, uint32_t minsize2, uint8_t precision, + const char* unit, bool needRestart, ESP3DOutput* output, + bool isFirst = false); }; extern Commands esp3d_commands; -#endif //COMMANDS_H +#endif // COMMANDS_H diff --git a/esp3d/src/core/esp3doutput.cpp b/esp3d/src/core/esp3doutput.cpp index e1e1ec30..a1b6893b 100644 --- a/esp3d/src/core/esp3doutput.cpp +++ b/esp3d/src/core/esp3doutput.cpp @@ -48,17 +48,17 @@ #if COMMUNICATION_PROTOCOL == RAW_SERIAL || \ COMMUNICATION_PROTOCOL == MKS_SERIAL || \ COMMUNICATION_PROTOCOL == SOCKET_SERIAL -uint8_t ESP3DOutput::_serialoutputflags = DEFAULT_SERIAL_OUTPUT_FLAG; +uint8_t ESP3DOutput::_serialoutputflags = 0; #endif // COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == // MKS_SERIAL || COMMUNICATION_PROTOCOL == SOCKET_SERIAL #if defined(HAS_DISPLAY) || defined(HAS_SERIAL_DISPLAY) -uint8_t ESP3DOutput::_remotescreenoutputflags = DEFAULT_REMOTE_SCREEN_FLAG; +uint8_t ESP3DOutput::_remotescreenoutputflags = 0; #endif // HAS_DISPLAY || HAS_SERIAL_DISPLAY #if defined(WS_DATA_FEATURE) uint8_t ESP3DOutput::_websocketoutputflags = DEFAULT_WEBSOCKET_FLAG; #endif // WS_DATA_FEATURE #if defined(TELNET_FEATURE) -uint8_t ESP3DOutput::_telnetoutputflags = DEFAULT_TELNET_FLAG; +uint8_t ESP3DOutput::_telnetoutputflags = 0; #endif // TELNET_FEATURE #if defined(DISPLAY_DEVICE) uint8_t ESP3DOutput::_screenoutputflags = DEFAULT_SCREEN_FLAG; diff --git a/esp3d/src/core/espcmd/ESP100.cpp b/esp3d/src/core/espcmd/ESP100.cpp index ad94b3e6..efe5ddfa 100644 --- a/esp3d/src/core/espcmd/ESP100.cpp +++ b/esp3d/src/core/espcmd/ESP100.cpp @@ -63,7 +63,8 @@ bool Commands::ESP100(const char* cmd_params, level_authenticate_type auth_type, } #endif // AUTHENTICATION_FEATURE if (noError) { - if (!WiFiConfig::isSSIDValid(parameter.c_str())) { + if (!Settings_ESP3D::isValidStringSetting(parameter.c_str(), + ESP_STA_SSID)) { response = format_response(COMMANDID, json, false, "Incorrect SSID"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP101.cpp b/esp3d/src/core/espcmd/ESP101.cpp index b6d04e8d..10121887 100644 --- a/esp3d/src/core/espcmd/ESP101.cpp +++ b/esp3d/src/core/espcmd/ESP101.cpp @@ -57,7 +57,8 @@ bool Commands::ESP101(const char* cmd_params, level_authenticate_type auth_type, if (clearSetting) { parameter = ""; } - if (!WiFiConfig::isPasswordValid(parameter.c_str())) { + if (!Settings_ESP3D::isValidStringSetting(parameter.c_str(), + ESP_STA_PASSWORD)) { response = format_response(COMMANDID, json, false, "Incorrect password"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP103.cpp b/esp3d/src/core/espcmd/ESP103.cpp index d2742596..7ebf6a88 100644 --- a/esp3d/src/core/espcmd/ESP103.cpp +++ b/esp3d/src/core/espcmd/ESP103.cpp @@ -99,20 +99,25 @@ bool Commands::ESP103(const char* cmd_params, level_authenticate_type auth_type, String GW = get_param(cmd_params, "GW="); String MSK = get_param(cmd_params, "MSK="); String DNS = get_param(cmd_params, "DNS="); - if (!NetConfig::isValidIP(IP.c_str())) { + + if (!Settings_ESP3D::isValidIPStringSetting(IP.c_str(), + ESP_STA_IP_VALUE)) { response = format_response(COMMANDID, json, false, "Incorrect IP"); noError = false; } - if (!NetConfig::isValidIP(GW.c_str())) { + if (!Settings_ESP3D::isValidIPStringSetting(GW.c_str(), + ESP_STA_GATEWAY_VALUE)) { response = format_response(COMMANDID, json, false, "Incorrect gateway"); noError = false; } - if (!NetConfig::isValidIP(MSK.c_str())) { + if (!Settings_ESP3D::isValidIPStringSetting(MSK.c_str(), + ESP_STA_MASK_VALUE)) { response = format_response(COMMANDID, json, false, "Incorrect mask"); noError = false; } - if (!NetConfig::isValidIP(DNS.c_str())) { + if (!Settings_ESP3D::isValidIPStringSetting(DNS.c_str(), + ESP_STA_DNS_VALUE)) { response = format_response(COMMANDID, json, false, "Incorrect dns"); noError = false; } diff --git a/esp3d/src/core/espcmd/ESP105.cpp b/esp3d/src/core/espcmd/ESP105.cpp index f8416c7f..a96d6c57 100644 --- a/esp3d/src/core/espcmd/ESP105.cpp +++ b/esp3d/src/core/espcmd/ESP105.cpp @@ -63,7 +63,8 @@ bool Commands::ESP105(const char* cmd_params, level_authenticate_type auth_type, } #endif // AUTHENTICATION_FEATURE if (noError) { - if (!WiFiConfig::isSSIDValid(parameter.c_str())) { + if (!Settings_ESP3D::isValidStringSetting(parameter.c_str(), + ESP_AP_SSID)) { response = format_response(COMMANDID, json, false, "Incorrect SSID"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP106.cpp b/esp3d/src/core/espcmd/ESP106.cpp index be9ebf00..0e1a6130 100644 --- a/esp3d/src/core/espcmd/ESP106.cpp +++ b/esp3d/src/core/espcmd/ESP106.cpp @@ -58,7 +58,8 @@ bool Commands::ESP106(const char* cmd_params, level_authenticate_type auth_type, if (clearSetting) { parameter = ""; } - if (!WiFiConfig::isPasswordValid(parameter.c_str())) { + if (!Settings_ESP3D::isValidStringSetting(parameter.c_str(), + ESP_AP_PASSWORD)) { response = format_response(COMMANDID, json, false, "Set failed"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP107.cpp b/esp3d/src/core/espcmd/ESP107.cpp index 279ca8fa..f0d7b6c5 100644 --- a/esp3d/src/core/espcmd/ESP107.cpp +++ b/esp3d/src/core/espcmd/ESP107.cpp @@ -65,7 +65,8 @@ bool Commands::ESP107(const char* cmd_params, level_authenticate_type auth_type, } #endif // AUTHENTICATION_FEATURE if (noError) { - if (!NetConfig::isValidIP(parameter.c_str())) { + if (!Settings_ESP3D::isValidIPStringSetting(parameter.c_str(), + ESP_AP_IP_VALUE)) { response = format_response(COMMANDID, json, false, "Incorrect IP"); noError = false; } diff --git a/esp3d/src/core/espcmd/ESP108.cpp b/esp3d/src/core/espcmd/ESP108.cpp index d10343c5..288f8645 100644 --- a/esp3d/src/core/espcmd/ESP108.cpp +++ b/esp3d/src/core/espcmd/ESP108.cpp @@ -65,8 +65,7 @@ bool Commands::ESP108(const char* cmd_params, level_authenticate_type auth_type, #endif // AUTHENTICATION_FEATURE if (noError) { int bbuf = parameter.toInt(); - if ((bbuf > Settings_ESP3D::get_max_byte(ESP_AP_CHANNEL)) || - (bbuf < Settings_ESP3D::get_min_byte(ESP_AP_CHANNEL))) { + if (!Settings_ESP3D::isValidByteSetting(bbuf, ESP_AP_CHANNEL)) { response = format_response(COMMANDID, json, false, "Incorrect channel"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP112.cpp b/esp3d/src/core/espcmd/ESP112.cpp index fa154d04..aa79868e 100644 --- a/esp3d/src/core/espcmd/ESP112.cpp +++ b/esp3d/src/core/espcmd/ESP112.cpp @@ -63,7 +63,8 @@ bool Commands::ESP112(const char* cmd_params, level_authenticate_type auth_type, } #endif // AUTHENTICATION_FEATURE if (noError) { - if (!NetConfig::isHostnameValid(parameter.c_str())) { + if (!Settings_ESP3D::isValidStringSetting(parameter.c_str(), + ESP_HOSTNAME)) { response = format_response(COMMANDID, json, false, "Incorrect hostname"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP121.cpp b/esp3d/src/core/espcmd/ESP121.cpp index 0b943218..094a257a 100644 --- a/esp3d/src/core/espcmd/ESP121.cpp +++ b/esp3d/src/core/espcmd/ESP121.cpp @@ -64,8 +64,7 @@ bool Commands::ESP121(const char* cmd_params, level_authenticate_type auth_type, #endif // AUTHENTICATION_FEATURE if (noError) { uint ibuf = parameter.toInt(); - if ((ibuf > Settings_ESP3D::get_max_int32_value(ESP_HTTP_PORT)) || - (ibuf < Settings_ESP3D::get_min_int32_value(ESP_HTTP_PORT))) { + if (!Settings_ESP3D::isValidIntegerSetting(ibuf, ESP_HTTP_PORT)) { response = format_response(COMMANDID, json, false, "Incorrect port"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP131.cpp b/esp3d/src/core/espcmd/ESP131.cpp index f01e24ec..50182755 100644 --- a/esp3d/src/core/espcmd/ESP131.cpp +++ b/esp3d/src/core/espcmd/ESP131.cpp @@ -63,8 +63,7 @@ bool Commands::ESP131(const char* cmd_params, level_authenticate_type auth_type, #endif // AUTHENTICATION_FEATURE if (noError) { uint ibuf = parameter.toInt(); - if ((ibuf > Settings_ESP3D::get_max_int32_value(ESP_TELNET_PORT)) || - (ibuf < Settings_ESP3D::get_min_int32_value(ESP_TELNET_PORT))) { + if (!Settings_ESP3D::isValidIntegerSetting(ibuf, ESP_TELNET_PORT)) { response = format_response(COMMANDID, json, false, "Incorrect port"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP140.cpp b/esp3d/src/core/espcmd/ESP140.cpp index 51aecd33..38b77786 100644 --- a/esp3d/src/core/espcmd/ESP140.cpp +++ b/esp3d/src/core/espcmd/ESP140.cpp @@ -64,8 +64,8 @@ bool Commands::ESP140(const char* cmd_params, level_authenticate_type auth_type, parameter = get_param(cmd_params, "srv1="); if (parameter.length() > 0) { hasParam = true; - if (parameter.length() < - Settings_ESP3D::get_max_string_size(ESP_TIME_SERVER1)) { + if (Settings_ESP3D::isValidIPStringSetting(parameter.c_str(), + ESP_TIME_SERVER1)) { if (!Settings_ESP3D::write_string(ESP_TIME_SERVER1, parameter.c_str())) { response = format_response(COMMANDID, json, false, @@ -79,8 +79,8 @@ bool Commands::ESP140(const char* cmd_params, level_authenticate_type auth_type, parameter = get_param(cmd_params, "srv2="); if (parameter.length() > 0) { hasParam = true; - if (parameter.length() < - Settings_ESP3D::get_max_string_size(ESP_TIME_SERVER2)) { + if (!Settings_ESP3D::isValidIPStringSetting(parameter.c_str(), + ESP_TIME_SERVER2)) { if (!Settings_ESP3D::write_string(ESP_TIME_SERVER2, parameter.c_str())) { response = format_response(COMMANDID, json, false, @@ -94,8 +94,8 @@ bool Commands::ESP140(const char* cmd_params, level_authenticate_type auth_type, parameter = get_param(cmd_params, "srv3="); if (parameter.length() > 0) { hasParam = true; - if (parameter.length() < - Settings_ESP3D::get_max_string_size(ESP_TIME_SERVER3)) { + if (!Settings_ESP3D::isValidIPStringSetting(parameter.c_str(), + ESP_TIME_SERVER3)) { if (!Settings_ESP3D::write_string(ESP_TIME_SERVER3, parameter.c_str())) { response = format_response(COMMANDID, json, false, diff --git a/esp3d/src/core/espcmd/ESP150.cpp b/esp3d/src/core/espcmd/ESP150.cpp index 1f8cd107..bc5be2af 100644 --- a/esp3d/src/core/espcmd/ESP150.cpp +++ b/esp3d/src/core/espcmd/ESP150.cpp @@ -81,8 +81,7 @@ bool Commands::ESP150(const char* cmd_params, level_authenticate_type auth_type, if (parameter.length() != 0) { hasParameter = true; uint ibuf = parameter.toInt(); - if ((ibuf > Settings_ESP3D::get_max_int32_value(ESP_BOOT_DELAY)) || - (ibuf < Settings_ESP3D::get_min_int32_value(ESP_BOOT_DELAY))) { + if (!Settings_ESP3D::isValidIntegerSetting(ibuf, ESP_BOOT_DELAY)) { response = format_response(COMMANDID, json, false, "Incorrect delay"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP161.cpp b/esp3d/src/core/espcmd/ESP161.cpp index c6cfaf56..df909fad 100644 --- a/esp3d/src/core/espcmd/ESP161.cpp +++ b/esp3d/src/core/espcmd/ESP161.cpp @@ -63,8 +63,7 @@ bool Commands::ESP161(const char* cmd_params, level_authenticate_type auth_type, #endif // AUTHENTICATION_FEATURE if (noError) { uint ibuf = parameter.toInt(); - if ((ibuf > Settings_ESP3D::get_max_int32_value(ESP_WEBSOCKET_PORT)) || - (ibuf < Settings_ESP3D::get_min_int32_value(ESP_WEBSOCKET_PORT))) { + if !(Settings_ESP3D::isValidIntegerSetting(ibuf, ESP_WEBSOCKET_PORT)) { response = format_response(COMMANDID, json, false, "Incorrect port"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP181.cpp b/esp3d/src/core/espcmd/ESP181.cpp index 01f17d69..be4e7a85 100644 --- a/esp3d/src/core/espcmd/ESP181.cpp +++ b/esp3d/src/core/espcmd/ESP181.cpp @@ -27,7 +27,7 @@ #define COMMANDID 181 // Set/Get Ftp ports //[ESP181]ctrl= active= passive= json= pwd= +// password> bool Commands::ESP181(const char* cmd_params, level_authenticate_type auth_type, ESP3DOutput* output) { bool noError = true; @@ -90,8 +90,7 @@ bool Commands::ESP181(const char* cmd_params, level_authenticate_type auth_type, if (parameter.length() > 0) { hasParam = true; ibuf = parameter.toInt(); - if ((ibuf > Settings_ESP3D::get_max_int32_value(ESP_FTP_CTRL_PORT)) || - (ibuf < Settings_ESP3D::get_min_int32_value(ESP_FTP_CTRL_PORT))) { + if (!Settings_ESP3D::isValidIntegerSetting(ibuf, ESP_FTP_CTRL_PORT)) { response = format_response(COMMANDID, json, false, "Incorrect ctrl port"); noError = false; @@ -107,10 +106,8 @@ bool Commands::ESP181(const char* cmd_params, level_authenticate_type auth_type, if (parameter.length() > 0) { ibuf = parameter.toInt(); hasParam = true; - if ((ibuf > Settings_ESP3D::get_max_int32_value( - ESP_FTP_DATA_ACTIVE_PORT)) || - (ibuf < Settings_ESP3D::get_min_int32_value( - ESP_FTP_DATA_ACTIVE_PORT))) { + if (!Settings_ESP3D::isValidIntegerSetting(ibuf, + ESP_FTP_DATA_ACTIVE_PORT)) { response = format_response(COMMANDID, json, false, "Incorrect active port"); noError = false; @@ -129,10 +126,8 @@ bool Commands::ESP181(const char* cmd_params, level_authenticate_type auth_type, if (parameter.length() > 0) { hasParam = true; ibuf = parameter.toInt(); - if ((ibuf > Settings_ESP3D::get_max_int32_value( - ESP_FTP_DATA_PASSIVE_PORT)) || - (ibuf < Settings_ESP3D::get_min_int32_value( - ESP_FTP_DATA_PASSIVE_PORT))) { + if (!Settings_ESP3D::isValidIntegerSetting( + ibuf, ESP_FTP_DATA_PASSIVE_PORT)) { response = format_response(COMMANDID, json, false, "Incorrect passive port"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP191.cpp b/esp3d/src/core/espcmd/ESP191.cpp index d34c5758..5656c7b3 100644 --- a/esp3d/src/core/espcmd/ESP191.cpp +++ b/esp3d/src/core/espcmd/ESP191.cpp @@ -63,8 +63,7 @@ bool Commands::ESP191(const char* cmd_params, level_authenticate_type auth_type, #endif // AUTHENTICATION_FEATURE if (noError) { uint ibuf = parameter.toInt(); - if ((ibuf > Settings_ESP3D::get_max_int32_value(ESP_WEBDAV_PORT)) || - (ibuf < Settings_ESP3D::get_min_int32_value(ESP_WEBDAV_PORT))) { + if (!Settings_ESP3D::isValidIntegerSetting(ibuf, ESP_WEBDAV_PORT)) { response = format_response(COMMANDID, json, false, "Incorrect port"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP202.cpp b/esp3d/src/core/espcmd/ESP202.cpp index ee5cc456..d077475a 100644 --- a/esp3d/src/core/espcmd/ESP202.cpp +++ b/esp3d/src/core/espcmd/ESP202.cpp @@ -55,9 +55,8 @@ bool Commands::ESP202(const char* cmd_params, level_authenticate_type auth_type, String(Settings_ESP3D::read_byte(ESP_SD_SPEED_DIV)).c_str()); } else { // set parameter = get_param(cmd_params, "SPEED="); - if ((parameter == "1") || (parameter == "2") || (parameter == "4") || - (parameter == "6") || (parameter == "8") || (parameter == "16") || - (parameter == "32")) { + if (Settings_ESP3D::isValidByteSetting(parameter.toInt(), + ESP_SD_SPEED_DIV)) { if (!Settings_ESP3D::write_byte(ESP_SD_SPEED_DIV, parameter.toInt())) { response = format_response(COMMANDID, json, false, "Set failed"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP400.cpp b/esp3d/src/core/espcmd/ESP400.cpp index f3854cff..89775577 100644 --- a/esp3d/src/core/espcmd/ESP400.cpp +++ b/esp3d/src/core/espcmd/ESP400.cpp @@ -32,6 +32,135 @@ #include "../../modules/time/time_service.h" #endif // TIMESTAMP_FEATURE #define COMMANDID 400 + +const char* YesNoLabels[] = {"no", "yes"}; +const char* YesNoValues[] = {"0", "1"}; +const char* RadioModeLabels[] = {"none" +#ifdef WIFI_FEATURE + , + "sta", + "ap", + "setup" +#endif // WIFI_FEATURE +#ifdef BLUETOOTH_FEATURE + , + "bt" +#endif // BLUETOOTH_FEATURE +#ifdef ETH_FEATURE + , + "eth-sta" +#endif // ETH_FEATURE +}; +const char* RadioModeValues[] = {"0" +#ifdef WIFI_FEATURE + , + "1", + "2", + "5" +#endif // WIFI_FEATURE + +#ifdef BLUETOOTH_FEATURE + , + "3" + +#endif // BLUETOOTH_FEATURE + +#ifdef ETH_FEATURE + , + "4" +#endif // ETH_FEATURE +}; + +const char* FallbackLabels[] = {"none" +#ifdef WIFI_FEATURE + , + "setup" +#endif // WIFI_FEATURE +#ifdef BLUETOOTH_FEATURE + , + "bt" +#endif // BLUETOOTH_FEATURE +}; +const char* FallbackValues[] = {"0" +#ifdef WIFI_FEATURE + , + "5" +#endif // WIFI_FEATURE +#ifdef BLUETOOTH_FEATURE + , + "3" +#endif // BLUETOOTH_FEATURE +}; + +const char* FirmwareLabels[] = {"Unknown", "Grbl", "Marlin", "Smoothieware", + "Repetier"}; + +const char* FirmwareValues[] = {"0", "10", "20", "40", "50"}; +#ifdef NOTIFICATION_FEATURE +const char* NotificationsLabels[] = {"none", "pushover", "email", + "line", "telegram", "ifttt"}; + +const char* NotificationsValues[] = {"0", "1", "2", "3", "4", "5"}; +#endif // NOTIFICATION_FEATURE + +const char* IpModeLabels[] = {"static", "dhcp"}; +const char* IpModeValues[] = {"0", "1"}; + +const char* SupportedApChannelsStr[] = {"1", "2", "3", "4", "5", "6", "7", + "8", "9", "10", "11", "12", "13", "14"}; + +const char* SupportedBaudListSizeStr[] = { + "9600", "19200", "38400", "57600", "74880", "115200", + "230400", "250000", "500000", "921600", "1958400"}; + +#ifdef SENSOR_DEVICE + +const char* SensorLabels[] = {"none" +#if SENSOR_DEVICE == DHT11_DEVICE || SENSOR_DEVICE == DHT22_DEVICE + , + "DHT11", + "DHT22" + +#endif // SENSOR_DEVICE == DHT11_DEVICE || SENSOR_DEVICE == DHT22_DEVICE +#if SENSOR_DEVICE == ANALOG_DEVICE + , + "Analog" +#endif // SENSOR_DEVICE == ANALOG_DEVICE +#if SENSOR_DEVICE == BMP280_DEVICE || SENSOR_DEVICE == BME280_DEVICE + , + "BMP280", + "BME280" +#endif // SENSOR_DEVICE == BMP280_DEVICE || SENSOR_DEVICE == BME280_DEVICE +}; +const char* SensorValues[] = {"0" +#if SENSOR_DEVICE == DHT11_DEVICE || SENSOR_DEVICE == DHT22_DEVICE + , + "1", + "2" +#endif // SENSOR_DEVICE == DHT11_DEVICE || SENSOR_DEVICE == DHT22_DEVICE + +#if SENSOR_DEVICE == ANALOG_DEVICE + , + "3" +#endif // SENSOR_DEVICE == ANALOG_DEVICE +#if SENSOR_DEVICE == BMP280_DEVICE || SENSOR_DEVICE == BME280_DEVICE + , + "4", + "5" +#endif // SENSOR_DEVICE == BMP280_DEVICE || SENSOR_DEVICE == BME280_DEVICE + +}; + +#endif // SENSOR_DEVICE + +#ifdef SD_DEVICE +#if SD_DEVICE != ESP_SDIO +const char* SupportedSPIDividerStr[] = {"1", "2", "4", "6", "8", "16", "32"}; +const uint8_t SupportedSPIDividerStrSize = + sizeof(SupportedSPIDividerStr) / sizeof(char*); +#endif // SD_DEVICE != ESP_SDIO +#endif // SD_DEVICE + // Get full ESP3D settings //[ESP400] bool Commands::ESP400(const char* cmd_params, level_authenticate_type auth_type, @@ -50,701 +179,373 @@ bool Commands::ESP400(const char* cmd_params, level_authenticate_type auth_type, format_response(COMMANDID, json, false, "Wrong authentication level"); noError = false; errorCode = 401; + if (json) { + output->printLN(response.c_str()); + } else { + if (noError) { + output->printERROR(response.c_str(), errorCode); + } + } + return false; } #else (void)auth_type; #endif // AUTHENTICATION_FEATURE - if (noError) { - parameter = clean_param(get_param(cmd_params, "")); - if (parameter.length() == 0) { - // Start JSON - output->print("{\"cmd\":\"400\",\"status\":\"ok\",\"data\":["); + if (json) { + output->print("{\"cmd\":\"400\",\"status\":\"ok\",\"data\":["); + } else { + output->println("Settings:"); + } #if defined(WIFI_FEATURE) || defined(ETH_FEATURE) || defined(BT_FEATURE) - // Hostname network/network - output->print("{\"F\":\"network/network\",\"P\":\""); - output->print(ESP_HOSTNAME); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print( - ESP3DOutput::encodeString(Settings_ESP3D::read_string(ESP_HOSTNAME))); - output->print("\",\"H\":\"hostname\" ,\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_HOSTNAME)); - output->print("\", \"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_HOSTNAME)); - output->print("\"}"); + // Hostname network/network + _dispatchSetting(json, "network/network", ESP_HOSTNAME, "hostname", NULL, + NULL, 32, 1, 1, -1, NULL, true, output, true); #endif // WIFI_FEATURE || ETH_FEATURE || BT_FEATURE - // radio mode network/network - output->print(",{\"F\":\"network/network\",\"P\":\""); - output->print(ESP_RADIO_MODE); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_RADIO_MODE)); - output->print("\",\"H\":\"radio mode\",\"O\":[{\"none\":\"0\"}"); -#ifdef WIFI_FEATURE - output->print(",{\"sta\":\"1\"},{\"ap\":\"2\"},{\"setup\":\"5\"}"); -#endif // WIFI_FEATURE -#ifdef BLUETOOTH_FEATURE - output->print(",{\"bt\":\"3\"}"); -#endif // BLUETOOTH_FEATURE -#ifdef ETH_FEATURE - output->print(",{\"eth-sta\":\"4\"}"); -#endif // ETH_FEATURE - output->print("]}"); -#if defined(WIFI_FEATURE) || defined(ETH_FEATURE) || defined(BT_FEATURE) - // Radio State at Boot - output->print(",{\"F\":\"network/network\",\"P\":\""); - output->print(ESP_BOOT_RADIO_STATE); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_BOOT_RADIO_STATE)); - output->print( - "\",\"H\":\"radio_boot\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); -#endif // -#ifdef WIFI_FEATURE - // STA SSID network/sta - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_SSID); - output->print("\",\"T\":\"S\",\"V\":\""); - output->print( - ESP3DOutput::encodeString(Settings_ESP3D::read_string(ESP_STA_SSID))); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_STA_SSID)); - output->print("\",\"H\":\"SSID\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_STA_SSID)); - output->print("\"}"); - // STA password - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_PASSWORD); - output->print( - "\",\"T\":\"S\",\"N\":\"1\",\"MS\":\"0\",\"R\":\"1\",\"V\":\""); - output->print(HIDDEN_PASSWORD); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_STA_PASSWORD)); - output->print("\",\"H\":\"pwd\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_STA_PASSWORD)); - output->print("\"}"); + // radio mode network/network + _dispatchSetting(json, "network/network", ESP_RADIO_MODE, "radio mode", + RadioModeValues, RadioModeLabels, + sizeof(RadioModeValues) / sizeof(char*), -1, -1, -1, NULL, + true, output); + + // Radio State at Boot + _dispatchSetting(json, "network/network", ESP_BOOT_RADIO_STATE, "radio_boot", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, NULL, true, + output); +#ifdef WIFI_FEATURE + // STA SSID network/sta + _dispatchSetting(json, "network/sta", ESP_STA_SSID, "SSID", nullptr, nullptr, + 32, 1, 1, -1, nullptr, true, output); + + // STA Password network/sta + _dispatchSetting(json, "network/sta", ESP_STA_PASSWORD, "pwd", nullptr, + nullptr, 64, 8, 0, -1, nullptr, true, output); #endif // WIFI_FEATURE #if defined(WIFI_FEATURE) || defined(ETH_FEATURE) - // STA IP mode - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_IP_MODE); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_STA_IP_MODE)); - output->print( - "\",\"H\":\"ip mode\",\"O\":[{\"dhcp\":\"1\"},{\"static\":\"0\"}]}"); + // STA IP mode + _dispatchSetting(json, "network/sta", ESP_STA_IP_MODE, "ip mode", + IpModeValues, IpModeLabels, + sizeof(IpModeLabels) / sizeof(char*), -1, -1, -1, nullptr, + true, output); + // STA static IP + _dispatchSetting(json, "network/sta", ESP_STA_IP_VALUE, "ip", nullptr, + nullptr, -1, -1, -1, -1, nullptr, true, output); - // STA static IP - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_IP_VALUE); - output->print("\",\"T\":\"A\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_IP_String(ESP_STA_IP_VALUE)); - output->print("\",\"H\":\"ip\"}"); + // STA static Gateway + _dispatchSetting(json, "network/sta", ESP_STA_GATEWAY_VALUE, "gw", nullptr, + nullptr, -1, -1, -1, -1, nullptr, true, output); + // STA static Mask + _dispatchSetting(json, "network/sta", ESP_STA_MASK_VALUE, "msk", nullptr, + nullptr, -1, -1, -1, -1, nullptr, true, output); + // STA static DNS + _dispatchSetting(json, "network/sta", ESP_STA_DNS_VALUE, "DNS", nullptr, + nullptr, -1, -1, -1, -1, nullptr, true, output); - // STA static Gateway - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_GATEWAY_VALUE); - output->print("\",\"T\":\"A\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_IP_String(ESP_STA_GATEWAY_VALUE)); - output->print("\",\"H\":\"gw\"}"); - - // STA static Mask - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_MASK_VALUE); - output->print("\",\"T\":\"A\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_IP_String(ESP_STA_MASK_VALUE)); - output->print("\",\"H\":\"msk\"}"); - - // STA static DNS - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_DNS_VALUE); - output->print("\",\"T\":\"A\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_IP_String(ESP_STA_DNS_VALUE)); - output->print("\",\"H\":\"DNS\"}"); #endif // WIFI_FEATURE || ETH_FEATURE + #if defined(WIFI_FEATURE) || defined(ETH_FEATURE) || defined(BT_FEATURE) - // Sta fallback mode - output->print(",{\"F\":\"network/sta\",\"P\":\""); - output->print(ESP_STA_FALLBACK_MODE); - output->print("\",\"T\":\"B\",\"R\":\"0\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_STA_FALLBACK_MODE)); - output->print("\",\"H\":\"sta fallback mode\",\"O\":[{\"none\":\"0\"}"); -#ifdef WIFI_FEATURE - output->print(",{\"setup\":\"5\"}"); -#endif // WIFI_FEATURE -#ifdef BLUETOOTH_FEATURE - output->print(",{\"bt\":\"3\"}"); -#endif // BLUETOOTH_FEATURE - output->print("]}"); + // Sta fallback mode + _dispatchSetting(json, "network/sta", ESP_STA_FALLBACK_MODE, + "sta fallback mode", FallbackValues, FallbackLabels, + sizeof(FallbackValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // WIFI_FEATURE || ETH_FEATURE || BT_FEATURE #if defined(WIFI_FEATURE) - // AP SSID network/ap - output->print(",{\"F\":\"network/ap\",\"P\":\""); - output->print(ESP_AP_SSID); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print( - ESP3DOutput::encodeString(Settings_ESP3D::read_string(ESP_AP_SSID))); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_AP_SSID)); - output->print("\",\"H\":\"SSID\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_AP_SSID)); - output->print("\"}"); + // AP SSID network/ap + _dispatchSetting(json, "network/ap", ESP_AP_SSID, "SSID", nullptr, nullptr, + 32, 1, 1, -1, nullptr, true, output); - // AP password - output->print(",{\"F\":\"network/ap\",\"P\":\""); - output->print(ESP_AP_PASSWORD); - output->print( - "\",\"T\":\"S\",\"N\":\"1\",\"MS\":\"0\",\"R\":\"1\",\"V\":\""); - output->print(HIDDEN_PASSWORD); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_AP_PASSWORD)); - output->print("\",\"H\":\"pwd\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_AP_PASSWORD)); - output->print("\"}"); + // AP password + _dispatchSetting(json, "network/ap", ESP_AP_PASSWORD, "pwd", nullptr, nullptr, + 64, 8, 0, -1, nullptr, true, output); + // AP static IP + _dispatchSetting(json, "network/ap", ESP_AP_IP_VALUE, "ip", nullptr, nullptr, + -1, -1, -1, -1, nullptr, true, output); - // AP static IP - output->print(",{\"F\":\"network/ap\",\"P\":\""); - output->print(ESP_AP_IP_VALUE); - output->print("\",\"T\":\"A\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_IP_String(ESP_AP_IP_VALUE)); - output->print("\",\"H\":\"ip\"}"); - - // AP Channel - output->print(",{\"F\":\"network/ap\",\"P\":\""); - output->print(ESP_AP_CHANNEL); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_AP_CHANNEL)); - output->print("\",\"H\":\"channel\",\"O\":["); - for (uint8_t i = Settings_ESP3D::get_min_byte(ESP_AP_CHANNEL); - i <= Settings_ESP3D::get_max_byte(ESP_AP_CHANNEL); i++) { - if (i > 1) { - output->print(","); - } - output->printf("{\"%d\":\"%d\"}", i, i); - } - output->print("]}"); + // AP Channel + _dispatchSetting(json, "network/ap", ESP_AP_CHANNEL, "channel", + SupportedApChannelsStr, SupportedApChannelsStr, + sizeof(SupportedApChannelsStr) / sizeof(char*), -1, -1, -1, + nullptr, true, output); #endif // WIFI_FEATURE #ifdef AUTHENTICATION_FEATURE - // Admin password - output->print(",{\"F\":\"security/security\",\"P\":\""); - output->print(ESP_ADMIN_PWD); - output->print("\",\"T\":\"S\",\"V\":\""); - output->print(HIDDEN_PASSWORD); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_ADMIN_PWD)); - output->print("\",\"H\":\"adm pwd\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_ADMIN_PWD)); - output->print("\"}"); + // Admin password + _dispatchSetting(json, "security/security", ESP_ADMIN_PWD, "adm pwd", nullptr, + nullptr, 20, 0, -1, -1, nullptr, true, output); + // User password + _dispatchSetting(json, "security/security", ESP_USER_PWD, "user pwd", nullptr, + nullptr, 20, 0, -1, -1, nullptr, true, output); - // User password - output->print(",{\"F\":\"security/security\",\"P\":\""); - output->print(ESP_USER_PWD); - output->print("\",\"T\":\"S\",\"V\":\""); - output->print(HIDDEN_PASSWORD); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_USER_PWD)); - output->print("\",\"H\":\"user pwd\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_USER_PWD)); - output->print("\"}"); + // session timeout + _dispatchSetting(json, "security/security", ESP_SESSION_TIMEOUT, + "session timeout", nullptr, nullptr, 255, 0, -1, -1, nullptr, + true, output); - // session timeout - output->print(",{\"F\":\"security/security\",\"P\":\""); - output->print(ESP_SESSION_TIMEOUT); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SESSION_TIMEOUT)); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_byte(ESP_SESSION_TIMEOUT)); - output->print("\",\"H\":\"session timeout\",\"M\":\""); - output->print(Settings_ESP3D::get_min_byte(ESP_SESSION_TIMEOUT)); - output->print("\"}"); #if COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == MKS_SERIAL - // Secure Serial - output->print(",{\"F\":\"security/security\",\"P\":\""); - output->print(ESP_SECURE_SERIAL); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SECURE_SERIAL)); - output->print( - "\",\"H\":\"serial\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // Secure Serial + _dispatchSetting(json, "security/security", ESP_SECURE_SERIAL, "serial", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); + #endif // COMMUNICATION_PROTOCOL #endif // AUTHENTICATION_FEATURE - #ifdef HTTP_FEATURE - // HTTP On service/http - output->print(",{\"F\":\"service/http\",\"P\":\""); - output->print(ESP_HTTP_ON); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_HTTP_ON)); - output->print( - "\",\"H\":\"enable\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); - - // HTTP Port - output->print(",{\"F\":\"service/http\",\"P\":\""); - output->print(ESP_HTTP_PORT); - output->print("\",\"T\":\"I\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_HTTP_PORT)); - output->print("\",\"H\":\"port\",\"S\":\""); - output->print(Settings_ESP3D::get_max_int32_value(ESP_HTTP_PORT)); - output->print("\",\"M\":\""); - output->print(Settings_ESP3D::get_min_int32_value(ESP_HTTP_PORT)); - output->print("\"}"); + // HTTP On service/http + _dispatchSetting(json, "service/http", ESP_HTTP_ON, "enable", YesNoValues, + YesNoLabels, sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, + nullptr, true, output); + // HTTP port + _dispatchSetting(json, "service/http", ESP_HTTP_PORT, "port", nullptr, + nullptr, 65535, 1, -1, -1, nullptr, true, output); #endif // HTTP_FEATURE #ifdef TELNET_FEATURE - // TELNET On service/telnet - output->print(",{\"F\":\"service/telnetp\",\"P\":\""); - output->print(ESP_TELNET_ON); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_TELNET_ON)); - output->print( - "\",\"H\":\"enable\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // TELNET On service/telnet + _dispatchSetting(json, "service/telnetp", ESP_TELNET_ON, "enable", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); + + // TELNET Port + _dispatchSetting(json, "service/telnetp", ESP_TELNET_PORT, "port", nullptr, + nullptr, 65535, 1, -1, -1, nullptr, true, output); +#endif // TELNET_FEATURE - // TELNET Port - output->print(",{\"F\":\"service/telnetp\",\"P\":\""); - output->print(ESP_TELNET_PORT); - output->print("\",\"T\":\"I\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_TELNET_PORT)); - output->print("\",\"H\":\"port\",\"S\":\""); - output->print(Settings_ESP3D::get_max_int32_value(ESP_TELNET_PORT)); - output->print("\",\"M\":\""); - output->print(Settings_ESP3D::get_min_int32_value(ESP_TELNET_PORT)); - output->print("\"}"); -#endif // TELNET #ifdef WS_DATA_FEATURE - // Websocket On service - output->print(",{\"F\":\"service/websocketp\",\"P\":\""); - output->print(ESP_WEBSOCKET_ON); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_WEBSOCKET_ON)); - output->print( - "\",\"H\":\"enable\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // Websocket On service + _dispatchSetting(json, "service/websocketp", ESP_WEBSOCKET_ON, "enable", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); - // Websocket Port - output->print(",{\"F\":\"service/websocketp\",\"P\":\""); - output->print(ESP_WEBSOCKET_PORT); - output->print("\",\"T\":\"I\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_WEBSOCKET_PORT)); - output->print("\",\"H\":\"port\",\"S\":\""); - output->print(Settings_ESP3D::get_max_int32_value(ESP_WEBSOCKET_PORT)); - output->print("\",\"M\":\""); - output->print(Settings_ESP3D::get_min_int32_value(ESP_WEBSOCKET_PORT)); - output->print("\"}"); + // Websocket Port + _dispatchSetting(json, "service/websocketp", ESP_WEBSOCKET_PORT, "port", + nullptr, nullptr, 65535, 1, -1, -1, nullptr, true, output); #endif // WS_DATA_FEATURE + #ifdef WEBDAV_FEATURE - // WebDav On service - output->print(",{\"F\":\"service/webdavp\",\"P\":\""); - output->print(ESP_WEBDAV_ON); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_WEBDAV_ON)); - output->print( - "\",\"H\":\"enable\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // WebDav On service + _dispatchSetting(json, "service/webdavp", ESP_WEBDAV_ON, "enable", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); - // WebDav Port - output->print(",{\"F\":\"service/webdavp\",\"P\":\""); - output->print(ESP_WEBDAV_PORT); - output->print("\",\"T\":\"I\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_WEBDAV_PORT)); - output->print("\",\"H\":\"port\",\"S\":\""); - output->print(Settings_ESP3D::get_max_int32_value(ESP_WEBDAV_PORT)); - output->print("\",\"M\":\""); - output->print(Settings_ESP3D::get_min_int32_value(ESP_WEBDAV_PORT)); - output->print("\"}"); + // WebDav Port + _dispatchSetting(json, "service/webdavp", ESP_WEBDAV_PORT, "port", nullptr, + nullptr, 65535, 1, -1, -1, nullptr, true, output); #endif // WEBDAV_FEATURE + #ifdef FTP_FEATURE - // FTP On service/ftp - output->print(",{\"F\":\"service/ftp\",\"P\":\""); - output->print(ESP_FTP_ON); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_FTP_ON)); - output->print( - "\",\"H\":\"enable\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // FTP On service/ftp + _dispatchSetting(json, "service/ftp", ESP_FTP_ON, "enable", YesNoValues, + YesNoLabels, sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, + nullptr, true, output); - // FTP Ports - output->print(",{\"F\":\"service/ftp\",\"P\":\""); - output->print(ESP_FTP_CTRL_PORT); - output->print("\",\"T\":\"I\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_FTP_CTRL_PORT)); - output->print("\",\"H\":\"control port\",\"S\":\""); - output->print(Settings_ESP3D::get_max_int32_value(ESP_FTP_CTRL_PORT)); - output->print("\",\"M\":\""); - output->print(Settings_ESP3D::get_min_int32_value(ESP_FTP_CTRL_PORT)); - output->print("\"}"); + // FTP Ports + // CTRL Port + _dispatchSetting(json, "service/ftp", ESP_FTP_CTRL_PORT, "control port", + nullptr, nullptr, 65535, 1, -1, -1, nullptr, true, output); - output->print(",{\"F\":\"service/ftp\",\"P\":\""); - output->print(ESP_FTP_DATA_ACTIVE_PORT); - output->print("\",\"T\":\"I\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_FTP_DATA_ACTIVE_PORT)); - output->print("\",\"H\":\"active port\",\"S\":\""); - output->print( - Settings_ESP3D::get_max_int32_value(ESP_FTP_DATA_ACTIVE_PORT)); - output->print("\",\"M\":\""); - output->print( - Settings_ESP3D::get_min_int32_value(ESP_FTP_DATA_ACTIVE_PORT)); - output->print("\"}"); + // Active Port + _dispatchSetting(json, "service/ftp", ESP_FTP_DATA_ACTIVE_PORT, "active port", + nullptr, nullptr, 65535, 1, -1, -1, nullptr, true, output); - output->print(",{\"F\":\"service/ftp\",\"P\":\""); - output->print(ESP_FTP_DATA_PASSIVE_PORT); - output->print("\",\"T\":\"I\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_FTP_DATA_PASSIVE_PORT)); - output->print("\",\"H\":\"passive port\",\"S\":\""); - output->print( - Settings_ESP3D::get_max_int32_value(ESP_FTP_DATA_PASSIVE_PORT)); - output->print("\",\"M\":\""); - output->print( - Settings_ESP3D::get_min_int32_value(ESP_FTP_DATA_PASSIVE_PORT)); - output->print("\"}"); + // Passive Port + _dispatchSetting(json, "service/ftp", ESP_FTP_DATA_PASSIVE_PORT, + "passive port", nullptr, nullptr, 65535, 1, -1, -1, nullptr, + true, output); #endif // FTP_FEATURE #if defined(ESP_SERIAL_BRIDGE_OUTPUT) - // Serial bridge On service - output->print(",{\"F\":\"service/serial_bridge\",\"P\":\""); - output->print(ESP_SERIAL_BRIDGE_ON); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SERIAL_BRIDGE_ON)); - output->print( - "\",\"H\":\"enable\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); - // Baud Rate - output->print(",{\"F\":\"service/serial_bridge\",\"P\":\""); - output->print(ESP_SERIAL_BRIDGE_BAUD); - output->print("\",\"T\":\"I\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_SERIAL_BRIDGE_BAUD)); - output->print("\",\"H\":\"baud\",\"O\":["); + // Serial bridge On service + _dispatchSetting(json, "service/serial_bridge", ESP_SERIAL_BRIDGE_ON, + "enable", YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); - bl = serial_service.get_baudratelist(&count); - for (uint8_t i = 0; i < count; i++) { - if (i > 0) { - output->print(","); - } - output->printf("{\"%ld\":\"%ld\"}", bl[i], bl[i]); - } - output->print("]}"); -#endif // defined(ESP_SERIAL_BRIDGE_OUTPUT) + // Baud Rate + _dispatchSetting(json, "service/serial_bridge", ESP_SERIAL_BRIDGE_BAUD, + "baud", SupportedBaudListSizeStr, SupportedBaudListSizeStr, + sizeof(SupportedBaudListSizeStr) / sizeof(char*), -1, -1, -1, + nullptr, true, output); +#endif // ESP_SERIAL_BRIDGE_OUTPUT #ifdef TIMESTAMP_FEATURE - // Internet Time - output->print(",{\"F\":\"service/time\",\"P\":\""); - output->print(ESP_INTERNET_TIME); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print((int8_t)Settings_ESP3D::read_byte(ESP_INTERNET_TIME)); - output->print( - "\",\"H\":\"i-time\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // Internet Time + _dispatchSetting(json, "service/time", ESP_INTERNET_TIME, "i-time", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); - // Time zone - output->print(",{\"F\":\"service/time\",\"P\":\""); - output->print(ESP_TIME_ZONE); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_string(ESP_TIME_ZONE)); - output->print("\",\"H\":\"tzone\",\"O\":["); - for (int8_t i = 0; i < SupportedTimeZonesSize; i++) { - if (i > 0) { - output->print(","); - } - output->printf("{\"%s\":\"%s\"}", SupportedTimeZones[i], - SupportedTimeZones[i]); - } - output->print("]}"); + // Time zone + _dispatchSetting(json, "service/time", ESP_TIME_ZONE, "tzone", + SupportedTimeZones, SupportedTimeZones, + SupportedTimeZonesSize, -1, -1, -1, nullptr, true, output); - // DST which is currently not supported automaticatly - /* output->print(",{\"F\":\"service/time\",\"P\":\""); - output->print(ESP_TIME_IS_DST); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_TIME_IS_DST)); - output->print("\",\"H\":\"dst\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}");*/ + // Time Server1 + _dispatchSetting(json, "service/time", ESP_TIME_SERVER1, "t-server", nullptr, + nullptr, 127, 0, -1, -1, nullptr, true, output); - // Time Server1 - output->print(",{\"F\":\"service/time\",\"P\":\""); - output->print(ESP_TIME_SERVER1); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print(ESP3DOutput::encodeString( - Settings_ESP3D::read_string(ESP_TIME_SERVER1))); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_TIME_SERVER1)); - output->print("\",\"H\":\"t-server\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_TIME_SERVER1)); - output->print("\"}"); + // Time Server2 + _dispatchSetting(json, "service/time", ESP_TIME_SERVER2, "t-server", nullptr, + nullptr, 127, 0, -1, -1, nullptr, true, output); - // 27- Time Server2 - output->print(",{\"F\":\"service/time\",\"P\":\""); - output->print(ESP_TIME_SERVER2); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print(ESP3DOutput::encodeString( - Settings_ESP3D::read_string(ESP_TIME_SERVER2))); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_TIME_SERVER2)); - output->print("\",\"H\":\"t-server\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_TIME_SERVER2)); - output->print("\"}"); - - // 28- Time Server3 - output->print(",{\"F\":\"service/time\",\"P\":\""); - output->print(ESP_TIME_SERVER3); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print(ESP3DOutput::encodeString( - Settings_ESP3D::read_string(ESP_TIME_SERVER3))); - output->print("\",\"S\":\""); - output->print(Settings_ESP3D::get_max_string_size(ESP_TIME_SERVER3)); - output->print("\",\"H\":\"t-server\",\"M\":\""); - output->print(Settings_ESP3D::get_min_string_size(ESP_TIME_SERVER3)); - output->print("\"}"); + // Time Server3 + _dispatchSetting(json, "service/time", ESP_TIME_SERVER3, "t-server", nullptr, + nullptr, 127, 0, -1, -1, nullptr, true, output); #endif // TIMESTAMP_FEATURE #ifdef NOTIFICATION_FEATURE - // Auto notification - output->print(",{\"F\":\"service/notification\",\"P\":\""); - output->print(ESP_AUTO_NOTIFICATION); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_AUTO_NOTIFICATION)); - output->print( - "\",\"H\":\"auto notif\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); - // Notification type - output->print(",{\"F\":\"service/notification\",\"P\":\""); - output->print(ESP_NOTIFICATION_TYPE); - output->print("\",\"T\":\"B\",\"R\":\"1\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_NOTIFICATION_TYPE)); - output->print( - "\",\"H\":\"notification\",\"O\":[{\"none\":\"0\"},{\"pushover\":\""); - output->print(ESP_PUSHOVER_NOTIFICATION); - output->print("\"},{\"email\":\""); - output->print(ESP_EMAIL_NOTIFICATION); - output->print("\"},{\"line\":\""); - output->print(ESP_LINE_NOTIFICATION); - output->print("\"},{\"telegram\":\""); - output->print(ESP_TELEGRAM_NOTIFICATION); - output->print("\"},{\"IFTTT\":\""); - output->print(ESP_IFTTT_NOTIFICATION); - output->print("\"}]}"); - // Token 1 - output->print(",{\"F\":\"service/notification\",\"P\":\""); - output->print(ESP_NOTIFICATION_TOKEN1); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print(HIDDEN_PASSWORD); - output->print("\",\"S\":\""); - output->print( - Settings_ESP3D::get_max_string_size(ESP_NOTIFICATION_TOKEN1)); - output->print("\",\"H\":\"t1\",\"M\":\""); - output->print( - Settings_ESP3D::get_min_string_size(ESP_NOTIFICATION_TOKEN1)); - output->print("\"}"); - // Token 2 - output->print(",{\"F\":\"service/notification\",\"P\":\""); - output->print(ESP_NOTIFICATION_TOKEN2); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print(HIDDEN_PASSWORD); - output->print("\",\"S\":\""); - output->print( - Settings_ESP3D::get_max_string_size(ESP_NOTIFICATION_TOKEN2)); - output->print("\",\"H\":\"t2\",\"M\":\""); - output->print( - Settings_ESP3D::get_min_string_size(ESP_NOTIFICATION_TOKEN2)); - output->print("\"}"); - // Notifications Settings - output->print(",{\"F\":\"service/notification\",\"P\":\""); - output->print(ESP_NOTIFICATION_SETTINGS); - output->print("\",\"T\":\"S\",\"R\":\"1\",\"V\":\""); - output->print(ESP3DOutput::encodeString( - Settings_ESP3D::read_string(ESP_NOTIFICATION_SETTINGS))); - output->print("\",\"S\":\""); - output->print( - Settings_ESP3D::get_max_string_size(ESP_NOTIFICATION_SETTINGS)); - output->print("\",\"H\":\"ts\",\"M\":\""); - output->print( - Settings_ESP3D::get_min_string_size(ESP_NOTIFICATION_SETTINGS)); - output->print("\"}"); + // Auto notification + _dispatchSetting(json, "service/notification", ESP_AUTO_NOTIFICATION, + "auto notif", YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); + + // Notification type + _dispatchSetting(json, "service/notification", ESP_NOTIFICATION_TYPE, + "notification", NotificationsValues, NotificationsLabels, + sizeof(NotificationsValues) / sizeof(char*), -1, -1, -1, + nullptr, true, output); + + // Token 1 + _dispatchSetting(json, "service/notification", ESP_NOTIFICATION_TOKEN1, "t1", + nullptr, nullptr, 63, 1, 1, -1, nullptr, true, output); + + // Token 2 + _dispatchSetting(json, "service/notification", ESP_NOTIFICATION_TOKEN2, "t2", + nullptr, nullptr, 63, 1, 1, -1, nullptr, true, output); + + // Notifications Settings + _dispatchSetting(json, "service/notification", ESP_NOTIFICATION_SETTINGS, + "ts", nullptr, nullptr, 128, 0, -1, -1, nullptr, true, + output); #endif // NOTIFICATION_FEATURE + #ifdef BUZZER_DEVICE - // Buzzer state - output->print(",{\"F\":\"device/device\",\"P\":\""); - output->print(ESP_BUZZER); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_BUZZER)); - output->print( - "\",\"H\":\"buzzer\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // Buzzer state + _dispatchSetting(json, "device/device", ESP_BUZZER, "buzzer", YesNoValues, + YesNoLabels, sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, + nullptr, true, output); #endif // BUZZER_DEVICE #ifdef SENSOR_DEVICE - // Sensor type - output->print(",{\"F\":\"device/sensor\",\"P\":\""); - output->print(ESP_SENSOR_TYPE); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SENSOR_TYPE)); - output->print("\",\"H\":\"type\",\"O\":[{\"none\":\"0\"}"); - for (uint8_t p = 0; p < esp3d_sensor.nbType(); p++) { - output->print(",{\""); - output->print(esp3d_sensor.GetModelString(p)); - output->print("\":\""); - output->print(esp3d_sensor.GetModel(p)); - output->print("\"}"); - } - output->print("]}"); + // Sensor type + _dispatchSetting(json, "device/sensor", ESP_SENSOR_TYPE, "type", SensorValues, + SensorLabels, sizeof(SensorValues) / sizeof(char*), -1, -1, + -1, nullptr, true, output); + + // Sensor interval + _dispatchSetting(json, "device/sensor", ESP_SENSOR_INTERVAL, "intervalms", + nullptr, nullptr, 60000, 0, -1, -1, nullptr, true, output); - // Sensor interval - output->print(",{\"F\":\"device/sensor\",\"P\":\""); - output->print(ESP_SENSOR_INTERVAL); - output->print("\",\"T\":\"I\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_SENSOR_INTERVAL)); - output->print("\",\"H\":\"intervalms\",\"S\":\""); - output->print(Settings_ESP3D::get_max_int32_value(ESP_SENSOR_INTERVAL)); - output->print("\",\"M\":\""); - output->print(Settings_ESP3D::get_min_int32_value(ESP_SENSOR_INTERVAL)); - output->print("\"}"); #endif // SENSOR_DEVICE #if defined(SD_DEVICE) #if SD_DEVICE != ESP_SDIO - // SPI SD Divider - output->print(",{\"F\":\"device/sd\",\"P\":\""); - output->print(ESP_SD_SPEED_DIV); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SD_SPEED_DIV)); - output->print( - "\",\"H\":\"speedx\",\"O\":[{\"1\":\"1\"},{\"2\":\"2\"},{\"3\":\"3\"}" - ",{\"4\":\"4\"},{\"6\":\"6\"},{\"8\":\"8\"},{\"16\":\"16\"},{\"32\":" - "\"32\"}]}"); + // SPI SD Divider + _dispatchSetting(json, "device/sd", ESP_SD_SPEED_DIV, "speedx", + SupportedSPIDividerStr, SupportedSPIDividerStr, + SupportedSPIDividerStrSize, -1, -1, -1, nullptr, true, + output); #endif // SD_DEVICE != ESP_SDIO #ifdef SD_UPDATE_FEATURE - // SD CHECK UPDATE AT BOOT feature - output->print(",{\"F\":\"device/sd\",\"P\":\""); - output->print(ESP_SD_CHECK_UPDATE_AT_BOOT); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SD_CHECK_UPDATE_AT_BOOT)); - output->print( - "\",\"H\":\"SD updater\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + // SD CHECK UPDATE AT BOOT feature + _dispatchSetting(json, "device/sd", ESP_SD_CHECK_UPDATE_AT_BOOT, "SD updater", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // SD_UPDATE_FEATURE #endif // SD_DEVICE + #if !defined(FIXED_FW_TARGET) - // Target FW - output->print(",{\"F\":\"system/system\",\"P\":\""); - output->print(ESP_TARGET_FW); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_TARGET_FW)); - output->print("\",\"H\":\"targetfw\",\"O\":[{\"repetier\":\""); - output->print(REPETIER); - output->print("\"},{\"marlin\":\""); - output->print(MARLIN); - output->print("\"},{\"smoothieware\":\""); - output->print(SMOOTHIEWARE); - output->print("\"},{\"grbl\":\""); - output->print(GRBL); - output->print("\"},{\"unknown\":\""); - output->print(UNKNOWN_FW); - output->print("\"}]}"); + // Target FW + _dispatchSetting(json, "system/system", ESP_TARGET_FW, "targetfw", + FirmwareValues, FirmwareLabels, + sizeof(FirmwareValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // FIXED_FW_TARGET #if COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == MKS_SERIAL - // Baud Rate - output->print(",{\"F\":\"system/system\",\"P\":\""); - output->print(ESP_BAUD_RATE); - output->print("\",\"T\":\"I\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_BAUD_RATE)); - output->print("\",\"H\":\"baud\",\"O\":["); - - bl = serial_service.get_baudratelist(&count); - for (uint8_t i = 0; i < count; i++) { - if (i > 0) { - output->print(","); - } - output->printf("{\"%ld\":\"%ld\"}", bl[i], bl[i]); - } - output->print("]}"); + // Baud Rate + _dispatchSetting(json, "system/system", ESP_BAUD_RATE, "baud", + SupportedBaudListSizeStr, SupportedBaudListSizeStr, + sizeof(SupportedBaudListSizeStr) / sizeof(char*), -1, -1, -1, + nullptr, true, output); #endif // COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == - // MKS_SERIAL Start delay - output->print(",{\"F\":\"system/boot\",\"P\":\""); - output->print(ESP_BOOT_DELAY); - output->print("\",\"T\":\"I\",\"V\":\""); - output->print(Settings_ESP3D::read_uint32(ESP_BOOT_DELAY)); - output->print("\",\"H\":\"bootdelay\",\"S\":\""); - output->print(Settings_ESP3D::get_max_int32_value(ESP_BOOT_DELAY)); - output->print("\",\"M\":\""); - output->print(Settings_ESP3D::get_min_int32_value(ESP_BOOT_DELAY)); - output->print("\"}"); - // Verbose boot - output->print(",{\"F\":\"system/boot\",\"P\":\""); - output->print(ESP_VERBOSE_BOOT); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_VERBOSE_BOOT)); - output->print( - "\",\"H\":\"verbose\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); - // Output flag - // Serial + // MKS_SERIAL + + // Start delay + _dispatchSetting(json, "system/boot", ESP_BOOT_DELAY, "bootdelay", nullptr, + nullptr, 40000, 0, -1, -1, nullptr, true, output); + + // Verbose boot + _dispatchSetting(json, "system/boot", ESP_VERBOSE_BOOT, "verbose", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); + +// Output flag +// Serial #if COMMUNICATION_PROTOCOL == RAW_SERIAL || \ COMMUNICATION_PROTOCOL == MKS_SERIAL || \ COMMUNICATION_PROTOCOL == SOCKET_SERIAL - output->print(",{\"F\":\"system/outputmsg\",\"P\":\""); - output->print(ESP_SERIAL_FLAG); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SERIAL_FLAG)); - output->print( - "\",\"H\":\"serial\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); -#endif // COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == - // MKS_SERIAL + + _dispatchSetting(json, "system/outputmsg", ESP_SERIAL_FLAG, "serial", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); +#endif // COMMUNICATION_PROTOCOL == RAW_SERIAL || + #if defined(ESP_SERIAL_BRIDGE_OUTPUT) - output->print(",{\"F\":\"system/outputmsg\",\"P\":\""); - output->print(ESP_SERIAL_BRIDGE_FLAG); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SERIAL_BRIDGE_FLAG)); - output->print( - "\",\"H\":\"serial_bridge\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + _dispatchSetting(json, "system/outputmsg", ESP_SERIAL_BRIDGE_FLAG, + "serial_bridge", YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // ESP_SERIAL_BRIDGE_OUTPUT + #if (defined(ESP3DLIB_ENV) && defined(HAS_DISPLAY)) || \ defined(HAS_SERIAL_DISPLAY) - // Printer SCREEN - output->print(",{\"F\":\"system/outputmsg\",\"P\":\""); - output->print(ESP_REMOTE_SCREEN_FLAG); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_REMOTE_SCREEN_FLAG)); - output->print( - "\",\"H\":\"M117\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + _dispatchSetting(json, "system/outputmsg", ESP_REMOTE_SCREEN_FLAG, "M117", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // ESP3DLIB_ENV + #ifdef DISPLAY_DEVICE - // ESP SCREEN - output->print(",{\"F\":\"system/outputmsg\",\"P\":\""); - output->print(ESP_SCREEN_FLAG); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_SCREEN_FLAG)); - output->print( - "\",\"H\":\"M117\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + _dispatchSetting(json, "system/outputmsg", ESP_SCREEN_FLAG, "M117", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // DISPLAY_DEVICE + #ifdef WS_DATA_FEATURE - // Websocket - output->print(",{\"F\":\"system/outputmsg\",\"P\":\""); - output->print(ESP_WEBSOCKET_FLAG); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_WEBSOCKET_FLAG)); - output->print("\",\"H\":\"ws\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + _dispatchSetting(json, "system/outputmsg", ESP_WEBSOCKET_FLAG, "ws", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // WS_DATA_FEATURE + #ifdef BLUETOOTH_FEATURE - // BT - output->print(",{\"F\":\"system/outputmsg\",\"P\":\""); - output->print(ESP_BT_FLAG); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_BT_FLAG)); - output->print("\",\"H\":\"BT\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + _dispatchSetting(json, "system/outputmsg", ESP_BT_FLAG, "BT", YesNoValues, + YesNoLabels, sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, + nullptr, true, output); #endif // BLUETOOTH_FEATURE + #ifdef TELNET_FEATURE - // Telnet - output->print(",{\"F\":\"system/outputmsg\",\"P\":\""); - output->print(ESP_TELNET_FLAG); - output->print("\",\"T\":\"B\",\"V\":\""); - output->print(Settings_ESP3D::read_byte(ESP_TELNET_FLAG)); - output->print( - "\",\"H\":\"telnet\",\"O\":[{\"no\":\"0\"},{\"yes\":\"1\"}]}"); + _dispatchSetting(json, "system/outputmsg", ESP_TELNET_FLAG, "telnet", + YesNoValues, YesNoLabels, + sizeof(YesNoValues) / sizeof(char*), -1, -1, -1, nullptr, + true, output); #endif // TELNET_FEATURE - output->print("]}"); - if (!json) { - output->printLN(""); - } - return true; - } else { - response = format_response(COMMANDID, json, false, - "This command doesn't take parameters"); - noError = false; - } - } + if (json) { - output->printLN(response.c_str()); + output->print("]}"); } else { - if (noError) { - output->printMSG(response.c_str()); - } else { - output->printERROR(response.c_str(), errorCode); - } + output->println("ok"); } - return noError; + return true; } diff --git a/esp3d/src/core/espcmd/ESP401.cpp b/esp3d/src/core/espcmd/ESP401.cpp index 8fd96141..6c85c305 100644 --- a/esp3d/src/core/espcmd/ESP401.cpp +++ b/esp3d/src/core/espcmd/ESP401.cpp @@ -86,138 +86,164 @@ bool Commands::ESP401(const char* cmd_params, level_authenticate_type auth_type, if (response) { // Byte value if (styp == "B") { - if (!Settings_ESP3D::write_byte(spos.toInt(), - (uint8_t)sval.toInt())) { - response = false; - } else { - // dynamique refresh is better than restart the boards - switch (spos.toInt()) { + if (Settings_ESP3D::isValidByteSetting((uint8_t)sval.toInt(), + spos.toInt())) { + if (!Settings_ESP3D::write_byte(spos.toInt(), + (uint8_t)sval.toInt())) { + response = false; + log_esp3d_e("Set failed"); + } else { + // dynamique refresh is better than restart the boards + switch (spos.toInt()) { #if defined(ESP_SERIAL_BRIDGE_OUTPUT) - case ESP_SERIAL_BRIDGE_ON: - if (!serial_bridge_service.started()) { - serial_bridge_service.begin(ESP_SERIAL_BRIDGE_OUTPUT); - } - break; + case ESP_SERIAL_BRIDGE_ON: + if (!serial_bridge_service.started()) { + serial_bridge_service.begin(ESP_SERIAL_BRIDGE_OUTPUT); + } + break; #endif // ESP_SERIAL_BRIDGE_OUTPUT - case ESP_SERIAL_BRIDGE_FLAG: - case ESP_SERIAL_FLAG: - case ESP_REMOTE_SCREEN_FLAG: - case ESP_WEBSOCKET_FLAG: - case ESP_TELNET_FLAG: - case ESP_SCREEN_FLAG: - case ESP_BT_FLAG: - ESP3DOutput::isOutput(ESP_ALL_CLIENTS, true); - break; - case ESP_VERBOSE_BOOT: - Settings_ESP3D::isVerboseBoot(true); - break; - case ESP_TARGET_FW: - Settings_ESP3D::GetFirmwareTarget(true); - break; + case ESP_SERIAL_BRIDGE_FLAG: + case ESP_SERIAL_FLAG: + case ESP_REMOTE_SCREEN_FLAG: + case ESP_WEBSOCKET_FLAG: + case ESP_TELNET_FLAG: + case ESP_SCREEN_FLAG: + case ESP_BT_FLAG: + ESP3DOutput::isOutput(ESP_ALL_CLIENTS, true); + break; + case ESP_VERBOSE_BOOT: + Settings_ESP3D::isVerboseBoot(true); + break; + case ESP_TARGET_FW: + Settings_ESP3D::GetFirmwareTarget(true); + break; #if COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == MKS_SERIAL - case ESP_SECURE_SERIAL: - serial_service.setParameters(); - break; + case ESP_SECURE_SERIAL: + serial_service.setParameters(); + break; #endif // COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == // MKS_SERIAL #ifdef AUTHENTICATION_FEATURE - case ESP_SESSION_TIMEOUT: - AuthenticationService::setSessionTimeout(1000 * 60 * - sval.toInt()); - break; + case ESP_SESSION_TIMEOUT: + AuthenticationService::setSessionTimeout(1000 * 60 * + sval.toInt()); + break; #endif // AUTHENTICATION_FEATURE #ifdef SD_DEVICE - case ESP_SD_SPEED_DIV: - ESP_SD::setSPISpeedDivider(sval.toInt()); - break; + case ESP_SD_SPEED_DIV: + ESP_SD::setSPISpeedDivider(sval.toInt()); + break; #endif // SD_DEVICE #ifdef TIMESTAMP_FEATURE - case ESP_INTERNET_TIME: - timeService.begin(); - break; + case ESP_INTERNET_TIME: + timeService.begin(); + break; #endif // TIMESTAMP_FEATURE #ifdef NOTIFICATION_FEATURE - case ESP_AUTO_NOTIFICATION: - notificationsservice.setAutonotification( - (sval.toInt() == 0) ? false : true); - break; + case ESP_AUTO_NOTIFICATION: + notificationsservice.setAutonotification( + (sval.toInt() == 0) ? false : true); + break; #endif // NOTIFICATION_FEATURE #ifdef SENSOR_DEVICE - case ESP_SENSOR_TYPE: - esp3d_sensor.begin(); - break; + case ESP_SENSOR_TYPE: + esp3d_sensor.begin(); + break; #endif // SENSOR_DEVICE #ifdef BUZZER_DEVICE - case ESP_BUZZER: - if (sval.toInt() == 1) { - esp3d_buzzer.begin(); - } else if (sval.toInt() == 0) { - esp3d_buzzer.end(); - } - break; + case ESP_BUZZER: + if (sval.toInt() == 1) { + esp3d_buzzer.begin(); + } else if (sval.toInt() == 0) { + esp3d_buzzer.end(); + } + break; #endif // BUZZER_DEVICE - default: - break; + default: + break; + } } + } else { + response = "Invalid value for V"; + noError = false; } } // Integer value if (styp == "I") { - if (!Settings_ESP3D::write_uint32(spos.toInt(), sval.toInt())) { - response = "Set failed"; - noError = false; - } else { - // dynamique refresh is better than restart the board - switch (spos.toInt()) { + if (Settings_ESP3D::isValidByteSetting(sval.toInt(), spos.toInt())) { + if (!Settings_ESP3D::write_uint32(spos.toInt(), sval.toInt())) { + response = "Set failed"; + noError = false; + log_esp3d_e("Set failed"); + } else { + // dynamique refresh is better than restart the board + switch (spos.toInt()) { #ifdef SENSOR_DEVICE - case ESP_SENSOR_INTERVAL: - esp3d_sensor.setInterval(sval.toInt()); - break; + case ESP_SENSOR_INTERVAL: + esp3d_sensor.setInterval(sval.toInt()); + break; #endif // SENSOR_DEVICE #if COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == MKS_SERIAL - case ESP_BAUD_RATE: - serial_service.updateBaudRate(sval.toInt()); - break; + case ESP_BAUD_RATE: + serial_service.updateBaudRate(sval.toInt()); + break; #endif // COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == // MKS_SERIAL #if defined(ESP_SERIAL_BRIDGE_OUTPUT) - case ESP_SERIAL_BRIDGE_BAUD: - serial_bridge_service.updateBaudRate(sval.toInt()); - break; + case ESP_SERIAL_BRIDGE_BAUD: + serial_bridge_service.updateBaudRate(sval.toInt()); + break; #endif // defined(ESP_SERIAL_BRIDGE_OUTPUT) - default: - break; + default: + break; + } } + } else { + response = "Invalid value for V"; + noError = false; } } // String value if (styp == "S") { - if (!Settings_ESP3D::write_string(spos.toInt(), sval.c_str())) { - response = "Set failed"; - noError = false; - } else { - // dynamique refresh is better than restart the board - switch (spos.toInt()) { + if (Settings_ESP3D::isValidStringSetting(sval.c_str(), + spos.toInt())) { + if (!Settings_ESP3D::write_string(spos.toInt(), sval.c_str())) { + response = "Set failed"; + noError = false; + log_esp3d_e("Set failed"); + } else { + // dynamique refresh is better than restart the board + switch (spos.toInt()) { #ifdef AUTHENTICATION_FEATURE - case ESP_ADMIN_PWD: - case ESP_USER_PWD: - AuthenticationService::update(); - break; + case ESP_ADMIN_PWD: + case ESP_USER_PWD: + AuthenticationService::update(); + break; #endif // AUTHENTICATION_FEATURE - default: - break; + default: + break; + } } + } else { + response = "Invalid value for V"; + noError = false; } } #if defined(WIFI_FEATURE) // IP address if (styp == "A") { - if (!Settings_ESP3D::write_IP_String(spos.toInt(), sval.c_str())) { - response = "Set failed"; - noError = false; + if (Settings_ESP3D::isValidIPStringSetting(sval.c_str(), + spos.toInt())) { + if (!Settings_ESP3D::write_IP_String(spos.toInt(), sval.c_str())) { + response = "Set failed"; + noError = false; + } else { + // dynamique refresh is better than restart the board + // TBD + } } else { - // dynamique refresh is better than restart the board - // TBD + response = "Invalid value for V"; + noError = false; } } #endif // WIFI_FEATURE diff --git a/esp3d/src/core/espcmd/ESP550.cpp b/esp3d/src/core/espcmd/ESP550.cpp index 5b6b216c..8c3e729f 100644 --- a/esp3d/src/core/espcmd/ESP550.cpp +++ b/esp3d/src/core/espcmd/ESP550.cpp @@ -38,7 +38,8 @@ bool Commands::ESP550(const char* cmd_params, level_authenticate_type auth_type, if (auth_type == LEVEL_ADMIN) { parameter = clean_param(get_param(cmd_params, "")); if (parameter.length() != 0) { - if (Settings_ESP3D::isLocalPasswordValid(parameter.c_str())) { + if (Settings_ESP3D::isValidStringSetting(parameter.c_str(), + ESP_ADMIN_PWD)) { if (!Settings_ESP3D::write_string(ESP_ADMIN_PWD, parameter.c_str())) { response = format_response(COMMANDID, json, false, "Set failed"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP555.cpp b/esp3d/src/core/espcmd/ESP555.cpp index 8aa530e5..2dc9b7cd 100644 --- a/esp3d/src/core/espcmd/ESP555.cpp +++ b/esp3d/src/core/espcmd/ESP555.cpp @@ -38,7 +38,8 @@ bool Commands::ESP555(const char* cmd_params, level_authenticate_type auth_type, if (auth_type != LEVEL_GUEST) { parameter = clean_param(get_param(cmd_params, "")); if (parameter.length() != 0) { - if (Settings_ESP3D::isLocalPasswordValid(parameter.c_str())) { + if (Settings_ESP3D::isValidStringSetting(parameter.c_str(), + ESP_USER_PWD)) { if (!Settings_ESP3D::write_string(ESP_USER_PWD, parameter.c_str())) { response = format_response(COMMANDID, json, false, "Set failed"); noError = false; diff --git a/esp3d/src/core/espcmd/ESP740.cpp b/esp3d/src/core/espcmd/ESP740.cpp index e4c14e4a..184d21c4 100644 --- a/esp3d/src/core/espcmd/ESP740.cpp +++ b/esp3d/src/core/espcmd/ESP740.cpp @@ -114,9 +114,9 @@ bool Commands::ESP740(const char* cmd_params, level_authenticate_type auth_type, String time = ""; line = ""; countf++; -#ifdef FILESYSTEM_TIMESTAMP_FEATURE +#ifdef SD_TIMESTAMP_FEATURE time = timeService.getDateTime((time_t)sub.getLastWrite()); -#endif // FILESYSTEM_TIMESTAMP_FEATURE +#endif // SD_TIMESTAMP_FEATURE if (json) { if (countd > 0 || countf > 1) { line += ","; diff --git a/esp3d/src/core/espcmd/ESP901.cpp b/esp3d/src/core/espcmd/ESP901.cpp index fc4b17e1..23f539e1 100644 --- a/esp3d/src/core/espcmd/ESP901.cpp +++ b/esp3d/src/core/espcmd/ESP901.cpp @@ -64,7 +64,7 @@ bool Commands::ESP901(const char* cmd_params, level_authenticate_type auth_type, #endif // AUTHENTICATION_FEATURE if (noError) { uint ibuf = parameter.toInt(); - if (serial_service.is_valid_baudrate(ibuf)) { + if (Settings_ESP3D::isValidIntegerSetting(ibuf, ESP_BAUD_RATE)) { response = format_response(COMMANDID, json, false, "Incorrect port"); noError = false; } else { diff --git a/esp3d/src/core/espcmd/ESP931.cpp b/esp3d/src/core/espcmd/ESP931.cpp index 58433288..add1b0fc 100644 --- a/esp3d/src/core/espcmd/ESP931.cpp +++ b/esp3d/src/core/espcmd/ESP931.cpp @@ -64,10 +64,11 @@ bool Commands::ESP931(const char* cmd_params, level_authenticate_type auth_type, #endif // AUTHENTICATION_FEATURE if (noError) { uint ibuf = parameter.toInt(); - if (serial_bridge_service.is_valid_baudrate(ibuf)) { + if (Settings_ESP3D.isValidIntegerSetting(ibuf, ESP_SERIAL_BRIDGE_BAUD)) { response = format_response(COMMANDID, json, false, "Incorrect port"); noError = false; - } else { + } + else { if (!Settings_ESP3D::write_uint32(ESP_SERIAL_BRIDGE_BAUD, ibuf)) { response = format_response(COMMANDID, json, false, "Set failed"); noError = false; diff --git a/esp3d/src/core/settings_esp3d.cpp b/esp3d/src/core/settings_esp3d.cpp index d5656ddd..0f42109b 100644 --- a/esp3d/src/core/settings_esp3d.cpp +++ b/esp3d/src/core/settings_esp3d.cpp @@ -19,6 +19,8 @@ */ #include "../include/esp3d_config.h" +#define STRINGIFY(x) #x +#define STRING(x) STRINGIFY(x) #if defined(ESP_SAVE_SETTINGS) #include "esp3doutput.h" #include "settings_esp3d.h" @@ -35,12 +37,21 @@ #include "../modules/wifi/wificonfig.h" #endif // WIFI_FEATURE #endif // WIFI_FEATURE || ETH_FEATURE +#ifdef SENSOR_DEVICE +#include "../modules/sensor/sensor.h" +#endif // SENSOR_DEVICE #if ESP_SAVE_SETTINGS == SETTINGS_IN_PREFERENCES #include #define NAMESPACE "ESP3D" #endif // SETTINGS_IN_PREFERENCES +#if defined(TIMESTAMP_FEATURE) +#include "../modules/time/time_service.h" +#endif // TIMESTAMP_FEATURE + +#include "../modules/serial/serial_service.h" + // Current Settings Version #define CURRENT_SETTINGS_VERSION "ESP3D04" @@ -57,128 +68,207 @@ #define MAX_NOTIFICATION_TOKEN_LENGTH 63 #define MAX_NOTIFICATION_SETTINGS_LENGTH 128 #define MAX_SERVER_ADDRESS_LENGTH 128 -#define MAX_TIME_ZONE_LENGTH 7 +#define MAX_TIME_ZONE_LENGTH 6 #define MIN_SERVER_ADDRESS_LENGTH 0 // default byte values #ifdef WIFI_FEATURE -#define DEFAULT_STA_FALLBACK_MODE ESP_AP_SETUP +#define DEFAULT_STA_FALLBACK_MODE STRING(ESP_AP_SETUP) #if defined(STATION_WIFI_SSID) && defined(STATION_WIFI_PASSWORD) -#define DEFAULT_ESP_RADIO_MODE ESP_WIFI_STA +#define DEFAULT_ESP_RADIO_MODE STRING(ESP_WIFI_STA) #else -#define DEFAULT_ESP_RADIO_MODE ESP_AP_SETUP +#define DEFAULT_ESP_RADIO_MODE STRING(ESP_AP_SETUP) #endif // STATION_WIFI_SSID && STATION_WIFI_PASSWORD #else // WIFI_FEATURE -#define DEFAULT_STA_FALLBACK_MODE ESP_NO_NETWORK +#define DEFAULT_STA_FALLBACK_MODE STRING(ESP_NO_NETWORK) #ifdef BLUETOOTH_FEATURE -#define DEFAULT_ESP_RADIO_MODE ESP_BT +#define DEFAULT_ESP_RADIO_MODE STRING(ESP_BT) #else // BLUETOOTH_FEATURE #ifdef ETH_FEATURE -#define DEFAULT_ESP_RADIO_MODE ESP_ETH_STA +#define DEFAULT_ESP_RADIO_MODE STRING(ESP_ETH_STA) #else // BLUETOOTH_FEATURE -#define DEFAULT_ESP_RADIO_MODE ESP_NO_NETWORK +#define DEFAULT_ESP_RADIO_MODE STRING(ESP_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_SETUP 0 - -#define DEFAULT_VERBOSE_BOOT 0 -#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_BUZZER_STATE "1" +#define DEFAULT_INTERNET_TIME "0" +#define DEFAULT_SETUP "0" +#define DEFAULT_VERBOSE_BOOT "0" +#define DEFAULT_STA_IP_MODE "1" +#define DEFAULT_AP_CHANNEL "11" +#define DEFAULT_SSID_VISIBLE "1" +#define DEFAULT_OUTPUT_FLAG "255" +#define DEFAULT_SD_SPI_DIV "4" #ifndef DEFAULT_FW -#define DEFAULT_FW UNKNOWN_FW +#define DEFAULT_FW "0" #endif // DEFAULT_FW #define DEFAULT_TIME_ZONE "+00:00" -#define DEFAULT_TIME_DST 0 -#define DEFAULT_SD_MOUNT ESP_SD_ROOT -#define DEFAULT_SD_CHECK_UPDATE_AT_BOOT 1 -#define DEFAULT_SENSOR_TYPE NO_SENSOR_DEVICE -#define DEFAULT_HTTP_ON 1 -#define DEFAULT_FTP_ON 1 -#define DEFAULT_SERIAL_BRIDGE_ON 1 -#define DEFAULT_WEBDAV_ON 1 -#define DEFAULT_TELNET_ON 1 -#define DEFAULT_WEBSOCKET_ON 1 -#define DEFAULT_NOTIFICATION_TYPE 0 +#define DEFAULT_TIME_DST "0" +#define DEFAULT_SD_MOUNT "1" +#define DEFAULT_SD_CHECK_UPDATE_AT_BOOT "1" +#define DEFAULT_SENSOR_TYPE "0" +#define DEFAULT_HTTP_ON "1" +#define DEFAULT_FTP_ON "1" +#define DEFAULT_SERIAL_BRIDGE_ON "1" +#define DEFAULT_WEBDAV_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 -#define DEFAULT_SECURE_SERIAL 1 -#define DEFAULT_BOOT_RADIO_STATE 1 +#define DEFAULT_AUTO_NOTIFICATION_STATE "1" +#define DEFAULT_SECURE_SERIAL "1" +#define DEFAULT_BOOT_RADIO_STATE "1" // default int values -#define DEFAULT_ESP_INT 0L -#define DEFAULT_BAUD_RATE 115200L -#define DEFAULT_SERIAL_BRIDGE_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_WEBDAV_PORT 8181L -#define DEFAULT_TELNET_PORT 23L -#define DEFAULT_SENSOR_INTERVAL 30000L -#define DEFAULT_BOOT_DELAY 10000L -#define DEFAULT_CALIBRATION_VALUE 0 -#define DEFAULT_CALIBRATION_DONE 0 -#define DEFAULT_SESSION_TIMEOUT 3 +#define DEFAULT_ESP_INT "0" +#define DEFAULT_BAUD_RATE "115200" +#define DEFAULT_SERIAL_BRIDGE_BAUD_RATE "115200" +#define DEFAULT_HTTP_PORT "80" +#define DEFAULT_FTP_CTRL_PORT "21" +#define DEFAULT_FTP_ACTIVE_PORT "20" +#define DEFAULT_FTP_PASSIVE_PORT "55600" +#define DEFAULT_WEBSOCKET_PORT "8282" +#define DEFAULT_WEBDAV_PORT "8181" +#define DEFAULT_TELNET_PORT "23" +#define DEFAULT_SENSOR_INTERVAL "30000" +#define DEFAULT_BOOT_DELAY "10000" +#define DEFAULT_CALIBRATION_VALUE "0" +#define DEFAULT_CALIBRATION_DONE "0" +#define DEFAULT_SESSION_TIMEOUT "3" + +// Default flags +#define DEFAULT_SERIAL_OUTPUT_FLAG "1" +#define DEFAULT_REMOTE_SCREEN_FLAG "1" +#define DEFAULT_WEBSOCKET_FLAG "1" +#define DEFAULT_TELNET_FLAG "1" +#define DEFAULT_BT_FLAG "1" +#define DEFAULT_SCREEN_FLAG "1" +#define DEFAULT_SERIAL_BRIDGE_FLAG "1" #ifdef WIFI_FEATURE // default string values -const char DEFAULT_AP_SSID[] = "ESP3D"; -const char DEFAULT_AP_PASSWORD[] = "12345678"; +#define DEFAULT_AP_SSID "ESP3D" +#define 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; +#define DEFAULT_STA_SSID STATION_WIFI_SSID +#define DEFAULT_STA_PASSWORD STATION_WIFI_PASSWORD #else -const char DEFAULT_STA_SSID[] = "NETWORK_SSID"; -const char DEFAULT_STA_PASSWORD[] = "12345678"; +#define DEFAULT_STA_SSID "NETWORK_SSID" +#define 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"; +#define 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) +#define DEFAULT_ADMIN_PWD "admin" +#define DEFAULT_USER_PWD "user" + +#define DEFAULT_TIME_SERVER1 "time.windows.com" +#define DEFAULT_TIME_SERVER2 "time.google.com" +#define DEFAULT_TIME_SERVER3 "0.pool.ntp.org" + +#define DEFAULT_SETTINGS_VERSION "ESP3D" + // 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 -#define DEFAULT_DNS_VALUE DEFAULT_GATEWAY_VALUE -const uint8_t DEFAULT_ADDRESS_VALUE[] = {0, 0, 0, 0}; -#endif // WIFI_FEATURE || ETH_FEATURE +#define DEFAULT_STA_IP_VALUE "192.168.0.254" +#define DEFAULT_STA_GATEWAY_VALUE DEFAULT_STA_IP_VALUE +#define DEFAULT_STA_MASK_VALUE "255.255.255.0" +#define DEFAULT_STA_DNS_VALUE DEFAULT_STA_IP_VALUE -uint8_t Settings_ESP3D::_FirmwareTarget = DEFAULT_FW; -bool Settings_ESP3D::_isverboseboot = DEFAULT_VERBOSE_BOOT; +#define DEFAULT_AP_IP_VALUE "192.1680.0.1" +#define DEFAULT_AP_GATEWAY_VALUE DEFAULT_AP_IP_VALUE +#define DEFAULT_AP_MASK_VALUE "255.255.255.0" +#define DEFAULT_AP_DNS_VALUE DEFAULT_AP_IP_VALUE + +uint8_t Settings_ESP3D::_FirmwareTarget = 0; +bool Settings_ESP3D::_isverboseboot = false; + +uint16_t ESP3DSettingsData[] = {ESP_RADIO_MODE, + ESP_STA_PASSWORD, + ESP_STA_SSID, + ESP_BOOT_RADIO_STATE, + ESP_STA_FALLBACK_MODE, + ESP_AP_SSID, + ESP_AP_PASSWORD, + ESP_STA_IP_VALUE, + ESP_STA_GATEWAY_VALUE, + ESP_STA_MASK_VALUE, + ESP_STA_DNS_VALUE, + ESP_AP_IP_VALUE, + ESP_SETTINGS_VERSION, + ESP_NOTIFICATION_TYPE, + ESP_CALIBRATION, + ESP_AP_CHANNEL, + ESP_BUZZER, + ESP_INTERNET_TIME, + ESP_SERIAL_FLAG, + ESP_HTTP_ON, + ESP_TELNET_ON, + ESP_WEBSOCKET_ON, + ESP_SD_SPEED_DIV, + ESP_SENSOR_TYPE, + ESP_TARGET_FW, + ESP_TIME_IS_DST, + ESP_REMOTE_SCREEN_FLAG, + ESP_SD_MOUNT, + ESP_SESSION_TIMEOUT, + ESP_WEBSOCKET_FLAG, + ESP_SD_CHECK_UPDATE_AT_BOOT, + ESP_SETUP, + ESP_TELNET_FLAG, + ESP_BT_FLAG, + ESP_SCREEN_FLAG, + ESP_FTP_ON, + ESP_AUTO_NOTIFICATION, + ESP_VERBOSE_BOOT, + ESP_WEBDAV_ON, + ESP_SECURE_SERIAL, + ESP_SERIAL_BRIDGE_FLAG, + ESP_SERIAL_BRIDGE_ON, + ESP_HOSTNAME, + ESP_ADMIN_PWD, + ESP_USER_PWD, + ESP_NOTIFICATION_TOKEN1, + ESP_NOTIFICATION_TOKEN2, + ESP_NOTIFICATION_SETTINGS, + ESP_TIME_SERVER1, + ESP_TIME_SERVER2, + ESP_TIME_SERVER3, + ESP_TIME_ZONE, + ESP_BAUD_RATE, + ESP_HTTP_PORT, + ESP_TELNET_PORT, + ESP_SENSOR_INTERVAL, + ESP_BOOT_DELAY, + ESP_WEBSOCKET_PORT, + ESP_CALIBRATION_1, + ESP_CALIBRATION_2, + ESP_CALIBRATION_3, + ESP_CALIBRATION_4, + ESP_CALIBRATION_5, + ESP_FTP_CTRL_PORT, + ESP_FTP_DATA_ACTIVE_PORT, + ESP_FTP_DATA_PASSIVE_PORT, + ESP_WEBDAV_PORT, + ESP_SERIAL_BRIDGE_BAUD + +}; +#if defined(SD_DEVICE) +const uint8_t SupportedSPIDivider[] = {1, 2, 4, 6, 8, 16, 32}; +const uint8_t SupportedSPIDividerSize = + sizeof(SupportedSPIDivider) / sizeof(uint8_t); +#endif // #ifdef SD_DEVICE +#if defined(WIFI_FEATURE) +const uint8_t SupportedApChannels[] = {1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14}; +const uint8_t SupportedApChannelsSize = + sizeof(SupportedApChannels) / sizeof(uint8_t); +#endif // WIFI_FEATURE bool Settings_ESP3D::begin() { if (GetSettingsVersion() == -1) { @@ -240,525 +330,13 @@ const char *Settings_ESP3D::GetFirmwareTargetShortName() { 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_BOOT_RADIO_STATE: - res = DEFAULT_BOOT_RADIO_STATE; - break; - case ESP_STA_FALLBACK_MODE: - res = DEFAULT_STA_FALLBACK_MODE; - break; -#if COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == MKS_SERIAL - case ESP_SECURE_SERIAL: - res = DEFAULT_SECURE_SERIAL; - break; -#endif // #if COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == - // MKS_SERIAL - case ESP_RADIO_MODE: - res = DEFAULT_ESP_RADIO_MODE; - break; - case ESP_VERBOSE_BOOT: - res = DEFAULT_VERBOSE_BOOT; - break; - case ESP_SETUP: - res = DEFAULT_SETUP; - break; -#ifdef AUTHENTICATION_FEATURE - case ESP_SESSION_TIMEOUT: - res = DEFAULT_SESSION_TIMEOUT; - break; -#endif // AUTHENTICATION_FEATURE -#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 -#if defined(WIFI_FEATURE) - case ESP_AP_CHANNEL: - res = DEFAULT_AP_CHANNEL; - break; -#endif // WIFI_FEATURE - case ESP_SERIAL_FLAG: - res = DEFAULT_SERIAL_OUTPUT_FLAG; - break; - case ESP_REMOTE_SCREEN_FLAG: - res = DEFAULT_REMOTE_SCREEN_FLAG; - break; - case ESP_WEBSOCKET_FLAG: - res = DEFAULT_WEBSOCKET_FLAG; - break; - case ESP_TELNET_FLAG: - res = DEFAULT_TELNET_FLAG; - break; - case ESP_BT_FLAG: - res = DEFAULT_BT_FLAG; - break; -#if defined(ESP_SERIAL_BRIDGE_OUTPUT) - case ESP_SERIAL_BRIDGE_FLAG: - res = DEFAULT_SERIAL_BRIDGE_FLAG; - break; - case ESP_SERIAL_BRIDGE_ON: - res = DEFAULT_SERIAL_BRIDGE_ON; - break; -#endif // defined() - case ESP_SCREEN_FLAG: - res = DEFAULT_SCREEN_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 WEBDAV_FEATURE - case ESP_WEBDAV_ON: - res = DEFAULT_WEBDAV_ON; - break; -#endif // WEBDAV_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_SD_CHECK_UPDATE_AT_BOOT: - res = DEFAULT_SD_CHECK_UPDATE_AT_BOOT; - break; -#endif // SD_DEVICE - case ESP_TARGET_FW: - res = DEFAULT_FW; - break; -#ifdef TIMESTAMP_FEATURE - case ESP_TIME_IS_DST: - res = DEFAULT_TIME_DST; - break; -#endif // TIMESTAMP_FEATURE - -#if defined(SENSOR_DEVICE) - case ESP_SENSOR_TYPE: - res = DEFAULT_SENSOR_TYPE; - break; -#endif // SENSOR_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_SERIAL_BRIDGE_BAUD: -#if defined(ESP_SERIAL_BRIDGE_OUTPUT) - res = DEFAULT_SERIAL_BRIDGE_BAUD_RATE; - break; -#endif // ESP_SERIAL_BRIDGE_OUT;UT - 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; - case ESP_STA_DNS_VALUE: - res = IPAddress(DEFAULT_DNS_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 WEBDAV_FEATURE - case ESP_WEBDAV_PORT: - res = DEFAULT_WEBDAV_PORT; - break; -#endif // WEBDAV_FEATURE -#if defined(SENSOR_DEVICE) - case ESP_SENSOR_INTERVAL: - res = DEFAULT_SENSOR_INTERVAL; - break; -#endif // SENSOR_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 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 WEBDAV_FEATURE - case ESP_WEBDAV_PORT: - res = MAX_WEBDAV_PORT; - break; -#endif // WEBDAV_FEATURE -#ifdef WS_DATA_FEATURE - case ESP_WEBSOCKET_PORT: - res = MAX_WEBSOCKET_PORT; - break; -#endif // WS_DATA_FEATURE -#if defined(SENSOR_DEVICE) - case ESP_SENSOR_INTERVAL: - res = MAX_SENSOR_INTERVAL; - break; -#endif // SENSOR_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 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 -#ifdef WEBDAV_FEATURE - case ESP_WEBDAV_PORT: - res = MIN_WEBDAV_PORT; - break; -#endif // WEBDAV_FEATURE -#if defined(SENSOR_DEVICE) - case ESP_SENSOR_INTERVAL: - res = MIN_SENSOR_INTERVAL; - break; -#endif // SENSOR_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 - 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 - 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_ZONE: - res = DEFAULT_TIME_ZONE; - break; - 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_ZONE: - res = MAX_TIME_ZONE_LENGTH; - break; - 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); + log_esp3d("read_byte %d", pos); + uint8_t value = getDefaultByteSetting(pos); + log_esp3d("default value %d", value); #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM // check if parameters are acceptable if ((pos + 1 > EEPROM_SIZE)) { @@ -778,9 +356,9 @@ uint8_t Settings_ESP3D::read_byte(int pos, bool *haserror) { } String p = "P_" + String(pos); if (prefs.isKey(p.c_str())) { - value = prefs.getChar(p.c_str(), get_default_byte_value(pos)); + value = prefs.getChar(p.c_str(), getDefaultByteSetting(pos)); } else { - value = get_default_byte_value(pos); + value = getDefaultByteSetting(pos); } prefs.end(); #endif // SETTINGS_IN_PREFERENCES @@ -836,14 +414,16 @@ bool Settings_ESP3D::is_string(const char *s, uint len) { // 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); + const ESP3DSettingDescription *query = getSettingPtr(pos); if (haserror) { *haserror = true; } - if (size_max == 0) { - log_esp3d_e("Error size string %d", pos); - return DEFAULT_ESP_STRING; + if (!query) { + log_esp3d_e("Error unknow entry %d", pos); + return ""; } + uint8_t size_max = query->size; + #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM static char *byte_buffer = NULL; size_max++; // do not forget the 0x0 for the end @@ -854,12 +434,12 @@ const char *Settings_ESP3D::read_string(int pos, bool *haserror) { // check if parameters are acceptable if (pos + size_max + 1 > EEPROM_SIZE) { log_esp3d_e("Error read string %d", pos); - return DEFAULT_ESP_STRING; + return ""; } byte_buffer = (char *)malloc(size_max + 1); if (!byte_buffer) { log_esp3d_e("Error mem read string %d", pos); - return DEFAULT_ESP_STRING; + return ""; } EEPROM.begin(EEPROM_SIZE); byte b = 1; // non zero for the while loop below @@ -894,9 +474,9 @@ const char *Settings_ESP3D::read_string(int pos, bool *haserror) { } String p = "P_" + String(pos); if (prefs.isKey(p.c_str())) { - res = prefs.getString(p.c_str(), get_default_string_value(pos)); + res = prefs.getString(p.c_str(), getDefaultStringSetting(pos)); } else { - res = get_default_string_value(pos); + res = getDefaultStringSetting(pos); } prefs.end(); @@ -916,7 +496,13 @@ const char *Settings_ESP3D::read_string(int pos, bool *haserror) { // 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); + const ESP3DSettingDescription *query = getSettingPtr(pos); + if (!query) { + log_esp3d_e("Error unknow entry %d", pos); + return false; + } + uint8_t size_max = query->size; + // check if parameters are acceptable if (size_max == 0) { log_esp3d_e("Error unknow entry %d", pos); @@ -966,7 +552,7 @@ uint32_t Settings_ESP3D::read_uint32(int pos, bool *haserror) { if (haserror) { *haserror = true; } - uint32_t res = get_default_int32_value(pos); + uint32_t res = getDefaultIntegerSetting(pos); #if ESP_SAVE_SETTINGS == SETTINGS_IN_EEPROM // check if parameters are acceptable uint8_t size_buffer = sizeof(uint32_t); @@ -993,7 +579,7 @@ uint32_t Settings_ESP3D::read_uint32(int pos, bool *haserror) { if (prefs.isKey(p.c_str())) { res = prefs.getUInt(p.c_str(), res); } else { - res = get_default_int32_value(pos); + res = getDefaultIntegerSetting(pos); } prefs.end(); #endif // SETTINGS_IN_PREFERENCES @@ -1010,7 +596,7 @@ uint32_t Settings_ESP3D::read_IP(int pos, bool *haserror) { // read an IP String Settings_ESP3D::read_IP_String(int pos, bool *haserror) { - return IPtoString(read_uint32(pos, haserror)); + return _IpToString(read_uint32(pos, haserror)); } // write a uint32 @@ -1057,304 +643,44 @@ bool Settings_ESP3D::write_IP(int pos, const uint32_t value) { // clear all entries bool Settings_ESP3D::reset(bool networkonly) { - // radio mode - Settings_ESP3D::write_byte( - ESP_RADIO_MODE, Settings_ESP3D::get_default_byte_value(ESP_RADIO_MODE)); - Settings_ESP3D::write_byte( - ESP_BOOT_RADIO_STATE, - Settings_ESP3D::get_default_byte_value(ESP_BOOT_RADIO_STATE)); - Settings_ESP3D::write_byte( - ESP_STA_FALLBACK_MODE, - Settings_ESP3D::get_default_byte_value(ESP_STA_FALLBACK_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)); + uint nb_settings = sizeof(ESP3DSettingsData) / sizeof(uint16_t); + for (uint i = 0; i < nb_settings; i++) { + if (networkonly && i == ESP_SETTINGS_VERSION) { + return true; + } -#endif // WIFI_FEATURE - -#if defined(WIFI_FEATURE) || defined(ETH_FEATURE) - // 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)); - // STA static DNS - Settings_ESP3D::write_IP( - ESP_STA_DNS_VALUE, - Settings_ESP3D::get_default_IP_value(ESP_STA_DNS_VALUE)); -#endif // WIFI_FEATURE || ETH_FEATURE - if (networkonly) { - return true; + const ESP3DSettingDescription *query = getSettingPtr(i); + if (query) { + switch (query->type) { + case ESP3DSettingType::string_t: + if (!Settings_ESP3D::write_string(i, query->default_val)) { + log_esp3d_e("Error reset string %d to %s", i, query->default_val); + return false; + } + break; + case ESP3DSettingType::byte_t: + if (!Settings_ESP3D::write_byte( + i, (uint8_t)strtoul(query->default_val, NULL, 0))) { + log_esp3d_e("Error reset byte %d to %s", i, query->default_val); + return false; + } + break; + case ESP3DSettingType::integer_t: + case ESP3DSettingType::ip_t: + if (!Settings_ESP3D::write_uint32(i, getDefaultIntegerSetting(i))) { + log_esp3d_e("Error reset uint32 %d to %s", i, query->default_val); + return false; + } + break; + default: + log_esp3d_e("Error unknow entry %d", i); + break; + } + } else { + log_esp3d_e("Error unknow entry %d", i); + } } - - 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"); - - // Setup done (internal only) - Settings_ESP3D::write_byte(ESP_SETUP, - Settings_ESP3D::get_default_byte_value(ESP_SETUP)); - // Verbose boot - Settings_ESP3D::write_byte( - ESP_VERBOSE_BOOT, - Settings_ESP3D::get_default_byte_value(ESP_VERBOSE_BOOT)); - // Secure Serial -#if COMMUNICATION_PROTOCOL == RAW_SERIAL || COMMUNICATION_PROTOCOL == MKS_SERIAL - Settings_ESP3D::write_byte( - ESP_SECURE_SERIAL, - Settings_ESP3D::get_default_byte_value(ESP_SECURE_SERIAL)); -#endif // COMMUNICATION PROTOCOL -#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)); - -#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 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 WEBDAV_FEATURE - // WebDav On - Settings_ESP3D::write_byte( - ESP_WEBDAV_ON, Settings_ESP3D::get_default_byte_value(ESP_WEBDAV_ON)); - // WebDav Port - Settings_ESP3D::write_uint32( - ESP_WEBDAV_PORT, - Settings_ESP3D::get_default_int32_value(ESP_WEBDAV_PORT)); -#endif // WEBDAV_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()); - // Session timeout - Settings_ESP3D::write_byte( - ESP_SESSION_TIMEOUT, - Settings_ESP3D::get_default_byte_value(ESP_SESSION_TIMEOUT)); -#endif // AUTHENTICATION_FEATURE - // Target FW - Settings_ESP3D::write_byte( - ESP_TARGET_FW, Settings_ESP3D::get_default_byte_value(ESP_TARGET_FW)); - // Output flags - Settings_ESP3D::write_byte( - ESP_SERIAL_FLAG, Settings_ESP3D::get_default_byte_value(ESP_SERIAL_FLAG)); - Settings_ESP3D::write_byte( - ESP_SERIAL_BRIDGE_FLAG, - Settings_ESP3D::get_default_byte_value(ESP_SERIAL_BRIDGE_FLAG)); - Settings_ESP3D::write_byte( - ESP_REMOTE_SCREEN_FLAG, - Settings_ESP3D::get_default_byte_value(ESP_REMOTE_SCREEN_FLAG)); - Settings_ESP3D::write_byte( - ESP_WEBSOCKET_FLAG, - Settings_ESP3D::get_default_byte_value(ESP_WEBSOCKET_FLAG)); - Settings_ESP3D::write_byte( - ESP_TELNET_FLAG, Settings_ESP3D::get_default_byte_value(ESP_TELNET_FLAG)); - Settings_ESP3D::write_byte( - ESP_BT_FLAG, Settings_ESP3D::get_default_byte_value(ESP_BT_FLAG)); - Settings_ESP3D::write_byte( - ESP_SCREEN_FLAG, Settings_ESP3D::get_default_byte_value(ESP_SCREEN_FLAG)); -#ifdef SD_DEVICE - // SPI SD Divider - Settings_ESP3D::write_byte( - ESP_SD_SPEED_DIV, - Settings_ESP3D::get_default_byte_value(ESP_SD_SPEED_DIV)); -#ifdef SD_UPDATE_FEATURE - // SD Update feature - Settings_ESP3D::write_byte( - ESP_SD_CHECK_UPDATE_AT_BOOT, - Settings_ESP3D::get_default_byte_value(ESP_SD_CHECK_UPDATE_AT_BOOT)); -#endif // SD_UPDATE_FEATURE -#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_string( - ESP_TIME_ZONE, - Settings_ESP3D::get_default_string_value(ESP_TIME_ZONE).c_str()); - // 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 SENSOR_DEVICE - // Sensor device - Settings_ESP3D::write_byte( - ESP_SENSOR_TYPE, Settings_ESP3D::get_default_byte_value(ESP_SENSOR_TYPE)); - // Sensor query interval - Settings_ESP3D::write_uint32( - ESP_SENSOR_INTERVAL, - Settings_ESP3D::get_default_int32_value(ESP_SENSOR_INTERVAL)); -#endif // SENSOR_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; + return true; } // Get Settings Version @@ -1376,11 +702,11 @@ int8_t Settings_ESP3D::GetSettingsVersion() { // write a IP from string bool Settings_ESP3D::write_IP_String(int pos, const char *value) { - return write_uint32(pos, StringtoIP(value)); + return write_uint32(pos, _stringToIP(value)); } // Helper to convert IP string to int -uint32_t Settings_ESP3D::StringtoIP(const char *s) { +uint32_t Settings_ESP3D::_stringToIP(const char *s) { uint32_t ip_int = 0; IPAddress ipaddr; if (ipaddr.fromString(s)) { @@ -1390,7 +716,7 @@ uint32_t Settings_ESP3D::StringtoIP(const char *s) { } // Helper to convert int to IP string -String Settings_ESP3D::IPtoString(uint32_t ip_int) { +String Settings_ESP3D::_IpToString(uint32_t ip_int) { static IPAddress ipaddr; ipaddr = ip_int; return ipaddr.toString(); @@ -1419,20 +745,779 @@ const char *Settings_ESP3D::TargetBoard() { #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)) { +#endif // ESP_SAVE_SETTINGS + +bool Settings_ESP3D::isValidIPStringSetting(const char *value, + ESP3DSettingIndex settingElement) { + const ESP3DSettingDescription *settingPtr = getSettingPtr(settingElement); + if (!settingPtr) { return false; } - // no space allowed - for (uint8_t i = 0; i < strlen(password); i++) { - c = password[i]; - if (c == ' ') { + if (settingPtr->type != ESP3DSettingType::ip_t) { + return false; + } + String ippart[4]; + uint index = 0; + for (uint8_t i = 0; i < strlen(value); i++) { + // only digit and . are allowed + if (!isDigit(value[i]) && value[i] != '.') { + return false; + } + if (value[i] == '.') { // new ip part + index++; + if (index > 3) { // only 4 parts allowed (IPv4 only for the moment) + return false; + } + } else { // fill the part + ippart[index] += value[i]; + } + } + if (index != 3) { // only exactly 4 parts allowed, no less + return false; + } + for (uint8_t i = 0; i < 4; i++) { // check each part + // max value is 255, no empty part, no part longer than 3 digits + if (ippart[i].toInt() > 255 || ippart[i].length() > 3 || + ippart[i].length() == 0) { return false; } } return true; } -#endif // ESP_SAVE_SETTINGS +bool Settings_ESP3D::isValidStringSetting(const char *value, + ESP3DSettingIndex settingElement) { + const ESP3DSettingDescription *settingPtr = getSettingPtr(settingElement); + if (!(settingPtr->type == ESP3DSettingType::string_t)) { + return false; + } + size_t len = strlen(value); + // cannot be over max size + if (len > settingPtr->size) { + return false; + } + // only printable char allowed + for (uint i = 0; i < strlen(value); i++) { + if (!isPrintable(value[i])) { + return false; + } + } + switch (settingElement) { + case ESP_SETTINGS_VERSION: + return (!strcmp(value, DEFAULT_SETTINGS_VERSION) == 0); + break; + case ESP_HOSTNAME: + // only letter and digit + for (uint i = 0; i < strlen(value); i++) { + char c = value[i]; + if (!(isdigit(c) || isalpha(c) || c == '-')) { + return false; + } + if (c == ' ') { + return false; + } + } + return (len >= 1); // at least 1 char for hostname + break; + case ESP_STA_SSID: + case ESP_AP_SSID: + return (len >= 1); // at least 1 char for ssid + break; + case ESP_ADMIN_PWD: + case ESP_USER_PWD: + for (uint i = 0; i < strlen(value); i++) { + if (value[i] == ' ') { // no space allowed + return false; + } + } + return (len >= 1); // at least 1 char for password + break; + case ESP_STA_PASSWORD: + case ESP_AP_PASSWORD: + return (len == 0 || + (len >= 8)); // no password or at least 8 char for password +#if defined(NOTIFICATION_FEATURE) + case ESP_NOTIFICATION_TOKEN1: + case ESP_NOTIFICATION_TOKEN2: + case ESP_NOTIFICATION_SETTINGS: + return true; // no more check for notification + break; +#endif // NOTIFICATION_FEATURE +#if defined(TIMESTAMP_FEATURE) + case ESP_TIME_SERVER1: + case ESP_TIME_SERVER2: + case ESP_TIME_SERVER3: + return true; // no more check for time server + break; + case ESP_TIME_ZONE: + if (len != settingPtr->size - 1) { + return false; + } + for (uint8_t i = 0; i < SupportedTimeZonesSize; i++) { + if (strcmp(value, SupportedTimeZones[i]) == 0) { + return true; + } + } + break; +#endif // TIMESTAMP_FEATURE + default: + return false; + } + return false; +} +bool Settings_ESP3D::isValidIntegerSetting(uint32_t value, + ESP3DSettingIndex settingElement) { + const ESP3DSettingDescription *settingPtr = getSettingPtr(settingElement); + if (!settingPtr) { + return false; + } + if (settingPtr->type != ESP3DSettingType::integer_t) { + return false; + } + switch (settingElement) { + case ESP_SERIAL_BRIDGE_BAUD: + case ESP_BAUD_RATE: + for (uint8_t i = 0; i < SupportedBaudListSize; i++) { + if (value == SupportedBaudList[i]) { + return true; + } + } + break; + case ESP_WEBDAV_PORT: + case ESP_HTTP_PORT: + case ESP_TELNET_PORT: + case ESP_FTP_CTRL_PORT: + case ESP_FTP_DATA_ACTIVE_PORT: + case ESP_FTP_DATA_PASSIVE_PORT: + case ESP_WEBSOCKET_PORT: + if (value >= 1 && value <= 65535) { + return true; + } + break; + case ESP_SENSOR_INTERVAL: + if (value >= MIN_SENSOR_INTERVAL && value <= MAX_SENSOR_INTERVAL) { + return true; + } + break; + case ESP_BOOT_DELAY: + if (value >= MIN_BOOT_DELAY && value <= MAX_BOOT_DELAY) { + return true; + } + break; + case ESP_CALIBRATION_1: + case ESP_CALIBRATION_2: + case ESP_CALIBRATION_3: + case ESP_CALIBRATION_4: + case ESP_CALIBRATION_5: + // no check for calibration currently + return true; + break; + default: + return false; + } + return false; +} +bool Settings_ESP3D::isValidByteSetting(uint8_t value, + ESP3DSettingIndex settingElement) { + const ESP3DSettingDescription *settingPtr = getSettingPtr(settingElement); + if (!settingPtr) { + return false; + } + if (settingPtr->type != ESP3DSettingType::byte_t) { + return false; + } + + switch (settingElement) { + case ESP_BUZZER: + case ESP_INTERNET_TIME: + case ESP_SERIAL_FLAG: + case ESP_REMOTE_SCREEN_FLAG: + case ESP_HTTP_ON: + case ESP_TELNET_ON: + case ESP_WEBSOCKET_ON: + case ESP_WEBSOCKET_FLAG: + case ESP_SD_CHECK_UPDATE_AT_BOOT: + case ESP_SETUP: + case ESP_TELNET_FLAG: + case ESP_BT_FLAG: + case ESP_SCREEN_FLAG: + case ESP_FTP_ON: + case ESP_AUTO_NOTIFICATION: + case ESP_SERIAL_BRIDGE_FLAG: + case ESP_SERIAL_BRIDGE_ON: + case ESP_VERBOSE_BOOT: + case ESP_WEBDAV_ON: + case ESP_SECURE_SERIAL: + case ESP_CALIBRATION: + case ESP_BOOT_RADIO_STATE: + if (value == (uint8_t)ESP3DState::off || + value == (uint8_t)ESP3DState::on) { + return true; + } + break; +#if defined(NOTIFICATION_FEATURE) + case ESP_NOTIFICATION_TYPE: + if (value == ESP_NO_NOTIFICATION || value == ESP_PUSHOVER_NOTIFICATION || + value == ESP_EMAIL_NOTIFICATION || value == ESP_LINE_NOTIFICATION || + value == ESP_TELEGRAM_NOTIFICATION || + value == ESP_IFTTT_NOTIFICATION) { + return true; + } + + break; +#endif // NOTIFICATION_FEATURE + case ESP_RADIO_MODE: + if (value == ESP_NO_NETWORK +#if defined(WIFI_FEATURE) + || value == ESP_WIFI_STA || value == ESP_WIFI_AP || + value == ESP_AP_SETUP +#endif // WIFI_FEATURE +#if defined(ETH_FEATURE) + || value == ESP_ETH +#endif // ETH_FEATURE +#if defined(BLUETOOTH_FEATURE) + || value == ESP_BT +#endif // BLUETOOTH_FEATURE + ) { + return true; + } + break; + case ESP_STA_IP_MODE: + if (value == DHCP_MODE || value == STATIC_IP_MODE) { + return true; + } + break; +#if defined(WIFI_FEATURE) + case ESP_AP_CHANNEL: + for (uint8_t i = 0; i < SupportedApChannelsSize; i++) { + if (value == SupportedApChannels[i]) { + return true; + } + } + break; +#endif // WIFI_FEATURE +#ifdef SD_DEVICE + case ESP_SD_SPEED_DIV: + for (uint8_t i = 0; i < SupportedSPIDividerSize; i++) { + if (value == SupportedSPIDivider[i]) { + return true; + } + } + break; + case ESP_SD_MOUNT: + if (value == ESP_SD_ROOT || value == ESP_SD_SUB_SD || + value == ESP_SD_SUB_EXT) { + return true; + } + break; +#endif // #ifdef SD_DEVICE +#ifdef SENSOR_DEVICE + case ESP_SENSOR_TYPE: + if (value == 0) { + return true; + } + for (uint8_t p = 0; p < esp3d_sensor.nbType(); p++) { + if (value == esp3d_sensor.GetModel(p)) { + return true; + } + } + break; +#endif // SENSOR_DEVICE + case ESP_TARGET_FW: + if (value == REPETIER || value == MARLIN || value == UNKNOWN_FW || + value == SMOOTHIEWARE || value == GRBL) { + return true; + } + break; + case ESP_SESSION_TIMEOUT: + // TODO: what should be the upper limit for session timeout? + // 0 means no timeout so it is ok to have 0 + return true; + break; + case ESP_STA_FALLBACK_MODE: + if (value == ESP_NO_NETWORK +#if defined(WIFI_FEATURE) + || value == ESP_AP_SETUP +#endif // WIFI_FEATURE +#if defined(BT_FEATURE) + || value == ESP_BT +#endif // BT_FEATURE + ) { + return true; + } + break; + + default: + return false; + } + + return true; +} + +uint32_t Settings_ESP3D::getDefaultIntegerSetting( + ESP3DSettingIndex settingElement) { + const ESP3DSettingDescription *query = getSettingPtr(settingElement); + if (query) { + if (query->type == ESP3DSettingType::ip_t) { + return _stringToIP(query->default_val); + } + if (query->type == ESP3DSettingType::integer_t) + return (uint32_t)strtoul(query->default_val, NULL, 0); + else { + log_esp3d_e("Error invalid type %d for %d", query->type, settingElement); + } + } + return 0; +} + +const char *Settings_ESP3D::getDefaultStringSetting( + ESP3DSettingIndex settingElement) { + const ESP3DSettingDescription *query = getSettingPtr(settingElement); + if (query) { + if (query->type == ESP3DSettingType::string_t || + query->type == ESP3DSettingType::ip_t) + return query->default_val; + else { + log_esp3d_e("Error invalid type %d for %d", query->type, settingElement); + } + } + return NULL; +} + +uint8_t Settings_ESP3D::getDefaultByteSetting( + ESP3DSettingIndex settingElement) { + log_esp3d("getDefaultByteSetting %d", settingElement); + const ESP3DSettingDescription *query = getSettingPtr(settingElement); + + if (query) { + log_esp3d("getDefaultByteSetting found"); + if (query->type == ESP3DSettingType::byte_t) { + log_esp3d("getDefaultByteSetting is %s", query->default_val); + return (uint8_t)strtoul(query->default_val, NULL, 0); + } else { + log_esp3d_e("Error invalid type %d for %d", query->type, settingElement); + } + } else { + log_esp3d_e("Error unknow entry %d", settingElement); + } + return 0; +} + +// get the description of a setting +// Unlike esp32 esp8266 does not have lot of memory so we hard code the +// settings and just generate one setting on demand +const ESP3DSettingDescription *Settings_ESP3D::getSettingPtr( + const ESP3DSettingIndex index) { + static ESP3DSettingDescription setting; + memset(&setting, 0, sizeof(setting)); + // index of setting + setting.index = index; + // type of setting + switch (index) { + case ESP_RADIO_MODE: + case ESP_NOTIFICATION_TYPE: + case ESP_CALIBRATION: + case ESP_AP_CHANNEL: + case ESP_BUZZER: + case ESP_INTERNET_TIME: + case ESP_SERIAL_FLAG: + case ESP_HTTP_ON: + case ESP_TELNET_ON: + case ESP_WEBSOCKET_ON: + case ESP_SD_SPEED_DIV: + case ESP_SENSOR_TYPE: + case ESP_TARGET_FW: + case ESP_TIME_IS_DST: + case ESP_REMOTE_SCREEN_FLAG: + case ESP_SD_MOUNT: + case ESP_SESSION_TIMEOUT: + case ESP_WEBSOCKET_FLAG: + case ESP_SD_CHECK_UPDATE_AT_BOOT: + case ESP_SETUP: + case ESP_TELNET_FLAG: + case ESP_BT_FLAG: + case ESP_SCREEN_FLAG: + case ESP_FTP_ON: + case ESP_AUTO_NOTIFICATION: + case ESP_VERBOSE_BOOT: + case ESP_WEBDAV_ON: + case ESP_SECURE_SERIAL: + case ESP_BOOT_RADIO_STATE: + case ESP_STA_FALLBACK_MODE: + case ESP_SERIAL_BRIDGE_FLAG: + case ESP_SERIAL_BRIDGE_ON: + case ESP_STA_IP_MODE: + setting.type = ESP3DSettingType::byte_t; // byte + break; + + case ESP_SETTINGS_VERSION: + case ESP_HOSTNAME: + case ESP_STA_PASSWORD: + case ESP_STA_SSID: + case ESP_ADMIN_PWD: + case ESP_USER_PWD: + case ESP_AP_SSID: + case ESP_AP_PASSWORD: + case ESP_NOTIFICATION_TOKEN1: + case ESP_NOTIFICATION_TOKEN2: + case ESP_NOTIFICATION_SETTINGS: + case ESP_TIME_SERVER1: + case ESP_TIME_SERVER2: + case ESP_TIME_SERVER3: + case ESP_TIME_ZONE: + setting.type = ESP3DSettingType::string_t; // string + break; + + case ESP_STA_IP_VALUE: + case ESP_STA_GATEWAY_VALUE: + case ESP_STA_MASK_VALUE: + case ESP_STA_DNS_VALUE: + case ESP_AP_IP_VALUE: + + setting.type = ESP3DSettingType::ip_t; // ip = 4 bytes + break; + + case ESP_BAUD_RATE: + case ESP_HTTP_PORT: + case ESP_TELNET_PORT: + case ESP_SENSOR_INTERVAL: + case ESP_BOOT_DELAY: + case ESP_WEBSOCKET_PORT: + case ESP_CALIBRATION_1: + case ESP_CALIBRATION_2: + case ESP_CALIBRATION_3: + case ESP_CALIBRATION_4: + case ESP_CALIBRATION_5: + case ESP_FTP_CTRL_PORT: + case ESP_FTP_DATA_ACTIVE_PORT: + case ESP_FTP_DATA_PASSIVE_PORT: + case ESP_WEBDAV_PORT: + case ESP_SERIAL_BRIDGE_BAUD: + + setting.type = ESP3DSettingType::integer_t; // integer = 4 bytes + break; + default: + setting.type = ESP3DSettingType::unknown_t; + break; + } + + // size of setting + switch (index) { + case ESP_RADIO_MODE: + case ESP_NOTIFICATION_TYPE: + case ESP_CALIBRATION: + case ESP_AP_CHANNEL: + case ESP_BUZZER: + case ESP_INTERNET_TIME: + case ESP_SERIAL_FLAG: + case ESP_HTTP_ON: + case ESP_TELNET_ON: + case ESP_WEBSOCKET_ON: + case ESP_SD_SPEED_DIV: + case ESP_SENSOR_TYPE: + case ESP_TARGET_FW: + case ESP_TIME_IS_DST: + case ESP_REMOTE_SCREEN_FLAG: + case ESP_SD_MOUNT: + case ESP_SESSION_TIMEOUT: + case ESP_WEBSOCKET_FLAG: + case ESP_SD_CHECK_UPDATE_AT_BOOT: + case ESP_SETUP: + case ESP_TELNET_FLAG: + case ESP_BT_FLAG: + case ESP_SCREEN_FLAG: + case ESP_FTP_ON: + case ESP_AUTO_NOTIFICATION: + case ESP_VERBOSE_BOOT: + case ESP_WEBDAV_ON: + case ESP_SECURE_SERIAL: + case ESP_BOOT_RADIO_STATE: + case ESP_STA_FALLBACK_MODE: + case ESP_SERIAL_BRIDGE_FLAG: + case ESP_SERIAL_BRIDGE_ON: + case ESP_STA_IP_MODE: + setting.size = 1; // 1 byte + break; + case ESP_STA_IP_VALUE: + case ESP_STA_GATEWAY_VALUE: + case ESP_STA_MASK_VALUE: + case ESP_STA_DNS_VALUE: + case ESP_AP_IP_VALUE: + case ESP_BAUD_RATE: + case ESP_HTTP_PORT: + case ESP_TELNET_PORT: + case ESP_SENSOR_INTERVAL: + case ESP_BOOT_DELAY: + case ESP_WEBSOCKET_PORT: + case ESP_CALIBRATION_1: + case ESP_CALIBRATION_2: + case ESP_CALIBRATION_3: + case ESP_CALIBRATION_4: + case ESP_CALIBRATION_5: + case ESP_FTP_CTRL_PORT: + case ESP_FTP_DATA_ACTIVE_PORT: + case ESP_FTP_DATA_PASSIVE_PORT: + case ESP_WEBDAV_PORT: + case ESP_SERIAL_BRIDGE_BAUD: + setting.size = 4; // 4 bytes + break; + // Note for string size is the max size of the string, in EEPROM it use + // the size + 1 for the ending 0x00 + case ESP_STA_SSID: + setting.size = 32; // 32 bytes, warning does not support multibyte char + // like chinese chars + break; + case ESP_SETTINGS_VERSION: + setting.size = 7; // 7 bytes + break; + case ESP_HOSTNAME: + setting.size = 32; // 32 bytes, warning does not support multibyte char + // like chinese chars + break; + case ESP_STA_PASSWORD: + setting.size = 64; // 64 bytes, warning does not support multibyte char + // like chinese chars + break; + case ESP_ADMIN_PWD: + case ESP_USER_PWD: + setting.size = 20; // 20 bytes + break; + case ESP_AP_SSID: + setting.size = 32; // 32 bytes, warning does not support multibyte char + // like chinese chars + break; + case ESP_AP_PASSWORD: + setting.size = 64; // 64 bytes, warning does not support multibyte char + // like chinese chars + break; + case ESP_NOTIFICATION_TOKEN1: + case ESP_NOTIFICATION_TOKEN2: + setting.size = 63; // 63 bytes + break; + case ESP_NOTIFICATION_SETTINGS: + setting.size = 128; // 128 bytes + break; + case ESP_TIME_SERVER1: + case ESP_TIME_SERVER2: + case ESP_TIME_SERVER3: + setting.size = 128; // 128 bytes + break; + case ESP_TIME_ZONE: + setting.size = 6; // 6 bytes + break; + + default: + break; + } + + // default value of setting in string + switch (index) { + case ESP_STA_IP_MODE: + setting.default_val = DEFAULT_STA_IP_MODE; + break; + case ESP_RADIO_MODE: + setting.default_val = DEFAULT_ESP_RADIO_MODE; + break; + case ESP_STA_SSID: + setting.default_val = DEFAULT_STA_SSID; + break; + case ESP_NOTIFICATION_TYPE: + setting.default_val = DEFAULT_NOTIFICATION_TYPE; + break; + case ESP_CALIBRATION: + setting.default_val = DEFAULT_CALIBRATION_DONE; + break; + case ESP_AP_CHANNEL: + setting.default_val = DEFAULT_AP_CHANNEL; + break; + case ESP_BUZZER: + setting.default_val = DEFAULT_BUZZER_STATE; + break; + case ESP_INTERNET_TIME: + setting.default_val = DEFAULT_INTERNET_TIME; + break; + case ESP_SERIAL_FLAG: + setting.default_val = DEFAULT_SERIAL_OUTPUT_FLAG; + break; + case ESP_HTTP_ON: + setting.default_val = DEFAULT_HTTP_ON; + break; + case ESP_TELNET_ON: + setting.default_val = DEFAULT_TELNET_ON; + break; + case ESP_WEBSOCKET_ON: + setting.default_val = DEFAULT_WEBSOCKET_ON; + break; + case ESP_SD_SPEED_DIV: + setting.default_val = DEFAULT_SD_SPI_DIV; + break; + case ESP_SENSOR_TYPE: + setting.default_val = DEFAULT_SENSOR_TYPE; + break; + case ESP_TARGET_FW: + setting.default_val = STRING(DEFAULT_FW); + break; + case ESP_TIME_IS_DST: + setting.default_val = DEFAULT_TIME_DST; + break; + case ESP_REMOTE_SCREEN_FLAG: + setting.default_val = DEFAULT_REMOTE_SCREEN_FLAG; + break; + case ESP_SD_MOUNT: + setting.default_val = DEFAULT_SD_MOUNT; + break; + case ESP_SESSION_TIMEOUT: + setting.default_val = DEFAULT_SESSION_TIMEOUT; + break; + case ESP_WEBSOCKET_FLAG: + setting.default_val = DEFAULT_WEBSOCKET_FLAG; + break; + case ESP_SD_CHECK_UPDATE_AT_BOOT: + setting.default_val = DEFAULT_SD_CHECK_UPDATE_AT_BOOT; + break; + case ESP_SETUP: + setting.default_val = DEFAULT_SETUP; + break; + case ESP_TELNET_FLAG: + setting.default_val = DEFAULT_TELNET_FLAG; + break; + case ESP_BT_FLAG: + setting.default_val = DEFAULT_BT_FLAG; + break; + case ESP_SCREEN_FLAG: + setting.default_val = DEFAULT_SCREEN_FLAG; + break; + case ESP_FTP_ON: + setting.default_val = DEFAULT_FTP_ON; + break; + case ESP_AUTO_NOTIFICATION: + setting.default_val = DEFAULT_AUTO_NOTIFICATION_STATE; + break; + case ESP_VERBOSE_BOOT: + setting.default_val = DEFAULT_VERBOSE_BOOT; + break; + case ESP_WEBDAV_ON: + setting.default_val = DEFAULT_WEBDAV_ON; + break; + case ESP_SECURE_SERIAL: + setting.default_val = DEFAULT_SECURE_SERIAL; + break; + case ESP_BOOT_RADIO_STATE: + setting.default_val = DEFAULT_BOOT_RADIO_STATE; + break; + case ESP_STA_FALLBACK_MODE: + setting.default_val = DEFAULT_STA_FALLBACK_MODE; + break; + case ESP_SERIAL_BRIDGE_FLAG: + setting.default_val = DEFAULT_SERIAL_BRIDGE_FLAG; + break; + case ESP_SERIAL_BRIDGE_ON: + setting.default_val = DEFAULT_SERIAL_BRIDGE_ON; + break; + case ESP_SERIAL_BRIDGE_BAUD: + setting.default_val = DEFAULT_SERIAL_BRIDGE_BAUD_RATE; + break; + case ESP_SETTINGS_VERSION: + setting.default_val = DEFAULT_SETTINGS_VERSION; + break; + case ESP_HOSTNAME: + setting.default_val = DEFAULT_HOSTNAME; + break; + case ESP_STA_PASSWORD: + setting.default_val = DEFAULT_STA_PASSWORD; + break; + case ESP_ADMIN_PWD: + setting.default_val = DEFAULT_ADMIN_PWD; + break; + case ESP_USER_PWD: + setting.default_val = DEFAULT_USER_PWD; + break; + case ESP_AP_SSID: + setting.default_val = DEFAULT_AP_SSID; + break; + case ESP_AP_PASSWORD: + setting.default_val = DEFAULT_AP_PASSWORD; + break; + case ESP_NOTIFICATION_TOKEN1: + setting.default_val = DEFAULT_NOTIFICATION_TOKEN1; + break; + case ESP_NOTIFICATION_TOKEN2: + setting.default_val = DEFAULT_NOTIFICATION_TOKEN2; + break; + case ESP_NOTIFICATION_SETTINGS: + setting.default_val = DEFAULT_NOTIFICATION_SETTINGS; + break; + case ESP_TIME_SERVER1: + setting.default_val = DEFAULT_TIME_SERVER1; + break; + case ESP_TIME_SERVER2: + setting.default_val = DEFAULT_TIME_SERVER2; + break; + case ESP_TIME_SERVER3: + setting.default_val = DEFAULT_TIME_SERVER3; + break; + case ESP_TIME_ZONE: + setting.default_val = DEFAULT_TIME_ZONE; + break; + case ESP_STA_IP_VALUE: + setting.default_val = DEFAULT_STA_IP_VALUE; + break; + case ESP_STA_GATEWAY_VALUE: + setting.default_val = DEFAULT_STA_GATEWAY_VALUE; + break; + case ESP_STA_MASK_VALUE: + setting.default_val = DEFAULT_STA_MASK_VALUE; + break; + case ESP_STA_DNS_VALUE: + setting.default_val = DEFAULT_STA_DNS_VALUE; + break; + case ESP_AP_IP_VALUE: + setting.default_val = DEFAULT_AP_IP_VALUE; + break; + case ESP_BAUD_RATE: + setting.default_val = DEFAULT_BAUD_RATE; + break; + case ESP_HTTP_PORT: + setting.default_val = DEFAULT_HTTP_PORT; + break; + case ESP_TELNET_PORT: + setting.default_val = DEFAULT_TELNET_PORT; + break; + case ESP_SENSOR_INTERVAL: + setting.default_val = DEFAULT_SENSOR_INTERVAL; + break; + case ESP_BOOT_DELAY: + setting.default_val = DEFAULT_BOOT_DELAY; + break; + case ESP_WEBSOCKET_PORT: + setting.default_val = DEFAULT_WEBSOCKET_PORT; + break; + case ESP_CALIBRATION_1: + case ESP_CALIBRATION_2: + case ESP_CALIBRATION_3: + case ESP_CALIBRATION_4: + case ESP_CALIBRATION_5: + setting.default_val = DEFAULT_CALIBRATION_VALUE; + break; + case ESP_FTP_CTRL_PORT: + setting.default_val = DEFAULT_FTP_CTRL_PORT; + break; + case ESP_FTP_DATA_ACTIVE_PORT: + setting.default_val = DEFAULT_FTP_ACTIVE_PORT; + break; + case ESP_FTP_DATA_PASSIVE_PORT: + setting.default_val = DEFAULT_FTP_PASSIVE_PORT; + break; + case ESP_WEBDAV_PORT: + setting.default_val = DEFAULT_WEBDAV_PORT; + break; + default: + log_esp3d_e("Invalid setting %d", index); + return NULL; + break; + } + log_esp3d("Got index %d:", setting.index); + log_esp3d("type %d:", setting.type); + log_esp3d("size %d:", setting.size); + log_esp3d("default_val %s:", setting.default_val); + return &setting; +} diff --git a/esp3d/src/core/settings_esp3d.h b/esp3d/src/core/settings_esp3d.h index 599e7f9a..31213eec 100644 --- a/esp3d/src/core/settings_esp3d.h +++ b/esp3d/src/core/settings_esp3d.h @@ -19,53 +19,86 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ - - #ifndef _SETTINGS_ESP3D_H #define _SETTINGS_ESP3D_H #include -class Settings_ESP3D -{ -public: - static bool begin(); - static uint8_t get_default_byte_value(int pos); - static uint32_t get_default_int32_value(int pos); - static uint32_t get_default_IP_value(int pos); - static const String & get_default_string_value(int pos); - static uint8_t get_max_string_size(int pos); - static uint8_t get_min_string_size(int pos); - static uint32_t get_max_int32_value(int pos); - static uint32_t get_min_int32_value(int pos); - static uint8_t get_max_byte(int pos); - static int8_t get_min_byte(int pos); - static uint8_t read_byte (int pos, bool * haserror = NULL); - static uint32_t read_uint32(int pos, bool * haserror = NULL); - static uint32_t read_IP(int pos, bool * haserror = NULL); - static String read_IP_String(int pos, bool * haserror = NULL); - static const char * read_string (int pos, bool *haserror = NULL); - static bool write_byte (int pos, const uint8_t value); - static bool write_string (int pos, const char * byte_buffer); - static bool write_uint32 (int pos, const uint32_t value); - static bool write_IP (int pos, const uint32_t value); - static bool write_IP_String (int pos, const char * value); - static bool reset(bool networkonly = false); - static int8_t GetSettingsVersion(); - static uint8_t GetFirmwareTarget(bool fromsettings = false); - static bool isVerboseBoot(bool fromsettings = false); - static uint8_t GetSDDevice(); - static const char* GetFirmwareTargetShortName(); - static String IPtoString(uint32_t ip_int); - static uint32_t StringtoIP(const char *s); - static const char * TargetBoard(); - static bool isLocalPasswordValid (const char * password); -private: - static bool is_string(const char * s, uint len); - static uint8_t _FirmwareTarget; - static bool _isverboseboot; +#include "../include/esp3d_config.h" + +enum class ESP3DState : uint8_t { + off = 0, + on = 1, }; +enum class ESP3DSettingType : uint8_t { + byte_t, // byte + integer_t, // 4 bytes + string_t, // string + ip_t, // 4 bytes + float_t, // 4 bytes + mask, // x bytes + bitsfield, // x bytes + unknown_t +}; -#endif //_SETTINGS_ESP3D_H +struct ESP3DSettingDescription { + ESP3DSettingIndex index; + ESP3DSettingType type; + uint16_t size; + const char *default_val; +}; +#ifdef SD_DEVICE +extern const uint8_t SupportedSPIDivider[]; +extern const uint8_t SupportedSPIDividerSize; +#endif // SD_DEVICE +#if defined(WIFI_FEATURE) +extern const uint8_t SupportedApChannels[]; +extern const uint8_t SupportedApChannelsSize; +#endif // WIFI_FEATURE +class Settings_ESP3D { + public: + static bool begin(); + static uint8_t read_byte(int pos, bool *haserror = NULL); + static uint32_t read_uint32(int pos, bool *haserror = NULL); + static uint32_t read_IP(int pos, bool *haserror = NULL); + static String read_IP_String(int pos, bool *haserror = NULL); + static const char *read_string(int pos, bool *haserror = NULL); + static bool write_byte(int pos, const uint8_t value); + static bool write_string(int pos, const char *byte_buffer); + static bool write_uint32(int pos, const uint32_t value); + static bool write_IP(int pos, const uint32_t value); + static bool write_IP_String(int pos, const char *value); + static bool reset(bool networkonly = false); + static int8_t GetSettingsVersion(); + static uint8_t GetFirmwareTarget(bool fromsettings = false); + static bool isVerboseBoot(bool fromsettings = false); + static uint8_t GetSDDevice(); + static const char *GetFirmwareTargetShortName(); + static const char *TargetBoard(); + + static bool isValidIPStringSetting(const char *value, + ESP3DSettingIndex settingElement); + static bool isValidStringSetting(const char *value, + ESP3DSettingIndex settingElement); + static bool isValidIntegerSetting(uint32_t value, + ESP3DSettingIndex settingElement); + static bool isValidByteSetting(uint8_t value, + ESP3DSettingIndex settingElement); + static uint32_t getDefaultIntegerSetting(ESP3DSettingIndex settingElement); + static const char *getDefaultStringSetting(ESP3DSettingIndex settingElement); + static uint8_t getDefaultByteSetting(ESP3DSettingIndex settingElement); + + static const ESP3DSettingDescription *getSettingPtr( + const ESP3DSettingIndex index); + + private: + static String _IpToString(uint32_t ip_int); + static uint32_t _stringToIP(const char *s); + static bool is_string(const char *s, uint len); + static uint8_t _FirmwareTarget; + static bool _isverboseboot; +}; + +#endif //_SETTINGS_ESP3D_H diff --git a/esp3d/src/include/defines.h b/esp3d/src/include/defines.h index e472211d..e3f28706 100644 --- a/esp3d/src/include/defines.h +++ b/esp3d/src/include/defines.h @@ -36,14 +36,7 @@ #define GRBLHAL 80 #define HP_GL 90 -// Default flags -#define DEFAULT_SERIAL_OUTPUT_FLAG 1 -#define DEFAULT_REMOTE_SCREEN_FLAG 1 -#define DEFAULT_WEBSOCKET_FLAG 1 -#define DEFAULT_TELNET_FLAG 1 -#define DEFAULT_BT_FLAG 1 -#define DEFAULT_SCREEN_FLAG 1 -#define DEFAULT_SERIAL_BRIDGE_FLAG 1 +typedef uint ESP3DSettingIndex; // position in EEPROM / preferences will use `P_` + to make a string // : P_0 for 0 diff --git a/esp3d/src/modules/boot_delay/boot_delay.cpp b/esp3d/src/modules/boot_delay/boot_delay.cpp index 8582d9b0..396f1cf6 100644 --- a/esp3d/src/modules/boot_delay/boot_delay.cpp +++ b/esp3d/src/modules/boot_delay/boot_delay.cpp @@ -18,69 +18,60 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -#include "../../include/esp3d_config.h" #include "boot_delay.h" -#include "../../core/settings_esp3d.h" + #include "../../core/esp3doutput.h" +#include "../../core/settings_esp3d.h" +#include "../../include/esp3d_config.h" + #if defined(RECOVERY_FEATURE) #include "../recovery/recovery_service.h" -#endif //RECOVERY_FEATURE +#endif // RECOVERY_FEATURE -BootDelay::BootDelay() -{ - _started = false; - _startdelay = 0; - _totalduration = 0; -} -BootDelay::~BootDelay() -{ - end(); +BootDelay::BootDelay() { + _started = false; + _startdelay = 0; + _totalduration = 0; } +BootDelay::~BootDelay() { end(); } -bool BootDelay::started() -{ - return _started; -} +bool BootDelay::started() { return _started; } -bool BootDelay::begin() -{ - _totalduration = Settings_ESP3D::read_uint32(ESP_BOOT_DELAY); - log_esp3d("Boot delay %d", _totalduration); - if (_totalduration > Settings_ESP3D::get_max_int32_value(ESP_BOOT_DELAY)) { - _totalduration = Settings_ESP3D::get_default_int32_value(ESP_BOOT_DELAY); - log_esp3d("Boot delay modified %d", _totalduration); - } - _started = true; - ESP3DOutput::toScreen(ESP_OUTPUT_PROGRESS, "0"); - if (_totalduration > 0) { - _startdelay = millis(); - handle(); - } - ESP3DOutput::toScreen(ESP_OUTPUT_PROGRESS, "100"); - log_esp3d("Boot delay done"); - return _started; -} -void BootDelay::end() -{ +bool BootDelay::begin() { + _totalduration = Settings_ESP3D::read_uint32(ESP_BOOT_DELAY); + log_esp3d("Boot delay %d", _totalduration); + if (!Settings_ESP3D::isValidIntegerSetting(_totalduration, ESP_BOOT_DELAY)) { + _totalduration = Settings_ESP3D::getDefaultIntegerSetting(ESP_BOOT_DELAY); + log_esp3d("Boot delay modified %d", _totalduration); + } + _started = true; + ESP3DOutput::toScreen(ESP_OUTPUT_PROGRESS, "0"); + if (_totalduration > 0) { + _startdelay = millis(); + handle(); + } + ESP3DOutput::toScreen(ESP_OUTPUT_PROGRESS, "100"); + log_esp3d("Boot delay done"); + return _started; } +void BootDelay::end() {} -void BootDelay::handle() -{ - uint8_t lastpercent = 0; - uint32_t lastSent = millis(); - while ((millis() - _startdelay) < _totalduration) { +void BootDelay::handle() { + uint8_t lastpercent = 0; + uint32_t lastSent = millis(); + while ((millis() - _startdelay) < _totalduration) { #if defined(RECOVERY_FEATURE) - recovery_service.handle(); -#endif //RECOVERY_FEATURE - //to avoid overfload 2x/sec is enough for progression - if ((millis() - lastSent) > 500) { - lastSent = millis(); - uint8_t p = (100*(millis() - _startdelay))/_totalduration; - if (p != lastpercent) { - lastpercent=p; - ESP3DOutput::toScreen(ESP_OUTPUT_PROGRESS, String(p).c_str()); - } - } - Hal::wait(10); + recovery_service.handle(); +#endif // RECOVERY_FEATURE + // to avoid overfload 2x/sec is enough for progression + if ((millis() - lastSent) > 500) { + lastSent = millis(); + uint8_t p = (100 * (millis() - _startdelay)) / _totalduration; + if (p != lastpercent) { + lastpercent = p; + ESP3DOutput::toScreen(ESP_OUTPUT_PROGRESS, String(p).c_str()); + } } + Hal::wait(10); + } } diff --git a/esp3d/src/modules/boot_delay/boot_delay.h b/esp3d/src/modules/boot_delay/boot_delay.h index a17d08d2..c2b962f1 100644 --- a/esp3d/src/modules/boot_delay/boot_delay.h +++ b/esp3d/src/modules/boot_delay/boot_delay.h @@ -18,27 +18,26 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ - - #ifndef _BOOT_DELAY_H #define _BOOT_DELAY_H -typedef void (progress_t)(uint8_t percent); +#include -class BootDelay -{ -public: - BootDelay(); - ~BootDelay(); - bool begin(); - void end(); - void handle(); - bool started(); -private: - bool _started; - uint32_t _startdelay; - uint32_t _totalduration; +typedef void(progress_t)(uint8_t percent); + +class BootDelay { + public: + BootDelay(); + ~BootDelay(); + bool begin(); + void end(); + void handle(); + bool started(); + + private: + bool _started; + uint32_t _startdelay; + uint32_t _totalduration; }; -#endif //_BOOT_DELAY_H - +#endif //_BOOT_DELAY_H diff --git a/esp3d/src/modules/http/handlers/handle-login.cpp b/esp3d/src/modules/http/handlers/handle-login.cpp index 2203716c..18e5937a 100644 --- a/esp3d/src/modules/http/handlers/handle-login.cpp +++ b/esp3d/src/modules/http/handlers/handle-login.cpp @@ -30,7 +30,6 @@ #include "../../../core/settings_esp3d.h" #include "../../authentication/authentication_service.h" - // login status check void HTTP_Server::handle_login() { HTTP_Server::set_http_headers(); @@ -67,7 +66,8 @@ void HTTP_Server::handle_login() { if (_webserver->hasArg("NEWPASSWORD")) { String newpassword = _webserver->arg("NEWPASSWORD"); // check new password - if (Settings_ESP3D::isLocalPasswordValid(newpassword.c_str())) { + if (Settings_ESP3D::isValidStringSetting(newpassword.c_str(), + ESP_ADMIN_PWD)) { if (!Settings_ESP3D::write_string(ESP_ADMIN_PWD, newpassword.c_str())) { code = 500; diff --git a/esp3d/src/modules/network/netconfig.cpp b/esp3d/src/modules/network/netconfig.cpp index b10a271a..c05b8b17 100644 --- a/esp3d/src/modules/network/netconfig.cpp +++ b/esp3d/src/modules/network/netconfig.cpp @@ -80,30 +80,6 @@ String NetConfig::IP_string_from_int(uint32_t ip_int) { return ipaddr.toString(); } -/** - * Check if Hostname string is valid - */ - -bool NetConfig::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 (uint i = 0; i < strlen(hostname); i++) { - c = hostname[i]; - if (!(isdigit(c) || isalpha(c) || c == '-')) { - return false; - } - if (c == ' ') { - return false; - } - } - return true; -} - /** * Get IP Integer what ever is enabled */ @@ -148,15 +124,6 @@ String NetConfig::localIP() { return currentIP; } -/** - * Check if IP string is valid - */ - -bool NetConfig::isValidIP(const char* string) { - IPAddress ip; - return ip.fromString(string); -} - // wifi event void NetConfig::onWiFiEvent(WiFiEvent_t event) { ESP3DOutput output(ESP_ALL_CLIENTS); diff --git a/esp3d/src/modules/network/netconfig.h b/esp3d/src/modules/network/netconfig.h index 5b64d4c3..313c7ec2 100644 --- a/esp3d/src/modules/network/netconfig.h +++ b/esp3d/src/modules/network/netconfig.h @@ -18,63 +18,55 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -//boundaries - - -#define MAX_WEBDAV_PORT 65001 -#define MIN_WEBDAV_PORT 1 -#define MAX_HTTP_PORT 65001 -#define MIN_HTTP_PORT 1 -#define MAX_FTP_PORT 65001 -#define MIN_FTP_PORT 1 -#define MAX_TELNET_PORT 65001 -#define MIN_TELNET_PORT 1 -#define MAX_WEBSOCKET_PORT 65001 -#define MIN_WEBSOCKET_PORT 1 -#define MAX_HOSTNAME_LENGTH 32 -#define MIN_HOSTNAME_LENGTH 1 - +// boundaries +#define MAX_WEBDAV_PORT 65001 +#define MIN_WEBDAV_PORT 1 +#define MAX_HTTP_PORT 65001 +#define MIN_HTTP_PORT 1 +#define MAX_FTP_PORT 65001 +#define MIN_FTP_PORT 1 +#define MAX_TELNET_PORT 65001 +#define MIN_TELNET_PORT 1 +#define MAX_WEBSOCKET_PORT 65001 +#define MIN_WEBSOCKET_PORT 1 +#define MAX_HOSTNAME_LENGTH 32 +#define MIN_HOSTNAME_LENGTH 1 #ifdef ARDUINO_ARCH_ESP32 #include -#endif //ARDUINO_ARCH_ESP32 +#endif // ARDUINO_ARCH_ESP32 #ifdef ARDUINO_ARCH_ESP8266 #include -#endif //ARDUINO_ARCH_ESP8266 +#endif // ARDUINO_ARCH_ESP8266 #ifndef _NET_CONFIG_H #define _NET_CONFIG_H -class NetConfig -{ -public: - static bool isValidIP(const char * string); - static bool isHostnameValid (const char * hostname); - static uint32_t IP_int_from_string(const char * s); - static String IP_string_from_int(uint32_t ip_int); - static bool isIPModeDHCP(uint8_t mode); - static bool isDHCPServer (uint8_t mode); - static const char* hostname(bool fromsettings = false); - static char * mac2str (uint8_t mac [8]); - static bool begin(); - static void end(); - static void handle(); - static uint8_t getMode(); - static void setMode(uint8_t mode); - static bool started() - { - return _started; - } - static String localIP(); - static IPAddress localIPAddress(); -private : - static String _hostname; - static void onWiFiEvent(WiFiEvent_t event); - static bool _needReconnect2AP; - static bool _events_registered; - static bool _started; - static uint8_t _mode; +class NetConfig { + public: + static uint32_t IP_int_from_string(const char* s); + static String IP_string_from_int(uint32_t ip_int); + static bool isIPModeDHCP(uint8_t mode); + static bool isDHCPServer(uint8_t mode); + static const char* hostname(bool fromsettings = false); + static char* mac2str(uint8_t mac[8]); + static bool begin(); + static void end(); + static void handle(); + static uint8_t getMode(); + static void setMode(uint8_t mode); + static bool started() { return _started; } + static String localIP(); + static IPAddress localIPAddress(); + + private: + static String _hostname; + static void onWiFiEvent(WiFiEvent_t event); + static bool _needReconnect2AP; + static bool _events_registered; + static bool _started; + static uint8_t _mode; }; -#endif //_NET_CONFIG_H +#endif //_NET_CONFIG_H diff --git a/esp3d/src/modules/serial/serial_service.cpp b/esp3d/src/modules/serial/serial_service.cpp index 6969c2ff..194c8efb 100644 --- a/esp3d/src/modules/serial/serial_service.cpp +++ b/esp3d/src/modules/serial/serial_service.cpp @@ -66,6 +66,7 @@ TaskHandle_t _hserialtask = nullptr; const long SupportedBaudList[] = {9600, 19200, 38400, 57600, 74880, 115200, 230400, 250000, 500000, 921600, 1958400}; +const size_t SupportedBaudListSize = sizeof(SupportedBaudList) / sizeof(long); #define TIMEOUT_SERIAL_FLUSH 1500 // Constructor @@ -140,13 +141,13 @@ bool SerialService::begin(uint8_t serialIndex) { switch (_id) { case MAIN_SERIAL: br = Settings_ESP3D::read_uint32(ESP_BAUD_RATE); - defaultBr = Settings_ESP3D::get_default_int32_value(ESP_BAUD_RATE); + defaultBr = Settings_ESP3D::getDefaultIntegerSetting(ESP_BAUD_RATE); break; #if defined(ESP_SERIAL_BRIDGE_OUTPUT) case BRIDGE_SERIAL: br = Settings_ESP3D::read_uint32(ESP_SERIAL_BRIDGE_BAUD); defaultBr = - Settings_ESP3D::get_default_int32_value(ESP_SERIAL_BRIDGE_BAUD); + Settings_ESP3D::getDefaultIntegerSetting(ESP_SERIAL_BRIDGE_BAUD); break; #endif // ESP_SERIAL_BRIDGE_OUTPUT default: @@ -159,7 +160,7 @@ bool SerialService::begin(uint8_t serialIndex) { _buffer_size = 0; // change only if different from current if (br != baudRate() || (_rxPin != -1) || (_txPin != -1)) { - if (!is_valid_baudrate(br)) { + if (!Settings_ESP3D::isValidIntegerSetting(br, ESP_BAUD_RATE)) { br = defaultBr; } Serials[_serialIndex]->setRxBufferSize(SERIAL_RX_BUFFER_SIZE); @@ -217,17 +218,6 @@ const long *SerialService::get_baudratelist(uint8_t *count) { return SupportedBaudList; } -// check if value is in baudrate list -bool SerialService::is_valid_baudrate(long br) { - uint8_t listesize = sizeof(SupportedBaudList) / sizeof(long); - for (uint8_t i = 0; i < listesize; i++) { - if (SupportedBaudList[i] == br) { - return true; - } - } - return false; -} - // Function which could be called in other loop void SerialService::process() { if (!_started) { @@ -421,15 +411,15 @@ bool SerialService::reset() { case MAIN_SERIAL: return Settings_ESP3D::write_uint32( ESP_BAUD_RATE, - Settings_ESP3D::get_default_int32_value(ESP_BAUD_RATE)); + Settings_ESP3D::getDefaultIntegerSetting(ESP_BAUD_RATE)); #if defined(ESP_SERIAL_BRIDGE_OUTPUT) case BRIDGE_SERIAL: res = Settings_ESP3D::write_byte( ESP_SERIAL_BRIDGE_ON, - Settings_ESP3D::get_default_byte_value(ESP_SERIAL_BRIDGE_ON)); + Settings_ESP3D::getDefaultByteSetting(ESP_SERIAL_BRIDGE_ON)); return res && Settings_ESP3D::write_uint32( ESP_SERIAL_BRIDGE_BAUD, - Settings_ESP3D::get_default_int32_value( + Settings_ESP3D::getDefaultIntegerSetting( ESP_SERIAL_BRIDGE_BAUD)); #endif // ESP_SERIAL_BRIDGE_OUTPUT default: diff --git a/esp3d/src/modules/serial/serial_service.h b/esp3d/src/modules/serial/serial_service.h index b0b3029d..7361f9f5 100644 --- a/esp3d/src/modules/serial/serial_service.h +++ b/esp3d/src/modules/serial/serial_service.h @@ -25,6 +25,9 @@ #define ESP3D_SERIAL_BUFFER_SIZE 1024 +extern const long SupportedBaudList[]; +extern const size_t SupportedBaudListSize; + class SerialService : public Print { public: SerialService(uint8_t id); @@ -43,7 +46,6 @@ class SerialService : public Print { void swap(); int availableForWrite(); int available(); - bool is_valid_baudrate(long br); size_t write(uint8_t c); size_t write(const uint8_t *buffer, size_t size); inline size_t write(const char *s) { return write((uint8_t *)s, strlen(s)); } diff --git a/esp3d/src/modules/time/time_service.h b/esp3d/src/modules/time/time_service.h index 5fbb2839..ae0c0bf9 100644 --- a/esp3d/src/modules/time/time_service.h +++ b/esp3d/src/modules/time/time_service.h @@ -22,6 +22,7 @@ #define _TIME_SERVICE_H #include +#include class TimeService { public: diff --git a/esp3d/src/modules/webdav/handlers/handler_get.cpp b/esp3d/src/modules/webdav/handlers/handler_get.cpp index 35ca7baa..d32ed1a3 100644 --- a/esp3d/src/modules/webdav/handlers/handler_get.cpp +++ b/esp3d/src/modules/webdav/handlers/handler_get.cpp @@ -104,7 +104,7 @@ void WebdavServer::handler_get(const char* url) { } } else { code = 400; - log_esp3d_e("Root cannot be deleted"); + log_esp3d_e("Root cannot be used as it is"); } if (code != 200) { log_esp3d_e("Sending response code %d", code); diff --git a/esp3d/src/modules/wifi/wificonfig.cpp b/esp3d/src/modules/wifi/wificonfig.cpp index a928462c..81c2c7b4 100644 --- a/esp3d/src/modules/wifi/wificonfig.cpp +++ b/esp3d/src/modules/wifi/wificonfig.cpp @@ -30,27 +30,8 @@ #include "../network/netconfig.h" #include "../wifi/wificonfig.h" - const uint8_t DEFAULT_AP_MASK_VALUE[] = {255, 255, 255, 0}; -/** - * Check if SSID string is valid - */ -bool WiFiConfig::isSSIDValid(const char* ssid) { - // limited size - // char c; - if (strlen(ssid) > MAX_SSID_LENGTH || strlen(ssid) < MIN_SSID_LENGTH) { - return false; - } - // only printable - for (uint i = 0; i < strlen(ssid); i++) { - if (!isPrintable(ssid[i])) { - return false; - } - } - return true; -} - const char* WiFiConfig::hostname() { static String tmp; #if defined(ARDUINO_ARCH_ESP8266) @@ -73,22 +54,6 @@ const char* WiFiConfig::hostname() { return tmp.c_str(); } -/** - * Check if password string is valid - */ - -bool WiFiConfig::isPasswordValid(const char* password) { - if (strlen(password) == 0) { - return true; // open network - } - // limited size - if ((strlen(password) > MAX_PASSWORD_LENGTH) || - (strlen(password) < MIN_PASSWORD_LENGTH)) { - return false; - } - return true; -} - /* * Get WiFi signal strength */ diff --git a/esp3d/src/modules/wifi/wificonfig.h b/esp3d/src/modules/wifi/wificonfig.h index 36b342cb..21c1d5e5 100644 --- a/esp3d/src/modules/wifi/wificonfig.h +++ b/esp3d/src/modules/wifi/wificonfig.h @@ -18,16 +18,16 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ -//boundaries -#define MIN_RSSI -78 -#define MAX_SSID_LENGTH 32 -#define MIN_SSID_LENGTH 1 -#define MIN_CHANNEL 1 -#define MAX_CHANNEL 14 -#define MAX_PASSWORD_LENGTH 64 -//min size of password is 0 or upper than 8 char -//0 is special case so let's put 8 -#define MIN_PASSWORD_LENGTH 8 +// boundaries +#define MIN_RSSI -78 +#define MAX_SSID_LENGTH 32 +#define MIN_SSID_LENGTH 1 +#define MIN_CHANNEL 1 +#define MAX_CHANNEL 14 +#define MAX_PASSWORD_LENGTH 64 +// min size of password is 0 or upper than 8 char +// 0 is special case so let's put 8 +#define MIN_PASSWORD_LENGTH 8 #ifdef ARDUINO_ARCH_ESP32 #include #define WIFI_NONE_SLEEP WIFI_PS_NONE @@ -35,7 +35,8 @@ #define WIFI_MODEM_SLEEP WIFI_PS_MAX_MODEM #define WIFI_PHY_MODE_11B WIFI_PROTOCOL_11B #define WIFI_PHY_MODE_11G WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G -#define WIFI_PHY_MODE_11N WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N +#define WIFI_PHY_MODE_11N \ + WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G | WIFI_PROTOCOL_11N #define AUTH_OPEN WIFI_AUTH_OPEN #define AUTH_WEP WIFI_AUTH_WEP #define AUTH_WPA_PSK WIFI_AUTH_WPA_PSK @@ -43,38 +44,37 @@ #define AUTH_WPA_WPA2_PSK WIFI_AUTH_WPA_WPA2_PSK #define ENC_TYPE_NONE AUTH_OPEN #define WiFiMode_t wifi_mode_t -#endif //ARDUINO_ARCH_ESP32 +#endif // ARDUINO_ARCH_ESP32 #ifdef ARDUINO_ARCH_ESP8266 #include -#endif //ARDUINO_ARCH_ESP8266 +#endif // ARDUINO_ARCH_ESP8266 #ifndef _WIFI_CONFIG_H #define _WIFI_CONFIG_H -class WiFiConfig -{ -public: - static bool isPasswordValid (const char * password); - static bool isSSIDValid (const char * ssid); - static bool StartAP(bool setupMode = false); - static bool StartSTA(); - static void StopWiFi(); - static int32_t getSignal (int32_t RSSI, bool filter=true); - static const char* getSleepModeString (); - static const char* getPHYModeString (uint8_t wifimode); - static bool is_AP_visible(); - static const char * AP_SSID(); - static const char * hostname(); - static const char * AP_Auth_String(); - static const char * AP_Gateway_String(); - static const char * AP_Mask_String(); - static const char* getConnectedSTA(uint8_t * totalcount = NULL, bool reset = false); - static bool started(); - static bool begin(int8_t & espMode); - static void end(); - static void handle(); -private : - static bool ConnectSTA2AP(); +class WiFiConfig { + public: + static bool StartAP(bool setupMode = false); + static bool StartSTA(); + static void StopWiFi(); + static int32_t getSignal(int32_t RSSI, bool filter = true); + static const char* getSleepModeString(); + static const char* getPHYModeString(uint8_t wifimode); + static bool is_AP_visible(); + static const char* AP_SSID(); + static const char* hostname(); + static const char* AP_Auth_String(); + static const char* AP_Gateway_String(); + static const char* AP_Mask_String(); + static const char* getConnectedSTA(uint8_t* totalcount = NULL, + bool reset = false); + static bool started(); + static bool begin(int8_t& espMode); + static void end(); + static void handle(); + + private: + static bool ConnectSTA2AP(); }; -#endif //_WIFI_CONFIG_H +#endif //_WIFI_CONFIG_H