From 8c4fc341d6cbbb403a7d8441a199083ecd678d80 Mon Sep 17 00:00:00 2001
From: Eric Duminil <eric.duminil@gmail.com>
Date: Tue, 15 Feb 2022 17:09:24 +0100
Subject: [PATCH] IotWebConf in src, not in platformio
---
.../src/lib/IotWebConf/CMakeLists.txt | 18 +
.../lib/IotWebConf/IotWebConf.code-workspace | 64 ++
.../src/lib/IotWebConf/IotWebConf.iml | 20 +
ampel-firmware/src/lib/IotWebConf/LICENSE.txt | 9 +
ampel-firmware/src/lib/IotWebConf/README.md | 111 ++
.../src/lib/IotWebConf/doc/HackingGuide.md | 232 ++++
.../IotWebConf/doc/MigrationGuide-v3.0.0.md | 263 +++++
.../lib/IotWebConf/doc/TParameter.plantuml | 272 +++++
.../src/lib/IotWebConf/doc/TParameter.png | Bin 0 -> 226919 bytes
.../src/lib/IotWebConf/doc/UsersManual.md | 225 ++++
.../src/lib/IotWebConf/keywords.txt | 125 +++
.../src/lib/IotWebConf/library.properties | 10 +
.../src/lib/IotWebConf/src/IotWebConf.cpp | 995 ++++++++++++++++++
.../src/lib/IotWebConf/src/IotWebConf.h | 662 ++++++++++++
.../src/IotWebConfESP32HTTPUpdateServer.h | 169 +++
.../IotWebConf/src/IotWebConfMultipleWifi.cpp | 112 ++
.../IotWebConf/src/IotWebConfMultipleWifi.h | 74 ++
.../src/IotWebConfOptionalGroup.cpp | 158 +++
.../IotWebConf/src/IotWebConfOptionalGroup.h | 116 ++
.../IotWebConf/src/IotWebConfParameter.cpp | 624 +++++++++++
.../lib/IotWebConf/src/IotWebConfParameter.h | 462 ++++++++
.../lib/IotWebConf/src/IotWebConfSettings.h | 73 ++
.../lib/IotWebConf/src/IotWebConfTParameter.h | 951 +++++++++++++++++
.../src/IotWebConfTParameterBuilder.h | 170 +++
.../src/lib/IotWebConf/src/IotWebConfUsing.h | 24 +
.../src/IotWebConfWebServerWrapper.h | 47 +
platformio.ini | 10 -
27 files changed, 5986 insertions(+), 10 deletions(-)
create mode 100644 ampel-firmware/src/lib/IotWebConf/CMakeLists.txt
create mode 100644 ampel-firmware/src/lib/IotWebConf/IotWebConf.code-workspace
create mode 100644 ampel-firmware/src/lib/IotWebConf/IotWebConf.iml
create mode 100644 ampel-firmware/src/lib/IotWebConf/LICENSE.txt
create mode 100644 ampel-firmware/src/lib/IotWebConf/README.md
create mode 100644 ampel-firmware/src/lib/IotWebConf/doc/HackingGuide.md
create mode 100644 ampel-firmware/src/lib/IotWebConf/doc/MigrationGuide-v3.0.0.md
create mode 100644 ampel-firmware/src/lib/IotWebConf/doc/TParameter.plantuml
create mode 100644 ampel-firmware/src/lib/IotWebConf/doc/TParameter.png
create mode 100644 ampel-firmware/src/lib/IotWebConf/doc/UsersManual.md
create mode 100644 ampel-firmware/src/lib/IotWebConf/keywords.txt
create mode 100644 ampel-firmware/src/lib/IotWebConf/library.properties
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConf.cpp
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConf.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfESP32HTTPUpdateServer.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.cpp
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.cpp
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.cpp
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfSettings.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameter.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameterBuilder.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfUsing.h
create mode 100644 ampel-firmware/src/lib/IotWebConf/src/IotWebConfWebServerWrapper.h
diff --git a/ampel-firmware/src/lib/IotWebConf/CMakeLists.txt b/ampel-firmware/src/lib/IotWebConf/CMakeLists.txt
new file mode 100644
index 0000000..fe478b1
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/CMakeLists.txt
@@ -0,0 +1,18 @@
+set(COMPONENT_SRCS
+ src/IotWebConf.cpp
+ src/IotWebConfMultipleWifi.cpp
+ src/IotWebConfOptionalGroup.cpp
+ src/IotWebConfParameter.cpp
+ src/IotWebConfESP32HTTPUpdateServer.cpp
+ )
+
+set(COMPONENT_ADD_INCLUDEDIRS
+ src/
+ )
+list(APPEND COMPONENT_REQUIRES "arduino")
+register_component()
+
+#ADD_DEFINITIONS(-DESP32)
+
+list(APPEND DEFINITIONS "ESP32")
+
diff --git a/ampel-firmware/src/lib/IotWebConf/IotWebConf.code-workspace b/ampel-firmware/src/lib/IotWebConf/IotWebConf.code-workspace
new file mode 100644
index 0000000..3cd0ab8
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/IotWebConf.code-workspace
@@ -0,0 +1,64 @@
+{
+ "folders": [
+ {
+ "path": "."
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf01Minimal"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf02StatusAndReset"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf03CustomParameters"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf03TypedParameters"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf04UpdateServer"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf05Callbacks"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf06MqttApp"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf07MqttRelay"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf08WebRelay"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf09CustomConnection"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf10CustomHtml"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf11AdvancedRuntime"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf12CustomParameterType"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf13OptionalGroup"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf14GroupChain"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf15MultipleWifi"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf16OffLineMode"
+ },
+ {
+ "path": "../IotWebConf-examples/IotWebConf17JsonConfig"
+ }
+ ],
+ "settings": {
+ "workbench.tree.indent": 16
+ }
+}
diff --git a/ampel-firmware/src/lib/IotWebConf/IotWebConf.iml b/ampel-firmware/src/lib/IotWebConf/IotWebConf.iml
new file mode 100644
index 0000000..745f22c
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/IotWebConf.iml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module version="4">
+ <component name="CheckStyle-IDEA-Module">
+ <option name="configuration">
+ <map />
+ </option>
+ </component>
+ <component name="NewModuleRootManager" inherit-compiler-output="true">
+ <exclude-output />
+ <content url="file://$MODULE_DIR$" />
+ <orderEntry type="sourceFolder" forTests="false" />
+ </component>
+ <component name="sonarModuleSettings">
+ <option name="alternativeWorkingDirPath" value="" />
+ <option name="localAnalysisScripName" value="<PROJECT>" />
+ <option name="serverName" value="<PROJECT>" />
+ <option name="useAlternativeWorkingDir" value="false" />
+ <option name="workingDirSelection" value="<MODULE>" />
+ </component>
+</module>
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/LICENSE.txt b/ampel-firmware/src/lib/IotWebConf/LICENSE.txt
new file mode 100644
index 0000000..e129fc3
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/LICENSE.txt
@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright 2018 Balazs Kelemen <prampec+arduino@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/ampel-firmware/src/lib/IotWebConf/README.md b/ampel-firmware/src/lib/IotWebConf/README.md
new file mode 100644
index 0000000..70ee741
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/README.md
@@ -0,0 +1,111 @@
+# IotWebConf [](https://github.com/prampec/IotWebConf/actions/workflows/test.platformio.yml)
+
+## Upgrading to v3.0.0
+Lately version 3.0.0 is released. This release is not backward compatible with
+older versions, and some modification have to be done on existing codes.
+**Please visit [Migration Guide](doc/MigrationGuide-v3.0.0.md) for
+ details!**
+
+## Summary
+IotWebConf is an Arduino library for ESP8266/ESP32 to provide a non-blocking standalone WiFi/AP web configuration portal.
+**For ESP8266, IotWebConf requires the esp8266 board package version 2.4.2 or later!**
+
+Please subscribe to the [discussion forum](https://groups.google.com/forum/#!forum/iotwebconf), if you want to be informed on the latest news.
+
+Also visit experimental [Discord server](https://discord.gg/GR3uQeD).
+
+**HELP WANTED!** If you are testing any GIT branches, please give me feedback to provide stable releases for the public.
+
+## Highlights
+
+ - Manages WiFi connection settings,
+ - Provides a config portal user interface,
+ - You can extend the configuration with your own sophisticated propery structure, that is stored automatically,
+ - Option to configure multiple WiFi connections. (Try next when the
+ last used one is just not available.)
+ - HTML customization,
+ - Validation support for the configuration property items,
+ - User code will be notified of status changes with callback methods,
+ - Configuration (including your custom items) stored in the EEPROM,
+ - Firmware OTA update support,
+ - Config portal remains available even after WiFi is connected,
+ - Automatic "Sign in to network" pop up in your browser (captive portal),
+ - Non-blocking - Your custom code will not be blocked in the whole process.
+ - Well documented header file, and examples from simple to complex levels.
+
+
+
+
+## How it works
+The idea is that the Thing will provide a web interface to allow modifying its configuration. E.g. for connecting to a local WiFi network, it needs the SSID and the password.
+
+When no WiFi is configured, or the configured network is unavailable it creates its own AP (access point), and lets clients connect to it directly to make the configuration.
+
+Furthermore there is a button (or let's say a Pin), that when pressed on startup will cause a default password to be used instead of the configured (forgotten) one.
+You can find the default password in the sources. :)
+
+IotWebConf saves configuration in the "EEPROM". You can extend the config portal with your custom configuration items. Those items will be also maintained by IotWebConf.
+
+Visit [Users Manual](doc/UsersManual.md) for detailed description!
+
+## Use cases
+ 1. **You turn on your IoT the first time** - It turns into AP (access point) mode, and waits for you on the 192.168.4.1 address with a web interface to set up your local network (and other configurations). For the first time a default password is used when you connect to the AP. When you connect to the AP, your device will likely automatically pop up the portal page. (We call this a Captive Portal.) When configuration is done, you must leave the AP. The device detects that no one is connected, and continues with normal operation.
+ 1. **WiFi configuration is changed, e.g. the Thing is moved to another location** - When the Thing cannot connect to the configured WiFi, it falls back to AP mode, and waits for you to change the network configuration. When no configuration was made, then it keeps trying to connect with the already configured settings. The Thing will not switch off the AP while anyone is connected to it, so you must leave the AP when finished with the configuration.
+ 1. **You want to connect to the AP, but have forgotten the configured AP WiFi password you set up previously** - Connect the appropriate pin on the Arduino to ground with a push button. Holding the button pressed while powering up the device causes the Thing to start the AP mode with the default password. (See Case 1. The pin is configured in the code.)
+ 1. **You want to change the configuration before the Thing connects to the Internet** - Fine! The Thing always starts up in AP mode and provides you a time frame to connect to it and make any modification to the configuration. Any time one is connected to the AP (provided by the device) the AP will stay on until the connection is closed. So take your time for the changes, the Thing will wait for you while you are connected to it.
+ 1. **You want to change the configuration at runtime** - No problem. IotWebConf keeps the config portal up and running even after the WiFi connection is finished. In this scenario you must enter username "admin" and password (already configured) to enter the config portal. Note, that the password provided for the authentication is not hidden from devices connected to the same WiFi network. You might want to force rebooting of the Thing to apply your changes.
+
+## User notes
+ - In the config portal you can double-tap on a password to reveal what
+you have typed in. (Double-tap again to hide revealed text.)
+ - When accessing the config portal via connected WiFi network a dialog
+with user-name and password will pop up. The password is the one you
+have configured for "AP password". The user name is "admin".
+ - Consult [Users Manual](doc/UsersManual.md) for more details!
+
+
+## IotWebConf vs. WiFiManager
+tzapu's WiFiManager is a great library. The features of IotWebConf may appear very similar to WiFiManager. However, IotWebConf tries to be different.
+ - WiFiManager does not allow you to configure **mutiple WiFi** connections. In IotWebConf there is a way to define more connections: if one is not available, the next is tried automatically.
+ - ~~WiFiManager does not manage your **custom properties**.~~ IotWebConf stores your configuration in "EEPROM".
+ - WiFiManager does not do **validation**. IotWebConf allow you to validate your property changes made in the config portal.
+ - ~~WiFiManager does not support ESP32.~~
+ - ~~With WiFiManager you cannot use both startup and **on-demand configuration**.~~ With IotWebConf the config portal remains available via the connected local WiFi.
+ - WiFiManager provides list of available networks, and an information page, while these features are cool, IotWebConf tries to keep the code simple. So these features are not (yet) provided by IotWebConf.
+ - IotWebConf is fitted for more advanced users. You can keep control of the web server setup, configuration item input field behavior, and validation.
+
+## Security aspects
+ - The initial system password must be modified by the user, so there is no build-in password.
+ - When connecting in AP mode, the WiFi provides an encryption layer (WPA/WPA2), so all your communication here is known to be safe. (The exact wifi encryption depends on the used board/chipset and implementation in the related esp/arduino framework.)
+ - When connecting through a WiFi router (WiFi mode), the Thing will ask for authentication when someone requests the config portal. This is required as the Thing will be visible for all devices sharing the same network. But be warned by the following note...
+ - NOTE: **When connecting through a WiFi router (WiFi mode), your communication is not hidden from devices connecting to the same network.** It communicates over unencrypted HTTP. So either: Do not allow ambiguous devices connecting to your WiFi router, or configure your Thing only in AP mode!
+ - However IotWebConf has a detailed debug output, passwords are not shown in this log by default. You have
+ to enable password visibility manually in the IotWebConf.h with the IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ if it is needed.
+
+## Compatibility
+IotWebConf is primary built for ESP8266. But meanwhile it was discovered, that the code can be adopted
+to ESP32. There are two major problems.
+ - ESP8266 uses specific naming for it's classes (e.g. ESP8266WebServer). However, ESP32 uses a more generic naming (e.g. WebServer). The idea here is to use the generic naming hoping that ESP8266 will adopt these "standards" sooner or later.
+ - ESP32 does not provide an HTTPUpdateServer implementation. So in this project we have implemented one. Whenever ESP32 provides an official HTTPUpdateServer, this local implementation will be removed.
+
+## Customizing and extending functionality
+IotWebConf is ment to be developer friendly by providing lots
+of customization options. See [HackingGuide](doc/HackingGuide.md) for
+details.
+
+## TODO / Feature requests
+ - We might want to add a "verify password" field.
+ - Provide an option, where IotWebConf renders HTML-response,
+handles HTTP-request for a specific branch of groups.
+ - Separate WiFi management from the code, so config portal can also
+be a standalone solution without any WiFi.
+
+## Known issues
+ - It is reported, that there might be unstable working with different lwIP variants. If you experiment serious problems, try to select another lwIP variant for your board in the Tools menu! (Tested with "v2 Lower Memory" version.)
+
+## Credits
+Although IotWebConf started without being influenced by any other solutions, in the final code you can find some segments borrowed from the WiFiManager library.
+ - https://github.com/tzapu/WiFiManager
+
+Thanks to [all contributors](https://github.com/prampec/IotWebConf/graphs/contributors) providing patches for the library!
diff --git a/ampel-firmware/src/lib/IotWebConf/doc/HackingGuide.md b/ampel-firmware/src/lib/IotWebConf/doc/HackingGuide.md
new file mode 100644
index 0000000..4251dbc
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/doc/HackingGuide.md
@@ -0,0 +1,232 @@
+# IotWebConf hacking guide
+
+IotWebConf comes with a lot of examples. These examples are intended
+to be easy to use, with clear goals. While IotWebConf is also ment to be
+developer friendly, providing lots of customization options.
+
+This documentation will try to explain features where you can customize
+IotWebConf on your need, or where a feature explanation might be out of the
+scope of regular examples.
+
+Please note, that header files are full of
+documentation, so please heavily consult ```IotWebConf.h``` header file
+while/beside reading this documentation.
+
+__Contents__:
+
+ - [PlatformIO](#using-iotwebconf-with-platformio)
+ - [Compile time configuration](#compile-time-configuration)
+ - [Groups and Parameters](#groups-and-parameters)
+ - [Optional and chained groups](#optional-and-chained-groups)
+ - [Using System parameter-group](#using-system-parameter-group)
+ - [Alternative WiFi connection](#alternative-wifi-connection)
+ - [Accessing system properties](#accessing-system-properties)
+ - [Use custom style](#use-custom-style)
+ - [Create your property class](#create-your-property-class)
+ - [Typed parameters](#typed-parameters-experimental)
+ - [Control on WiFi connection status change](#control-on-wifi-connection-status-change)
+ - [Use alternative WebServer](#use-alternative-webserver)
+
+## Using IotWebConf with PlatformIO
+It is recommended to use PlatformIO instead of the Arduino environment.
+
+With v3.0.0, a folder ```pio``` is provided with scripts that transforms
+examples to PlatformIO compatible format. You can use these as templates
+for your project. (On the other hand, these scripts creating soft-link
+loops, and having soft link loops in these folders might cause Arduino
+and other environment to fail. Just keep in mind, if something goes
+wrong with your IDE, then examples-pio is likely the corporate.)
+
+## Compile time configuration
+IotWebConf includes a configuration file named IotWebConfSettings.h.
+This configuration file works on C pre-compiler mechanism. This means
+you cannot use it in Arduino environment, so I encourage everyone to
+switch to PlatformIO.
+
+In the PlatformIO you can do configuration changes by adding lines to
+ platformio.ini like this:
+```
+build_flags =
+ -DIOTWEBCONF_DEFAULT_WIFI_CONNECTION_TIMEOUT_MS="60000"
+ -DIOTWEBCONF_DEBUG_DISABLED
+```
+
+**Note:** You must not use ```#define IOTWEBCONF_CONFIG_START 20```, or
+similar defines in your .ino file (e.g. before the includes). It will eventually
+just not work, as all .cpp files are compiled separately for each other.
+Thus, you must use the ```-D``` compiler flag for the job.
+
+## Groups and Parameters
+With version 3.0.0 IotWebConf introduces individual parameter classes for
+each type, and you can organize your parameters into groups.
+You can also free to add groups into groups to make a tree hierarchy.
+
+## Optional and chained groups
+With ```OptionalParameterGroup```, the group you have defined will have
+a special appearance in the config portal, as the fieldset in which the
+group items are shown can be hidden (inactive) / shown (active).
+
+E.g you want to create a group with property items, that are not mandatory,
+so you can hide these options in the config portal by default, and
+only reveal the contents, when it is strictly requested.
+There is a specific example covering this very feature under
+```IotWebConf13OptionalGroup```.
+
+```ChainedParameterGroup```s can be linked. One after another. The
+property sets will reveal on after another, when user requests is. The
+difference between ```OptionalParameterGroup``` and ```ChainedParameterGroup```
+is that second group item in a chained list can only be added, when
+the first item is already visible.
+There is a specific example covering this very feature under
+```IotWebConf14GroupChain```.
+
+## Using system parameter-group
+By default, you should add your own parameter group, that will appear as
+a new field-set on the Config Portal. However, there is a special group
+maintained by IotWebConf called the System group, where you are also
+allowed to add your own custom properties.
+
+Example:
+```
+ iotWebConf.addSystemParameter(&stringParam);
+```
+
+You can directly access system-parameter group by calling
+```getSystemParameterGroup()```.
+
+Example:
+```
+ ParameterGroup* systemParameters = iotWebConf.getSystemParameterGroup();
+ systemParameters.label = "My Custom Label";
+```
+
+There is another group "WiFi parameters" managed by IotWebConf, that
+can be retrieved by getWifiParameterGroup().
+
+## Alternative WiFi connection
+With v3.0.0 you can set up multiple WiFi connection by utilizing the
+MultipleWifiAddition class can be found in IotWebConfMultipleWifi.h .
+
+This class basically set up some handlers in iotWebConf to
+1. display optional WiFi settings in admin GUI,
+2. use these alternative settings in case previous WiFi connection
+attempts fails.
+
+The maximal number of connection settings are determined compile-time,
+as we want to avoid any dynamic memory allocations in Arduino.
+
+There is a complete example covering this topic, please visit example
+```IotWebConf15MultipleWifi```!
+
+## Accessing system properties
+IotWebConf comes with some parameters, that are required for the basic
+functionality. You can retrieve these parameter by getters, e.g.
+```getThingNameParameter()```. You can directly modify these items as
+seen in the code block below.
+
+There is a dedicated example covering this topic, so please visit
+example ```IotWebConf11AdvancedRuntime```!
+
+```
+ // -- Update Thing name
+ strncpy(
+ iotWebConf.getThingNameParameter()->valueBuffer,
+ "My changed name",
+ iotWebConf.getThingNameParameter()->getLength());
+ iotWebConf.saveConfig();
+```
+
+Here is list of some of the system parameter-acccessors, please consult
+IotWebConf.h for further details.
+- getSystemParameterGroup()
+- getThingNameParameter()
+- getApPasswordParameter()
+- getWifiParameterGroup()
+- getWifiSsidParameter()
+- getWifiPasswordParameter()
+- getApTimeoutParameter()
+
+## Use custom style
+You can provide your own custom HTML template by updating default
+HTML format provider. For this you should utilize the
+ ```setHtmlFormatProvider()``` method.
+
+There is a complete example about this topic, so please visit example
+```IotWebConf10CustomHtml```!
+
+## Create your property class
+With version 3.0.0 you are free to create your own property class.
+It is done by inheriting the iotwebconf::Parameter C++ class. You can use
+other property types e.g. PasswordProperty as a template for this.
+
+Now, custom properties are mainly handy, when you would like to create
+some special HTML form item. But eventually you can change the whole
+behaviour of your parameter handling. E.g. by overriding ```storeValue()```
+and ```loadValue()``` you can basically convert your internal data format
+to whatever you like. The [Typed parameters](#typed-parameters-experimental)
+approach is just an excellent example for this option.
+
+You can also override ParameterGroup class in case you need some special
+group appearance.
+
+There is a complete example about this topic, so please visit example
+```IotWebConf12CustomParameterType```!
+
+## Typed parameters (experimental)
+A new parameter structure is introduced, where the parameters does not
+require a "valueBuffer" anymore. Storing the parameter is done in a
+native format, e.g. a 8-bit integers are stored in one byte of EEPROM.
+
+This was achieved by utilizing the ```template``` technology of C++.
+While the result is spectacular, the ```template``` makes thing very
+complicated under the hood.
+
+Builder pattern is also introduced for the typed parameters. See example
+```IotWebConf03TypedParameters``` for details. Please compare example
+IotWebConf03TypedParameters and IotWebConf03TypedParameters for the
+difference in the usage of the two different approach.
+
+**Please note, that Typed Parameters are very experimental, and the
+interface might be a subject of change in the future.**
+
+
+(This image was created by PlantUML, the source file is generate with command
+```hpp2plantuml -i src/IotWebConfTParameter.h -o doc/TParameter.plantuml```)
+
+## Control on WiFi connection status change
+IotWebConf provides a feature to control WiFi connection events by defining
+your custom handler event handler.
+
+With ```setWifiConnectionFailedHandler()``` you can set up a handler, that
+will be called, when a connection to a WiFi network failed (most likely
+timed out). Now, when you return with a new valid connection-info from
+your callback, IotWebConf will not fall back to AP mode, but try the
+connection you have just provided. With this method you can theoretically
+set up multiple WiFi networks for IotWebConf to try connect to after
+one-by-one if the previous one fails. Some days IotWebConf might also
+provide this feature out of the box.
+
+There is a second method, where you can define a specific handler, this
+is the ```setWifiConnectionHandler()```. Your method will be called when
+IotWebConf trying to establish connection to a WiFi network.
+
+For details please consult ```IotWebConf.h``` header file!
+
+## Use alternative WebServer
+
+There was an expressed need from your side for supporting specific types of
+Web servers. (E.g https
+web server or async web server.) So, with v3.0.0 there is an option to
+use web server of your choice. To achieve this, you will call IotWebConf
+constructor, that accepts a ```WebServerWrapper``` pointer.
+In the WebServerWrapper you have the implement all expected web server
+functionalities (as seen in the header file). You can use
+the ```StandardWebServerWrapper``` as a template for that.
+
+Further more, you also need to provide your custom ```WebRequestWrapper```
+instances when calling ```handleCaptivePortal()```, ```handleConfig()``` and
+```handleNotFound()```.
+
+Unfortunately I currently do not have the time to implement solutions
+for Async Web Server os Secure Web Server. If you can do that with the
+instruction above, please provide me the pull request!
diff --git a/ampel-firmware/src/lib/IotWebConf/doc/MigrationGuide-v3.0.0.md b/ampel-firmware/src/lib/IotWebConf/doc/MigrationGuide-v3.0.0.md
new file mode 100644
index 0000000..51c6c59
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/doc/MigrationGuide-v3.0.0.md
@@ -0,0 +1,263 @@
+# Migration guide to v3.0.0
+
+In v3.0.0 some changes were introduced, that are not backward
+compatible with v2.x.x versions.
+This guide contains all modifications that should be done in existing
+codes, to reflect the changes.
+
+For better understanding some code examples are also shown here, but
+I would recommend comparing git changes in the examples.
+
+## Changes introduced in v3.0.0
+
+ - [Namespaces](#namespaces)
+ - [Parameter classes](#parameter-classes)
+ - [Parameter grouping](#grouping-parameters)
+ - [Default value handling](#default-value-handling)
+ - [Hidden parameters](#hidden-parameters)
+ - [UpdateServer changes](#updateserver-changes)
+ - [configSave](#configsave)
+ - [formValidator](#formvalidator)
+
+## Namespaces
+
+With v3.0.0, IotWebConf library started to use namespaces. Namespace
+is a C++ technique, where to goal is to avoid name collision over
+different libraries.
+
+The namespace for IotWebConf become ```iotwebconf::```. From now on
+you should use this prefix for each type defined by the library
+except for the IotWebConf class itself.
+
+There are more ways to update your code. Let's see some variations!
+
+### Migration steps: easy way
+For easy migration IotWebConf has provided a header file prepared
+with predefined aliases to hide namespaces, so you can still use
+the legacy types.
+
+Include helper header file as follows.
+
+Code before:
+```C++
+#include <IotWebConf.h>
+```
+
+Code after:
+```C++
+#include <IotWebConf.h>
+#include <IotWebConfUsing.h>
+```
+
+### Migration steps: proper way
+Use namespace prefixes before every type name.
+
+Code before:
+```C++
+IotWebConfParameter mqttServerParam =
+ IotWebConfParameter("MQTT server", "mqttServer", mqttServerValue, STRING_LEN);
+```
+
+Code after:
+```C++
+iotwebconf::Parameter mqttServerParam =
+ iotwebconf::Parameter("MQTT server", "mqttServer", mqttServerValue, STRING_LEN);
+```
+
+### Migration steps: optimist way
+Define namespaces at the beginning of the code and use simple type name.
+Everywhere later on. This works only until name-collision with other
+library occur.
+
+Code after:
+```C++
+using namespace iotwebconf;
+...
+Parameter mqttServerParam =
+ Parameter("MQTT server", "mqttServer", mqttServerValue, STRING_LEN);
+```
+
+## Parameter classes
+
+Previously there was just the ```IotWebConfParameter``` and the
+actual type was provided as an argument of this one-and-only type.
+Now it turned out, that it is a better idea to use specific classes
+for each individual types. So from now on you must specify the type
+of the parameter by creating that very type e.g. using
+```IotWebConfTextParameter```.
+
+For compatibility reasons the signature is the same before, except
+the type string should not be provided anymore.
+
+New parameter types are also introduced (e.g.
+ ```IotWebConfSelectParameter```),
+and it is very likely that with newer versions, more and more types will
+ arrive.
+Creating your custom parameter is now become much more easy as well.
+
+### Migrations steps
+Replace IotWebConfParameter types with specific parameter type.
+
+Code before:
+```C++
+IotWebConfParameter mqttServerParam =
+ IotWebConfParameter("MQTT server", "mqttServer", mqttServerValue , STRING_LEN);
+IotWebConfParameter mqttUserPasswordParam =
+ IotWebConfParameter("MQTT password", "mqttPass", mqttUserPasswordValue , STRING_LEN, "password");
+```
+
+Code after:
+```C++
+IotWebConfTextParameter mqttServerParam =
+ IotWebConfTextParameter("MQTT server", "mqttServer", mqttServerValue , STRING_LEN);
+IotWebConfPasswordParameter mqttUserPasswordParam =
+ IotWebConfPasswordParameter("MQTT password", "mqttPass ", mqttUserPasswordValue, STRING_LEN);
+```
+
+Note, that ```IotWebConfTextParameter``` and
+```IotWebConfPasswordParameter``` words are just aliases and eventually you
+should use ```iotwebconf::TextParameter```,
+```iotwebconf::PasswordParameter```, etc.
+
+_Note, that with version 3.0.0 a new typed parameter approach is introduced,
+you might want to immediately migrate to this parameter types, but
+typed-parameters are still in testing phase and might be a subject of
+change._
+
+## Grouping parameters
+
+With v3.0.0 "separator" disappears. Separators were used to create
+field sets in the rendered HTML. Now you must directly define connected
+items by adding them to specific parameter groups.
+(It is also possible to add a group within a group.)
+
+You need to add prepared groups to IotWebConf instead of individual
+parameters. (However there is a specific group created by IotWebConf for
+storing system parameters, you can also add your
+properties into the system group.)
+
+Code before:
+```C++
+IotWebConfSeparator separator1 =
+ IotWebConfSeparator();
+IotWebConfParameter intParam =
+ IotWebConfParameter("Int param", "intParam", intParamValue, NUMBER_LEN, "number",
+ "1..100", nullptr, "min='1' max='100' step='1'");
+
+...
+
+void setup()
+{
+...
+ iotWebConf.addParameter(&separator1);
+ iotWebConf.addParameter(&intParam);
+...
+```
+
+Code after:
+```C++
+IotWebConfParameterGroup group1 =
+ IotWebConfParameterGroup("group1", "");
+IotWebConfNumberParameter intParam =
+ IotWebConfNumberParameter("Int param", "intParam", intParamValue, NUMBER_LEN,
+ "20", "1..100", "min='1' max='100' step='1'");
+
+...
+
+void setup()
+{
+...
+ group1.addItem(&intParam);
+...
+ iotWebConf.addParameterGroup(&group1);
+...
+```
+
+Also note, that ```IotWebConfParameterGroup``` and
+```IotWebConfNumberParameter``` words are just aliases and eventually you
+should use ```iotwebconf::ParameterGroup```,
+```iotwebconf::NumberParameter```, etc.
+
+## Default value handling
+
+For the Parameters you could always specify "defaultValue". In v2.x
+.x this value was intended to be appeared in the config portal, if no
+values are specified. Now with v3.0.0, defaultValue has a different
+meaning. Now it is
+automatically assigned to the parameter, when this is the **first
+time** configuration is loading.
+
+This means you do not have to set these values manually.
+
+In the example below, the body of the ```if``` is done by IotWebConf
+automatically.
+```
+ // -- Initializing the configuration.
+ bool validConfig = iotWebConf.init();
+ if (!validConfig)
+ {
+ // DO NOT DO THIS! Use default values instead.
+ strncpy(mqttServerValue, "192.168.1.10", STRING_LEN);
+ }
+```
+
+## Hidden parameters
+
+IotWebConf can save and load parameters, that are not populated to the
+web interface. To mark an item as hidden, you should have set the last
+parameter of the constructor to visible=false.
+
+From v3.0.0, you will need to add hidden items to a specific group managed
+by IotWebConf.
+```
+iotWebConf.addHiddenParameter(&myHiddenParameter);
+```
+
+## UpdateServer changes
+
+In prior versions, IotWebConf activated HTTP Update server automatically.
+With version 3.0.0, IotWebConf dropped the dependency to UpdateServer. The
+activation will still be triggered, but the actual switching action
+should be provided externally (at your code).
+
+A quite complicated code needs to introduced because of this change, and
+you need to manually include UpdateServer to your code. See example:
+ ```IotWebConf04UpdateServer``` for details!
+
+Changed lines:
+
+```
+// Include Update server
+#ifdef ESP8266
+# include <ESP8266HTTPUpdateServer.h>
+#elif defined(ESP32)
+# include <IotWebConfESP32HTTPUpdateServer.h>
+#endif
+
+// Create Update Server
+#ifdef ESP8266
+ESP8266HTTPUpdateServer httpUpdater;
+#elif defined(ESP32)
+HTTPUpdateServer httpUpdater;
+#endif
+
+ // In setup register callbacks performing Update Server hooks.
+ iotWebConf.setupUpdateServer(
+ [](const char* updatePath) { httpUpdater.setup(&server, updatePath); },
+ [](const char* userName, char* password) { httpUpdater.updateCredentials(userName, password); });
+```
+
+Note, that ESP32 still doesn't provide Update Server solution out of the
+box. IotWebConf still provides an implementation for that, but it is now
+completely independent of the core codes.
+
+## configSave
+Method configSave is renamed to saveConfig.
+
+## formValidator
+The formValidator() methods from now on will have a
+```webRequestWrapper``` parameter.
+
+```
+bool formValidator(iotwebconf::WebRequestWrapper* webRequestWrapper);
+```
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/doc/TParameter.plantuml b/ampel-firmware/src/lib/IotWebConf/doc/TParameter.plantuml
new file mode 100644
index 0000000..f9802f0
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/doc/TParameter.plantuml
@@ -0,0 +1,272 @@
+@startuml
+
+
+
+
+
+/' Objects '/
+
+namespace iotwebconf {
+ class BoolDataType {
+ +BoolDataType()
+ #fromString() : bool
+ }
+
+ class CharArrayDataType <len> {
+ +CharArrayDataType()
+ #update() : bool
+ #getInputLength() : int
+ #applyDefaultValue() : void
+ #loadValue() : void
+ #storeValue() : void
+ }
+
+ class CheckboxTParameter {
+ +CheckboxTParameter()
+ #renderHtml() : String
+ +isChecked() : bool
+ #getInputType() : char*
+ -_checkedStr : const char*
+ #update() : void
+ }
+
+ abstract class ConfigItemBridge {
+ #ConfigItemBridge()
+ #{abstract} toString() : String
+ #{abstract} update() : bool
+ #getInputLength() : int
+ +debugTo() : void
+ +update() : void
+ }
+
+ abstract class DataType <ValueType, (_DefaultValueType)> {
+ +DataType()
+ #toString() : String
+ #_value : ValueType
+ +getValue() : ValueType&
+ +operator*() : ValueType&
+ #_defaultValue : _DefaultValueType
+ #{abstract} update() : bool
+ #validate() : bool
+ #getStorageSize() : int
+ }
+
+ class DoubleDataType {
+ +DoubleDataType()
+ #fromString() : double
+ }
+
+ class FloatDataType {
+ +FloatDataType()
+ #fromString() : float
+ }
+
+ class FloatTParameter {
+ +FloatTParameter()
+ +isMaxDefined() : bool
+ +isMinDefined() : bool
+ #getInputType() : char*
+ +getMax() : float
+ +getMin() : float
+ }
+
+ abstract class InputParameter {
+ +InputParameter()
+ +getCustomHtml() : String
+ #getHtmlTemplate() : String
+ #renderHtml() : String
+ #{abstract} getInputType() : char*
+ +customHtml : const char*
+ +errorMessage : const char*
+ +label : const char*
+ +placeholder : const char*
+ #clearErrorMessage() : void
+ +renderHtml() : void
+ +setPlaceholder() : void
+ }
+
+ class IntTParameter <ValueType, (base)> {
+ +IntTParameter()
+ +getMax() : ValueType
+ +getMin() : ValueType
+ +isMaxDefined() : bool
+ +isMinDefined() : bool
+ #getInputType() : char*
+ }
+
+ class IpDataType {
+ #toString() : String
+ #update() : bool
+ }
+
+ class OptionsTParameter <len> {
+ +OptionsTParameter()
+ #OptionsTParameter()
+ #_optionNames : const char*
+ #_optionValues : const char*
+ #_nameLength : size_t
+ #_optionCount : size_t
+ +setNameLength() : void
+ +setOptionCount() : void
+ +setOptionNames() : void
+ +setOptionValues() : void
+ }
+
+ class PasswordTParameter <len> {
+ +PasswordTParameter()
+ #renderHtml() : String
+ +update() : bool
+ #getInputType() : char*
+ -_customHtmlPwd : const char*
+ +debugTo() : void
+ }
+
+ abstract class PrimitiveDataType <ValueType> {
+ +PrimitiveDataType()
+ -_max : ValueType
+ -_min : ValueType
+ #{abstract} fromString() : ValueType
+ #getMax() : ValueType
+ #getMin() : ValueType
+ #isMaxDefined() : ValueType
+ #isMinDefined() : ValueType
+ -_maxDefined : bool
+ -_minDefined : bool
+ #update() : bool
+ #applyDefaultValue() : void
+ #loadValue() : void
+ +setMax() : void
+ +setMin() : void
+ #storeValue() : void
+ }
+
+ abstract class PrimitiveInputParameter <ValueType> {
+ +PrimitiveInputParameter()
+ +getCustomHtml() : String
+ +{abstract} getMax() : ValueType
+ +{abstract} getMin() : ValueType
+ +step : ValueType
+ +{abstract} isMaxDefined() : bool
+ +{abstract} isMinDefined() : bool
+ +setStep() : void
+ }
+
+ class SelectTParameter <len> {
+ +SelectTParameter()
+ +SelectTParameter()
+ #renderHtml() : String
+ }
+
+ class SignedIntDataType <ValueType, (base)> {
+ +SignedIntDataType()
+ #fromString() : ValueType
+ }
+
+ class StringDataType {
+ #toString() : String
+ #update() : bool
+ }
+
+ class TextTParameter <len> {
+ +TextTParameter()
+ #getInputType() : char*
+ }
+
+ class UnsignedIntDataType <ValueType, (base)> {
+ +UnsignedIntDataType()
+ #fromString() : ValueType
+ }
+}
+
+
+
+
+
+/' Inheritance relationships '/
+
+iotwebconf.BoolDataType <|-- iotwebconf.CheckboxTParameter
+
+
+iotwebconf.CharArrayDataType <|-- iotwebconf.PasswordTParameter
+
+
+iotwebconf.CharArrayDataType <|-- iotwebconf.TextTParameter
+
+
+iotwebconf.ConfigItemBridge <|-- iotwebconf.DataType
+
+
+iotwebconf.ConfigItemBridge <|-- iotwebconf.InputParameter
+
+
+iotwebconf.DataType <|-- iotwebconf.CharArrayDataType
+
+
+iotwebconf.DataType <|-- iotwebconf.IpDataType
+
+
+iotwebconf.DataType <|-- iotwebconf.PrimitiveDataType
+
+
+iotwebconf.DataType <|-- iotwebconf.StringDataType
+
+
+iotwebconf.FloatDataType <|-- iotwebconf.FloatTParameter
+
+
+iotwebconf.InputParameter <|-- iotwebconf.CheckboxTParameter
+
+
+iotwebconf.InputParameter <|-- iotwebconf.PasswordTParameter
+
+
+iotwebconf.InputParameter <|-- iotwebconf.PrimitiveInputParameter
+
+
+iotwebconf.InputParameter <|-- iotwebconf.TextTParameter
+
+
+iotwebconf.OptionsTParameter <|-- iotwebconf.SelectTParameter
+
+
+iotwebconf.PrimitiveDataType <|-- iotwebconf.BoolDataType
+
+
+iotwebconf.PrimitiveDataType <|-- iotwebconf.DoubleDataType
+
+
+iotwebconf.PrimitiveDataType <|-- iotwebconf.FloatDataType
+
+
+iotwebconf.PrimitiveDataType <|-- iotwebconf.SignedIntDataType
+
+
+iotwebconf.PrimitiveDataType <|-- iotwebconf.UnsignedIntDataType
+
+
+iotwebconf.PrimitiveInputParameter <|-- iotwebconf.FloatTParameter
+
+
+iotwebconf.PrimitiveInputParameter <|-- iotwebconf.IntTParameter
+
+
+iotwebconf.SignedIntDataType <|-- iotwebconf.IntTParameter
+
+
+iotwebconf.TextTParameter <|-- iotwebconf.OptionsTParameter
+
+
+
+
+
+/' Aggregation relationships '/
+
+
+
+
+
+/' Nested objects '/
+
+
+
+@enduml
diff --git a/ampel-firmware/src/lib/IotWebConf/doc/TParameter.png b/ampel-firmware/src/lib/IotWebConf/doc/TParameter.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6b9a3c0661339b692bcc541937581eeeed51e9c
GIT binary patch
literal 226919
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
M86EY!(^l922juJGp#T5?
literal 0
HcmV?d00001
diff --git a/ampel-firmware/src/lib/IotWebConf/doc/UsersManual.md b/ampel-firmware/src/lib/IotWebConf/doc/UsersManual.md
new file mode 100644
index 0000000..88f7cf2
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/doc/UsersManual.md
@@ -0,0 +1,225 @@
+# IotWebConf users manual template
+
+This documentation is mainly for makers are about to came out with their
+own product, and prepare for that with a Users manual.
+Or for ones who are want to understand the basic functionality of
+IotWebConf.
+
+This document can be used as a template, modify it with the actual
+product specific details. We will only cover the basic functionality
+(including status and reset), but will __not__ talk about options like:
+- Firmware update (OTA),
+- Static IP option,
+- Multiply WiFi option,
+- Offline mode option,
+- Skip AP-mode option.
+
+#### Hardware setup
+
+The document assumes, that the device is equipped with
+the indicator LED and the "reset" button, just as it can be seen
+in example `IotWebConf02StatusAndReset`.
+
+As mentioned above a "default" options-set is assumed as well.
+
+## Starting up the device at the first time
+
+When you are starting up the device for the first time, the device
+will create its own WiFi Access Point with SSID _testThing_.
+The status indicator rapidly flashes (it is mostly on).
+
+Use your smartphone (or tablet, or computer) to detect the created
+WiFi network, and connect to it by using the default password
+_smrtThng8266_. After a successful WiFi connection a configuration
+page is popped up in your smartphone's web browser.
+
+Note, that at this point even if the network is not configured,
+the device is already ready to use with the factory defaults in
+an off-line manner.
+
+## Configuration page (Config portal)
+
+After you have connected to the access point created by the
+device (as described above), you need to enter the configuration
+page on the web-browser of your smartphone.
+On the configuration page you will see some fields you can
+set.
+
+Except for the password fields, you will see the item values
+previously set. (Or for first time setup, the factory default.)
+
+For the password fields you will never see any previously set
+values, and typed values are also hidden. You can __reveal the
+password__ text you have typed by double-clicking (double-tapping) on
+the password field. You can then double-click (double-tap)
+a second time to hide the text again. It is recommended to
+hide the passwords before submitting the configuration form,
+as browsers are likely to save non-password form values to
+use them as recommendation.
+
+_TODO: you can provide some more description on specific
+fields you are about to use._
+
+When you are finished providing all the values of your need,
+please press the Apply button.
+
+Some fields are protected with constraints, and a validation is
+performed. In case there is an error in the validation of
+any field none of them are saved. You even need to re-type values
+for filled-out passwords in this case.
+
+## Configuration options
+
+After the first boot, there are some values needs to be set up.
+These items are maked with __*__ (star) in the list below.
+
+You can set up the following values in the configuration page:
+
+- __Thing name__ - Please change the name of the device to
+a name you think describes it the most. It is advised to
+incorporate a location here in case you are planning to
+set up multiple devices in the same area. You should only use
+english letters, and the "_" underscore character. Thus, must not
+use Space, dots, etc. E.g. `lamp_livingroom` __*__
+- __AP password__ - This password is used, when you want to
+access the device later on. You must provide a password with at least 8,
+at most 32 characters.
+You are free to use any characters, further more you are
+encouraged to pick a password at least 12 characters long containing
+at least 3 character classes. __*__
+- __WiFi SSID__ - The name of the WiFi network you want the device
+to connect to. __*__
+- __WiFi password__ - The password of the network above. Note, that
+unsecured passwords are not supported in your protection. __*__
+
+_TODO: add your own configuration here_
+
+Note, that in "First boot" mode you are free to save any
+partial data, but on-line mode will not enter until you have
+provided all mandatory data.
+
+## Connecting to a WiFi network
+
+When you have successfully applied the mandatory configurations,
+the device will try to connect to the required WiFi network. While
+connecting, the indicator LED will alter between On/Off in a moderated
+speed.
+
+If the WiFi connection is successfull, the indicator LED will turn off,
+and performes rapid blinks with long delays.
+
+If the WiFi connection fails, the device will __fall back to Access Point
+mode__. This means, that the device will form its own WiFi network, on
+what you can connect to, and correct network connection setup.
+
+This time you will see the `Thing Name` value as the access point name
+ (SSID),
+and you need to use the `AP password` you have configured previously.
+
+This also means, that if the configured WiFi network is not available,
+the device will fall back to Access Point mode, stays there for some
+seconds (so that you can perform changes if needed), and after some
+seconds it will __retry connecting to the WiFi network__.
+
+The Access Point mode is indicated with rapid blinks, where the indicator
+LED is mostly on.
+Access Point mode will kept as long as any connection is alive to it.
+Thus, you need to disconnect from the Access Point for the device to
+continue its operation.
+
+## Second startup and rescue mode
+
+In case you have already set up a WiFi network in the config portal,
+the device will automatically tries to (re)connect to it. However,
+when the device boots up it will __always starts the Access Point
+mode__ as described in previous section.
+
+In case you have __lost the password__ you have configured, you need to
+enter the rescue mode. To __enter the rescue mode__, you need to press
+and hold the button on the device while powering it up. This time you
+can enter the Access Point provided by the device with the factory-default
+password, that is _smrtThng8266_. The rescue mode will not be release
+until you have connected to the access point, it will be
+released after you have disconnected from it.
+
+## Configuration in connected mode
+
+After the device successfully connected to the configured WiFi network
+the temporary Access Point is terminated, but you can still connect
+to the device using its IP address. To determine the IP address of the
+device, you might want to consult with your WiFi router. (Devices
+are intented to be access by name as well, but this option is not
+reliable, thus, it cannot be recommended.)
+
+When you want to access the Config Portal of the device __via a WiFi
+network__ from your Web Browser, a login page will be displayed, where
+you need to enter:
+- User name: `admin`
+- Password: the password you have set up previously as __AP Password__.
+
+#### Security notes connecting from WiFi network
+
+While WiFi networks are known to be relatively safe by hiding its trafic
+from the public, it is not safe between parties connected to the network.
+And our device does not support secure Web connection.
+
+This means, when enter the configuration page via WiFi network, other
+parties can monitor your traffic.
+
+Recommendations to avoid compromisation:
+- Try to make your configurations in Access Point mode,
+- Set up a dedicated WiFi network to your IOT devices, where uncertain
+parties are not allowed to connect.
+
+
+## Blinking codes
+
+Prevoius chapters were mentioned blinking patterns, now here is a
+table summarize the menaning of the blink codes.
+
+- __Rapid blinking__ (mostly on, interrupted by short off periods) -
+Entered Access Point mode. This means the device create an own WiFi
+network around it. You can connect to the device with your smartphone
+(or WiFi capable computer).
+- __Alternating on/off blinking__ - Trying to connect the configured
+WiFi network.
+- __Mostly off with occasional short flash__ - The device is online.
+
+## Troubleshooting
+
+>I have turned on my device, but it blinks like crazy. What should I do?
+
+- Diagnose: Your device is not configured.
+- Solution:
+You need to turn on your smartphone, search for WiFi networks, and connect
+to `testThing`. Follow the instruction at
+[Starting up the device at the first time](#starting-up-the-device-at-the-first-time)
+
+>After I start up the device, the device just blinks as crazy and
+>later chills. But while it is blinking I cannot connect to it. Is this
+>intended?
+
+- Diagnose: This is an expected behaviour. At startup time you are able
+ connect directly
+to the device directly via a temporary created access point to perform some
+configuration changes. (The idea here, is that you can change WiFi
+setting in case it was changed before trying to connect to it.)
+
+>My device is either blinks like crazy, or with an alternating pattern,
+>but eventually it does not stop that. Why is that?
+
+- Diagnose: Your device cannot connect to the configured WiFi
+network.
+Your network setup was changed, you have miss-typed the settings, or
+the device is out of the network range.
+- Solution: At the time the device rapidly blinks, connect to it with
+your smartphone and alter the WiFi configuration (SSID and password).
+If this doesn't help try to provide stronger WiFi signal for the device.
+
+> I have forgot the password I have set. What should I do?
+
+- Solution: Turn off your device. Press and hold the button on the
+device while powering it up. The device will start up in Access Pont
+mode, you can connect to this temporary WiFi network with your
+smartphone using the initial password, that is _smrtThng8266_, and
+set up a new password for the device.
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/keywords.txt b/ampel-firmware/src/lib/IotWebConf/keywords.txt
new file mode 100644
index 0000000..12813df
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/keywords.txt
@@ -0,0 +1,125 @@
+# Datatypes (KEYWORD1)
+# Methods and Functions (KEYWORD2)
+# Constants (LITERAL1)
+
+# IotWebConf.h
+
+WifiAuthInfo KEYWORD1
+
+HtmlFormatProvider KEYWORD1
+getHead KEYWORD2
+getStyle KEYWORD2
+getScript KEYWORD2
+getHeadExtension KEYWORD2
+getHeadEnd KEYWORD2
+getFormStart KEYWORD2
+getFormEnd KEYWORD2
+getFormSaved KEYWORD2
+getEnd KEYWORD2
+getUpdate KEYWORD2
+getConfigVer KEYWORD2
+
+StandardWebRequestWrapper KEYWORD1
+
+StandardWebServerWrapper KEYWORD1
+
+WifiParameterGroup KEYWORD1
+
+IotWebConf KEYWORD1
+setConfigPin KEYWORD2
+setStatusPin KEYWORD2
+setupUpdateServer KEYWORD2
+init KEYWORD2
+doLoop KEYWORD2
+handleCaptivePortal KEYWORD2
+handleConfig KEYWORD2
+handleNotFound KEYWORD2
+setWifiConnectionCallback KEYWORD2
+setConfigSavingCallback KEYWORD2
+setConfigSavedCallback KEYWORD2
+setFormValidator KEYWORD2
+setApConnectionHandler KEYWORD2
+setWifiConnectionHandler KEYWORD2
+setWifiConnectionFailedHandler KEYWORD2
+addParameterGroup KEYWORD2
+addHiddenParameter KEYWORD2
+addSystemParameter KEYWORD2
+getThingName KEYWORD2
+delay KEYWORD2
+setWifiConnectionTimeoutMs KEYWORD2
+blink KEYWORD2
+fineBlink KEYWORD2
+stopCustomBlink KEYWORD2
+disableBlink KEYWORD2
+enableBlink KEYWORD2
+isBlinkEnabled KEYWORD2
+getState KEYWORD2
+setApTimeoutMs KEYWORD2
+getApTimeoutMs KEYWORD2
+resetWifiAuthInfo KEYWORD2
+skipApStartup KEYWORD2
+forceApMode KEYWORD2
+getSystemParameterGroup KEYWORD2
+getThingNameParameter KEYWORD2
+getApPasswordParameter KEYWORD2
+getWifiParameterGroup KEYWORD2
+getWifiSsidParameter KEYWORD2
+getWifiPasswordParameter KEYWORD2
+getApTimeoutParameter KEYWORD2
+saveConfig KEYWORD2
+setHtmlFormatProvider KEYWORD2
+getHtmlFormatProvider KEYWORD2
+
+
+#IotWebConfParameter.h
+
+SerializationData KEYWORD1
+
+ConfigItem KEYWORD1
+visible KEYWORD2
+getId KEYWORD2
+
+IotWebConfParameterGroup KEYWORD1
+ParameterGroup KEYWORD1
+addItem KEYWORD2
+label KEYWORD2
+
+IotWebConfParameter KEYWORD1
+Parameter KEYWORD1
+label KEYWORD2
+valueBuffer KEYWORD2
+defaultValue KEYWORD2
+errorMessage KEYWORD2
+getLength KEYWORD2
+
+IotWebConfTextParameter KEYWORD1
+TextParameter KEYWORD1
+placeholder KEYWORD2
+customHtml KEYWORD2
+
+IotWebConfPasswordParameter KEYWORD1
+PasswordParameter KEYWORD1
+
+IotWebConfNumberParameter KEYWORD1
+NumberParameter KEYWORD1
+
+IotWebConfCheckboxParameter KEYWORD1
+CheckboxParameter KEYWORD1
+isChecked KEYWORD2
+
+IotWebConfSelectParameter KEYWORD1
+SelectParameter KEYWORD1
+
+#IotWebConfOptionalGroup.h
+
+OptionalGroupHtmlFormatProvider KEYWORD1
+OptionalParameterGroup KEYWORD1
+ChainedParameterGroup KEYWORD1
+setNext KEYWORD2
+getNext KEYWORD2
+
+#IotWebConfOptionalGroup.h
+
+ChainedWifiParameterGroup KEYWORD1
+MultipleWifiAddition KEYWORD1
+
diff --git a/ampel-firmware/src/lib/IotWebConf/library.properties b/ampel-firmware/src/lib/IotWebConf/library.properties
new file mode 100644
index 0000000..908fb5d
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/library.properties
@@ -0,0 +1,10 @@
+name=IotWebConf
+version=3.2.0
+author=Balazs Kelemen <prampec+arduino@gmail.com>
+maintainer=Balazs Kelemen <prampec+arduino@gmail.com>
+sentence=ESP8266/ESP32 non-blocking WiFi/AP web configuration.
+paragraph=IotWebConf will start up in AP (access point) mode, and provide a config portal for entering WiFi connection and other user-settings. The configuration is persisted in EEPROM. The config portal will stay available after WiFi connection was made. A WiFiManager alternative.
+category=Communication
+url=https://github.com/prampec/IotWebConf
+architectures=esp8266,esp32
+includes=IotWebConf.h
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConf.cpp b/ampel-firmware/src/lib/IotWebConf/src/IotWebConf.cpp
new file mode 100644
index 0000000..bbf1b96
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConf.cpp
@@ -0,0 +1,995 @@
+/**
+ * IotWebConf.cpp -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#include <EEPROM.h>
+
+#include "IotWebConf.h"
+
+#ifdef IOTWEBCONF_CONFIG_USE_MDNS
+# ifdef ESP8266
+# include <ESP8266mDNS.h>
+# elif defined(ESP32)
+# include <ESPmDNS.h>
+# endif
+#endif
+
+#define IOTWEBCONF_STATUS_ENABLED ((this->_statusPin >= 0) && this->_blinkEnabled)
+
+////////////////////////////////////////////////////////////////
+
+namespace iotwebconf
+{
+
+IotWebConf::IotWebConf(
+ const char* defaultThingName, DNSServer* dnsServer, WebServerWrapper* webServerWrapper,
+ const char* initialApPassword, const char* configVersion)
+{
+ this->_thingNameParameter.defaultValue = defaultThingName;
+ this->_dnsServer = dnsServer;
+ this->_webServerWrapper = webServerWrapper;
+ this->_initialApPassword = initialApPassword;
+ this->_configVersion = configVersion;
+
+ this->_apTimeoutParameter.visible = false;
+ this->_systemParameters.addItem(&this->_thingNameParameter);
+ this->_systemParameters.addItem(&this->_apPasswordParameter);
+ this->_systemParameters.addItem(&this->_wifiParameters);
+ this->_systemParameters.addItem(&this->_apTimeoutParameter);
+
+ this->_allParameters.addItem(&this->_systemParameters);
+ this->_allParameters.addItem(&this->_customParameterGroups);
+ this->_allParameters.addItem(&this->_hiddenParameters);
+
+ this->_wifiAuthInfo = {this->_wifiParameters._wifiSsid, this->_wifiParameters._wifiPassword};
+}
+
+char* IotWebConf::getThingName()
+{
+ return this->_thingName;
+}
+
+void IotWebConf::setConfigPin(int configPin)
+{
+ this->_configPin = configPin;
+}
+
+void IotWebConf::setStatusPin(int statusPin, int statusOnLevel)
+{
+ this->_statusPin = statusPin;
+ this->_statusOnLevel = statusOnLevel;
+}
+
+bool IotWebConf::init()
+{
+ // -- Setup pins.
+ if (this->_configPin >= 0)
+ {
+ pinMode(this->_configPin, INPUT_PULLUP);
+ this->_forceDefaultPassword = (digitalRead(this->_configPin) == LOW);
+ }
+ if (IOTWEBCONF_STATUS_ENABLED)
+ {
+ pinMode(this->_statusPin, OUTPUT);
+ digitalWrite(this->_statusPin, !this->_statusOnLevel);
+ }
+
+ // -- Load configuration from EEPROM.
+ bool validConfig = this->loadConfig();
+ if (!validConfig)
+ {
+ // -- No config
+ this->_apPassword[0] = '\0';
+ this->_wifiParameters._wifiSsid[0] = '\0';
+ this->_wifiParameters._wifiPassword[0] = '\0';
+ }
+ this->_apTimeoutMs = atoi(this->_apTimeoutStr) * 1000;
+
+ // -- Setup mdns
+#ifdef ESP8266
+ WiFi.hostname(this->_thingName);
+#elif defined(ESP32)
+ WiFi.setHostname(this->_thingName);
+#endif
+#ifdef IOTWEBCONF_CONFIG_USE_MDNS
+ MDNS.begin(this->_thingName);
+ MDNS.addService("http", "tcp", IOTWEBCONF_CONFIG_USE_MDNS);
+#endif
+
+ return validConfig;
+}
+
+//////////////////////////////////////////////////////////////////
+
+void IotWebConf::addParameterGroup(ParameterGroup* group)
+{
+ this->_customParameterGroups.addItem(group);
+}
+
+void IotWebConf::addHiddenParameter(ConfigItem* parameter)
+{
+ this->_hiddenParameters.addItem(parameter);
+}
+
+void IotWebConf::addSystemParameter(ConfigItem* parameter)
+{
+ this->_systemParameters.addItem(parameter);
+}
+
+int IotWebConf::initConfig()
+{
+ int size = this->_allParameters.getStorageSize();
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("Config version: ");
+ Serial.println(this->_configVersion);
+ Serial.print("Config size: ");
+ Serial.println(size);
+#endif
+
+ return size;
+}
+
+/**
+ * Load the configuration from the eeprom.
+ */
+bool IotWebConf::loadConfig()
+{
+ int size = this->initConfig();
+ EEPROM.begin(
+ IOTWEBCONF_CONFIG_START + IOTWEBCONF_CONFIG_VERSION_LENGTH + size);
+
+ bool result;
+ if (this->testConfigVersion())
+ {
+ int start = IOTWEBCONF_CONFIG_START + IOTWEBCONF_CONFIG_VERSION_LENGTH;
+ IOTWEBCONF_DEBUG_LINE(F("Loading configurations"));
+ this->_allParameters.loadValue([&](SerializationData* serializationData)
+ {
+ this->readEepromValue(start, serializationData->data, serializationData->length);
+ start += serializationData->length;
+ });
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ this->_allParameters.debugTo(&Serial);
+#endif
+ result = true;
+ }
+ else
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Wrong config version. Applying defaults."));
+ this->_allParameters.applyDefaultValue();
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ this->_allParameters.debugTo(&Serial);
+#endif
+
+ result = false;
+ }
+
+ EEPROM.end();
+ return result;
+}
+
+void IotWebConf::saveConfig()
+{
+ int size = this->initConfig();
+ if (this->_configSavingCallback != nullptr)
+ {
+ this->_configSavingCallback(size);
+ }
+ EEPROM.begin(
+ IOTWEBCONF_CONFIG_START + IOTWEBCONF_CONFIG_VERSION_LENGTH + size);
+
+ this->saveConfigVersion();
+ int start = IOTWEBCONF_CONFIG_START + IOTWEBCONF_CONFIG_VERSION_LENGTH;
+ IOTWEBCONF_DEBUG_LINE(F("Saving configuration"));
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ this->_allParameters.debugTo(&Serial);
+ Serial.println();
+#endif
+ this->_allParameters.storeValue([&](SerializationData* serializationData)
+ {
+ this->writeEepromValue(start, serializationData->data, serializationData->length);
+ start += serializationData->length;
+ });
+
+ EEPROM.end();
+
+ this->_apTimeoutMs = atoi(this->_apTimeoutStr) * 1000;
+
+ if (this->_configSavedCallback != nullptr)
+ {
+ this->_configSavedCallback();
+ }
+}
+
+void IotWebConf::readEepromValue(int start, byte* valueBuffer, int length)
+{
+ for (int t = 0; t < length; t++)
+ {
+ *((char*)valueBuffer + t) = EEPROM.read(start + t);
+ }
+}
+void IotWebConf::writeEepromValue(int start, byte* valueBuffer, int length)
+{
+ for (int t = 0; t < length; t++)
+ {
+ EEPROM.write(start + t, *((char*)valueBuffer + t));
+ }
+}
+
+bool IotWebConf::testConfigVersion()
+{
+ for (byte t = 0; t < IOTWEBCONF_CONFIG_VERSION_LENGTH; t++)
+ {
+ if (EEPROM.read(IOTWEBCONF_CONFIG_START + t) != this->_configVersion[t])
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+void IotWebConf::saveConfigVersion()
+{
+ for (byte t = 0; t < IOTWEBCONF_CONFIG_VERSION_LENGTH; t++)
+ {
+ EEPROM.write(IOTWEBCONF_CONFIG_START + t, this->_configVersion[t]);
+ }
+}
+
+void IotWebConf::setWifiConnectionCallback(std::function<void()> func)
+{
+ this->_wifiConnectionCallback = func;
+}
+
+void IotWebConf::setConfigSavingCallback(std::function<void(int size)> func)
+{
+ this->_configSavingCallback = func;
+}
+
+void IotWebConf::setConfigSavedCallback(std::function<void()> func)
+{
+ this->_configSavedCallback = func;
+}
+
+void IotWebConf::setFormValidator(
+ std::function<bool(WebRequestWrapper* webRequestWrapper)> func)
+{
+ this->_formValidator = func;
+}
+
+void IotWebConf::setWifiConnectionTimeoutMs(unsigned long millis)
+{
+ this->_wifiConnectionTimeoutMs = millis;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+void IotWebConf::handleConfig(WebRequestWrapper* webRequestWrapper)
+{
+ if (this->_state == OnLine)
+ {
+ // -- Authenticate
+ if (!webRequestWrapper->authenticate(
+ IOTWEBCONF_ADMIN_USER_NAME, this->_apPassword))
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Requesting authentication."));
+ webRequestWrapper->requestAuthentication();
+ return;
+ }
+ }
+
+ bool dataArrived = webRequestWrapper->hasArg("iotSave");
+ if (!dataArrived || !this->validateForm(webRequestWrapper))
+ {
+ // -- Display config portal
+ IOTWEBCONF_DEBUG_LINE(F("Configuration page requested."));
+
+ // Send chunked output instead of one String, to avoid
+ // filling memory if using many parameters.
+ webRequestWrapper->sendHeader(
+ "Cache-Control", "no-cache, no-store, must-revalidate");
+ webRequestWrapper->sendHeader("Pragma", "no-cache");
+ webRequestWrapper->sendHeader("Expires", "-1");
+ webRequestWrapper->setContentLength(CONTENT_LENGTH_UNKNOWN);
+ webRequestWrapper->send(200, "text/html; charset=UTF-8", "");
+
+ String content = htmlFormatProvider->getHead();
+ content.replace("{v}", "Config ESP");
+ content += htmlFormatProvider->getScript();
+ content += htmlFormatProvider->getStyle();
+ content += htmlFormatProvider->getHeadExtension();
+ content += htmlFormatProvider->getHeadEnd();
+
+ content += htmlFormatProvider->getFormStart();
+
+ webRequestWrapper->sendContent(content);
+
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.println("Rendering parameters:");
+ this->_systemParameters.debugTo(&Serial);
+ this->_customParameterGroups.debugTo(&Serial);
+#endif
+ // -- Add parameters to the form
+ this->_systemParameters.renderHtml(dataArrived, webRequestWrapper);
+ this->_customParameterGroups.renderHtml(dataArrived, webRequestWrapper);
+
+ content = htmlFormatProvider->getFormEnd();
+
+ if (this->_updatePath != nullptr)
+ {
+ String pitem = htmlFormatProvider->getUpdate();
+ pitem.replace("{u}", this->_updatePath);
+ content += pitem;
+ }
+
+ // -- Fill config version string;
+ {
+ String pitem = htmlFormatProvider->getConfigVer();
+ pitem.replace("{v}", this->_configVersion);
+ content += pitem;
+ }
+
+ content += htmlFormatProvider->getEnd();
+
+ webRequestWrapper->sendContent(content);
+ webRequestWrapper->sendContent(F(""));
+ webRequestWrapper->stop();
+ }
+ else
+ {
+ // -- Save config
+ IOTWEBCONF_DEBUG_LINE(F("Updating configuration"));
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ this->_systemParameters.debugTo(&Serial);
+ this->_customParameterGroups.debugTo(&Serial);
+ Serial.println();
+#endif
+ this->_systemParameters.update(webRequestWrapper);
+ this->_customParameterGroups.update(webRequestWrapper);
+
+ this->saveConfig();
+
+ String page = htmlFormatProvider->getHead();
+ page.replace("{v}", "Config ESP");
+ page += htmlFormatProvider->getScript();
+ page += htmlFormatProvider->getStyle();
+// page += _customHeadElement;
+ page += htmlFormatProvider->getHeadExtension();
+ page += htmlFormatProvider->getHeadEnd();
+ page += "Configuration saved. ";
+ if (this->_apPassword[0] == '\0')
+ {
+ page += F("You must change the default AP password to continue. Return "
+ "to <a href=''>configuration page</a>.");
+ }
+ else if (this->_wifiParameters._wifiSsid[0] == '\0')
+ {
+ page += F("You must provide the local wifi settings to continue. Return "
+ "to <a href=''>configuration page</a>.");
+ }
+ else if (this->_state == NotConfigured)
+ {
+ page += F("Please disconnect from WiFi AP to continue!");
+ }
+ else
+ {
+ page += F("Return to <a href='/'>home page</a>.");
+ }
+ page += htmlFormatProvider->getEnd();
+
+ webRequestWrapper->sendHeader("Content-Length", String(page.length()));
+ webRequestWrapper->send(200, "text/html; charset=UTF-8", page);
+ }
+}
+
+bool IotWebConf::validateForm(WebRequestWrapper* webRequestWrapper)
+{
+ // -- Clean previous error messages.
+ this->_systemParameters.clearErrorMessage();
+ this->_customParameterGroups.clearErrorMessage();
+
+ // -- Call external validator.
+ bool valid = true;
+ if (this->_formValidator != nullptr)
+ {
+ valid = this->_formValidator(webRequestWrapper);
+ }
+
+ // -- Internal validation.
+ int l = webRequestWrapper->arg(this->_thingNameParameter.getId()).length();
+ if (3 > l)
+ {
+ this->_thingNameParameter.errorMessage =
+ "Give a name with at least 3 characters.";
+ valid = false;
+ }
+ l = webRequestWrapper->arg(this->_apPasswordParameter.getId()).length();
+ if ((0 < l) && (l < 8))
+ {
+ this->_apPasswordParameter.errorMessage =
+ "Password length must be at least 8 characters.";
+ valid = false;
+ }
+ l = webRequestWrapper->arg(this->_wifiParameters.wifiPasswordParameter.getId()).length();
+ if ((0 < l) && (l < 8))
+ {
+ this->_wifiParameters.wifiPasswordParameter.errorMessage =
+ "Password length must be at least 8 characters.";
+ valid = false;
+ }
+
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(F("Form validation result is: "));
+ Serial.println(valid ? "positive" : "negative");
+#endif
+
+ return valid;
+}
+
+void IotWebConf::handleNotFound(WebRequestWrapper* webRequestWrapper)
+{
+ if (this->handleCaptivePortal(webRequestWrapper))
+ {
+ // If captive portal redirect instead of displaying the error page.
+ return;
+ }
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(F("Requested a non-existing page '"));
+ Serial.print(webRequestWrapper->uri());
+ Serial.println("'");
+#endif
+ String message = "Requested a non-existing page\n\n";
+ message += "URI: ";
+ message += webRequestWrapper->uri();
+ message += "\n";
+
+ webRequestWrapper->sendHeader(
+ "Cache-Control", "no-cache, no-store, must-revalidate");
+ webRequestWrapper->sendHeader("Pragma", "no-cache");
+ webRequestWrapper->sendHeader("Expires", "-1");
+ webRequestWrapper->sendHeader("Content-Length", String(message.length()));
+ webRequestWrapper->send(404, "text/plain", message);
+}
+
+/**
+ * Redirect to captive portal if we got a request for another domain.
+ * Return true in that case so the page handler do not try to handle the request
+ * again. (Code from WifiManager project.)
+ */
+bool IotWebConf::handleCaptivePortal(WebRequestWrapper* webRequestWrapper)
+{
+ String host = webRequestWrapper->hostHeader();
+ String thingName = String(this->_thingName);
+ thingName.toLowerCase();
+ if (!isIp(host) && !host.startsWith(thingName))
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("Request for ");
+ Serial.print(host);
+ Serial.print(" redirected to ");
+ Serial.print(webRequestWrapper->localIP());
+ Serial.print(":");
+ Serial.println(webRequestWrapper->localPort());
+#endif
+ webRequestWrapper->sendHeader(
+ "Location", String("http://") + toStringIp(webRequestWrapper->localIP()) + ":" + webRequestWrapper->localPort(), true);
+ webRequestWrapper->send(302, "text/plain", ""); // Empty content inhibits Content-length header so we have to close the socket ourselves.
+ webRequestWrapper->stop(); // Stop is needed because we sent no content length
+ return true;
+ }
+ return false;
+}
+
+/** Is this an IP? */
+bool IotWebConf::isIp(String str)
+{
+ for (size_t i = 0; i < str.length(); i++)
+ {
+ int c = str.charAt(i);
+ if (c != '.' && c != ':' && (c < '0' || c > '9'))
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+/** IP to String? */
+String IotWebConf::toStringIp(IPAddress ip)
+{
+ String res = "";
+ for (int i = 0; i < 3; i++)
+ {
+ res += String((ip >> (8 * i)) & 0xFF) + ".";
+ }
+ res += String(((ip >> 8 * 3)) & 0xFF);
+ return res;
+}
+
+/////////////////////////////////////////////////////////////////////////////////
+
+void IotWebConf::delay(unsigned long m)
+{
+ unsigned long delayStart = millis();
+ while (m > millis() - delayStart)
+ {
+ this->doLoop();
+ // -- Note: 1ms might not be enough to perform a full yield. So
+ // 'yield' in 'doLoop' is eventually a good idea.
+ delayMicroseconds(1000);
+ }
+}
+
+void IotWebConf::doLoop()
+{
+ doBlink();
+ yield(); // -- Yield should not be necessary, but cannot hurt either.
+ if (this->_state == Boot)
+ {
+ // -- After boot, fall immediately to AP mode.
+ NetworkState startupState = ApMode;
+ if (this->_startupOffLine)
+ {
+ startupState = OffLine;
+ }
+ else if (this->_skipApStartup)
+ {
+ if (mustStayInApMode())
+ {
+ IOTWEBCONF_DEBUG_LINE(
+ F("SkipApStartup is requested, but either no WiFi was set up, or "
+ "configButton was pressed."));
+ }
+ else
+ {
+ // -- Startup state can be WiFi, if it is requested and also possible.
+ IOTWEBCONF_DEBUG_LINE(F("SkipApStartup mode was applied"));
+ startupState = Connecting;
+ }
+ }
+ this->changeState(startupState);
+ }
+ else if (
+ (this->_state == NotConfigured) ||
+ (this->_state == ApMode))
+ {
+ // -- We must only leave the AP mode, when no slaves are connected.
+ // -- Other than that AP mode has a timeout. E.g. after boot, or when retry
+ // connecting to WiFi
+ checkConnection();
+ checkApTimeout();
+ this->_dnsServer->processNextRequest();
+ this->_webServerWrapper->handleClient();
+ }
+ else if (this->_state == Connecting)
+ {
+ if (checkWifiConnection())
+ {
+ this->changeState(OnLine);
+ return;
+ }
+ }
+ else if (this->_state == OnLine)
+ {
+ // -- In server mode we provide web interface. And check whether it is time
+ // to run the client.
+ this->_webServerWrapper->handleClient();
+ if (WiFi.status() != WL_CONNECTED)
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Not connected. Try reconnect..."));
+ this->changeState(Connecting);
+ return;
+ }
+ }
+}
+
+/**
+ * What happens, when a state changed...
+ */
+void IotWebConf::changeState(NetworkState newState)
+{
+ switch (newState)
+ {
+ case ApMode:
+ {
+ // -- In AP mode we must override the default AP password. Otherwise we stay
+ // in STATE_NOT_CONFIGURED.
+ if (mustUseDefaultPassword())
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ if (this->_forceDefaultPassword)
+ {
+ Serial.println("AP mode forced by reset pin");
+ }
+ else
+ {
+ Serial.println("AP password was not set in configuration");
+ }
+#endif
+ newState = NotConfigured;
+ }
+ break;
+ }
+ default:
+ break;
+ }
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("State changing from: ");
+ Serial.print(this->_state);
+ Serial.print(" to ");
+ Serial.println(newState);
+#endif
+ NetworkState oldState = this->_state;
+ this->_state = newState;
+ this->stateChanged(oldState, newState);
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("State changed from: ");
+ Serial.print(oldState);
+ Serial.print(" to ");
+ Serial.println(newState);
+#endif
+}
+
+/**
+ * What happens, when a state changed...
+ */
+void IotWebConf::stateChanged(NetworkState oldState, NetworkState newState)
+{
+// updateOutput();
+ switch (newState)
+ {
+ case OffLine:
+ WiFi.disconnect(true);
+ WiFi.mode(WIFI_OFF);
+ this->blinkInternal(22000, 6);
+ break;
+ case ApMode:
+ case NotConfigured:
+ if (newState == ApMode)
+ {
+ this->blinkInternal(300, 90);
+ }
+ else
+ {
+ this->blinkInternal(300, 50);
+ }
+ if ((oldState == Connecting) ||
+ (oldState == OnLine))
+ {
+ WiFi.disconnect(true);
+ }
+ setupAp();
+ if (this->_updateServerSetupFunction != nullptr)
+ {
+ this->_updateServerSetupFunction(this->_updatePath);
+ }
+ this->_webServerWrapper->begin();
+ this->_apConnectionState = NoConnections;
+ this->_apStartTimeMs = millis();
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ if (mustStayInApMode())
+ {
+ if (this->_forceDefaultPassword)
+ {
+ Serial.println(F("Default password was forced."));
+ }
+ if (this->_apPassword[0] == '\0')
+ {
+ Serial.println(F("AP password was not set."));
+ }
+ if (this->_wifiParameters._wifiSsid[0] == '\0')
+ {
+ Serial.println(F("WiFi SSID was not set."));
+ }
+ if (this->_forceApMode)
+ {
+ Serial.println(F("AP was forced."));
+ }
+ Serial.println(F("Will stay in AP mode."));
+ }
+ else
+ {
+ Serial.print(F("AP timeout (ms): "));
+ Serial.println(this->_apTimeoutMs);
+ }
+#endif
+ break;
+ case Connecting:
+ if ((oldState == ApMode) ||
+ (oldState == NotConfigured))
+ {
+ stopAp();
+ }
+ if ((oldState == Boot) && (this->_updateServerSetupFunction != nullptr))
+ {
+ // We've skipped AP mode, so update server needs to be set up now.
+ this->_updateServerSetupFunction(this->_updatePath);
+ }
+ this->blinkInternal(1000, 50);
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("Connecting to [");
+ Serial.print(this->_wifiAuthInfo.ssid);
+# ifdef IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ Serial.print("] with password [");
+ Serial.print(this->_wifiAuthInfo.password);
+ Serial.println("]");
+# else
+ Serial.println(F("] (password is hidden)"));
+# endif
+ Serial.print(F("WiFi timeout (ms): "));
+ Serial.println(this->_wifiConnectionTimeoutMs);
+#endif
+ this->_wifiConnectionStart = millis();
+ WiFi.mode(WIFI_STA);
+ this->_wifiConnectionHandler(
+ this->_wifiAuthInfo.ssid, this->_wifiAuthInfo.password);
+ break;
+ case OnLine:
+ this->blinkInternal(8000, 2);
+ if (this->_updateServerUpdateCredentialsFunction != nullptr)
+ {
+ this->_updateServerUpdateCredentialsFunction(
+ IOTWEBCONF_ADMIN_USER_NAME, this->_apPassword);
+ }
+ this->_webServerWrapper->begin();
+ IOTWEBCONF_DEBUG_LINE(F("Accepting connection"));
+ if (this->_wifiConnectionCallback != nullptr)
+ {
+ this->_wifiConnectionCallback();
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+void IotWebConf::checkApTimeout()
+{
+ if ( !mustStayInApMode() )
+ {
+ // -- Only move on, when we have a valid WifF and AP configured.
+ if ((this->_apConnectionState == Disconnected) ||
+ (((millis() - this->_apStartTimeMs) > this->_apTimeoutMs) &&
+ (this->_apConnectionState != HasConnection)))
+ {
+ this->changeState(Connecting);
+ }
+ }
+}
+
+void IotWebConf::goOnLine(bool apMode)
+{
+ if (this->_state != OffLine)
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Requested OnLine mode, but was not offline."));
+ return;
+ }
+ if (apMode || mustStayInApMode())
+ {
+ this->changeState(ApMode);
+ }
+ else
+ {
+ this->changeState(Connecting);
+ }
+}
+
+/**
+ * Checks whether we have anyone joined to our AP.
+ * If so, we must not change state. But when our guest leaved, we can
+ * immediately move on.
+ */
+void IotWebConf::checkConnection()
+{
+ if ((this->_apConnectionState == NoConnections) &&
+ (WiFi.softAPgetStationNum() > 0))
+ {
+ this->_apConnectionState = HasConnection;
+ IOTWEBCONF_DEBUG_LINE(F("Connection to AP."));
+ }
+ else if (
+ (this->_apConnectionState == HasConnection) &&
+ (WiFi.softAPgetStationNum() == 0))
+ {
+ this->_apConnectionState = Disconnected;
+ IOTWEBCONF_DEBUG_LINE(F("Disconnected from AP."));
+ if (this->_forceDefaultPassword)
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Releasing forced AP mode."));
+ this->_forceDefaultPassword = false;
+ }
+ }
+}
+
+bool IotWebConf::checkWifiConnection()
+{
+ if (WiFi.status() != WL_CONNECTED)
+ {
+ if ((millis() - this->_wifiConnectionStart) > this->_wifiConnectionTimeoutMs)
+ {
+ // -- WiFi not available, fall back to AP mode.
+ IOTWEBCONF_DEBUG_LINE(F("Giving up."));
+ WiFi.disconnect(true);
+ WifiAuthInfo* newWifiAuthInfo = _wifiConnectionFailureHandler();
+ if (newWifiAuthInfo != nullptr)
+ {
+ // -- Try connecting with another connection info.
+ this->_wifiAuthInfo.ssid = newWifiAuthInfo->ssid;
+ this->_wifiAuthInfo.password = newWifiAuthInfo->password;
+ this->changeState(Connecting);
+ }
+ else
+ {
+ this->changeState(ApMode);
+ }
+ }
+ return false;
+ }
+
+ // -- Connected
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.println("WiFi connected");
+ Serial.print("IP address: ");
+ Serial.println(WiFi.localIP());
+#endif
+
+ return true;
+}
+
+void IotWebConf::setupAp()
+{
+ WiFi.mode(WIFI_AP);
+
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("Setting up AP: ");
+ Serial.println(this->_thingName);
+#endif
+ if (this->_state == NotConfigured)
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("With default password: ");
+# ifdef IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ Serial.println(this->_initialApPassword);
+# else
+ Serial.println(F("<hidden>"));
+# endif
+#endif
+ this->_apConnectionHandler(this->_thingName, this->_initialApPassword);
+ }
+ else
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print("Use password: ");
+# ifdef IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ Serial.println(this->_apPassword);
+# else
+ Serial.println(F("<hidden>"));
+# endif
+#endif
+ this->_apConnectionHandler(this->_thingName, this->_apPassword);
+ }
+
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(F("AP IP address: "));
+ Serial.println(WiFi.softAPIP());
+#endif
+ // delay(500); // Without delay I've seen the IP address blank
+ // Serial.print(F("AP IP address: "));
+ // Serial.println(WiFi.softAPIP());
+
+ /* Setup the DNS server redirecting all the domains to the apIP */
+ this->_dnsServer->setErrorReplyCode(DNSReplyCode::NoError);
+ this->_dnsServer->start(IOTWEBCONF_DNS_PORT, "*", WiFi.softAPIP());
+}
+
+void IotWebConf::stopAp()
+{
+ WiFi.softAPdisconnect(true);
+ WiFi.mode(WIFI_OFF);
+}
+
+////////////////////////////////////////////////////////////////////
+
+void IotWebConf::blink(unsigned long repeatMs, byte dutyCyclePercent)
+{
+ if (repeatMs == 0)
+ {
+ this->stopCustomBlink();
+ }
+ else
+ {
+ this->_blinkOnMs = repeatMs * dutyCyclePercent / 100;
+ this->_blinkOffMs = repeatMs * (100 - dutyCyclePercent) / 100;
+ }
+}
+
+void IotWebConf::fineBlink(unsigned long onMs, unsigned long offMs)
+{
+ this->_blinkOnMs = onMs;
+ this->_blinkOffMs = offMs;
+}
+
+void IotWebConf::stopCustomBlink()
+{
+ this->_blinkOnMs = this->_internalBlinkOnMs;
+ this->_blinkOffMs = this->_internalBlinkOffMs;
+}
+
+void IotWebConf::blinkInternal(unsigned long repeatMs, byte dutyCyclePercent)
+{
+ this->blink(repeatMs, dutyCyclePercent);
+ this->_internalBlinkOnMs = this->_blinkOnMs;
+ this->_internalBlinkOffMs = this->_blinkOffMs;
+}
+
+void IotWebConf::doBlink()
+{
+ if (IOTWEBCONF_STATUS_ENABLED)
+ {
+ unsigned long now = millis();
+ unsigned long delayMs =
+ this->_blinkStateOn ? this->_blinkOnMs : this->_blinkOffMs;
+ if (delayMs < now - this->_lastBlinkTime)
+ {
+ this->_blinkStateOn = !this->_blinkStateOn;
+ this->_lastBlinkTime = now;
+ digitalWrite(this->_statusPin, this->_blinkStateOn ? this->_statusOnLevel : !this->_statusOnLevel);
+ }
+ }
+}
+
+void IotWebConf::forceApMode(bool doForce)
+{
+ if (this->_forceApMode == doForce)
+ {
+ // Already in the requested mode;
+ return;
+ }
+
+ this->_forceApMode = doForce;
+ if (doForce)
+ {
+ if (this->_state != ApMode)
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Start forcing AP mode"));
+ this->changeState(ApMode);
+ }
+ }
+ else
+ {
+ if (this->_state == ApMode)
+ {
+ if (this->mustStayInApMode())
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Requested stopping to force AP mode, but we cannot leave the AP mode now."));
+ }
+ else
+ {
+ IOTWEBCONF_DEBUG_LINE(F("Stopping AP mode force."));
+ this->changeState(Connecting);
+ }
+ }
+ }
+}
+
+bool IotWebConf::connectAp(const char* apName, const char* password)
+{
+ return WiFi.softAP(apName, password);
+}
+void IotWebConf::connectWifi(const char* ssid, const char* password)
+{
+ WiFi.begin(ssid, password);
+}
+WifiAuthInfo* IotWebConf::handleConnectWifiFailure()
+{
+ return nullptr;
+}
+
+} // end namespace
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConf.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConf.h
new file mode 100644
index 0000000..ae7739c
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConf.h
@@ -0,0 +1,662 @@
+/**
+ * IotWebConf.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConf_h
+#define IotWebConf_h
+
+#include <Arduino.h>
+#include <IotWebConfParameter.h>
+#include <IotWebConfSettings.h>
+#include <IotWebConfWebServerWrapper.h>
+
+#ifdef ESP8266
+# include <ESP8266WiFi.h>
+# include <ESP8266WebServer.h>
+#elif defined(ESP32)
+# include <WiFi.h>
+# include <WebServer.h>
+#endif
+#include <DNSServer.h> // -- For captive portal
+
+#ifdef ESP8266
+# ifndef WebServer
+# define WebServer ESP8266WebServer
+# endif
+#endif
+
+// -- HTML page fragments
+const char IOTWEBCONF_HTML_HEAD[] PROGMEM = "<!DOCTYPE html><html lang=\"en\"><head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1, user-scalable=no\"/><title>{v}</title>\n";
+const char IOTWEBCONF_HTML_STYLE_INNER[] PROGMEM = ".de{background-color:#ffaaaa;} .em{font-size:0.8em;color:#bb0000;padding-bottom:0px;} .c{text-align: center;} div,input,select{padding:5px;font-size:1em;} input{width:95%;} select{width:100%} input[type=checkbox]{width:auto;scale:1.5;margin:10px;} body{text-align: center;font-family:verdana;} button{border:0;border-radius:0.3rem;background-color:#16A1E7;color:#fff;line-height:2.4rem;font-size:1.2rem;width:100%;} fieldset{border-radius:0.3rem;margin: 0px;}\n";
+const char IOTWEBCONF_HTML_SCRIPT_INNER[] PROGMEM = "function c(l){document.getElementById('s').value=l.innerText||l.textContent;document.getElementById('p').focus();}; function pw(id) { var x=document.getElementById(id); if(x.type==='password') {x.type='text';} else {x.type='password';} };";
+const char IOTWEBCONF_HTML_HEAD_END[] PROGMEM = "</head><body>";
+const char IOTWEBCONF_HTML_BODY_INNER[] PROGMEM = "<div style='text-align:left;display:inline-block;min-width:260px;'>\n";
+const char IOTWEBCONF_HTML_FORM_START[] PROGMEM = "<form action='' method='post'><input type='hidden' name='iotSave' value='true'>\n";
+const char IOTWEBCONF_HTML_FORM_END[] PROGMEM = "<button type='submit' style='margin-top: 10px;'>Apply</button></form>\n";
+const char IOTWEBCONF_HTML_SAVED[] PROGMEM = "<div>Configuration saved<br />Return to <a href='/'>home page</a>.</div>\n";
+const char IOTWEBCONF_HTML_END[] PROGMEM = "</div></body></html>";
+const char IOTWEBCONF_HTML_UPDATE[] PROGMEM = "<div style='padding-top:25px;'><a href='{u}'>Firmware update</a></div>\n";
+const char IOTWEBCONF_HTML_CONFIG_VER[] PROGMEM = "<div style='font-size: .6em;'>Firmware config version '{v}'</div>\n";
+
+// -- User name on login.
+#define IOTWEBCONF_ADMIN_USER_NAME "admin"
+
+namespace iotwebconf
+{
+
+// -- AP connection state
+enum ApConnectionState
+{
+ NoConnections, // -- No connection on AP.
+ HasConnection, // -- Has connection on AP.
+ Disconnected // -- All previous connection on AP was disconnected.
+};
+
+enum NetworkState
+{
+ Boot,
+ NotConfigured,
+ ApMode,
+ Connecting,
+ OnLine,
+ OffLine
+};
+
+class IotWebConf;
+
+typedef struct WifiAuthInfo
+{
+ const char* ssid;
+ const char* password;
+} WifiAuthInfo;
+
+/**
+ * Class for providing HTML format segments.
+ */
+class HtmlFormatProvider
+{
+public:
+ virtual String getHead() { return FPSTR(IOTWEBCONF_HTML_HEAD); }
+ virtual String getStyle() { return "<style>" + getStyleInner() + "</style>"; }
+ virtual String getScript() { return "<script>" + getScriptInner() + "</script>"; }
+ virtual String getHeadExtension() { return ""; }
+ virtual String getHeadEnd() { return String(FPSTR(IOTWEBCONF_HTML_HEAD_END)) + getBodyInner(); }
+ virtual String getFormStart() { return FPSTR(IOTWEBCONF_HTML_FORM_START); }
+ virtual String getFormEnd() { return FPSTR(IOTWEBCONF_HTML_FORM_END); }
+ virtual String getFormSaved() { return FPSTR(IOTWEBCONF_HTML_SAVED); }
+ virtual String getEnd() { return FPSTR(IOTWEBCONF_HTML_END); }
+ virtual String getUpdate() { return FPSTR(IOTWEBCONF_HTML_UPDATE); }
+ virtual String getConfigVer() { return FPSTR(IOTWEBCONF_HTML_CONFIG_VER); }
+protected:
+ virtual String getStyleInner() { return FPSTR(IOTWEBCONF_HTML_STYLE_INNER); }
+ virtual String getScriptInner() { return FPSTR(IOTWEBCONF_HTML_SCRIPT_INNER); }
+ virtual String getBodyInner() { return FPSTR(IOTWEBCONF_HTML_BODY_INNER); }
+};
+
+class StandardWebRequestWrapper : public WebRequestWrapper
+{
+public:
+ StandardWebRequestWrapper(WebServer* server) { this->_server = server; };
+
+ const String hostHeader() const override { return this->_server->hostHeader(); };
+ IPAddress localIP() override { return this->_server->client().localIP(); };
+ uint16_t localPort() override { return this->_server->client().localPort(); };
+ const String uri() const { return this->_server->uri(); };
+ bool authenticate(const char * username, const char * password) override
+ { return this->_server->authenticate(username, password); };
+ void requestAuthentication() override
+ { this->_server->requestAuthentication(); };
+ bool hasArg(const String& name) override { return this->_server->hasArg(name); };
+ String arg(const String name) override { return this->_server->arg(name); };
+ void sendHeader(const String& name, const String& value, bool first = false) override
+ { this->_server->sendHeader(name, value, first); };
+ void setContentLength(const size_t contentLength) override
+ { this->_server->setContentLength(contentLength); };
+ void send(int code, const char* content_type = nullptr, const String& content = String("")) override
+ { this->_server->send(code, content_type, content); };
+ void sendContent(const String& content) override { this->_server->sendContent(content); };
+ void stop() override { this->_server->client().stop(); };
+
+private:
+ WebServer* _server;
+ friend IotWebConf;
+};
+
+class StandardWebServerWrapper : public WebServerWrapper
+{
+public:
+ StandardWebServerWrapper(WebServer* server) { this->_server = server; };
+
+ void handleClient() override { this->_server->handleClient(); };
+ void begin() override { this->_server->begin(); };
+
+private:
+ StandardWebServerWrapper() { };
+ WebServer* _server;
+ friend IotWebConf;
+};
+
+class WifiParameterGroup : public ParameterGroup
+{
+public:
+ WifiParameterGroup(const char* id, const char* label = nullptr) : ParameterGroup(id, label)
+ {
+ this->addItem(&this->wifiSsidParameter);
+ this->addItem(&this->wifiPasswordParameter);
+ }
+ TextParameter wifiSsidParameter =
+ TextParameter("WiFi SSID", "iwcWifiSsid", this->_wifiSsid, IOTWEBCONF_WORD_LEN);
+ PasswordParameter wifiPasswordParameter =
+ PasswordParameter("WiFi password", "iwcWifiPassword", this->_wifiPassword, IOTWEBCONF_PASSWORD_LEN);
+ char _wifiSsid[IOTWEBCONF_WORD_LEN];
+ char _wifiPassword[IOTWEBCONF_PASSWORD_LEN];
+};
+
+/**
+ * Main class of the module.
+ */
+class IotWebConf
+{
+public:
+ /**
+ * Create a new configuration handler.
+ * @thingName - Initial value for the thing name. Used in many places like AP name, can be changed by the user.
+ * @dnsServer - A created DNSServer, that can be configured for captive portal.
+ * @server - A created web server. Will be started upon connection success.
+ * @initialApPassword - Initial value for AP mode. Can be changed by the user.
+ * @configVersion - When the software is updated and the configuration is changing, this key should also be changed,
+ * so that the config portal will force the user to reenter all the configuration values.
+ */
+ IotWebConf(
+ const char* thingName, DNSServer* dnsServer, WebServer* server,
+ const char* initialApPassword, const char* configVersion = "init") :
+ IotWebConf(thingName, dnsServer, &this->_standardWebServerWrapper, initialApPassword, configVersion)
+ {
+ this->_standardWebServerWrapper._server = server;
+ }
+
+ IotWebConf(
+ const char* thingName, DNSServer* dnsServer, WebServerWrapper* server,
+ const char* initialApPassword, const char* configVersion = "init");
+
+ /**
+ * Provide an Arduino pin here, that has a button connected to it with the other end of the pin is connected to GND.
+ * The button pin is queried at for input on boot time (init time).
+ * If the button was pressed, the thing will enter AP mode with the initial password.
+ * Must be called before init()!
+ * @configPin - An Arduino pin. Will be configured as INPUT_PULLUP!
+ */
+ void setConfigPin(int configPin);
+
+ /**
+ * Provide an Arduino pin for status indicator (LOW = on). Blink codes:
+ * - Rapid blinks - The thing is in AP mode with default password.
+ * - Rapid blinks, but mostly on - AP mode, waiting for configuration changes.
+ * - Normal blinks - Connecting to WiFi.
+ * - Mostly off with rare rapid blinks - WiFi is connected performing normal operation.
+ * User can also apply custom blinks. See blink() method!
+ * Must be called before init()!
+ * @statusPin - An Arduino pin. Will be configured as OUTPUT!
+ * @statusOnLevel - Logic level of the On state of the status pin. Default is LOW.
+ */
+ void setStatusPin(int statusPin, int statusOnLevel = LOW);
+
+ /**
+ * Add an UpdateServer instance to the system. The firmware update link will appear on the config portal.
+ * The UpdateServer will be added to the WebServer with the path provided here (or with "firmware",
+ * if none was provided).
+ * Login user will be IOTWEBCONF_ADMIN_USER_NAME, password is the password provided in the config portal.
+ * Should be called before init()!
+ * @updateServer - An uninitialized UpdateServer instance.
+ * @updatePath - (Optional) The path to set up the UpdateServer with. Will be also used in the config portal.
+ */
+ void setupUpdateServer(
+ std::function<void(const char* _updatePath)> setup,
+ std::function<void(const char* userName, char* password)> updateCredentials,
+ const char* updatePath = "/firmware")
+ {
+ this->_updateServerSetupFunction = setup;
+ this->_updateServerUpdateCredentialsFunction = updateCredentials;
+ this->_updatePath = updatePath;
+ }
+
+ /**
+ * Start up the IotWebConf module.
+ * Loads all configuration from the EEPROM, and initialize the system.
+ * Will return false, if no configuration (with specified config version) was found in the EEPROM.
+ */
+ bool init();
+
+ /**
+ * IotWebConf is a non-blocking, state controlled system. Therefor it should be
+ * regularly triggered from the user code.
+ * So call this method any time you can.
+ */
+ void doLoop();
+
+ /**
+ * Each WebServer URL handler method should start with calling this method.
+ * If this method return true, the request was already served by it.
+ */
+ bool handleCaptivePortal(WebRequestWrapper* webRequestWrapper);
+ bool handleCaptivePortal()
+ {
+ StandardWebRequestWrapper webRequestWrapper = StandardWebRequestWrapper(this->_standardWebServerWrapper._server);
+ return handleCaptivePortal(&webRequestWrapper);
+ }
+
+ /**
+ * Config URL web request handler. Call this method to handle config request.
+ */
+ void handleConfig(WebRequestWrapper* webRequestWrapper);
+ void handleConfig()
+ {
+ StandardWebRequestWrapper webRequestWrapper = StandardWebRequestWrapper(this->_standardWebServerWrapper._server);
+ handleConfig(&webRequestWrapper);
+ }
+
+ /**
+ * URL-not-found web request handler. Used for handling captive portal request.
+ */
+ void handleNotFound(WebRequestWrapper* webRequestWrapper);
+ void handleNotFound()
+ {
+ StandardWebRequestWrapper webRequestWrapper = StandardWebRequestWrapper(this->_standardWebServerWrapper._server);
+ handleNotFound(&webRequestWrapper);
+ }
+
+ /**
+ * Specify a callback method, that will be called upon WiFi connection success.
+ * Should be called before init()!
+ */
+ void setWifiConnectionCallback(std::function<void()> func);
+
+ /**
+ * Specify a callback method, that will be called when settings is being changed.
+ * This is very handy if you have other routines, that are modifying the "EEPROM"
+ * parallel to IotWebConf, now this is the time to disable these routines.
+ * Should be called before init()!
+ */
+ void setConfigSavingCallback(std::function<void(int size)> func);
+
+ /**
+ * Specify a callback method, that will be called when settings have been changed.
+ * All pending EEPROM manipulations are done by the time this method is called.
+ * Should be called before init()!
+ */
+ void setConfigSavedCallback(std::function<void()> func);
+
+ /**
+ * Specify a callback method, that will be called when form validation is required.
+ * If the method will return false, the configuration will not be saved.
+ * Should be called before init()!
+ */
+ void setFormValidator(std::function<bool(WebRequestWrapper* webRequestWrapper)> func);
+
+ /**
+ * Specify your custom Access Point connection handler. Please use IotWebConf::connectAp() as
+ * reference when implementing your custom solution.
+ */
+ void setApConnectionHandler(
+ std::function<bool(const char* apName, const char* password)> func)
+ {
+ _apConnectionHandler = func;
+ }
+
+ /**
+ * Specify your custom WiFi connection handler. Please use IotWebConf::connectWifi() as
+ * reference when implementing your custom solution.
+ * Your method will be called when IotWebConf trying to establish
+ * connection to a WiFi network.
+ */
+ void setWifiConnectionHandler(
+ std::function<void(const char* ssid, const char* password)> func)
+ {
+ _wifiConnectionHandler = func;
+ }
+
+ /**
+ * With this method you can specify your custom WiFi timeout handler.
+ * This handler can manage what should happen, when WiFi connection timed out.
+ * By default the handler implementation returns with nullptr, as seen on reference implementation
+ * IotWebConf::handleConnectWifiFailure(). This means we need to fall back to AP mode.
+ * If it method returns with a (new) WiFi settings, it is used as a next try.
+ * Note, that in case once you have returned with nullptr, you might also want to
+ * resetWifiAuthInfo(), that sets the auth info used for the next time to the
+ * one set up in the admin portal.
+ * Note, that this feature is provided because of the option of providing multiple
+ * WiFi settings utilized by the MultipleWifiAddition class. (See IotWebConfMultipleWifi.h)
+ */
+ void setWifiConnectionFailedHandler( std::function<WifiAuthInfo*()> func )
+ {
+ _wifiConnectionFailureHandler = func;
+ }
+
+ /**
+ * Add a custom parameter group, that will be handled by the IotWebConf module.
+ * The parameters in this group will be saved to/loaded from EEPROM automatically,
+ * and will appear on the config portal.
+ * Must be called before init()!
+ */
+ void addParameterGroup(ParameterGroup* group);
+
+ /**
+ * Add a custom parameter group, that will be handled by the IotWebConf module.
+ * The parameters in this group will be saved to/loaded from EEPROM automatically,
+ * but will NOT appear on the config portal.
+ * Must be called before init()!
+ */
+ void addHiddenParameter(ConfigItem* parameter);
+
+ /**
+ * Add a custom parameter group, that will be handled by the IotWebConf module.
+ * The parameters in this group will be saved to/loaded from EEPROM automatically,
+ * but will NOT appear on the config portal.
+ * Must be called before init()!
+ */
+ void addSystemParameter(ConfigItem* parameter);
+
+ /**
+ * Getter for the actually configured thing name.
+ */
+ char* getThingName();
+
+ /**
+ * Use this delay, to prevent blocking IotWebConf.
+ */
+ void delay(unsigned long millis);
+
+ /**
+ * IotWebConf tries to connect to the local network for an amount of time before falling back to AP mode.
+ * The default amount can be updated with this setter.
+ * Should be called before init()!
+ */
+ void setWifiConnectionTimeoutMs(unsigned long millis);
+
+ /**
+ * Interrupts internal blinking cycle and applies new values for
+ * blinking the status LED (if one configured with setStatusPin() prior init()
+ * ).
+ * @repeatMs - Defines the the period of one on-off cycle in milliseconds.
+ * @dutyCyclePercent - LED on/off percent. 100 means always on, 0 means
+ * always off. When called with repeatMs = 0, then internal blink cycle will
+ * be continued.
+ */
+ void blink(unsigned long repeatMs, byte dutyCyclePercent);
+
+ /**
+ * Similar to blink, but here we define exact on and off times for more
+ * precise timings.
+ * @onMs - Milliseconds for the LED turned on.
+ * @offMs - Milliseconds for the LED turned off.
+ */
+ void fineBlink(unsigned long onMs, unsigned long offMs);
+
+ /**
+ * Stop custom blinking defined by blink() or fineBlink() and continues with
+ * the internal blink cycle.
+ */
+ void stopCustomBlink();
+
+ /**
+ * Disables blinking, so allows user code to control same LED.
+ */
+ void disableBlink() { this->_blinkEnabled = false; }
+
+ /**
+ * Enables blinking if it has been disabled by disableBlink().
+ */
+ void enableBlink() { this->_blinkEnabled = true; }
+
+ /**
+ * Returns blink enabled state modified by disableBlink() and enableBlink().
+ */
+ bool isBlinkEnabled() { return this->_blinkEnabled; }
+
+ /**
+ * Return the current state.
+ */
+ NetworkState getState() { return this->_state; };
+
+ /**
+ * This method can be used to set the AP timeout directly without modifying the apTimeoutParameter.
+ * Note, that apTimeoutMs value will be reset to the value of apTimeoutParameter on init and on config save.
+ */
+ void setApTimeoutMs(unsigned long apTimeoutMs)
+ {
+ this->_apTimeoutMs = apTimeoutMs;
+ };
+
+ /**
+ * Returns the actual value of the AP timeout in use.
+ */
+ unsigned long getApTimeoutMs() { return this->_apTimeoutMs; };
+
+ /**
+ * Returns the current WiFi authentication credentials. These are usually the configured ones,
+ * but might be overwritten by setWifiConnectionFailedHandler().
+ */
+ WifiAuthInfo getWifiAuthInfo() { return _wifiAuthInfo; };
+
+ /**
+ * Resets the authentication credentials for WiFi connection to the configured one.
+ * With the return value of setWifiConnectionFailedHandler() one can provide alternative connection settings,
+ * that can be reset with resetWifiAuthInfo().
+ */
+ void resetWifiAuthInfo()
+ {
+ _wifiAuthInfo = {this->_wifiParameters._wifiSsid, this->_wifiParameters._wifiPassword};
+ };
+
+ /**
+ *
+ */
+ void startupOffLine() { this->_startupOffLine = true; }
+
+ /**
+ * By default IotWebConf starts up in AP mode. Calling this method before the init will force IotWebConf
+ * to connect immediately to the configured WiFi network.
+ * Note, this method only takes effect, when WiFi mode is enabled, thus when a valid WiFi connection is
+ * set up, and AP mode is not forced by ConfigPin (see setConfigPin() for details).
+ */
+ void skipApStartup() { this->_skipApStartup = true; }
+
+ /**
+ * By default IotWebConf will continue startup in WiFi mode, when no configuration request arrived
+ * in AP mode. With this method holding the AP mode can be forced.
+ * Further more, instant AP mode can forced even when we are currently in WiFi mode.
+ * @value - When TRUE, AP mode is forced/entered.
+ * When FALSE, AP mode is released, normal operation will continue.
+ */
+ void forceApMode(bool value);
+
+ /**
+ *
+ */
+ void goOffLine() { this->changeState(OffLine); }
+
+ /**
+ *
+ */
+ void goOnLine(bool apMode = true);
+
+ /**
+ *
+ */
+ unsigned long getApStartTimeMs() { return this->_apStartTimeMs; }
+
+ /**
+ * Get internal parameters, for manual handling.
+ * Normally you don't need to access these parameters directly.
+ * Note, that changing valueBuffer of these parameters should be followed by saveConfig()!
+ */
+ ParameterGroup* getRootParameterGroup()
+ {
+ return &this->_allParameters;
+ };
+ ParameterGroup* getSystemParameterGroup()
+ {
+ return &this->_systemParameters;
+ };
+ Parameter* getThingNameParameter()
+ {
+ return &this->_thingNameParameter;
+ };
+ Parameter* getApPasswordParameter()
+ {
+ return &this->_apPasswordParameter;
+ };
+ WifiParameterGroup* getWifiParameterGroup()
+ {
+ return &this->_wifiParameters;
+ };
+ Parameter* getWifiSsidParameter()
+ {
+ return &this->_wifiParameters.wifiSsidParameter;
+ };
+ Parameter* getWifiPasswordParameter()
+ {
+ return &this->_wifiParameters.wifiPasswordParameter;
+ };
+ Parameter* getApTimeoutParameter()
+ {
+ return &this->_apTimeoutParameter;
+ };
+
+ /**
+ * If config parameters are modified directly, the new values can be saved by this method.
+ * Note, that init() must pretend saveConfig()!
+ * Also note, that saveConfig writes to EEPROM, and EEPROM can be written only some thousand times
+ * in the lifetime of an ESP8266 module.
+ */
+ void saveConfig();
+
+ /**
+ * Loads all configuration from the EEPROM without initializing the system.
+ * Will return false, if no configuration (with specified config version) was found in the EEPROM.
+ */
+ bool loadConfig();
+
+ /**
+ * With this method you can override the default HTML format provider to
+ * provide custom HTML segments.
+ */
+ void
+ setHtmlFormatProvider(HtmlFormatProvider* customHtmlFormatProvider)
+ {
+ this->htmlFormatProvider = customHtmlFormatProvider;
+ }
+ HtmlFormatProvider* getHtmlFormatProvider()
+ {
+ return this->htmlFormatProvider;
+ }
+
+private:
+ const char* _initialApPassword = nullptr;
+ const char* _configVersion;
+ DNSServer* _dnsServer;
+ WebServerWrapper* _webServerWrapper;
+ StandardWebServerWrapper _standardWebServerWrapper = StandardWebServerWrapper();
+ std::function<void(const char* _updatePath)>
+ _updateServerSetupFunction = nullptr;
+ std::function<void(const char* userName, char* password)>
+ _updateServerUpdateCredentialsFunction = nullptr;
+ int _configPin = -1;
+ int _statusPin = -1;
+ int _statusOnLevel = LOW;
+ const char* _updatePath = nullptr;
+ bool _forceDefaultPassword = false;
+ bool _startupOffLine = false;
+ bool _skipApStartup = false;
+ bool _forceApMode = false;
+ ParameterGroup _allParameters = ParameterGroup("iwcAll");
+ ParameterGroup _systemParameters = ParameterGroup("iwcSys", "System configuration");
+ ParameterGroup _customParameterGroups = ParameterGroup("iwcCustom");
+ ParameterGroup _hiddenParameters = ParameterGroup("hidden");
+ WifiParameterGroup _wifiParameters = WifiParameterGroup("iwcWifi0");
+ TextParameter _thingNameParameter =
+ TextParameter("Thing name", "iwcThingName", this->_thingName, IOTWEBCONF_WORD_LEN);
+ PasswordParameter _apPasswordParameter =
+ PasswordParameter("AP password", "iwcApPassword", this->_apPassword, IOTWEBCONF_PASSWORD_LEN);
+ NumberParameter _apTimeoutParameter =
+ NumberParameter("Startup delay (seconds)", "iwcApTimeout", this->_apTimeoutStr, IOTWEBCONF_WORD_LEN, IOTWEBCONF_DEFAULT_AP_MODE_TIMEOUT_SECS, nullptr, "min='1' max='600'");
+ char _thingName[IOTWEBCONF_WORD_LEN];
+ char _apPassword[IOTWEBCONF_PASSWORD_LEN];
+ char _apTimeoutStr[IOTWEBCONF_WORD_LEN];
+ unsigned long _apTimeoutMs;
+ // TODO: Add to WifiParameterGroup
+ unsigned long _wifiConnectionTimeoutMs =
+ IOTWEBCONF_DEFAULT_WIFI_CONNECTION_TIMEOUT_MS;
+ NetworkState _state = Boot;
+ unsigned long _apStartTimeMs = 0;
+ ApConnectionState _apConnectionState = NoConnections;
+ std::function<void()> _wifiConnectionCallback = nullptr;
+ std::function<void(int)> _configSavingCallback = nullptr;
+ std::function<void()> _configSavedCallback = nullptr;
+ std::function<bool(WebRequestWrapper* webRequestWrapper)> _formValidator = nullptr;
+ std::function<void(const char*, const char*)> _apConnectionHandler =
+ &(IotWebConf::connectAp);
+ std::function<void(const char*, const char*)> _wifiConnectionHandler =
+ &(IotWebConf::connectWifi);
+ std::function<WifiAuthInfo*()> _wifiConnectionFailureHandler =
+ &(IotWebConf::handleConnectWifiFailure);
+ unsigned long _internalBlinkOnMs = 500;
+ unsigned long _internalBlinkOffMs = 500;
+ unsigned long _blinkOnMs = 500;
+ unsigned long _blinkOffMs = 500;
+ bool _blinkEnabled = true;
+ bool _blinkStateOn = false;
+ unsigned long _lastBlinkTime = 0;
+ unsigned long _wifiConnectionStart = 0;
+ // TODO: authinfo
+ WifiAuthInfo _wifiAuthInfo;
+ HtmlFormatProvider htmlFormatProviderInstance;
+ HtmlFormatProvider* htmlFormatProvider = &htmlFormatProviderInstance;
+
+ int initConfig();
+ bool testConfigVersion();
+ void saveConfigVersion();
+ void readEepromValue(int start, byte* valueBuffer, int length);
+ void writeEepromValue(int start, byte* valueBuffer, int length);
+
+ bool validateForm(WebRequestWrapper* webRequestWrapper);
+
+ void changeState(NetworkState newState);
+ void stateChanged(NetworkState oldState, NetworkState newState);
+ bool mustUseDefaultPassword()
+ {
+ return this->_forceDefaultPassword || (this->_apPassword[0] == '\0');
+ }
+ bool mustStayInApMode()
+ {
+ return this->_forceDefaultPassword || (this->_apPassword[0] == '\0') ||
+ (this->_wifiParameters._wifiSsid[0] == '\0') || this->_forceApMode;
+ }
+ bool isIp(String str);
+ String toStringIp(IPAddress ip);
+ void doBlink();
+ void blinkInternal(unsigned long repeatMs, byte dutyCyclePercent);
+
+ void checkApTimeout();
+ void checkConnection();
+ bool checkWifiConnection();
+ void setupAp();
+ void stopAp();
+
+ static bool connectAp(const char* apName, const char* password);
+ static void connectWifi(const char* ssid, const char* password);
+ static WifiAuthInfo* handleConnectWifiFailure();
+};
+
+} // end namespace
+
+using iotwebconf::IotWebConf;
+
+#endif
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfESP32HTTPUpdateServer.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfESP32HTTPUpdateServer.h
new file mode 100644
index 0000000..b1357bf
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfESP32HTTPUpdateServer.h
@@ -0,0 +1,169 @@
+/**
+ * IotWebConfESP32HTTPUpdateServer.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ *
+ * Notes on IotWebConfESP32HTTPUpdateServer:
+ * ESP32 doesn't implement a HTTPUpdateServer. However it seams, that to code
+ * from ESP8266 covers nearly all the same functionality.
+ * So we need to implement our own HTTPUpdateServer for ESP32, and code is
+ * reused from
+ * https://github.com/esp8266/Arduino/blob/master/libraries/ESP8266HTTPUpdateServer/src/
+ * version: 41de43a26381d7c9d29ce879dd5d7c027528371b
+ */
+#ifdef ESP32
+
+#ifndef __HTTP_UPDATE_SERVER_H
+#define __HTTP_UPDATE_SERVER_H
+
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+#include <StreamString.h>
+#include <Update.h>
+
+#define emptyString F("")
+
+class WebServer;
+
+class HTTPUpdateServer
+{
+ public:
+ HTTPUpdateServer(bool serial_debug=false)
+ {
+ _serial_output = serial_debug;
+ _server = nullptr;
+ _username = emptyString;
+ _password = emptyString;
+ _authenticated = false;
+ }
+
+
+ void setup(WebServer *server)
+ {
+ setup(server, emptyString, emptyString);
+ }
+
+ void setup(WebServer *server, const String& path)
+ {
+ setup(server, path, emptyString, emptyString);
+ }
+
+ void setup(WebServer *server, const String& username, const String& password)
+ {
+ setup(server, "/update", username, password);
+ }
+
+ void setup(WebServer *server, const String& path, const String& username, const String& password)
+ {
+ _server = server;
+ _username = username;
+ _password = password;
+
+ // handler for the /update form page
+ _server->on(path.c_str(), HTTP_GET, [&](){
+ if(_username != emptyString && _password != emptyString && !_server->authenticate(_username.c_str(), _password.c_str()))
+ return _server->requestAuthentication();
+ _server->send_P(200, PSTR("text/html"), serverIndex);
+ });
+
+ // handler for the /update form POST (once file upload finishes)
+ _server->on(path.c_str(), HTTP_POST, [&](){
+ if(!_authenticated)
+ return _server->requestAuthentication();
+ if (Update.hasError()) {
+ _server->send(200, F("text/html"), String(F("Update error: ")) + _updaterError);
+ } else {
+ _server->client().setNoDelay(true);
+ _server->send_P(200, PSTR("text/html"), successResponse);
+ delay(100);
+ _server->client().stop();
+ ESP.restart();
+ }
+ },[&](){
+ // handler for the file upload, get's the sketch bytes, and writes
+ // them through the Update object
+ HTTPUpload& upload = _server->upload();
+
+ if(upload.status == UPLOAD_FILE_START){
+ _updaterError = String();
+ if (_serial_output)
+ Serial.setDebugOutput(true);
+
+ _authenticated = (_username == emptyString || _password == emptyString || _server->authenticate(_username.c_str(), _password.c_str()));
+ if(!_authenticated){
+ if (_serial_output)
+ Serial.printf("Unauthenticated Update\n");
+ return;
+ }
+
+ /// WiFiUDP::stopAll();
+ if (_serial_output)
+ Serial.printf("Update: %s\n", upload.filename.c_str());
+ /// uint32_t maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
+ /// if(!Update.begin(maxSketchSpace)){//start with max available size
+ if(!Update.begin(UPDATE_SIZE_UNKNOWN)){//start with max available size
+ _setUpdaterError();
+ }
+ } else if(_authenticated && upload.status == UPLOAD_FILE_WRITE && !_updaterError.length()){
+ if (_serial_output) Serial.printf(".");
+ if(Update.write(upload.buf, upload.currentSize) != upload.currentSize){
+ _setUpdaterError();
+ }
+ } else if(_authenticated && upload.status == UPLOAD_FILE_END && !_updaterError.length()){
+ if(Update.end(true)){ //true to set the size to the current progress
+ if (_serial_output) Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
+ } else {
+ _setUpdaterError();
+ }
+ if (_serial_output) Serial.setDebugOutput(false);
+ } else if(_authenticated && upload.status == UPLOAD_FILE_ABORTED){
+ Update.end();
+ if (_serial_output) Serial.println("Update was aborted");
+ }
+ delay(0);
+ });
+ }
+
+ void updateCredentials(const String& username, const String& password)
+ {
+ _username = username;
+ _password = password;
+ }
+
+ protected:
+ void _setUpdaterError()
+ {
+ if (_serial_output) Update.printError(Serial);
+ StreamString str;
+ Update.printError(str);
+ _updaterError = str.c_str();
+ }
+
+ private:
+ bool _serial_output;
+ WebServer *_server;
+ String _username;
+ String _password;
+ bool _authenticated;
+ String _updaterError;
+ const char* serverIndex PROGMEM =
+R"(<html><body><form method='POST' action='' enctype='multipart/form-data'>
+ <input type='file' name='update'>
+ <input type='submit' value='Update'>
+ </form>
+ </body></html>)";
+ const char* successResponse PROGMEM =
+"<META http-equiv=\"refresh\" content=\"15;URL=/\">Update Success! Rebooting...\n";
+};
+
+/////////////////////////////////////////////////////////////////////////////////
+
+#endif
+
+#endif
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.cpp b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.cpp
new file mode 100644
index 0000000..3cc7a9a
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.cpp
@@ -0,0 +1,112 @@
+/**
+ * IotWebConfMultipleWifi.cpp -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2021 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#include "IotWebConfMultipleWifi.h"
+
+namespace iotwebconf
+{
+
+MultipleWifiAddition::MultipleWifiAddition(
+ IotWebConf* iotWebConf,
+ ChainedWifiParameterGroup sets[],
+ size_t setsSize)
+{
+ this->_iotWebConf = iotWebConf;
+ this->_firstSet = &sets[0];
+ this->_currentSet = &sets[0];
+
+ ChainedWifiParameterGroup* set = &sets[0];
+ for(size_t i=1; i<setsSize; i++)
+ {
+ set->setNext(&sets[i]);
+ set = &sets[i];
+ }
+}
+
+void MultipleWifiAddition::init()
+{
+ // -- Add parameter groups.
+ ChainedWifiParameterGroup* set = this->_firstSet;
+ while(set != nullptr)
+ {
+ this->_iotWebConf->addSystemParameter(set);
+ set = (ChainedWifiParameterGroup*)set->getNext();
+ }
+
+ // -- Add custom format provider.
+ this->_iotWebConf->setHtmlFormatProvider(
+ &this->_optionalGroupHtmlFormatProvider);
+
+ // -- Set up handler, that will selects next connection info to use.
+ this->_iotWebConf->setFormValidator([&](WebRequestWrapper* webRequestWrapper)
+ {
+ return this->formValidator(webRequestWrapper);
+ });
+
+ // -- Set up handler, that will selects next connection info to use.
+ this->_iotWebConf->setWifiConnectionFailedHandler([&]()
+ {
+ WifiAuthInfo* result;
+ while (true)
+ {
+ if (this->_currentSet == nullptr)
+ {
+ this->_currentSet = this->_firstSet;
+ this->_iotWebConf->resetWifiAuthInfo();
+ result = nullptr;
+ break;
+ }
+ else
+ {
+ if (this->_currentSet->isActive())
+ {
+ result = &this->_currentSet->wifiAuthInfo;
+ this->_currentSet =
+ (iotwebconf::ChainedWifiParameterGroup*)this->_currentSet->getNext();
+ break;
+ }
+ else
+ {
+ this->_currentSet =
+ (iotwebconf::ChainedWifiParameterGroup*)this->_currentSet->getNext();
+ }
+ }
+ }
+ return result;
+ });
+};
+
+bool MultipleWifiAddition::formValidator(
+ WebRequestWrapper* webRequestWrapper)
+{
+ ChainedWifiParameterGroup* set = this->_firstSet;
+ bool valid = true;
+
+ while(set != nullptr)
+ {
+ if (set->isActive())
+ {
+ PasswordParameter* pwdParam = &set->wifiPasswordParameter;
+ int l = webRequestWrapper->arg(pwdParam->getId()).length();
+ if ((0 < l) && (l < 8))
+ {
+ pwdParam->errorMessage = "Password length must be at least 8 characters.";
+ valid = false;
+ }
+ }
+
+ set = (ChainedWifiParameterGroup*)set->getNext();
+ }
+
+ return valid;
+};
+
+}
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.h
new file mode 100644
index 0000000..33a5b48
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfMultipleWifi.h
@@ -0,0 +1,74 @@
+/**
+ * IotWebConfMultipleWifi.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2021 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConfMultipleWifi_h
+#define IotWebConfMultipleWifi_h
+
+#include "IotWebConfOptionalGroup.h"
+#include "IotWebConf.h" // for WebRequestWrapper
+
+namespace iotwebconf
+{
+
+class ChainedWifiParameterGroup : public ChainedParameterGroup
+{
+public:
+ ChainedWifiParameterGroup(const char* id) : ChainedParameterGroup(id, "WiFi connection")
+ {
+ // -- Update parameter Ids to have unique ID for all parameters within the application.
+ snprintf(this->_wifiSsidParameterId, IOTWEBCONF_WORD_LEN, "%s-ssid", this->getId());
+ snprintf(this->_wifiPasswordParameterId, IOTWEBCONF_WORD_LEN, "%s-pwd", this->getId());
+
+ this->addItem(&this->wifiSsidParameter);
+ this->addItem(&this->wifiPasswordParameter);
+ }
+ TextParameter wifiSsidParameter =
+ TextParameter("WiFi SSID", this->_wifiSsidParameterId, this->wifiSsid, IOTWEBCONF_WORD_LEN);
+ PasswordParameter wifiPasswordParameter =
+ PasswordParameter("WiFi password", this->_wifiPasswordParameterId, this->wifiPassword, IOTWEBCONF_PASSWORD_LEN);
+ char wifiSsid[IOTWEBCONF_WORD_LEN];
+ char wifiPassword[IOTWEBCONF_PASSWORD_LEN];
+ WifiAuthInfo wifiAuthInfo = { wifiSsid, wifiPassword};
+protected:
+
+private:
+ char _wifiSsidParameterId[IOTWEBCONF_WORD_LEN];
+ char _wifiPasswordParameterId[IOTWEBCONF_WORD_LEN];
+};
+
+class MultipleWifiAddition
+{
+public:
+ MultipleWifiAddition(
+ IotWebConf* iotWebConf,
+ ChainedWifiParameterGroup sets[],
+ size_t setsSize);
+ /**
+ * Note, that init() calls setFormValidator, that overwrites existing
+ * formValidator setup. Thus your setFormValidator should be called
+ * _after_ multipleWifiAddition.init() .
+ */
+ virtual void init();
+
+ virtual bool formValidator(
+ WebRequestWrapper* webRequestWrapper);
+
+protected:
+ IotWebConf* _iotWebConf;
+ ChainedWifiParameterGroup* _firstSet;
+ ChainedWifiParameterGroup* _currentSet;
+
+ iotwebconf::OptionalGroupHtmlFormatProvider _optionalGroupHtmlFormatProvider;
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.cpp b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.cpp
new file mode 100644
index 0000000..9e64649
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.cpp
@@ -0,0 +1,158 @@
+/**
+ * IotWebConfOptionalGroup.cpp -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *s
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#include "IotWebConfOptionalGroup.h"
+
+namespace iotwebconf
+{
+
+OptionalParameterGroup::OptionalParameterGroup(const char* id, const char* label, bool defaultVisible)
+ : ParameterGroup(id, label)
+{
+ this->_defaultActive = defaultVisible;
+}
+
+
+int OptionalParameterGroup::getStorageSize()
+{
+ return ParameterGroup::getStorageSize() + 1;
+}
+
+void OptionalParameterGroup::applyDefaultValue()
+{
+ this->_active = this->_defaultActive;
+ ParameterGroup::applyDefaultValue();
+}
+
+void OptionalParameterGroup::storeValue(
+ std::function<void(SerializationData* serializationData)> doStore)
+{
+ // -- Store active flag.
+ byte data[1];
+ data[0] = (byte)this->_active;
+ SerializationData serializationData;
+ serializationData.length = 1;
+ serializationData.data = data;
+ doStore(&serializationData);
+
+ // -- Store other items.
+ ParameterGroup::storeValue(doStore);
+}
+void OptionalParameterGroup::loadValue(
+ std::function<void(SerializationData* serializationData)> doLoad)
+{
+ // -- Load activity.
+ byte data[1];
+ SerializationData serializationData;
+ serializationData.length = 1;
+ serializationData.data = data;
+ doLoad(&serializationData);
+ this->_active = (bool)data[0];
+
+ // -- Load other items.
+ ParameterGroup::loadValue(doLoad);
+}
+
+void OptionalParameterGroup::renderHtml(
+ bool dataArrived, WebRequestWrapper* webRequestWrapper)
+{
+ if (this->label != nullptr)
+ {
+ String content = getStartTemplate();
+ content.replace("{b}", this->label);
+ content.replace("{i}", this->getId());
+ content.replace("{v}", this->_active ? "active" : "inactive");
+ if (this->_active)
+ {
+ content.replace("{cb}", "hide");
+ content.replace("{cf}", "");
+ }
+ else
+ {
+ content.replace("{cb}", "");
+ content.replace("{cf}", "hide");
+ }
+ webRequestWrapper->sendContent(content);
+ }
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ if (current->visible)
+ {
+ current->renderHtml(dataArrived, webRequestWrapper);
+ }
+ current = this->getNextItemOf(current);
+ }
+ if (this->label != nullptr)
+ {
+ String content = getEndTemplate();
+ content.replace("{b}", this->label);
+ content.replace("{i}", this->getId());
+ webRequestWrapper->sendContent(content);
+ }
+}
+
+void OptionalParameterGroup::update(WebRequestWrapper* webRequestWrapper)
+{
+ // -- Get active variable
+ String activeId = String(this->getId());
+ activeId += 'v';
+ if (webRequestWrapper->hasArg(activeId))
+ {
+ String activeStr = webRequestWrapper->arg(activeId);
+ this->_active = activeStr.equals("active");
+ }
+
+ // Update other items.
+ ParameterGroup::update(webRequestWrapper);
+}
+
+void OptionalParameterGroup::debugTo(Stream* out)
+{
+ out->print('(');
+ out->print(this->_active ? "active" : "inactive");
+ out->print(')');
+
+ // Print rest.
+ ParameterGroup::debugTo(out);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+String ChainedParameterGroup::getStartTemplate()
+{
+ String result = OptionalParameterGroup::getStartTemplate();
+
+ if ((this->_prevGroup != nullptr) && (!this->_prevGroup->isActive()))
+ {
+ result.replace("{cb}", "hide");
+ }
+ return result;
+};
+
+String ChainedParameterGroup::getEndTemplate()
+{
+ String result;
+ if (this->_nextGroup == nullptr)
+ {
+ result = OptionalParameterGroup::getEndTemplate();
+ }
+ else
+ {
+ result = FPSTR(IOTWEBCONF_HTML_FORM_CHAINED_GROUP_NEXTID);
+ result.replace("{in}", this->_nextGroup->getId());
+ result += OptionalParameterGroup::getEndTemplate();
+ }
+ return result;
+};
+
+
+}
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.h
new file mode 100644
index 0000000..60a2b1f
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfOptionalGroup.h
@@ -0,0 +1,116 @@
+/**
+ * IotWebConfOptionalGroup.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConfOptionalGroup_h
+#define IotWebConfOptionalGroup_h
+
+#include "IotWebConf.h" // For HtmlFormatProvider ... TODO: should be reorganized
+#include "IotWebConfParameter.h"
+
+const char IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_JAVASCRIPT[] PROGMEM =
+ " function show(id) { var x=document.getElementById(id); x.classList.remove('hide'); }\n"
+ " function hide(id) { var x=document.getElementById(id); x.classList.add('hide'); }\n"
+ " function val(id) { var x=document.getElementById(id); return x.value; }\n"
+ " function setVal(id, val) { var x=document.getElementById(id); x.value = val; }\n"
+ " function showFs(id) {\n"
+ " show(id); hide(id + 'b'); setVal(id + 'v', 'active'); var n=document.getElementById(id + 'next');\n"
+ " if (n) { var nId = n.value; if (val(nId + 'v') == 'inactive') { show(nId + 'b'); }}\n"
+ " }\n"
+ " function hideFs(id) {\n"
+ " hide(id); show(id + 'b'); setVal(id + 'v', 'inactive'); var n=document.getElementById(id + 'next');\n"
+ " if (n) { var nId = n.value; if (val(nId + 'v') == 'inactive') { hide(nId + 'b'); }}\n"
+ " }\n";
+const char IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_CSS[] PROGMEM =
+ ".hide{display: none;}\n";
+const char IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_START[] PROGMEM =
+ "<button id='{i}b' class='{cb}' onclick=\"showFs('{i}'); return false;\">+ {b}</button>\n"
+ "<fieldset id='{i}' class='{cf}'><legend>{b}</legend>\n"
+ "<button onclick=\"hideFs('{i}'); return false;\">Remove this set</button>\n"
+ "<input id='{i}v' name='{i}v' type='hidden' value='{v}'/>\n"
+ "\n";
+const char IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_END[] PROGMEM =
+ "</fieldset>\n";
+const char IOTWEBCONF_HTML_FORM_CHAINED_GROUP_NEXTID[] PROGMEM =
+ "<input type='hidden' id='{i}next' value='{in}'/>\n";
+
+namespace iotwebconf
+{
+
+class OptionalGroupHtmlFormatProvider : public HtmlFormatProvider
+{
+protected:
+ String getScriptInner() override
+ {
+ return
+ HtmlFormatProvider::getScriptInner() +
+ String(FPSTR(IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_JAVASCRIPT));
+ }
+ String getStyleInner() override
+ {
+ return
+ HtmlFormatProvider::getStyleInner() +
+ String(FPSTR(IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_CSS));
+ }
+};
+
+/**
+ * With OptionalParameterGroup buttons will appear in the GUI,
+ * to show and hide this specific group of parameters. The idea
+ * behind this feature to add/remove optional parameter set
+ * in the config portal.
+ */
+class OptionalParameterGroup : public ParameterGroup
+{
+public:
+ OptionalParameterGroup(const char* id, const char* label, bool defaultActive);
+ bool isActive() { return this->_active; }
+ void setActive(bool active) { this->_active = active; }
+
+protected:
+ int getStorageSize() override;
+ void applyDefaultValue() override;
+ void storeValue(std::function<void(
+ SerializationData* serializationData)> doStore) override;
+ void loadValue(std::function<void(
+ SerializationData* serializationData)> doLoad) override;
+ void renderHtml(bool dataArrived, WebRequestWrapper* webRequestWrapper) override;
+ virtual String getStartTemplate() { return FPSTR(IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_START); };
+ virtual String getEndTemplate() { return FPSTR(IOTWEBCONF_HTML_FORM_OPTIONAL_GROUP_END); };
+ void update(WebRequestWrapper* webRequestWrapper) override;
+ void debugTo(Stream* out) override;
+
+private:
+ bool _defaultActive;
+ bool _active;
+};
+
+class ChainedParameterGroup;
+
+class ChainedParameterGroup : public OptionalParameterGroup
+{
+public:
+ ChainedParameterGroup(const char* id, const char* label, bool defaultActive = false) :
+ OptionalParameterGroup(id, label, defaultActive) { };
+ void setNext(ChainedParameterGroup* nextGroup) { this->_nextGroup = nextGroup; nextGroup->_prevGroup = this; };
+ ChainedParameterGroup* getNext() { return this->_nextGroup; };
+
+protected:
+ virtual String getStartTemplate() override;
+ virtual String getEndTemplate() override;
+
+protected:
+ ChainedParameterGroup* _prevGroup = nullptr;
+ ChainedParameterGroup* _nextGroup = nullptr;
+};
+
+}
+
+#endif
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.cpp b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.cpp
new file mode 100644
index 0000000..83aa153
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.cpp
@@ -0,0 +1,624 @@
+/**
+ * IotWebConfParameter.cpp -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#include <IotWebConfParameter.h>
+
+namespace iotwebconf
+{
+
+ParameterGroup::ParameterGroup(
+ const char* id, const char* label) :
+ ConfigItem(id)
+{
+ this->label = label;
+}
+
+void ParameterGroup::addItem(ConfigItem* configItem)
+{
+ if (configItem->_parentItem != nullptr)
+ {
+ return; // Item must not be added two times.
+ }
+ if (this->_firstItem == nullptr)
+ {
+ this->_firstItem = configItem;
+ return;
+ }
+ ConfigItem* current = this->_firstItem;
+ while (current->_nextItem != nullptr)
+ {
+ current = current->_nextItem;
+ }
+ current->_nextItem = configItem;
+ configItem->_parentItem = this;
+}
+
+int ParameterGroup::getStorageSize()
+{
+ int size = 0;
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ size += current->getStorageSize();
+ current = current->_nextItem;
+ }
+ return size;
+}
+void ParameterGroup::applyDefaultValue()
+{
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ current->applyDefaultValue();
+ current = current->_nextItem;
+ }
+}
+
+void ParameterGroup::storeValue(
+ std::function<void(SerializationData* serializationData)> doStore)
+{
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ current->storeValue(doStore);
+ current = current->_nextItem;
+ }
+}
+void ParameterGroup::loadValue(
+ std::function<void(SerializationData* serializationData)> doLoad)
+{
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ current->loadValue(doLoad);
+ current = current->_nextItem;
+ }
+}
+
+void ParameterGroup::renderHtml(
+ bool dataArrived, WebRequestWrapper* webRequestWrapper)
+{
+ if (this->label != nullptr)
+ {
+ String content = getStartTemplate();
+ content.replace("{b}", this->label);
+ content.replace("{i}", this->getId());
+ webRequestWrapper->sendContent(content);
+ }
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ if (current->visible)
+ {
+ current->renderHtml(dataArrived, webRequestWrapper);
+ }
+ current = current->_nextItem;
+ }
+ if (this->label != nullptr)
+ {
+ String content = getEndTemplate();
+ content.replace("{b}", this->label);
+ content.replace("{i}", this->getId());
+ webRequestWrapper->sendContent(content);
+ }
+}
+void ParameterGroup::update(WebRequestWrapper* webRequestWrapper)
+{
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ current->update(webRequestWrapper);
+ current = current->_nextItem;
+ }
+}
+void ParameterGroup::clearErrorMessage()
+{
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ current->clearErrorMessage();
+ current = current->_nextItem;
+ }
+}
+void ParameterGroup::debugTo(Stream* out)
+{
+ out->print('[');
+ out->print(this->getId());
+ out->println(']');
+
+ // -- Here is some overcomplicated logic to have nice debug output.
+ bool ownItem = false;
+ bool lastItem = false;
+ PrefixStreamWrapper stream =
+ PrefixStreamWrapper(
+ out,
+ [&](Stream* out1)
+ {
+ if (ownItem)
+ {
+ ownItem = false;
+ return (size_t)0;
+ }
+ if (lastItem)
+ {
+ return out1->print(" ");
+ }
+ else
+ {
+ return out1->print("| ");
+ }
+ });
+
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ if (current->_nextItem == nullptr)
+ {
+ out->print("\\-- ");
+ }
+ else
+ {
+ out->print("|-- ");
+ }
+ ownItem = true;
+ lastItem = (current->_nextItem == nullptr);
+ current->debugTo(&stream);
+ current = current->_nextItem;
+ }
+}
+
+#ifdef IOTWEBCONF_ENABLE_JSON
+void ParameterGroup::loadFromJson(JsonObject jsonObject)
+{
+ if (jsonObject.containsKey(this->getId()))
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(F("Applying values from JSON for groupId: "));
+ Serial.println(this->getId());
+#endif
+ JsonObject myObject = jsonObject[this->getId()];
+ ConfigItem* current = this->_firstItem;
+ while (current != nullptr)
+ {
+ current->loadFromJson(myObject);
+ current = current->_nextItem;
+ }
+ }
+ else
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(F("Group data not found in JSON. Skipping groupId: "));
+ Serial.println(this->getId());
+#endif
+ }
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+Parameter::Parameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue) :
+ ConfigItem(id)
+{
+ this->label = label;
+ this->valueBuffer = valueBuffer;
+ this->_length = length;
+ this->defaultValue = defaultValue;
+
+ this->errorMessage = nullptr;
+}
+int Parameter::getStorageSize()
+{
+ return this->_length;
+}
+void Parameter::applyDefaultValue()
+{
+ if (defaultValue != nullptr)
+ {
+ strncpy(this->valueBuffer, this->defaultValue, this->getLength());
+ }
+ else
+ {
+ this->valueBuffer[0] = '\0';
+ }
+}
+void Parameter::storeValue(
+ std::function<void(SerializationData* serializationData)> doStore)
+{
+ SerializationData serializationData;
+ serializationData.length = this->_length;
+ serializationData.data = (byte*)this->valueBuffer;
+ doStore(&serializationData);
+}
+void Parameter::loadValue(
+ std::function<void(SerializationData* serializationData)> doLoad)
+{
+ SerializationData serializationData;
+ serializationData.length = this->_length;
+ serializationData.data = (byte*)this->valueBuffer;
+ doLoad(&serializationData);
+}
+void Parameter::update(WebRequestWrapper* webRequestWrapper)
+{
+ if (webRequestWrapper->hasArg(this->getId()))
+ {
+ String newValue = webRequestWrapper->arg(this->getId());
+ this->update(newValue);
+ }
+}
+void Parameter::clearErrorMessage()
+{
+ this->errorMessage = nullptr;
+}
+#ifdef IOTWEBCONF_ENABLE_JSON
+void Parameter::loadFromJson(JsonObject jsonObject)
+{
+ if (jsonObject.containsKey(this->getId()))
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(F("Applying value from JSON for parameterId: "));
+ Serial.println(this->getId());
+#endif
+ const char* value = jsonObject[this->getId()];
+ this->update(String(value));
+ }
+ else
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(F("No value found in JSON for parameterId: "));
+ Serial.println(this->getId());
+#endif
+ }
+}
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+TextParameter::TextParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue,
+ const char* placeholder,
+ const char* customHtml)
+ : Parameter(label, id, valueBuffer, length, defaultValue)
+{
+ this->placeholder = placeholder;
+ this->customHtml = customHtml;
+}
+
+void TextParameter::renderHtml(
+ bool dataArrived, WebRequestWrapper* webRequestWrapper)
+{
+ String content = this->renderHtml(
+ dataArrived,
+ webRequestWrapper->hasArg(this->getId()),
+ webRequestWrapper->arg(this->getId()));
+ webRequestWrapper->sendContent(content);
+}
+String TextParameter::renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost)
+{
+ return this->renderHtml("text", hasValueFromPost, valueFromPost);
+}
+String TextParameter::renderHtml(
+ const char* type, bool hasValueFromPost, String valueFromPost)
+{
+ TextParameter* current = this;
+ char parLength[12];
+
+ String pitem = getHtmlTemplate();
+
+ pitem.replace("{b}", current->label);
+ pitem.replace("{t}", type);
+ pitem.replace("{i}", current->getId());
+ pitem.replace("{p}", current->placeholder == nullptr ? "" : current->placeholder);
+ snprintf(parLength, 12, "%d", current->getLength()-1);
+ pitem.replace("{l}", parLength);
+ if (hasValueFromPost)
+ {
+ // -- Value from previous submit
+ pitem.replace("{v}", valueFromPost);
+ }
+ else
+ {
+ // -- Value from config
+ pitem.replace("{v}", current->valueBuffer);
+ }
+ pitem.replace(
+ "{c}", current->customHtml == nullptr ? "" : current->customHtml);
+ pitem.replace(
+ "{s}",
+ current->errorMessage == nullptr ? "" : "de"); // Div style class.
+ pitem.replace(
+ "{e}",
+ current->errorMessage == nullptr ? "" : current->errorMessage);
+
+ return pitem;
+}
+
+void TextParameter::update(String newValue)
+{
+ newValue.toCharArray(this->valueBuffer, this->getLength());
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(this->getId());
+ Serial.print(": ");
+ Serial.println(this->valueBuffer);
+#endif
+}
+
+void TextParameter::debugTo(Stream* out)
+{
+ Parameter* current = this;
+ out->print("'");
+ out->print(current->getId());
+ out->print("' with value: '");
+ out->print(current->valueBuffer);
+ out->println("'");
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+NumberParameter::NumberParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue,
+ const char* placeholder,
+ const char* customHtml)
+ : TextParameter(label, id, valueBuffer, length, defaultValue,
+ placeholder, customHtml)
+{
+}
+
+String NumberParameter::renderHtml(
+ bool dataArrived,
+ bool hasValueFromPost, String valueFromPost)
+{
+ return TextParameter::renderHtml("number", hasValueFromPost, valueFromPost);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+PasswordParameter::PasswordParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue,
+ const char* placeholder,
+ const char* customHtml)
+ : TextParameter(label, id, valueBuffer, length, defaultValue,
+ placeholder, customHtml)
+{
+}
+
+String PasswordParameter::renderHtml(
+ bool dataArrived,
+ bool hasValueFromPost, String valueFromPost)
+{
+ return TextParameter::renderHtml("password", true, String(""));
+}
+
+void PasswordParameter::debugTo(Stream* out)
+{
+ Parameter* current = this;
+ out->print("'");
+ out->print(current->getId());
+ out->print("' with value: ");
+#ifdef IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ out->print("'");
+ out->print(current->valueBuffer);
+ out->println("'");
+#else
+ out->println(F("<hidden>"));
+#endif
+}
+
+void PasswordParameter::update(String newValue)
+{
+ Parameter* current = this;
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(this->getId());
+ Serial.print(": ");
+#endif
+ if (newValue.length() > 0)
+ {
+ // -- Value was set.
+ newValue.toCharArray(current->valueBuffer, current->getLength());
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+# ifdef IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ Serial.println(current->valueBuffer);
+# else
+ Serial.println("<updated>");
+# endif
+#endif
+ }
+ else
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.println("<was not changed>");
+#endif
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+CheckboxParameter::CheckboxParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ bool defaultValue)
+ : TextParameter(label, id, valueBuffer, length, defaultValue ? "selected" : nullptr,
+ nullptr, nullptr)
+{
+}
+
+String CheckboxParameter::renderHtml(
+ bool dataArrived,
+ bool hasValueFromPost, String valueFromPost)
+{
+ bool checkSelected = false;
+ if (dataArrived)
+ {
+ if (hasValueFromPost && valueFromPost.equals("selected"))
+ {
+ checkSelected = true;
+ }
+ }
+ else
+ {
+ if (this->isChecked())
+ {
+ checkSelected = true;
+ }
+ }
+
+ if (checkSelected)
+ {
+ this->customHtml = CheckboxParameter::_checkedStr;
+ }
+ else
+ {
+ this->customHtml = nullptr;
+ }
+
+
+ return TextParameter::renderHtml("checkbox", true, "selected");
+}
+
+void CheckboxParameter::update(WebRequestWrapper* webRequestWrapper)
+{
+ if (webRequestWrapper->hasArg(this->getId()))
+ {
+ String newValue = webRequestWrapper->arg(this->getId());
+ return TextParameter::update(newValue);
+ }
+ else if (this->visible)
+ {
+ // HTML will not post back unchecked checkboxes.
+ return TextParameter::update("");
+ }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+OptionsParameter::OptionsParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* optionValues, const char* optionNames, size_t optionCount, size_t nameLength,
+ const char* defaultValue)
+ : TextParameter(label, id, valueBuffer, length, defaultValue,
+ nullptr, nullptr)
+{
+ this->_optionValues = optionValues;
+ this->_optionNames = optionNames;
+ this->_optionCount = optionCount;
+ this->_nameLength = nameLength;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+SelectParameter::SelectParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* optionValues, const char* optionNames, size_t optionCount, size_t nameLength,
+ const char* defaultValue)
+ : OptionsParameter(label, id, valueBuffer, length, optionValues, optionNames,
+ optionCount, nameLength, defaultValue)
+{
+}
+
+String SelectParameter::renderHtml(
+ bool dataArrived,
+ bool hasValueFromPost, String valueFromPost)
+{
+ TextParameter* current = this;
+
+ String options = "";
+
+ for (size_t i=0; i<this->_optionCount; i++)
+ {
+ const char *optionValue = (this->_optionValues + (i*this->getLength()) );
+ const char *optionName = (this->_optionNames + (i*this->_nameLength) );
+ String oitem = FPSTR(IOTWEBCONF_HTML_FORM_OPTION);
+ oitem.replace("{v}", optionValue);
+// if (sizeof(this->_optionNames) > i)
+ {
+ oitem.replace("{n}", optionName);
+ }
+// else
+// {
+// oitem.replace("{n}", "?");
+// }
+ if ((hasValueFromPost && (valueFromPost == optionValue)) ||
+ (strncmp(current->valueBuffer, optionValue, this->getLength()) == 0))
+ {
+ // -- Value from previous submit
+ oitem.replace("{s}", " selected");
+ }
+ else
+ {
+ // -- Value from config
+ oitem.replace("{s}", "");
+ }
+
+ options += oitem;
+ }
+
+ String pitem = FPSTR(IOTWEBCONF_HTML_FORM_SELECT_PARAM);
+
+ pitem.replace("{b}", current->label);
+ pitem.replace("{i}", current->getId());
+ pitem.replace(
+ "{c}", current->customHtml == nullptr ? "" : current->customHtml);
+ pitem.replace(
+ "{s}",
+ current->errorMessage == nullptr ? "" : "de"); // Div style class.
+ pitem.replace(
+ "{e}",
+ current->errorMessage == nullptr ? "" : current->errorMessage);
+ pitem.replace("{o}", options);
+
+ return pitem;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+PrefixStreamWrapper::PrefixStreamWrapper(
+ Stream* originalStream,
+ std::function<size_t(Stream* stream)> prefixWriter)
+{
+ this->_originalStream = originalStream;
+ this->_prefixWriter = prefixWriter;
+}
+size_t PrefixStreamWrapper::write(uint8_t data)
+{
+ size_t sizeOut = checkNewLine();
+ sizeOut += this->_originalStream->write(data);
+ if (data == 10) // NewLine
+ {
+ this->_newLine = true;
+ }
+ return sizeOut;
+}
+size_t PrefixStreamWrapper::write(const uint8_t *buffer, size_t size)
+{
+ size_t sizeOut = checkNewLine();
+ sizeOut += this->_originalStream->write(buffer, size);
+ if (*(buffer + size-1) == 10) // Ends with new line
+ {
+ this->_newLine = true;
+ }
+ return sizeOut;
+}
+size_t PrefixStreamWrapper::checkNewLine()
+{
+ if (this->_newLine)
+ {
+ this->_newLine = false;
+ return this->_prefixWriter(this->_originalStream);
+ }
+ return 0;
+}
+
+} // end namespace
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.h
new file mode 100644
index 0000000..1f83691
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfParameter.h
@@ -0,0 +1,462 @@
+/**
+ * IotWebConfParameter.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConfParameter_h
+#define IotWebConfParameter_h
+
+#include <Arduino.h>
+#include <functional>
+#include <IotWebConfSettings.h>
+#include <IotWebConfWebServerWrapper.h>
+
+#ifdef IOTWEBCONF_ENABLE_JSON
+# include <ArduinoJson.h>
+#endif
+
+const char IOTWEBCONF_HTML_FORM_GROUP_START[] PROGMEM =
+ "<fieldset id='{i}'><legend>{b}</legend>\n";
+const char IOTWEBCONF_HTML_FORM_GROUP_END[] PROGMEM =
+ "</fieldset>\n";
+
+const char IOTWEBCONF_HTML_FORM_PARAM[] PROGMEM =
+ "<div class='{s}'><label for='{i}'>{b}</label><input type='{t}' id='{i}' "
+ "name='{i}' {l} placeholder='{p}' value='{v}' {c}/>"
+ "<div class='em'>{e}</div></div>\n";
+
+const char IOTWEBCONF_HTML_FORM_SELECT_PARAM[] PROGMEM =
+ "<div class='{s}'><label for='{i}'>{b}</label><select id='{i}' "
+ "name='{i}' {c}/>\n{o}"
+ "</select><div class='em'>{e}</div></div>\n";
+const char IOTWEBCONF_HTML_FORM_OPTION[] PROGMEM =
+ "<option value='{v}'{s}>{n}</option>\n";
+
+namespace iotwebconf
+{
+
+typedef struct SerializationData
+{
+ byte* data;
+ int length;
+} SerializationData;
+
+class ConfigItem
+{
+public:
+ bool visible = true;
+ const char* getId() { return this->_id; }
+
+ /**
+ * Calculate the size of bytes should be stored in the EEPROM.
+ */
+ virtual int getStorageSize() = 0;
+
+ /**
+ * On initial startup (when no data was saved), it may be required to apply a default value
+ * to the parameter.
+ */
+ virtual void applyDefaultValue() = 0;
+
+ /**
+ * Save data.
+ * @doStore - A method is passed as a parameter, that will performs the actual EEPROM access.
+ * The argument 'serializationData' of this referenced method should be pre-filled with
+ * the size and the serialized data before calling the method.
+ */
+ virtual void storeValue(std::function<void(SerializationData* serializationData)> doStore) = 0;
+
+ /**
+ * Load data.
+ * @doLoad - A method is passed as a parameter, that will performs the actual EEPROM access.
+ * The argument 'serializationData' of this referenced method should be pre-filled with
+ * the size of the expected data, and the data buffer should be allocated with this size.
+ * The doLoad will fill the data from the EEPROM.
+ */
+ virtual void loadValue(std::function<void(SerializationData* serializationData)> doLoad) = 0;
+
+ /**
+ * This method will create the HTML form item for the config portal.
+ *
+ * @dataArrived - True if there was a form post, where (some) form
+ * data arrived from the client.
+ * @webRequestWrapper - The webRequestWrapper, that will send the rendered content to the client.
+ * The webRequestWrapper->sendContent() method should be used in the implementations.
+ */
+ virtual void renderHtml(bool dataArrived, WebRequestWrapper* webRequestWrapper) = 0;
+
+ /**
+ * New value arrived from the form post. The value should be stored in the
+ * in this config item.
+ *
+ * @webRequestWrapper - The webRequestWrapper, that will send the rendered content to the client.
+ * The webRequestWrapper->hasArg() and webRequestWrapper->arg() methods should be used in the
+ * implementations.
+ */
+ virtual void update(WebRequestWrapper* webRequestWrapper) = 0;
+
+ /**
+ * Before validating the form post, it is required to clear previous error messages.
+ */
+ virtual void clearErrorMessage() = 0;
+
+ /**
+ * This method should display information to Serial containing the parameter
+ * ID and the current value of the parameter (if it is confidential).
+ * Will only be called if debug is enabled.
+ */
+ virtual void debugTo(Stream* out) = 0;
+
+#ifdef IOTWEBCONF_ENABLE_JSON
+ /**
+ *
+ */
+ virtual void loadFromJson(JsonObject jsonObject) = 0;
+#endif
+
+protected:
+ ConfigItem(const char* id) { this->_id = id; };
+
+private:
+ const char* _id = 0;
+ ConfigItem* _parentItem = nullptr;
+ ConfigItem* _nextItem = nullptr;
+ friend class ParameterGroup; // Allow ParameterGroup to access _nextItem.
+};
+
+class ParameterGroup : public ConfigItem
+{
+public:
+ ParameterGroup(const char* id, const char* label = nullptr);
+ void addItem(ConfigItem* configItem);
+ const char *label;
+ void applyDefaultValue() override;
+#ifdef IOTWEBCONF_ENABLE_JSON
+ virtual void loadFromJson(JsonObject jsonObject) override;
+#endif
+
+protected:
+ int getStorageSize() override;
+ void storeValue(std::function<void(
+ SerializationData* serializationData)> doStore) override;
+ void loadValue(std::function<void(
+ SerializationData* serializationData)> doLoad) override;
+ void renderHtml(bool dataArrived, WebRequestWrapper* webRequestWrapper) override;
+ void update(WebRequestWrapper* webRequestWrapper) override;
+ void clearErrorMessage() override;
+ void debugTo(Stream* out) override;
+ /**
+ * One can override this method in case a specific HTML template is required
+ * for a group.
+ */
+ virtual String getStartTemplate() { return FPSTR(IOTWEBCONF_HTML_FORM_GROUP_START); };
+ /**
+ * One can override this method in case a specific HTML template is required
+ * for a group.
+ */
+ virtual String getEndTemplate() { return FPSTR(IOTWEBCONF_HTML_FORM_GROUP_END); };
+
+ ConfigItem* _firstItem = nullptr;
+ ConfigItem* getNextItemOf(ConfigItem* parent) { return parent->_nextItem; };
+
+ friend class IotWebConf; // Allow IotWebConf to access protected members.
+
+private:
+};
+
+/**
+ * Parameters is a configuration item of the config portal.
+ * The parameter will have its input field on the configuration page,
+ * and the provided value will be saved to the EEPROM.
+ */
+class Parameter : public ConfigItem
+{
+public:
+ /**
+ * Create a parameter for the config portal.
+ *
+ * @label - Displayable label at the config portal.
+ * @id - Identifier used for HTTP queries and as configuration key. Must not
+ * contain spaces nor other special characters.
+ * @valueBuffer - Configuration value will be loaded to this buffer from the
+ * EEPROM.
+ * @length - The buffer should have a length provided here.
+ * @defaultValue - Defalt value set on startup, when no configuration ever saved
+ * with the current config-version.
+ */
+ Parameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue = nullptr);
+
+ const char* label;
+ char* valueBuffer;
+ const char* defaultValue;
+ const char* errorMessage;
+
+ int getLength() { return this->_length; }
+ void applyDefaultValue() override;
+#ifdef IOTWEBCONF_ENABLE_JSON
+ virtual void loadFromJson(JsonObject jsonObject) override;
+#endif
+
+protected:
+ // Overrides
+ int getStorageSize() override;
+ void storeValue(std::function<void(SerializationData* serializationData)> doStore) override;
+ void loadValue(std::function<void(SerializationData* serializationData)> doLoad) override;
+ virtual void update(WebRequestWrapper* webRequestWrapper) override;
+ virtual void update(String newValue) = 0;
+ void clearErrorMessage() override;
+
+private:
+ int _length;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * TexParameters is to store text based parameters.
+ */
+class TextParameter : public Parameter
+{
+public:
+ /**
+ * Create a text parameter for the config portal.
+ *
+ * @placeholder (optional) - Text appear in an empty input box.
+ * @customHtml (optional) - The text of this parameter will be added into
+ * the HTML INPUT field.
+ * (See Parameter for arguments!)
+ */
+ TextParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue = nullptr,
+ const char* placeholder = nullptr,
+ const char* customHtml = nullptr);
+
+ /**
+ * This variable is meant to store a value that is displayed in an empty
+ * (not filled) field.
+ */
+ const char* placeholder;
+
+ /**
+ * Usually this variable is used when rendering the form input field
+ * so one can customize the rendered outcome of this particular item.
+ */
+ const char* customHtml;
+
+protected:
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost);
+ // Overrides
+ virtual void renderHtml(bool dataArrived, WebRequestWrapper* webRequestWrapper) override;
+ virtual void update(String newValue) override;
+ virtual void debugTo(Stream* out) override;
+ /**
+ * One can override this method in case a specific HTML template is required
+ * for a parameter.
+ */
+ virtual String getHtmlTemplate() { return FPSTR(IOTWEBCONF_HTML_FORM_PARAM); };
+
+ /**
+ * Renders a standard HTML form INPUT.
+ * @type - The type attribute of the html input field.
+ */
+ virtual String renderHtml(const char* type, bool hasValueFromPost, String valueFromPost);
+
+private:
+ friend class IotWebConf;
+ friend class WifiParameterGroup;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The Password parameter has a special handling, as the value will be
+ * overwritten in the EEPROM only if value was provided on the config portal.
+ * Because of this logic, "password" type field with length more then
+ * IOTWEBCONF_PASSWORD_LEN characters are not supported.
+ */
+class PasswordParameter : public TextParameter
+{
+public:
+ /**
+ * Create a password parameter for the config portal.
+ *
+ * (See TextParameter for arguments!)
+ */
+ PasswordParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue = nullptr,
+ const char* placeholder = nullptr,
+ const char* customHtml = "ondblclick=\"pw(this.id)\"");
+
+protected:
+ // Overrides
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost) override;
+ virtual void update(String newValue) override;
+ virtual void debugTo(Stream* out) override;
+
+private:
+ friend class IotWebConf;
+ friend class WifiParameterGroup;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * This is just a text parameter, that is rendered with type 'number'.
+ */
+class NumberParameter : public TextParameter
+{
+public:
+ /**
+ * Create a numeric parameter for the config portal.
+ *
+ * (See TextParameter for arguments!)
+ */
+ NumberParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* defaultValue = nullptr,
+ const char* placeholder = nullptr,
+ const char* customHtml = nullptr);
+
+protected:
+ // Overrides
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost) override;
+
+private:
+ friend class IotWebConf;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Checkbox parameter is represended as a text parameter but has a special
+ * handling. As the value is either empty or has the word "selected".
+ * Note, that form post will not send value if checkbox was not selected.
+ */
+class CheckboxParameter : public TextParameter
+{
+public:
+ /**
+ * Create a checkbox parameter for the config portal.
+ *
+ * (See TextParameter for arguments!)
+ */
+ CheckboxParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ bool defaultValue = false);
+ bool isChecked() { return strncmp(this->valueBuffer, "selected", this->getLength()) == 0; }
+
+protected:
+ // Overrides
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost) override;
+ virtual void update(WebRequestWrapper* webRequestWrapper) override;
+
+private:
+ friend class IotWebConf;
+ bool _checked;
+ const char* _checkedStr = "checked='checked'";
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Options parameter is a structure, that handles multiple values when redering
+ * the HTML representation.
+ */
+class OptionsParameter : public TextParameter
+{
+public:
+ /**
+ * @optionValues - List of values to choose from with, where each value
+ * can have a maximal size of 'length'. Contains 'optionCount' items.
+ * @optionNames - List of names to render for the values, where each
+ * name can have a maximal size of 'nameLength'. Contains 'optionCount'
+ * items.
+ * @optionCount - Size of both 'optionValues' and 'optionNames' lists.
+ * @nameLength - Size of any item in optionNames list.
+ * (See TextParameter for arguments!)
+ */
+ OptionsParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* optionValues, const char* optionNames, size_t optionCount, size_t nameLength,
+ const char* defaultValue = nullptr);
+
+protected:
+ const char* _optionValues;
+ const char* _optionNames;
+ size_t _optionCount;
+ size_t _nameLength;
+
+private:
+ friend class IotWebConf;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Select parameter is an option parameter, that rendered as HTML SELECT.
+ * Basically it is a dropdown combobox.
+ */
+class SelectParameter : public OptionsParameter
+{
+public:
+ /**
+ * Create a select parameter for the config portal.
+ *
+ * (See OptionsParameter for arguments!)
+ */
+ SelectParameter(
+ const char* label, const char* id, char* valueBuffer, int length,
+ const char* optionValues, const char* optionNames, size_t optionCount, size_t namesLenth,
+ const char* defaultValue = nullptr);
+
+protected:
+ // Overrides
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost) override;
+
+private:
+ friend class IotWebConf;
+};
+
+/**
+ * This class is here just to make some nice indents on debug output
+ * for group tree.
+ */
+class PrefixStreamWrapper : public Stream
+{
+public:
+ PrefixStreamWrapper(
+ Stream* originalStream,
+ std::function<size_t(Stream* stream)> prefixWriter);
+ size_t write(uint8_t) override;
+ size_t write(const uint8_t *buffer, size_t size) override;
+ int available() override { return _originalStream->available(); };
+ int read() override { return _originalStream->read(); };
+ int peek() override { return _originalStream->peek(); };
+ void flush() override { return _originalStream->flush(); };
+
+private:
+ Stream* _originalStream;
+ std::function<size_t(Stream* stream)> _prefixWriter;
+ bool _newLine = true;
+
+ size_t checkNewLine();
+};
+
+} // end namespace
+
+#endif
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfSettings.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfSettings.h
new file mode 100644
index 0000000..430137d
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfSettings.h
@@ -0,0 +1,73 @@
+/**
+ * IotWebConfSettings.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConfSettings_h
+#define IotWebConfSettings_h
+
+// -- We might want to place the config in the EEPROM in an offset.
+#ifndef IOTWEBCONF_CONFIG_START
+# define IOTWEBCONF_CONFIG_START 0
+#endif
+
+// -- Maximal length of any string used in IotWebConfig configuration (e.g.
+// ssid).
+#ifndef IOTWEBCONF_WORD_LEN
+# define IOTWEBCONF_WORD_LEN 33
+#endif
+// -- Maximal length of password used in IotWebConfig configuration.
+#ifndef IOTWEBCONF_PASSWORD_LEN
+# define IOTWEBCONF_PASSWORD_LEN 33
+#endif
+
+// -- IotWebConf tries to connect to the local network for an amount of time
+// before falling back to AP mode.
+#ifndef IOTWEBCONF_DEFAULT_WIFI_CONNECTION_TIMEOUT_MS
+# define IOTWEBCONF_DEFAULT_WIFI_CONNECTION_TIMEOUT_MS 30000
+#endif
+
+// -- Thing will stay in AP mode for an amount of time on boot, before retrying
+// to connect to a WiFi network.
+#ifndef IOTWEBCONF_DEFAULT_AP_MODE_TIMEOUT_SECS
+# define IOTWEBCONF_DEFAULT_AP_MODE_TIMEOUT_SECS "30"
+#endif
+
+// -- mDNS should allow you to connect to this device with a hostname provided
+// by the device. E.g. mything.local
+// (This is not very likely to work, and MDNS is not very well documented.)
+#ifndef IOTWEBCONF_CONFIG_DONT_USE_MDNS
+# define IOTWEBCONF_CONFIG_USE_MDNS 80
+#endif
+
+// -- Logs progress information to Serial if enabled.
+#ifndef IOTWEBCONF_DEBUG_DISABLED
+# define IOTWEBCONF_DEBUG_TO_SERIAL
+#endif
+
+// -- Logs passwords to Serial if enabled.
+//#define IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+
+// -- Helper define for serial debug
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+# define IOTWEBCONF_DEBUG_LINE(MSG) Serial.println(MSG)
+#else
+# define IOTWEBCONF_DEBUG_LINE(MSG)
+#endif
+
+// -- EEPROM config starts with a special prefix of length defined here.
+#ifndef IOTWEBCONF_CONFIG_VERSION_LENGTH
+# define IOTWEBCONF_CONFIG_VERSION_LENGTH 4
+#endif
+
+#ifndef IOTWEBCONF_DNS_PORT
+# define IOTWEBCONF_DNS_PORT 53
+#endif
+
+#endif
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameter.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameter.h
new file mode 100644
index 0000000..9bd42e3
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameter.h
@@ -0,0 +1,951 @@
+/**
+ * IotWebConfTParameter.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2021 Balazs Kelemen <prampec+arduino@gmail.com>
+ * rovo89
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConfTParameter_h
+#define IotWebConfTParameter_h
+
+// TODO: This file is a mess. Help wanted to organize thing!
+
+#include <IotWebConfParameter.h>
+#include <Arduino.h>
+#include <IPAddress.h>
+#include <errno.h>
+
+// At least in PlatformIO, strtoimax/strtoumax are defined, but not implemented.
+#if 1
+#define strtoimax strtoll
+#define strtoumax strtoull
+#endif
+
+namespace iotwebconf
+{
+
+/**
+ * This class is to hide web related properties from the
+ * data manipulation.
+ */
+class ConfigItemBridge : public ConfigItem
+{
+public:
+ virtual void update(WebRequestWrapper* webRequestWrapper) override
+ {
+ if (webRequestWrapper->hasArg(this->getId()))
+ {
+ String newValue = webRequestWrapper->arg(this->getId());
+ this->update(newValue);
+ }
+ }
+ void debugTo(Stream* out) override
+ {
+ out->print("'");
+ out->print(this->getId());
+ out->print("' with value: '");
+ out->print(this->toString());
+ out->println("'");
+ }
+
+protected:
+ ConfigItemBridge(const char* id) : ConfigItem(id) { }
+ virtual int getInputLength() { return 0; };
+ virtual bool update(String newValue, bool validateOnly = false) = 0;
+ virtual String toString() = 0;
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+/**
+ * DataType is the data related part of the parameter.
+ * It does not care about web and visualization, but takes care of the
+ * data validation and storing.
+ */
+template <typename ValueType, typename _DefaultValueType = ValueType>
+class DataType : virtual public ConfigItemBridge
+{
+public:
+ using DefaultValueType = _DefaultValueType;
+
+ DataType(const char* id, DefaultValueType defaultValue) :
+ ConfigItemBridge(id),
+ _defaultValue(defaultValue)
+ {
+ }
+
+ /**
+ * value() can be used to get the value, but it can also
+ * be used set it like this: p.value() = newValue
+ */
+ ValueType& value() { return this->_value; }
+ ValueType& operator*() { return this->_value; }
+
+protected:
+ int getStorageSize() override
+ {
+ return sizeof(ValueType);
+ }
+
+ virtual bool update(String newValue, bool validateOnly = false) = 0;
+ bool validate(String newValue) { return update(newValue, true); }
+ virtual String toString() override { return String(this->_value); }
+
+ ValueType _value;
+ const DefaultValueType _defaultValue;
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+class StringDataType : public DataType<String>
+{
+public:
+ using DataType<String>::DataType;
+
+protected:
+ virtual bool update(String newValue, bool validateOnly) override {
+ if (!validateOnly)
+ {
+ this->_value = newValue;
+ }
+ return true;
+ }
+ virtual String toString() override { return this->_value; }
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+template <size_t len>
+class CharArrayDataType : public DataType<char[len], const char*>
+{
+public:
+using DataType<char[len], const char*>::DataType;
+ CharArrayDataType(const char* id, const char* defaultValue) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ DataType<char[len], const char*>::DataType(id, defaultValue) { };
+ virtual void applyDefaultValue() override
+ {
+ strncpy(this->_value, this->_defaultValue, len);
+ }
+
+protected:
+ virtual bool update(String newValue, bool validateOnly) override
+ {
+ if (newValue.length() + 1 > len)
+ {
+ return false;
+ }
+ if (!validateOnly)
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(this->getId());
+ Serial.print(": ");
+ Serial.println(newValue);
+#endif
+ strncpy(this->_value, newValue.c_str(), len);
+ }
+ return true;
+ }
+ void storeValue(std::function<void(
+ SerializationData* serializationData)> doStore) override
+ {
+ SerializationData serializationData;
+ serializationData.length = len;
+ serializationData.data = (byte*)this->_value;
+ doStore(&serializationData);
+ }
+ void loadValue(std::function<void(
+ SerializationData* serializationData)> doLoad) override
+ {
+ SerializationData serializationData;
+ serializationData.length = len;
+ serializationData.data = (byte*)this->_value;
+ doLoad(&serializationData);
+ }
+ virtual int getInputLength() override { return len; };
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+/**
+ * All non-complex types should be inherited from this base class.
+ */
+template <typename ValueType>
+class PrimitiveDataType : public DataType<ValueType>
+{
+public:
+using DataType<ValueType>::DataType;
+ PrimitiveDataType(const char* id, ValueType defaultValue) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ DataType<ValueType>::DataType(id, defaultValue) { };
+
+ void setMax(ValueType val) { this->_max = val; this->_maxDefined = true; }
+ void setMin(ValueType val) { this->_min = val; this->_minDefined = true; }
+
+ virtual void applyDefaultValue() override
+ {
+ this->_value = this->_defaultValue;
+ }
+
+protected:
+ virtual bool update(String newValue, bool validateOnly) override
+ {
+ errno = 0;
+ ValueType val = fromString(newValue);
+ if ((errno == ERANGE)
+ || (this->_minDefined && (val < this->_min))
+ || (this->_maxDefined && (val > this->_max)))
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(this->getId());
+ Serial.print(" value not accepted: ");
+ Serial.println(val);
+#endif
+ return false;
+ }
+ if (!validateOnly)
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(this->getId());
+ Serial.print(": ");
+ Serial.println((ValueType)val);
+#endif
+ this->_value = (ValueType) val;
+ }
+ return true;
+ }
+ void storeValue(std::function<void(
+ SerializationData* serializationData)> doStore) override
+ {
+ SerializationData serializationData;
+ serializationData.length = this->getStorageSize();
+ serializationData.data =
+ reinterpret_cast<byte*>(&this->_value);
+ doStore(&serializationData);
+ }
+ void loadValue(std::function<void(
+ SerializationData* serializationData)> doLoad) override
+ {
+ byte buf[this->getStorageSize()];
+ SerializationData serializationData;
+ serializationData.length = this->getStorageSize();
+ serializationData.data = buf;
+ doLoad(&serializationData);
+ ValueType* valuePointer = reinterpret_cast<ValueType*>(buf);
+ this->_value = *valuePointer;
+ }
+ virtual ValueType fromString(String stringValue) = 0;
+
+ ValueType getMax() { return this->_max; }
+ ValueType getMin() { return this->_min; }
+ ValueType isMaxDefined() { return this->_maxDefined; }
+ ValueType isMinDefined() { return this->_minDefined; }
+
+private:
+ ValueType _min;
+ ValueType _max;
+ bool _minDefined = false;
+ bool _maxDefined = false;
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+template <typename ValueType, int base = 10>
+class SignedIntDataType : public PrimitiveDataType<ValueType>
+{
+public:
+ SignedIntDataType(const char* id, ValueType defaultValue) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ PrimitiveDataType<ValueType>::PrimitiveDataType(id, defaultValue) { };
+
+protected:
+ virtual ValueType fromString(String stringValue)
+ {
+ return (ValueType)strtoimax(stringValue.c_str(), nullptr, base);
+ }
+};
+
+template <typename ValueType, int base = 10>
+class UnsignedIntDataType : public PrimitiveDataType<ValueType>
+{
+public:
+ UnsignedIntDataType(const char* id, ValueType defaultValue) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ PrimitiveDataType<ValueType>::PrimitiveDataType(id, defaultValue) { };
+
+protected:
+ virtual ValueType fromString(String stringValue)
+ {
+ return (ValueType)strtoumax(stringValue.c_str(), nullptr, base);
+ }
+};
+
+class BoolDataType : public PrimitiveDataType<bool>
+{
+public:
+ BoolDataType(const char* id, bool defaultValue) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ PrimitiveDataType<bool>::PrimitiveDataType(id, defaultValue) { };
+
+protected:
+ virtual bool fromString(String stringValue)
+ {
+ return stringValue.c_str()[0] == 1;
+ }
+};
+
+class FloatDataType : public PrimitiveDataType<float>
+{
+public:
+ FloatDataType(const char* id, float defaultValue) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ PrimitiveDataType<float>::PrimitiveDataType(id, defaultValue) { };
+
+protected:
+ virtual float fromString(String stringValue)
+ {
+ return atof(stringValue.c_str());
+ }
+};
+
+class DoubleDataType : public PrimitiveDataType<double>
+{
+public:
+ DoubleDataType(const char* id, double defaultValue) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ PrimitiveDataType<double>::PrimitiveDataType(id, defaultValue) { };
+
+protected:
+ virtual double fromString(String stringValue)
+ {
+ return strtod(stringValue.c_str(), nullptr);
+ }
+};
+
+/////////////////////////////////////////////////////////////////////////
+
+class IpDataType : public DataType<IPAddress>
+{
+using DataType<IPAddress>::DataType;
+
+protected:
+ virtual bool update(String newValue, bool validateOnly) override
+ {
+ if (validateOnly)
+ {
+ IPAddress ip;
+ return ip.fromString(newValue);
+ }
+ else
+ {
+ return this->_value.fromString(newValue);
+ }
+ }
+
+ virtual String toString() override { return this->_value.toString(); }
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+/**
+ * Input parameter is the part of the parameter that is responsible
+ * for the appearance of the parameter in HTML.
+ */
+class InputParameter : virtual public ConfigItemBridge
+{
+public:
+ InputParameter(const char* id, const char* label) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ label(label) { }
+
+ virtual void renderHtml(
+ bool dataArrived, WebRequestWrapper* webRequestWrapper) override
+ {
+ String content = this->renderHtml(
+ dataArrived,
+ webRequestWrapper->hasArg(this->getId()),
+ webRequestWrapper->arg(this->getId()));
+ webRequestWrapper->sendContent(content);
+ }
+
+ const char* label;
+
+ /**
+ * This variable is meant to store a value that is displayed in an empty
+ * (not filled) field.
+ */
+ const char* placeholder = nullptr;
+ virtual void setPlaceholder(const char* placeholder) { this->placeholder = placeholder; }
+
+ /**
+ * Usually this variable is used when rendering the form input field
+ * so one can customize the rendered outcome of this particular item.
+ */
+ const char* customHtml = nullptr;
+
+ /**
+ * Used when rendering the input field. Is is overridden by different
+ * implementations.
+ */
+ virtual String getCustomHtml()
+ {
+ return String(customHtml == nullptr ? "" : customHtml);
+ }
+
+ const char* errorMessage = nullptr;
+
+protected:
+ void clearErrorMessage() override
+ {
+ this->errorMessage = nullptr;
+ }
+
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost)
+ {
+ String pitem = String(this->getHtmlTemplate());
+
+ pitem.replace("{b}", this->label);
+ pitem.replace("{t}", this->getInputType());
+ pitem.replace("{i}", this->getId());
+ pitem.replace(
+ "{p}", this->placeholder == nullptr ? "" : this->placeholder);
+ int length = this->getInputLength();
+ if (length > 0)
+ {
+ char parLength[11];
+ snprintf(parLength, 11, "%d", length);
+ String maxLength = String("maxlength=") + parLength;
+ pitem.replace("{l}", maxLength);
+ }
+ else
+ {
+ pitem.replace("{l}", "");
+ }
+ if (hasValueFromPost)
+ {
+ // -- Value from previous submit
+ pitem.replace("{v}", valueFromPost);
+ }
+ else
+ {
+ // -- Value from config
+ pitem.replace("{v}", this->toString());
+ }
+ pitem.replace("{c}", this->getCustomHtml());
+ pitem.replace(
+ "{s}",
+ this->errorMessage == nullptr ? "" : "de"); // Div style class.
+ pitem.replace(
+ "{e}",
+ this->errorMessage == nullptr ? "" : this->errorMessage);
+
+ return pitem;
+ }
+
+ /**
+ * One can override this method in case a specific HTML template is required
+ * for a parameter.
+ */
+ virtual String getHtmlTemplate() { return FPSTR(IOTWEBCONF_HTML_FORM_PARAM); };
+ virtual const char* getInputType() = 0;
+};
+
+template <size_t len>
+class TextTParameter : public CharArrayDataType<len>, public InputParameter
+{
+public:
+using CharArrayDataType<len>::CharArrayDataType;
+ TextTParameter(const char* id, const char* label, const char* defaultValue) :
+ ConfigItemBridge(id),
+ CharArrayDataType<len>::CharArrayDataType(id, defaultValue),
+ InputParameter::InputParameter(id, label) { }
+
+protected:
+ virtual const char* getInputType() override { return "text"; }
+};
+
+class CheckboxTParameter : public BoolDataType, public InputParameter
+{
+public:
+ CheckboxTParameter(const char* id, const char* label, const bool defaultValue) :
+ ConfigItemBridge(id),
+ BoolDataType::BoolDataType(id, defaultValue),
+ InputParameter::InputParameter(id, label) { }
+ bool isChecked() { return this->value(); }
+
+protected:
+ virtual const char* getInputType() override { return "checkbox"; }
+
+ virtual void update(WebRequestWrapper* webRequestWrapper) override
+ {
+ bool selected = false;
+ if (webRequestWrapper->hasArg(this->getId()))
+ {
+ String valueFromPost = webRequestWrapper->arg(this->getId());
+ selected = valueFromPost.equals("selected");
+ }
+// this->update(String(selected ? "1" : "0"));
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(this->getId());
+ Serial.print(": ");
+ Serial.println(selected ? "selected" : "not selected");
+#endif
+ this->_value = selected;
+ }
+
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost) override
+ {
+ bool checkSelected = false;
+ if (dataArrived)
+ {
+ if (hasValueFromPost && valueFromPost.equals("selected"))
+ {
+ checkSelected = true;
+ }
+ }
+ else
+ {
+ if (this->isChecked())
+ {
+ checkSelected = true;
+ }
+ }
+
+ if (checkSelected)
+ {
+ this->customHtml = CheckboxTParameter::_checkedStr;
+ }
+ else
+ {
+ this->customHtml = nullptr;
+ }
+
+ return InputParameter::renderHtml(dataArrived, true, String("selected"));
+ }
+private:
+ const char* _checkedStr = "checked='checked'";
+};
+
+template <size_t len>
+class PasswordTParameter : public CharArrayDataType<len>, public InputParameter
+{
+public:
+using CharArrayDataType<len>::CharArrayDataType;
+ PasswordTParameter(const char* id, const char* label, const char* defaultValue) :
+ ConfigItemBridge(id),
+ CharArrayDataType<len>::CharArrayDataType(id, defaultValue),
+ InputParameter::InputParameter(id, label)
+ {
+ this->customHtml = _customHtmlPwd;
+ }
+
+ void debugTo(Stream* out)
+ {
+ out->print("'");
+ out->print(this->getId());
+ out->print("' with value: ");
+#ifdef IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ out->print("'");
+ out->print(this->_value);
+ out->println("'");
+#else
+ out->println(F("<hidden>"));
+#endif
+ }
+
+ virtual bool update(String newValue, bool validateOnly) override
+ {
+ if (newValue.length() + 1 > len)
+ {
+ return false;
+ }
+ if (validateOnly)
+ {
+ return true;
+ }
+
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.print(this->getId());
+ Serial.print(": ");
+#endif
+ if (newValue.length() > 0)
+ {
+ // -- Value was set.
+ strncpy(this->_value, newValue.c_str(), len);
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+# ifdef IOTWEBCONF_DEBUG_PWD_TO_SERIAL
+ Serial.println(this->_value);
+# else
+ Serial.println("<updated>");
+# endif
+#endif
+ }
+ else
+ {
+#ifdef IOTWEBCONF_DEBUG_TO_SERIAL
+ Serial.println("<was not changed>");
+#endif
+ }
+ return true;
+ }
+
+protected:
+ virtual const char* getInputType() override { return "password"; }
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost) override
+ {
+ return InputParameter::renderHtml(dataArrived, true, String(""));
+ }
+private:
+ const char* _customHtmlPwd = "ondblclick=\"pw(this.id)\"";
+};
+
+/**
+ * All non-complex type input parameters should be inherited from this
+ * base class.
+ */
+template <typename ValueType>
+class PrimitiveInputParameter :
+ public InputParameter
+{
+public:
+ PrimitiveInputParameter(const char* id, const char* label) :
+ ConfigItemBridge::ConfigItemBridge(id),
+ InputParameter::InputParameter(id, label) { }
+
+ virtual String getCustomHtml() override
+ {
+ String modifiers = String(this->customHtml);
+
+ if (this->isMinDefined())
+ {
+ modifiers += " min='" ;
+ modifiers += this->getMin();
+ modifiers += "'";
+ }
+ if (this->isMaxDefined())
+ {
+ modifiers += " max='";
+ modifiers += this->getMax();
+ modifiers += "'";
+ }
+ if (this->step != 0)
+ {
+ modifiers += " step='";
+ modifiers += this->step;
+ modifiers += "'";
+ }
+
+ return modifiers;
+ }
+
+ ValueType step = 0;
+ void setStep(ValueType step) { this->step = step; }
+ virtual ValueType getMin() = 0;
+ virtual ValueType getMax() = 0;
+ virtual bool isMinDefined() = 0;
+ virtual bool isMaxDefined() = 0;
+};
+
+template <typename ValueType, int base = 10>
+class IntTParameter :
+ public virtual SignedIntDataType<ValueType, base>,
+ public PrimitiveInputParameter<ValueType>
+{
+public:
+ IntTParameter(const char* id, const char* label, ValueType defaultValue) :
+ ConfigItemBridge(id),
+ SignedIntDataType<ValueType, base>::SignedIntDataType(id, defaultValue),
+ PrimitiveInputParameter<ValueType>::PrimitiveInputParameter(id, label) { }
+
+ // TODO: somehow organize these methods into common parent.
+ virtual ValueType getMin() override
+ {
+ return PrimitiveDataType<ValueType>::getMin();
+ }
+ virtual ValueType getMax() override
+ {
+ return PrimitiveDataType<ValueType>::getMax();
+ }
+
+ virtual bool isMinDefined() override
+ {
+ return PrimitiveDataType<ValueType>::isMinDefined();
+ }
+ virtual bool isMaxDefined() override
+ {
+ return PrimitiveDataType<ValueType>::isMaxDefined();
+ }
+
+protected:
+ virtual const char* getInputType() override { return "number"; }
+};
+
+template <typename ValueType, int base = 10>
+class UIntTParameter :
+ public virtual UnsignedIntDataType<ValueType, base>,
+ public PrimitiveInputParameter<ValueType>
+{
+public:
+ UIntTParameter(const char* id, const char* label, ValueType defaultValue) :
+ ConfigItemBridge(id),
+ UnsignedIntDataType<ValueType, base>::UnsignedIntDataType(id, defaultValue),
+ PrimitiveInputParameter<ValueType>::PrimitiveInputParameter(id, label) { }
+
+ // TODO: somehow organize these methods into common parent.
+ virtual ValueType getMin() override
+ {
+ return PrimitiveDataType<ValueType>::getMin();
+ }
+ virtual ValueType getMax() override
+ {
+ return PrimitiveDataType<ValueType>::getMax();
+ }
+
+ virtual bool isMinDefined() override
+ {
+ return PrimitiveDataType<ValueType>::isMinDefined();
+ }
+ virtual bool isMaxDefined() override
+ {
+ return PrimitiveDataType<ValueType>::isMaxDefined();
+ }
+
+protected:
+ virtual const char* getInputType() override { return "number"; }
+};
+
+class FloatTParameter :
+ public FloatDataType,
+ public PrimitiveInputParameter<float>
+{
+public:
+ FloatTParameter(const char* id, const char* label, float defaultValue) :
+ ConfigItemBridge(id),
+ FloatDataType::FloatDataType(id, defaultValue),
+ PrimitiveInputParameter<float>::PrimitiveInputParameter(id, label) { }
+
+ virtual float getMin() override
+ {
+ return PrimitiveDataType<float>::getMin();
+ }
+ virtual float getMax() override
+ {
+ return PrimitiveDataType<float>::getMax();
+ }
+
+ virtual bool isMinDefined() override
+ {
+ return PrimitiveDataType<float>::isMinDefined();
+ }
+ virtual bool isMaxDefined() override
+ {
+ return PrimitiveDataType<float>::isMaxDefined();
+ }
+
+protected:
+ virtual const char* getInputType() override { return "number"; }
+};
+
+/**
+ * Options parameter is a structure, that handles multiple values when redering
+ * the HTML representation.
+ */
+template <size_t len>
+class OptionsTParameter : public TextTParameter<len>
+{
+public:
+ /**
+ * @optionValues - List of values to choose from with, where each value
+ * can have a maximal size of 'length'. Contains 'optionCount' items.
+ * @optionNames - List of names to render for the values, where each
+ * name can have a maximal size of 'nameLength'. Contains 'optionCount'
+ * items.
+ * @optionCount - Size of both 'optionValues' and 'optionNames' lists.
+ * @nameLength - Size of any item in optionNames list.
+ * (See TextParameter for arguments!)
+ */
+ OptionsTParameter(
+ const char* id, const char* label, const char* defaultValue,
+ const char* optionValues, const char* optionNames,
+ size_t optionCount, size_t nameLength) :
+ ConfigItemBridge(id),
+ TextTParameter<len>(id, label, defaultValue)
+ {
+ this->_optionValues = optionValues;
+ this->_optionNames = optionNames;
+ this->_optionCount = optionCount;
+ this->_nameLength = nameLength;
+ }
+
+ // TODO: make these protected
+ void setOptionValues(const char* optionValues) { this->_optionValues = optionValues; }
+ void setOptionNames(const char* optionNames) { this->_optionNames = optionNames; }
+ void setOptionCount(size_t optionCount) { this->_optionCount = optionCount; }
+ void setNameLength(size_t nameLength) { this->_nameLength = nameLength; }
+protected:
+ OptionsTParameter(
+ const char* id, const char* label, const char* defaultValue) :
+ ConfigItemBridge(id),
+ TextTParameter<len>(id, label, defaultValue)
+ {
+ }
+
+ const char* _optionValues;
+ const char* _optionNames;
+ size_t _optionCount;
+ size_t _nameLength;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Select parameter is an option parameter, that rendered as HTML SELECT.
+ * Basically it is a dropdown combobox.
+ */
+template <size_t len>
+class SelectTParameter : public OptionsTParameter<len>
+{
+public:
+ /**
+ * Create a select parameter for the config portal.
+ *
+ * (See OptionsParameter for arguments!)
+ */
+ SelectTParameter(
+ const char* id, const char* label, const char* defaultValue,
+ const char* optionValues, const char* optionNames,
+ size_t optionCount, size_t nameLength) :
+ ConfigItemBridge(id),
+ OptionsTParameter<len>(
+ id, label, defaultValue, optionValues, optionNames, optionCount, nameLength)
+ { }
+ // TODO: make this protected
+ SelectTParameter(
+ const char* id, const char* label, const char* defaultValue) :
+ ConfigItemBridge(id),
+ OptionsTParameter<len>(id, label, defaultValue) { }
+
+protected:
+ // Overrides
+ virtual String renderHtml(
+ bool dataArrived, bool hasValueFromPost, String valueFromPost) override
+ {
+ String options = "";
+
+ for (size_t i=0; i<this->_optionCount; i++)
+ {
+ const char *optionValue = (this->_optionValues + (i*len) );
+ const char *optionName = (this->_optionNames + (i*this->_nameLength) );
+ String oitem = FPSTR(IOTWEBCONF_HTML_FORM_OPTION);
+ oitem.replace("{v}", optionValue);
+// if (sizeof(this->_optionNames) > i)
+ {
+ oitem.replace("{n}", optionName);
+ }
+// else
+// {
+// oitem.replace("{n}", "?");
+// }
+ if ((hasValueFromPost && (valueFromPost == optionValue)) ||
+ (strncmp(this->value(), optionValue, len) == 0))
+ {
+ // -- Value from previous submit
+ oitem.replace("{s}", " selected");
+ }
+ else
+ {
+ // -- Value from config
+ oitem.replace("{s}", "");
+ }
+
+ options += oitem;
+ }
+
+ String pitem = FPSTR(IOTWEBCONF_HTML_FORM_SELECT_PARAM);
+
+ pitem.replace("{b}", this->label);
+ pitem.replace("{i}", this->getId());
+ pitem.replace(
+ "{c}", this->customHtml == nullptr ? "" : this->customHtml);
+ pitem.replace(
+ "{s}",
+ this->errorMessage == nullptr ? "" : "de"); // Div style class.
+ pitem.replace(
+ "{e}",
+ this->errorMessage == nullptr ? "" : this->errorMessage);
+ pitem.replace("{o}", options);
+
+ return pitem;
+ }
+
+private:
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Color chooser.
+ */
+class ColorTParameter : public CharArrayDataType<8>, public InputParameter
+{
+public:
+using CharArrayDataType<8>::CharArrayDataType;
+ ColorTParameter(const char* id, const char* label, const char* defaultValue) :
+ ConfigItemBridge(id),
+ CharArrayDataType<8>::CharArrayDataType(id, defaultValue),
+ InputParameter::InputParameter(id, label) { }
+
+protected:
+ virtual const char* getInputType() override { return "color"; }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Date chooser.
+ */
+class DateTParameter : public CharArrayDataType<11>, public InputParameter
+{
+public:
+using CharArrayDataType<11>::CharArrayDataType;
+ DateTParameter(const char* id, const char* label, const char* defaultValue) :
+ ConfigItemBridge(id),
+ CharArrayDataType<11>::CharArrayDataType(id, defaultValue),
+ InputParameter::InputParameter(id, label) { }
+
+protected:
+ virtual const char* getInputType() override { return "date"; }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Time chooser.
+ */
+class TimeTParameter : public CharArrayDataType<6>, public InputParameter
+{
+public:
+using CharArrayDataType<6>::CharArrayDataType;
+ TimeTParameter(const char* id, const char* label, const char* defaultValue) :
+ ConfigItemBridge(id),
+ CharArrayDataType<6>::CharArrayDataType(id, defaultValue),
+ InputParameter::InputParameter(id, label) { }
+
+protected:
+ virtual const char* getInputType() override { return "time"; }
+};
+
+} // end namespace
+
+#include <IotWebConfTParameterBuilder.h>
+
+#endif
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameterBuilder.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameterBuilder.h
new file mode 100644
index 0000000..ce546dd
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfTParameterBuilder.h
@@ -0,0 +1,170 @@
+/**
+ * IotWebConfTParameter.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2021 Balazs Kelemen <prampec+arduino@gmail.com>
+ * rovo89
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConfTParameterBuilder_h
+#define IotWebConfTParameterBuilder_h
+
+#include <IotWebConfTParameter.h>
+
+namespace iotwebconf
+{
+
+template <typename ParamType> class Builder;
+
+template <typename ParamType>
+class AbstractBuilder
+{
+public:
+ AbstractBuilder(const char* id) : _id(id) { };
+ virtual ParamType build() const
+ {
+ ParamType instance = std::move(
+ ParamType(this->_id, this->_label, this->_defaultValue));
+ this->apply(&instance);
+ return instance;
+ }
+
+ Builder<ParamType>& label(const char* label)
+ { this->_label = label; return static_cast<Builder<ParamType>&>(*this); }
+ Builder<ParamType>& defaultValue(typename ParamType::DefaultValueType defaultValue)
+ { this->_defaultValue = defaultValue; return static_cast<Builder<ParamType>&>(*this); }
+
+protected:
+ virtual ParamType* apply(ParamType* instance) const
+ {
+ return instance;
+ }
+ const char* _label;
+ const char* _id;
+ typename ParamType::DefaultValueType _defaultValue;
+};
+
+template <typename ParamType>
+class Builder : public AbstractBuilder<ParamType>
+{
+public:
+ Builder(const char* id) : AbstractBuilder<ParamType>(id) { };
+};
+
+///////////////////////////////////////////////////////////////////////////
+
+template <typename ValueType, typename ParamType>
+class PrimitiveBuilder :
+ public AbstractBuilder<ParamType>
+{
+public:
+ PrimitiveBuilder<ValueType, ParamType>(const char* id) :
+ AbstractBuilder<ParamType>(id) { };
+ Builder<ParamType>& min(ValueType min) { this->_minDefined = true; this->_min = min; return static_cast<Builder<ParamType>&>(*this); }
+ Builder<ParamType>& max(ValueType max) { this->_maxDefined = true; this->_max = max; return static_cast<Builder<ParamType>&>(*this); }
+ Builder<ParamType>& step(ValueType step) { this->_step = step; return static_cast<Builder<ParamType>&>(*this); }
+ Builder<ParamType>& placeholder(const char* placeholder) { this->_placeholder = placeholder; return static_cast<Builder<ParamType>&>(*this); }
+
+protected:
+ virtual ParamType* apply(
+ ParamType* instance) const override
+ {
+ if (this->_minDefined)
+ {
+ instance->setMin(this->_min);
+ }
+ if (this->_maxDefined)
+ {
+ instance->setMax(this->_max);
+ }
+ instance->setStep(this->_step);
+ instance->setPlaceholder(this->_placeholder);
+ return instance;
+ }
+
+ bool _minDefined = false;
+ bool _maxDefined = false;
+ ValueType _min;
+ ValueType _max;
+ ValueType _step = 0;
+ const char* _placeholder = nullptr;
+};
+
+template <typename ValueType, int base>
+class Builder<IntTParameter<ValueType, base>> :
+ public PrimitiveBuilder<ValueType, IntTParameter<ValueType, base>>
+{
+public:
+ Builder<IntTParameter<ValueType, base>>(const char* id) :
+ PrimitiveBuilder<ValueType, IntTParameter<ValueType, base>>(id) { };
+};
+
+template <typename ValueType, int base>
+class Builder<UIntTParameter<ValueType, base>> :
+ public PrimitiveBuilder<ValueType, UIntTParameter<ValueType, base>>
+{
+public:
+ Builder<UIntTParameter<ValueType, base>>(const char* id) :
+ PrimitiveBuilder<ValueType, UIntTParameter<ValueType, base>>(id) { };
+};
+
+template <>
+class Builder<FloatTParameter> :
+ public PrimitiveBuilder<float, FloatTParameter>
+{
+public:
+ Builder<FloatTParameter>(const char* id) :
+ PrimitiveBuilder<float, FloatTParameter>(id) { };
+};
+
+
+template <size_t len>
+class Builder<SelectTParameter<len>> :
+ public AbstractBuilder<SelectTParameter<len>>
+{
+public:
+ Builder<SelectTParameter<len>>(const char* id) :
+ AbstractBuilder<SelectTParameter<len>>(id) { };
+
+ virtual SelectTParameter<len> build() const override
+ {
+ return SelectTParameter<len>(
+ this->_id, this->_label, this->_defaultValue,
+ this->_optionValues, this->_optionNames,
+ this->_optionCount, this->_nameLength);
+ }
+
+ Builder<SelectTParameter<len>>& optionValues(const char* optionValues)
+ { this->_optionValues = optionValues; return *this; }
+ Builder<SelectTParameter<len>>& optionNames(const char* optionNames)
+ { this->_optionNames = optionNames; return *this; }
+ Builder<SelectTParameter<len>>& optionCount(size_t optionCount)
+ { this->_optionCount = optionCount; return *this; }
+ Builder<SelectTParameter<len>>& nameLength(size_t nameLength)
+ { this->_nameLength = nameLength; return *this; }
+
+protected:
+ virtual SelectTParameter<len>* apply(
+ SelectTParameter<len>* instance) const override
+ {
+ instance->setOptionValues(this->_optionValues);
+ instance->setOptionNames(this->_optionNames);
+ instance->setOptionCount(this->_optionCount);
+ instance->setNameLength(this->_nameLength);
+ return instance;
+ }
+
+private:
+ const char* _optionValues;
+ const char* _optionNames;
+ size_t _optionCount;
+ size_t _nameLength;
+};
+
+} // End namespace
+
+#endif
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfUsing.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfUsing.h
new file mode 100644
index 0000000..c8e121a
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfUsing.h
@@ -0,0 +1,24 @@
+/**
+ * IotWebConfUsing.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef IotWebConfUsing_h
+#define IotWebConfUsing_h
+
+// This "using" lines are just aliases, and should avoided.
+
+using IotWebConfParameterGroup = iotwebconf::ParameterGroup;
+using IotWebConfTextParameter = iotwebconf::TextParameter;
+using IotWebConfPasswordParameter = iotwebconf::PasswordParameter;
+using IotWebConfNumberParameter = iotwebconf::NumberParameter;
+using IotWebConfCheckboxParameter = iotwebconf::CheckboxParameter;
+using IotWebConfSelectParameter = iotwebconf::SelectParameter;
+
+#endif
\ No newline at end of file
diff --git a/ampel-firmware/src/lib/IotWebConf/src/IotWebConfWebServerWrapper.h b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfWebServerWrapper.h
new file mode 100644
index 0000000..6d9a3b7
--- /dev/null
+++ b/ampel-firmware/src/lib/IotWebConf/src/IotWebConfWebServerWrapper.h
@@ -0,0 +1,47 @@
+/**
+ * IotWebConfWebServerWrapper.h -- IotWebConf is an ESP8266/ESP32
+ * non blocking WiFi/AP web configuration library for Arduino.
+ * https://github.com/prampec/IotWebConf
+ *
+ * Copyright (C) 2020 Balazs Kelemen <prampec+arduino@gmail.com>
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+#ifndef WebServerWrapper_h
+#define WebServerWrapper_h
+
+#include <Arduino.h>
+#include <IPAddress.h>
+
+namespace iotwebconf
+{
+
+class WebRequestWrapper
+{
+public:
+ virtual const String hostHeader() const;
+ virtual IPAddress localIP();
+ virtual uint16_t localPort();
+ virtual const String uri() const;
+ virtual bool authenticate(const char * username, const char * password);
+ virtual void requestAuthentication();
+ virtual bool hasArg(const String& name);
+ virtual String arg(const String name);
+ virtual void sendHeader(const String& name, const String& value, bool first = false);
+ virtual void setContentLength(const size_t contentLength);
+ virtual void send(int code, const char* content_type = nullptr, const String& content = String(""));
+ virtual void sendContent(const String& content);
+ virtual void stop();
+};
+
+class WebServerWrapper
+{
+public:
+ virtual void handleClient();
+ virtual void begin();
+};
+
+} // end namespace
+#endif
\ No newline at end of file
diff --git a/platformio.ini b/platformio.ini
index 7c418fb..43f3d44 100644
--- a/platformio.ini
+++ b/platformio.ini
@@ -16,13 +16,6 @@ platform = espressif8266
board = esp12e
framework = arduino
monitor_speed = 115200
-lib_deps =
- EEPROM
- DNSServer
- prampec/IotWebConf@^3.2.0
-build_flags =
-; Disabling debug helps a bit with available memory.
- -D IOTWEBCONF_DEBUG_DISABLED
[env:esp32]
platform = espressif32
@@ -31,9 +24,6 @@ framework = arduino
monitor_speed = 115200
lib_deps =
MCCI LoRaWAN LMIC library
- EEPROM
- DNSServer
- prampec/IotWebConf@^3.2.0
build_flags =
-D ARDUINO_LMIC_PROJECT_CONFIG_H_SUPPRESS
-D CFG_eu868=1
--
GitLab