v8.0.3

v8.0.1

.gitignore

@@ -2,14 +2,13 @@
 .pio/
 .vscode/
 .code-workspace
-.helper/
 /sd-card/htm./.vscode/
+/code/build
 
 CMakeLists.txt.user
 CMakeCache.txt
 CMakeFiles
 CMakeScripts
-Testing
 Makefile
 cmake_install.cmake
 install_manifest.txt

Changelog.md

@@ -1,6 +1,208 @@
 # Versions
 
+
+
+##### 6.7.2 Image Processing in Memory - (2021-05-01)
+
+* NEW 6.7.2: Updated html for setup modus - remove reboot on edit configuration)
+
+* NEW 6.7.1: Improved stability of camera (back to v6.6.1) - remove black strips and areas
+
+* Upgrade digital CNN to v8.3.0  (added new type of digits)
+
+* Internal update: TFlite (v2.5), esp32cam, startup sequence
+
+* Rollback to espressif v2.1.0, as v3.2.0 shows unstable reboot
+
+* Bugfix: WLan-passwords, reset of hostname
+
+
+##### 6.6.1 Image Processing in Memory - (2021-04-05)
+
+* NEW 6.6.1: failed SD card initialization indicated by fast blinking LED at startup
+* Improved SD-card handling (increase compatibility with more type of cards)
+
+##### 6.5.0 Image Processing in Memory - (2021-03-25)
+
+* Upgrade digital CNN to v8.2.0  (added new type of digits)
+* Supporting alignment structures in ROI definition
+* Bug fixing: definition of  hostname in `config.ini`
+
+##### 6.4.0 Image Processing in Memory - (2021-03-20)
+
+* Additional alignment marks for settings the ROIs (analog and digit)
+* Upgrade analog CNN to v7.0.0 (added new type of pointer)
+
+##### 6.3.1 Image Processing in Memory - (2021-03-16)
+
+* NEW: 6.3.1: bug fixing in initial edit reference image and `config.ini` (Spelling error in `InitialRotate`)
+* Initial setup mode: bug fixing, error correction
+* Bug-fixing
+
+##### 6.2.2 Image Processing in Memory - (2021-03-10)
+
+* NEW 6.2.2: bug fixing
+* NEW 6.2.1: Changed brightness and contrast to default if not enabled (resolves to bright images)
+* Determination of fixed illumination settings during startup - speed up of 5s in each run
+* Update digital CNN to v8.1.1 (additional digital images trained)
+* Extended error message in MQTT error message
+
+
+* Image brightness is now adjustable 
+
+
+* Bug fixing: minor topics 
+
+
+##### 6.1.0 Image Processing in Memory - (2021-01-20)
+
+* Disabling of analog / digital counters in configuration 
+* Improved Alignment Algorithm (`AlignmentAlgo`  = `Default`,  `Accurate` , `Fast`)
+* Analog counters: `ExtendedResolution` (last digit is extended by sub comma value of CNN)
+* `config.ini`: additional parameter `hostname`  (additional to wlan.ini)
+* Switching of GPIO12/13 via http-interface: `/GPIO?GPIO=12&Status=high/low`
+* Bug fixing: html configuration page, wlan password ("=" now possible)
+
+##### 6.0.0 Image Processing in Memory - (2021-01-02)
+
+* **Major change**: image processing fully in memory - no need of SD card buffer anymore
+
+  * Need to limit camera resolution to VGA (due to memory limits)
+* MQTT: Last Will Testament (LWT) implemented: "connection lost" in case of connection lost to `TopicError`
+* Disabled `CheckDigitIncreaseConsistency` in default configuration - must now be explicit enabled if needed
+* Update digital CNN to v7.2.1 (additional digital images trained) 
+* Setting of arbitrary time server in `config.ini`
+* Option for fixed IP-, DNS-Settings in `wlan.ini`
+* Increased stability (internal image and camera handling)
+* Bug fixing: edit digits, handling PreValue, html-bugs
+
+
+
+##### 5.0.0 Setup Modus - (2020-12-06)
+
+* Implementation of initial setup modus for fresh installation
+
+* Code restructuring (full compatibility between pure ESP-IDF and Platformio w/ espressif)
+
+  
+
+##### 4.1.1 Configuration editor - (2020-12-02)
+
+* Bug fixing: internal improvement of file handling (reduce not responding)
+
+
+##### 4.1.0 Configuration editor - (2020-11-30)
+
+* Implementation of configuration editor (including basic and expert mode)
+
+* Adjustable time zone to adjust to local time setting (incl. daylight saving time)
+
+* MQTT: additional topic for error reporting
+
+* standardized access to current logfile via `http://IP-ADRESS/logfileact`
+
+* Update digital CNN to v7.2.0, analog CNN to 6.3.0
+
+* Bug fixing: truncation error,  CheckDigitConsistency & PreValue implementation
+
+
+
+##### 4.0.0 Tflite Core - (2020-11-15)
+
+* Implementation of rolling log-files
+
+* Update Tflite-Core to master@20201108 (v2.4)
+
+* Bug-fixing for reducing reboots
+
+  
+
+##### 3.1.0 MQTT-Client - (2020-10-26)
+
+* Update digital CNN to v6.5.0 and HTML (Info to hostname, IP, ssid)
+
+* New implementation of "checkDigitConsistency" also for digits
+* MQTT-Adapter: user and password for sign in MQTT-Broker
+
+##### 3.0.0 MQTT-Client  (2020-10-14)
+
+* Implementation of MQTT Client
+* Improved Version Control
+* bug-fixing
+
+
+
+##### 2.2.1 Version Control  (2020-09-27)
+
+* Bug-Fixing (hostname in wlan.ini and error handling inside flow)
+
+
+##### 2.2.0 Version Control  (2020-09-27)
+
+* Integrated automated versioning system (menu: SYSTEM --> INFO)
+* Update Build-System to PlatformIO - Espressif 32 v2.0.0 (ESP-IDF 4.1)
+
+
+##### 2.1.0 Decimal Shift, Chrome & Edge  (2020-09-25)
+
+* Implementation of Decimal Shift
+
+* Update default CNN for digits to v6.4.0
+
+* Improvement HTML
+
+* Support for Chrome and Edge
+
+* Reduce logging to minimum - extended logging on demand
+
+* Implementation of hostname in wlan.ini (`hostname = "HOSTNAME")`
+
+* Bug fixing, code corrections
+
+
+##### 2.0.0 Layout update  (2020-09-12)
+
+  * Update to **new and modern layout**
+  * Support for Chrome improved
+  * Improved robustness: improved error handling in auto flow reduces spontaneous reboots
+  * File server: Option for "DELETE ALL"
+  * WLan: support of spaces in SSID and password
+  * Reference Image: Option for mirror image, option for image update on the fly
+  * additional parameter in `wasserzaehler.html?noerror=true`  to suppress an potential error message
+  * bug fixing
+
+
+
+##### 1.1.3 (2020-09-09)
+
+* **Bug in configuration of analog ROIs corrected** - correction in v.1.0.2 did not work properly
+* Improved update page for the web server (`/html` can be updated via a zip-file, which is provided in `/firmware/html.zip`)
+* Improved Chrome support
+
+##### 1.1.0 (2020-09-06)
+
+* Implementation of "delete complete directory"
+  **Attention: beside the `firmware.bin`, also the content of `/html` needs to be updated!**
+
+
+
+##### 1.0.2 (2020-09-06)
+
+* Bug in configuration of analog ROIs corrected
+* minor bug correction
+
+##### 1.0.1 (2020-09-05)
+
+* preValue.ini Bug corrected
+* minor bug correction
+
+##### 1.0.0 (2020-09-04)
+
+* **First usable version** - compatible to previous project (https://github.com/jomjol/water-meter-system-complete)
+* NEW: 
+  * no docker container for CNN calculation necessary
+  * web based configuration editor on board
+
 ##### 0.1.0 (2020-08-07)
 
-* Initial Version
-
+* Initial Version

FeatureRequest.md

@@ -0,0 +1,117 @@
+## Feature Requests
+
+**There are a lot of ideas for further improvements, but only limited capacity on side of the developer.** Therefore I have created this page as a collection of ideas. 
+
+1. Who ever has a new idea can put it here, so it that it is not forgotten. 
+
+2. Who ever has time, capacity and passion to support, can take any of the ideas and implement them. 
+   I will support and help where ever I can!
+   
+   
+
+____
+
+#### #9 Basic auth for the UI
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/283
+
+* Implementation of an authentication mechanism.
+
+#### #8 MQTT configurable readout intervall
+
+Make the readout intervall configurable via MQTT.
+
+* Change the mqtt part to receive and process input and not only sending
+
+#### #7 Extended Error Handling
+
+Check different types of error (e.g. tflite not availabe) and generate an error on the html page.
+
+To do:
+
+* Make a list of "important" errors
+* Implement a checking algo
+* Extend the firmware and html page for the error handling
+
+#### ~~#6 Check for double ROI names~~ - implemented v8.0.0
+
+~~Check during configuration, that ROI names are unique.~~
+
+~~To do:~~
+
+* ~~Implementation of ROI name checking in html code before saving analog or digital ROIs~~
+
+  
+
+#### #5 Configurable decimal separator (point or comma) 
+
+Decimal separator configurable for different systems
+
+To do:
+
+* Implementation of decimal point into postprocessing module
+* Extension of configuration
+* Adaption of the html configuration to implement shifting
+
+
+
+#### ~~#4 Initial Shifting and Rotation~~ - implemented v7.0.0
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/123~~
+
+~~Implementation of a shifting additional to the initial rotation of the raw camera input~~
+
+~~To do:~~
+
+* ~~Implementation of shifting~~
+* ~~Extension of configuration~~
+* ~~Adaption of the html configuration to implement shifting~~
+
+
+
+#### ~~#3 Allow grouping of digits to multiple reading values~~ - implemented v8.0.0
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/123~~
+
+~~Implementation of two different independent readouts in one setup~~
+
+~~To do:~~
+
+* ~~Extend the configuration, setting and processing flow for two independend readouts~~
+
+
+
+
+
+____
+
+#### #2 MQTT-controll with callback 
+* https://github.com/jomjol/AI-on-the-edge-device/issues/105
+
+Extend the MQTT client to also enable callbacks for configuration setting
+
+To do:
+
+* implement callback for receiving information and override `config.ini` settings
+
+* change configuration management to handle online updates (currently changes need a restart)
+
+* think about the startup, as there the default config is loaded 
+
+  
+
+____
+
+#### ~~#1 Optional GPIO for external flash/lighting~~ - implemented (v8.0.0)
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/133~~
+
+~~Implementation of an an extrnal flash / lightning through GPIOs.~~
+
+* ~~available GPIOs: 12 & 13 (currently in use for html switching)~~
+
+~~To do:~~
+
+* ~~Implementation of a software module for external light source (e.g. WS8132 LED controller, ...)~~
+* ~~Update of the camera module to use the external light instead of the internal flash light~~
+* ~~Adopt the configuration algorithm with a configurable light source~~

README.md

@@ -4,24 +4,42 @@ This is an example of Artificial Intelligence (AI) calculations on a very cheap
 
 ### Details on **function**, **installation** and **configuration** can be found on the **[Wiki Page](https://github.com/jomjol/AI-on-the-edge-device/wiki)**
 
-A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4571627
+A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4573481
+
+respectively ESP32-Cam housing only: https://www.thingiverse.com/thing:4571627
 
 <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/watermeter_all.jpg" width="200"><img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/main.jpg" width="200"><img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/size.png" width="200"> 
 
 <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/watermeter.jpg" width="600"> 
-<img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/edit_reference.jpg" width="600"> 
+
+<img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/powermeter.jpg" width="600"> 
 
 
 
+
+## Donate
+
+------
+
+If you would like to support the developer with a cup of coffee you can do that via [Paypal](https://www.paypal.com/donate?hosted_button_id=8TRSVYNYKDSWL).
+
+<form action="https://www.paypal.com/donate" method="post" target="_top">
+<input type="hidden" name="hosted_button_id" value="8TRSVYNYKDSWL" />
+<input type="image" src="https://www.paypalobjects.com/en_US/DK/i/btn/btn_donateCC_LG.gif" border="0" name="submit" title="PayPal - The safer, easier way to pay online!" alt="Donate with PayPal button" />
+<img alt="" border="0" src="https://www.paypal.com/en_DE/i/scr/pixel.gif" width="1" height="1" />
+</form>
+If you have any technical topics, you can file a issue in this repository. 
+
+In other cases you can contact the developer via email: <img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/mail.jpg" height="25"> 
+
 ## Change log
 
 ------
 
 ### Known Issues
 
-* Parts of the web page only works correctly in **Firefox** and Chrome!
-  With **Edge** not all parts (especially the configuration) are **not full functional**.
-* spontaneous reboot, especially in case of intensive web server access (improved since v2.0.0)
+* slow response of web server during picture analysis
+* spontaneous reboots (mostly due to html access during image processing) - self recovery implemented
 
 ------
 
@@ -29,58 +47,74 @@ A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4571
 
 
 
-##### Rolling - (2020-09-12)
+##### 8.0.3 - Multi Meter Support (2021-07-25)
 
-* based on v2.0.0 (2020-09-12)
+* NEW 8.0.3: bug fix: reboot during `config.ini` handling, html error
+* NEW 8.0.2: saving roundes prevalue, bug fix html server
+* NEW 8.0.1: bug fix html handling of parameter `FixedExposure` and `ImageSize`
+* Dual / multi meter support (more than 1 number to be recognized)
+  This is implemented with the feature "number" on the ROI definition as well as selected options
+* MQTT: standardization of the naming - including new topics (`json`,  `freeMem `, `uptime`)c
+* Preparation for extended GPIO support (thanks to Zwerk2k) - not tested and fully functional yet
+* Bug fixing: html server, memory leak, MQTT connect, hostname, turn of flash LED
+
+<span style="color: red;">**ATTENTION: the configuration and prevalue files are modified automatically and will not be backward compatible!**</span> 
+
+
+
+##### 7.1.2 MQTT-Update - (2021-06-17)
+
+* NEW: 7.1.2: bug fix setting hostname, Flash-LED not off during rebootNEW: 7.1.1: bug fix wlan password with "="  (again)
+* MQTT error message: changes "no error", send retain flag
+* Update wlan handling to esp-idf 4.1
+* Upgrade digital CNN to v8.7.0  (added new images)
+* Bug fix: MQTT, WLAN, LED-Controll, GPIO usage, fixed IP, calculation flow rate
 
   
 
-##### 2.0.0 Layout update  (2020-09-12)
+##### 7.0.1 MQTT-Update - (2021-05-13)
 
-  * Update to **new and modern layout**
-  * Support for Chrome improved
-  * Improved robustness: improved error handling in auto flow reduces spontaneous reboots
-  * File server: Option for "DELETE ALL"
-  * WLan: support of spaces in SSID and password
-  * Reference Image: Option for mirror image, option for image update on the fly
-  * additional parameter in `wasserzaehler.html?noerror=true`  to suppress an potential error message
-  * bug fixing
+* NEW: 7.0.1: bug fix wlan password with "=" 
+
+* Upgrade digital CNN to v8.5.0  (added new images)
+
+* New MQTT topics: flow rate (units/minute), time stamp (last correct read readout)
+
+* Update MQTT/Error topic to " " in case no error (instead of empty string)
+
+* Portrait or landscape image orientation in rotated image (avoid cropping)
+
+  
+
+
+## Additional ideas
+
+There are some ideas and feature request, which are not followed currently - mainly due to capacity reasons on side of the developer. They are collected here: [FeatureRequest.md](FeatureRequest.md)
 
 
 
-##### 1.1.3 (2020-09-09)
+------
 
-* **Bug in configuration of analog ROIs corrected** - correction in v.1.0.2 did not work properly
-* Improved update page for the web server (`/html` can be updated via a zip-file, which is provided in `/firmware/html.zip`)
-* Improved Chrome support
+## History
 
-##### 1.1.0 (2020-09-06)
+##### 6.7.2 Image Processing in Memory - (2021-05-01)
 
-* Implementation of "delete complete directory"
-  **Attention: beside the `firmware.bin`, also the content of `/html` needs to be updated!**
+##### 5.0.0 Setup Modus - (2020-12-06)
+
+##### 4.1.1 Configuration editor - (2020-12-02)
+
+##### 4.0.0 Tflite Core - (2020-11-15)
+##### 3.1.0 MQTT-Client - (2020-10-26)
+
+##### 2.2.1 Version Control - (2020-09-27)
 
 
+##### 2.1.0 Decimal Shift, Chrome & Edge - (2020-09-25)
 
-##### 1.0.2 (2020-09-06)
 
-* Bug in configuration of analog ROIs corrected
-* minor bug correction
+##### 2.0.0 Layout update - (2020-09-12)
 
-##### 1.0.1 (2020-09-05)
-
-* preValue.ini Bug corrected
-* minor bug correction
-
-##### 1.0.0 (2020-09-04)
-
-* **First usable version** - compatible to previous project (https://github.com/jomjol/water-meter-system-complete)
-* NEW: 
-  * no docker container for CNN calculation necessary
-  * web based configuration editor on board
-
-##### 0.1.0 (2020-08-07)
-
-* Initial Version
+##### 1.1.3 Initial Version - (2020-09-09)
 
 
 #### [Full Changelog](Changelog.md)
@@ -89,4 +123,4 @@ A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4571
 
 ## Solved topics
 
-* n.a.
+* n.a.

code/.gitignore

@@ -3,4 +3,3 @@
 .vscode/c_cpp_properties.json
 .vscode/launch.json
 .vscode/ipch
-.helper

code/.helper/copy.bat

@@ -1,3 +1,3 @@
-copy "C:\Users\Muell\Documents\Programmieren\GitHub\AI-on-the-edge-device\code\.pio\build\esp32cam\firmware.bin" "C:\Users\Muell\Documents\Programmieren\GitHub\AI-on-the-edge-device\firmware\firmware.bin"
-copy "C:\Users\Muell\Documents\Programmieren\GitHub\AI-on-the-edge-device\code\.pio\build\esp32cam\bootloader.bin" "C:\Users\Muell\Documents\Programmieren\GitHub\AI-on-the-edge-device\firmware\bootloader.bin"
-copy "C:\Users\Muell\Documents\Programmieren\GitHub\AI-on-the-edge-device\code\.pio\build\esp32cam\partitions.bin" "C:\Users\Muell\Documents\Programmieren\GitHub\AI-on-the-edge-device\firmware\partitions.bin"
+copy "..\..\code\.pio\build\esp32cam\firmware.bin" "..\..\firmware\firmware.bin"
+copy "..\..\code\.pio\build\esp32cam\bootloader.bin" "..\..\firmware\bootloader.bin"
+copy "..\..\code\.pio\build\esp32cam\partitions.bin" "..\..\firmware\partitions.bin"

code/.helper/makezip.bat

@@ -0,0 +1 @@
+powershell Compress-Archive "..\..\sd-card\html\*.*" "..\..\firmware\html.zip"

code/CMakeLists.txt

@@ -1,8 +1,15 @@
-cmake_minimum_required(VERSION 3.16.0)
+cmake_minimum_required(VERSION 3.13.4)
 
 list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
 
 set(PROJECT_VER "0.0.9.3")
 
+ADD_CUSTOM_COMMAND(
+    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/version.cpp
+           ${CMAKE_CURRENT_BINARY_DIR}/_version.cpp
+    COMMAND ${CMAKE_COMMAND} -P
+            ${CMAKE_CURRENT_SOURCE_DIR}/version.cmake)
+
+
 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
 project(esp32cam-server-only)

code/components/esp32-camera-master/.gitignore

@@ -0,0 +1 @@
+*.DS_Store

code/components/esp32-camera-master/CMakeLists.txt

@@ -0,0 +1,35 @@
+if(IDF_TARGET STREQUAL "esp32")
+  set(COMPONENT_SRCS
+    driver/camera.c
+    driver/sccb.c
+    driver/sensor.c
+    driver/xclk.c
+    sensors/ov2640.c
+    sensors/ov3660.c
+    sensors/ov5640.c
+    sensors/ov7725.c
+    sensors/ov7670.c
+    sensors/nt99141.c
+    conversions/yuv.c
+    conversions/to_jpg.cpp
+    conversions/to_bmp.c
+    conversions/jpge.cpp
+    conversions/esp_jpg_decode.c
+    )
+
+  set(COMPONENT_ADD_INCLUDEDIRS
+    driver/include
+    conversions/include
+    )
+
+  set(COMPONENT_PRIV_INCLUDEDIRS
+    driver/private_include
+    sensors/private_include
+    conversions/private_include
+    )
+
+  set(COMPONENT_REQUIRES driver)
+  set(COMPONENT_PRIV_REQUIRES freertos nvs_flash)
+
+  register_component()
+endif()

code/components/esp32-camera-master/Kconfig

@@ -0,0 +1,71 @@
+menu "Camera configuration"
+
+    config OV7670_SUPPORT
+        bool "Support OV7670 VGA"
+        default y
+        help
+            Enable this option if you want to use the OV7670.
+            Disable this option to safe memory.
+
+    config OV7725_SUPPORT
+        bool "Support OV7725 SVGA"
+        default n
+        help
+            Enable this option if you want to use the OV7725.
+            Disable this option to save memory.
+
+    config NT99141_SUPPORT
+        bool "Support NT99141 HD"
+        default y
+        help
+            Enable this option if you want to use the NT99141.
+            Disable this option to save memory.
+
+    config OV2640_SUPPORT
+        bool "Support OV2640 2MP"
+        default y
+        help
+            Enable this option if you want to use the OV2640.
+            Disable this option to save memory.
+
+    config OV3660_SUPPORT
+        bool "Support OV3660 3MP"
+        default y
+        help
+            Enable this option if you want to use the OV3360.
+            Disable this option to save memory.
+
+    config OV5640_SUPPORT
+        bool "Support OV5640 5MP"
+        default y
+        help
+            Enable this option if you want to use the OV5640.
+            Disable this option to save memory.
+
+    choice SCCB_HARDWARE_I2C_PORT
+        bool "I2C peripheral to use for SCCB"
+        default SCCB_HARDWARE_I2C_PORT1
+
+        config SCCB_HARDWARE_I2C_PORT0
+            bool "I2C0"
+        config SCCB_HARDWARE_I2C_PORT1
+            bool "I2C1"
+
+    endchoice
+
+    choice CAMERA_TASK_PINNED_TO_CORE
+        bool "Camera task pinned to core"
+        default CAMERA_CORE0
+        help
+            Pin the camera handle task to a certain core(0/1). It can also be done automatically choosing NO_AFFINITY.
+
+        config CAMERA_CORE0
+            bool "CORE0"
+        config CAMERA_CORE1
+            bool "CORE1"
+        config CAMERA_NO_AFFINITY
+            bool "NO_AFFINITY"
+
+    endchoice
+
+endmenu

code/components/esp32-camera-master/README.md

@@ -0,0 +1,358 @@
+# ESP32 Camera Driver
+
+## General Information
+
+This repository hosts ESP32 compatible driver for OV2640, OV3660, OV5640, OV7670 and OV7725 image sensors. Additionally it provides a few tools, which allow converting the captured frame data to the more common BMP and JPEG formats.
+
+## Important to Remember
+
+- Except when using CIF or lower resolution with JPEG, the driver requires PSRAM to be installed and activated.
+- Using YUV or RGB puts a lot of strain on the chip because writing to PSRAM is not particularly fast. The result is that image data might be missing. This is particularly true if WiFi is enabled. If you need RGB data, it is recommended that JPEG is captured and then turned into RGB using `fmt2rgb888` or `fmt2bmp`/`frame2bmp`.
+- When 1 frame buffer is used, the driver will wait for the current frame to finish (VSYNC) and start I2S DMA. After the frame is acquired, I2S will be stopped and the frame buffer returned to the application. This approach gives more control over the system, but results in longer time to get the frame.
+- When 2 or more frame bufers are used, I2S is running in continuous mode and each frame is pushed to a queue that the application can access. This approach puts more strain on the CPU/Memory, but allows for double the frame rate. Please use only with JPEG.
+
+## Installation Instructions
+
+
+### Using esp-idf
+
+- Clone or download and extract the repository to the components folder of your ESP-IDF project
+- Enable PSRAM in `menuconfig`
+- Include `esp_camera.h` in your code
+
+### Using PlatformIO
+
+The easy way -- on the `env` section of `platformio.ini`, add the following:
+
+```ini
+[env]
+lib_deps =
+  esp32-camera
+```
+
+Now the `esp_camera.h` is available to be included:
+
+```c
+#include "esp_camera.h"
+```
+
+Enable PSRAM on `menuconfig` or type it direclty on `sdkconfig`. Check the [official doc](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-esp32-spiram-support) for more info.
+
+```
+CONFIG_ESP32_SPIRAM_SUPPORT=y
+```
+
+***Arduino*** The easy-way (content above) only seems to work if you're using `framework=arduino` which seems to take a bunch of the guesswork out (thanks Arduino!) but also suck up a lot more memory and flash, almost crippling the performance.  If you plan to use the `framework=espidf` then read the sections below carefully!!
+
+## Platform.io lib/submodule (for framework=espidf)
+
+It's probably easier to just skip the platform.io library registry version and link the git repo as a submodule. (i.e. using code outside the platform.io library management). In this example we will install this as a submodule inside the platform.io $project/lib folder: 
+```
+cd $project\lib
+git submodule add -b master https://github.com/espressif/esp32-camera.git
+```
+
+Then in `platformio.ini` file
+```
+build_flags =
+   -I../lib/esp32-camera
+```
+After that `#include "esp_camera.h"` statement will be available. Now the module is included, and you're hopefully back to the same place as the easy-Arduino way. 
+
+**Warning about platform.io/espidf and fresh (not initialized) git repos**
+There is a sharp-edge on you'll discover in the platform.io build process (in espidf v3.3 & 4.0.1) where a project which has only had `git init`  but nothing committed will crash platform.io build process with highly non-useful output.  The cause is due to lack of a version (making you think you did something wrong, when you didn't at all) - the output is horribly non-descript.  Solution: the devs want you to create a file called version.txt with a number in it, or simply commit any file to the projects git repo and use git. This happens because platform.io build process tries to be too clever and determine the build version number from the git repo - it's a sharp edge you'll only encounter if you're experimenting on a new project with no commits .. like wtf is my camera not working let's try a 'clean project'?!  </rant> 
+
+## Platform.io Kconfig 
+Kconfig is used by the platform.io menuconfig (accessed by running: `pio run -t menuconfig`) to interactively manage the various #ifdef statements throughout the espidf and supporting libraries (i.e. this repo: esp32-camera and arduino-esp32.git).  The menuconfig process generates the `sdkconfig` file which is ultimately used behind the scenes by espidf compile+build process. 
+
+**Make sure to append or symlink** [this `Kconfig`](./Kconfig) content into the `Kconfig` of your project. 
+
+You symlink (or copy) the included Kconfig into your platform.io projects src directory.  The file should be named `Kconfig.projbuild` in your projects src\ directory or you could also add the library path to a CMakefile.txt and hope the `Kconfig` (or `Kconfig.projbuild`) gets discovered by the menuconfig process, though this unpredictable for me. 
+
+The unpredictable wonky behavior in platform.io build process around Kconfig naming (Kconfig vs. Kconfig.projbuild) occurs between espidf versions 3.3 and 4.0 - but if you don't see "Camera configuration" in your `pio run -t menuconfig` then there is no point trying to test camera code (it may compile, but it probably won't work!) and it seems the platform.io devs (when they built their wrapper around the espidf menuconfig) didn't implement it properly.  You've probably already figured out you can't use the espidf build tools since the files are in totally different locations and also different versions with sometimes different syntax.   This is one of those times you might consider changing the `platformio.ini` from `platform=espressif32` to `platform=https://github.com/platformio/platform-espressif32.git#develop` to get a more recent version of the espidf 4.0 tools. 
+
+However with a bit of patience and experimenting you'll figure the Kconfig out. Once Kconfig (or Kconfig.projbuild) is working then you will be able to choose the configurations according to your setup or the camera libraries will be compiled.  Although you might also need to delete your .pio/build directory before the options appear .. again, the `pio run -t menuconfig` doens't always notice the new Kconfig files! 
+
+If you miss-skip-ignore this critical step the camera module will compile but camera logic inside the library will be 'empty' because the Kconfig sets the proper #ifdef statements during the build process to initialize the selected cameras.  It's very not optional! 
+
+### Kconfig options
+
+| config                            | description                                                                                                                                                  | default                        |
+| --------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------ |
+| CONFIG_OV2640_SUPPORT             | Support for OV2640 camera                                                                                                                                    | enabled                        |
+| CONFIG_OV7725_SUPPORT             | Support for OV7725 camera                                                                                                                                    | disabled                       |
+| CONFIG_OV3660_SUPPORT             | Support for OV3660 camera                                                                                                                                    | enabled                        |
+| CONFIG_OV5640_SUPPORT             | Support for OV5640 camera                                                                                                                                    | enabled                        |
+| CONFIG_SCCB_HARDWARE_I2C          | Enable this option if you want to use hardware I2C to control the camera. Disable this option to use software I2C.                                           | enabled                        |
+| CONFIG_SCCB_HARDWARE_I2C_PORT     | I2C peripheral to use for SCCB. Can be I2C0 and I2C1.                                                                                                        | CONFIG_SCCB_HARDWARE_I2C_PORT1 |
+| CONFIG_CAMERA_TASK_PINNED_TO_CORE | Pin the camera handle task to a certain core(0/1). It can also be done automatically choosing NO_AFFINITY. Can be CAMERA_CORE0, CAMERA_CORE1 or NO_AFFINITY. | CONFIG_CAMERA_CORE0            |
+
+## Examples
+
+### Initialization
+
+```c
+#include "esp_camera.h"
+
+//WROVER-KIT PIN Map
+#define CAM_PIN_PWDN    -1 //power down is not used
+#define CAM_PIN_RESET   -1 //software reset will be performed
+#define CAM_PIN_XCLK    21
+#define CAM_PIN_SIOD    26
+#define CAM_PIN_SIOC    27
+
+#define CAM_PIN_D7      35
+#define CAM_PIN_D6      34
+#define CAM_PIN_D5      39
+#define CAM_PIN_D4      36
+#define CAM_PIN_D3      19
+#define CAM_PIN_D2      18
+#define CAM_PIN_D1       5
+#define CAM_PIN_D0       4
+#define CAM_PIN_VSYNC   25
+#define CAM_PIN_HREF    23
+#define CAM_PIN_PCLK    22
+
+static camera_config_t camera_config = {
+    .pin_pwdn  = CAM_PIN_PWDN,
+    .pin_reset = CAM_PIN_RESET,
+    .pin_xclk = CAM_PIN_XCLK,
+    .pin_sscb_sda = CAM_PIN_SIOD,
+    .pin_sscb_scl = CAM_PIN_SIOC,
+
+    .pin_d7 = CAM_PIN_D7,
+    .pin_d6 = CAM_PIN_D6,
+    .pin_d5 = CAM_PIN_D5,
+    .pin_d4 = CAM_PIN_D4,
+    .pin_d3 = CAM_PIN_D3,
+    .pin_d2 = CAM_PIN_D2,
+    .pin_d1 = CAM_PIN_D1,
+    .pin_d0 = CAM_PIN_D0,
+    .pin_vsync = CAM_PIN_VSYNC,
+    .pin_href = CAM_PIN_HREF,
+    .pin_pclk = CAM_PIN_PCLK,
+
+    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
+    .xclk_freq_hz = 20000000,
+    .ledc_timer = LEDC_TIMER_0,
+    .ledc_channel = LEDC_CHANNEL_0,
+
+    .pixel_format = PIXFORMAT_JPEG,//YUV422,GRAYSCALE,RGB565,JPEG
+    .frame_size = FRAMESIZE_UXGA,//QQVGA-QXGA Do not use sizes above QVGA when not JPEG
+
+    .jpeg_quality = 12, //0-63 lower number means higher quality
+    .fb_count = 1 //if more than one, i2s runs in continuous mode. Use only with JPEG
+};
+
+esp_err_t camera_init(){
+    //power up the camera if PWDN pin is defined
+    if(CAM_PIN_PWDN != -1){
+        pinMode(CAM_PIN_PWDN, OUTPUT);
+        digitalWrite(CAM_PIN_PWDN, LOW);
+    }
+
+    //initialize the camera
+    esp_err_t err = esp_camera_init(&camera_config);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Camera Init Failed");
+        return err;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t camera_capture(){
+    //acquire a frame
+    camera_fb_t * fb = esp_camera_fb_get();
+    if (!fb) {
+        ESP_LOGE(TAG, "Camera Capture Failed");
+        return ESP_FAIL;
+    }
+    //replace this with your own function
+    process_image(fb->width, fb->height, fb->format, fb->buf, fb->len);
+  
+    //return the frame buffer back to the driver for reuse
+    esp_camera_fb_return(fb);
+    return ESP_OK;
+}
+```
+
+### JPEG HTTP Capture
+
+```c
+#include "esp_camera.h"
+#include "esp_http_server.h"
+#include "esp_timer.h"
+
+typedef struct {
+        httpd_req_t *req;
+        size_t len;
+} jpg_chunking_t;
+
+static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){
+    jpg_chunking_t *j = (jpg_chunking_t *)arg;
+    if(!index){
+        j->len = 0;
+    }
+    if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){
+        return 0;
+    }
+    j->len += len;
+    return len;
+}
+
+esp_err_t jpg_httpd_handler(httpd_req_t *req){
+    camera_fb_t * fb = NULL;
+    esp_err_t res = ESP_OK;
+    size_t fb_len = 0;
+    int64_t fr_start = esp_timer_get_time();
+
+    fb = esp_camera_fb_get();
+    if (!fb) {
+        ESP_LOGE(TAG, "Camera capture failed");
+        httpd_resp_send_500(req);
+        return ESP_FAIL;
+    }
+    res = httpd_resp_set_type(req, "image/jpeg");
+    if(res == ESP_OK){
+        res = httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");
+    }
+
+    if(res == ESP_OK){
+        if(fb->format == PIXFORMAT_JPEG){
+            fb_len = fb->len;
+            res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
+        } else {
+            jpg_chunking_t jchunk = {req, 0};
+            res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
+            httpd_resp_send_chunk(req, NULL, 0);
+            fb_len = jchunk.len;
+        }
+    }
+    esp_camera_fb_return(fb);
+    int64_t fr_end = esp_timer_get_time();
+    ESP_LOGI(TAG, "JPG: %uKB %ums", (uint32_t)(fb_len/1024), (uint32_t)((fr_end - fr_start)/1000));
+    return res;
+}
+```
+
+### JPEG HTTP Stream
+
+```c
+#include "esp_camera.h"
+#include "esp_http_server.h"
+#include "esp_timer.h"
+
+#define PART_BOUNDARY "123456789000000000000987654321"
+static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
+static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
+static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";
+
+esp_err_t jpg_stream_httpd_handler(httpd_req_t *req){
+    camera_fb_t * fb = NULL;
+    esp_err_t res = ESP_OK;
+    size_t _jpg_buf_len;
+    uint8_t * _jpg_buf;
+    char * part_buf[64];
+    static int64_t last_frame = 0;
+    if(!last_frame) {
+        last_frame = esp_timer_get_time();
+    }
+
+    res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
+    if(res != ESP_OK){
+        return res;
+    }
+
+    while(true){
+        fb = esp_camera_fb_get();
+        if (!fb) {
+            ESP_LOGE(TAG, "Camera capture failed");
+            res = ESP_FAIL;
+            break;
+        }
+        if(fb->format != PIXFORMAT_JPEG){
+            bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
+            if(!jpeg_converted){
+                ESP_LOGE(TAG, "JPEG compression failed");
+                esp_camera_fb_return(fb);
+                res = ESP_FAIL;
+            }
+        } else {
+            _jpg_buf_len = fb->len;
+            _jpg_buf = fb->buf;
+        }
+
+        if(res == ESP_OK){
+            res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
+        }
+        if(res == ESP_OK){
+            size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
+
+            res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
+        }
+        if(res == ESP_OK){
+            res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
+        }
+        if(fb->format != PIXFORMAT_JPEG){
+            free(_jpg_buf);
+        }
+        esp_camera_fb_return(fb);
+        if(res != ESP_OK){
+            break;
+        }
+        int64_t fr_end = esp_timer_get_time();
+        int64_t frame_time = fr_end - last_frame;
+        last_frame = fr_end;
+        frame_time /= 1000;
+        ESP_LOGI(TAG, "MJPG: %uKB %ums (%.1ffps)",
+            (uint32_t)(_jpg_buf_len/1024),
+            (uint32_t)frame_time, 1000.0 / (uint32_t)frame_time);
+    }
+
+    last_frame = 0;
+    return res;
+}
+```
+
+### BMP HTTP Capture
+
+```c
+#include "esp_camera.h"
+#include "esp_http_server.h"
+#include "esp_timer.h"
+
+esp_err_t bmp_httpd_handler(httpd_req_t *req){
+    camera_fb_t * fb = NULL;
+    esp_err_t res = ESP_OK;
+    int64_t fr_start = esp_timer_get_time();
+
+    fb = esp_camera_fb_get();
+    if (!fb) {
+        ESP_LOGE(TAG, "Camera capture failed");
+        httpd_resp_send_500(req);
+        return ESP_FAIL;
+    }
+
+    uint8_t * buf = NULL;
+    size_t buf_len = 0;
+    bool converted = frame2bmp(fb, &buf, &buf_len);
+    esp_camera_fb_return(fb);
+    if(!converted){
+        ESP_LOGE(TAG, "BMP conversion failed");
+        httpd_resp_send_500(req);
+        return ESP_FAIL;
+    }
+
+    res = httpd_resp_set_type(req, "image/x-windows-bmp")
+       || httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.bmp")
+       || httpd_resp_send(req, (const char *)buf, buf_len);
+    free(buf);
+    int64_t fr_end = esp_timer_get_time();
+    ESP_LOGI(TAG, "BMP: %uKB %ums", (uint32_t)(buf_len/1024), (uint32_t)((fr_end - fr_start)/1000));
+    return res;
+}
+```
+
+
+

code/components/esp32-camera-master/component.mk

@@ -0,0 +1,4 @@
+COMPONENT_ADD_INCLUDEDIRS := driver/include conversions/include
+COMPONENT_PRIV_INCLUDEDIRS := driver/private_include conversions/private_include sensors/private_include
+COMPONENT_SRCDIRS := driver conversions sensors
+CXXFLAGS += -fno-rtti

code/components/esp32-camera-master/conversions/include/img_converters.h

@@ -62,7 +62,8 @@ bool frame2jpg_cb(camera_fb_t * fb, uint8_t quality, jpg_out_cb cb, void * arg);
  * @param height    Height in pixels of the source image
  * @param format    Format of the source image
  * @param quality   JPEG quality of the resulting image
- * @param out       Pointer to be populated with the address of the resulting buffer
+ * @param out       Pointer to be populated with the address of the resulting buffer.
+ *                  You MUST free the pointer once you are done with it.
  * @param out_len   Pointer to be populated with the length of the output buffer
  *
  * @return true on success

code/components/esp32-camera-master/conversions/to_bmp.c

@@ -20,6 +20,17 @@
 #include "sdkconfig.h"
 #include "esp_jpg_decode.h"
 
+#include "esp_system.h"
+#if ESP_IDF_VERSION_MAJOR >= 4 // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/spiram.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "esp_spiram.h"
+#endif
+
 #if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
 #include "esp32-hal-log.h"
 #define TAG ""
@@ -306,7 +317,7 @@ bool fmt2bmp(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixf
     }
     *out = out_buf;
     *out_len = out_size;
-    return true;
+    return true; 
 }
 
 bool frame2bmp(camera_fb_t * fb, uint8_t ** out, size_t * out_len)

code/components/esp32-camera-master/conversions/to_jpg.cpp

@@ -16,7 +16,7 @@
 #include "esp_attr.h"
 #include "soc/efuse_reg.h"
 #include "esp_heap_caps.h"
-#include <esp_camera.h>
+#include "esp_camera.h"
 #include "img_converters.h"
 #include "jpge.h"
 #include "yuv.h"
@@ -215,8 +215,7 @@ bool fmt2jpg(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixf
 {
     //todo: allocate proper buffer for holding JPEG data
     //this should be enough for CIF frame size
-//    int jpg_buf_len = 64*1024;
-    int jpg_buf_len = 256*1024;     // Anpassung wg. zu kleiner Bitmaps
+    int jpg_buf_len = 64*1024;
 
 
     uint8_t * jpg_buf = (uint8_t *)_malloc(jpg_buf_len);

code/components/esp32-camera-master/driver/camera.c

@@ -36,14 +36,6 @@
 #include "esp_camera.h"
 #include "camera_common.h"
 #include "xclk.h"
-
-#define CONFIG_OV2640_SUPPORT 1
-//#define CONFIG_OV7725_SUPPORT 1
-//#define CONFIG_OV7725_SUPPORT 1
-//#define CONFIG_OV3660_SUPPORT 1
-//#define CONFIG_OV5640_SUPPORT 1
-
-
 #if CONFIG_OV2640_SUPPORT
 #include "ov2640.h"
 #endif
@@ -56,6 +48,12 @@
 #if CONFIG_OV5640_SUPPORT
 #include "ov5640.h"
 #endif
+#if CONFIG_NT99141_SUPPORT
+#include "nt99141.h"
+#endif
+#if CONFIG_OV7670_SUPPORT
+#include "ov7670.h"
+#endif
 
 typedef enum {
     CAMERA_NONE = 0,
@@ -64,6 +62,8 @@ typedef enum {
     CAMERA_OV2640 = 2640,
     CAMERA_OV3660 = 3660,
     CAMERA_OV5640 = 5640,
+    CAMERA_OV7670 = 7670,
+    CAMERA_NT99141 = 9141,
 } camera_model_t;
 
 #define REG_PID        0x0A
@@ -377,12 +377,10 @@ static inline void IRAM_ATTR i2s_conf_reset()
     }
 }
 
-static void i2s_init()
+static void i2s_gpio_init(const camera_config_t* config)
 {
-    camera_config_t* config = &s_state->config;
-
     // Configure input GPIOs
-    gpio_num_t pins[] = {
+    const gpio_num_t pins[] = {
         config->pin_d7,
         config->pin_d6,
         config->pin_d5,
@@ -399,15 +397,21 @@ static void i2s_init()
         .mode = GPIO_MODE_INPUT,
         .pull_up_en = GPIO_PULLUP_ENABLE,
         .pull_down_en = GPIO_PULLDOWN_DISABLE,
-        .intr_type = GPIO_INTR_DISABLE
+        .intr_type = GPIO_INTR_DISABLE,
+        .pin_bit_mask = 0LL
     };
     for (int i = 0; i < sizeof(pins) / sizeof(gpio_num_t); ++i) {
         if (rtc_gpio_is_valid_gpio(pins[i])) {
             rtc_gpio_deinit(pins[i]);
         }
-        conf.pin_bit_mask = 1LL << pins[i];
-        gpio_config(&conf);
+        conf.pin_bit_mask |= 1LL << pins[i];
     }
+    gpio_config(&conf);
+}
+
+static void i2s_init()
+{
+    camera_config_t* config = &s_state->config;
 
     // Route input GPIOs to I2S peripheral using GPIO matrix
     gpio_matrix_in(config->pin_d0, I2S0I_DATA_IN0_IDX, false);
@@ -746,7 +750,7 @@ static void IRAM_ATTR dma_filter_buffer(size_t buf_idx)
         if(s_state->sensor.pixformat == PIXFORMAT_JPEG) {
             uint32_t sig = *((uint32_t *)s_state->fb->buf) & 0xFFFFFF;
             if(sig != 0xffd8ff) {
-                ets_printf("bh 0x%08x\n", sig);
+                ESP_LOGD(TAG,"unexpected JPEG signature 0x%08x\n", sig);
                 s_state->fb->bad = 1;
                 return;
             }
@@ -963,11 +967,15 @@ esp_err_t camera_probe(const camera_config_t* config, camera_model_t* out_camera
         return ESP_ERR_NO_MEM;
     }
 
-    ESP_LOGD(TAG, "Enabling XCLK output");
-    camera_enable_out_clock(config);
+    if(config->pin_xclk >= 0) {
+      ESP_LOGD(TAG, "Enabling XCLK output");
+      camera_enable_out_clock(config);
+    }
 
-    ESP_LOGD(TAG, "Initializing SSCB");
-    SCCB_Init(config->pin_sscb_sda, config->pin_sscb_scl);
+    if (config->pin_sscb_sda != -1) {
+      ESP_LOGD(TAG, "Initializing SSCB");
+      SCCB_Init(config->pin_sscb_sda, config->pin_sscb_scl);
+    }
 	
     if(config->pin_pwdn >= 0) {
         ESP_LOGD(TAG, "Resetting camera by power down line");
@@ -1019,16 +1027,33 @@ esp_err_t camera_probe(const camera_config_t* config, camera_model_t* out_camera
         slv_addr = SCCB_Probe();
     }
 #endif
+#if CONFIG_NT99141_SUPPORT
+   if (slv_addr == 0x2a)
+    {
+        ESP_LOGD(TAG, "Resetting NT99141");
+        SCCB_Write16(0x2a, 0x3008, 0x01);//bank sensor
+    }
+#endif 
 
     s_state->sensor.slv_addr = slv_addr;
     s_state->sensor.xclk_freq_hz = config->xclk_freq_hz;
 
-#if (CONFIG_OV3660_SUPPORT || CONFIG_OV5640_SUPPORT)
+#if (CONFIG_OV3660_SUPPORT || CONFIG_OV5640_SUPPORT || CONFIG_NT99141_SUPPORT)
     if(s_state->sensor.slv_addr == 0x3c){
         id->PID = SCCB_Read16(s_state->sensor.slv_addr, REG16_CHIDH);
         id->VER = SCCB_Read16(s_state->sensor.slv_addr, REG16_CHIDL);
         vTaskDelay(10 / portTICK_PERIOD_MS);
         ESP_LOGD(TAG, "Camera PID=0x%02x VER=0x%02x", id->PID, id->VER);
+    } else if(s_state->sensor.slv_addr == 0x2a){
+        id->PID = SCCB_Read16(s_state->sensor.slv_addr, 0x3000);
+        id->VER = SCCB_Read16(s_state->sensor.slv_addr, 0x3001);
+        vTaskDelay(10 / portTICK_PERIOD_MS);
+        ESP_LOGD(TAG, "Camera PID=0x%02x VER=0x%02x", id->PID, id->VER);
+        if(config->xclk_freq_hz > 10000000)
+        {
+            ESP_LOGE(TAG, "NT99141: only XCLK under 10MHz is supported, and XCLK is now set to 10M");
+            s_state->sensor.xclk_freq_hz = 10000000;
+        }    
     } else {
 #endif
         id->PID = SCCB_Read(s_state->sensor.slv_addr, REG_PID);
@@ -1039,7 +1064,7 @@ esp_err_t camera_probe(const camera_config_t* config, camera_model_t* out_camera
         ESP_LOGD(TAG, "Camera PID=0x%02x VER=0x%02x MIDL=0x%02x MIDH=0x%02x",
                  id->PID, id->VER, id->MIDH, id->MIDL);
 
-#if (CONFIG_OV3660_SUPPORT || CONFIG_OV5640_SUPPORT)
+#if (CONFIG_OV3660_SUPPORT || CONFIG_OV5640_SUPPORT || CONFIG_NT99141_SUPPORT)
     }
 #endif
 
@@ -1068,6 +1093,18 @@ esp_err_t camera_probe(const camera_config_t* config, camera_model_t* out_camera
         *out_camera_model = CAMERA_OV5640;
         ov5640_init(&s_state->sensor);
         break;
+#endif
+#if CONFIG_OV7670_SUPPORT
+    case OV7670_PID:
+        *out_camera_model = CAMERA_OV7670;
+        ov7670_init(&s_state->sensor);
+        break;
+#endif
+#if CONFIG_NT99141_SUPPORT
+        case NT99141_PID:
+        *out_camera_model = CAMERA_NT99141;
+        NT99141_init(&s_state->sensor);
+        break;
 #endif
     default:
         id->PID = 0;
@@ -1124,6 +1161,20 @@ esp_err_t camera_init(const camera_config_t* config)
                 frame_size = FRAMESIZE_QSXGA;
             }
             break;
+#endif
+#if CONFIG_OV7670_SUPPORT
+        case OV7670_PID:
+            if (frame_size > FRAMESIZE_VGA) {
+                frame_size = FRAMESIZE_VGA;
+            }
+            break;
+#endif
+#if CONFIG_NT99141_SUPPORT
+        case NT99141_PID:
+            if (frame_size > FRAMESIZE_HD) {
+                frame_size = FRAMESIZE_HD;
+            }
+            break;
 #endif
         default:
             return ESP_ERR_CAMERA_NOT_SUPPORTED;
@@ -1134,7 +1185,7 @@ esp_err_t camera_init(const camera_config_t* config)
 
     if (pix_format == PIXFORMAT_GRAYSCALE) {
         s_state->fb_size = s_state->width * s_state->height;
-        if (s_state->sensor.id.PID == OV3660_PID || s_state->sensor.id.PID == OV5640_PID) {
+        if (s_state->sensor.id.PID == OV3660_PID || s_state->sensor.id.PID == OV5640_PID || s_state->sensor.id.PID == NT99141_PID) {
             if (is_hs_mode()) {
                 s_state->sampling_mode = SM_0A00_0B00;
                 s_state->dma_filter = &dma_filter_yuyv_highspeed;
@@ -1155,20 +1206,28 @@ esp_err_t camera_init(const camera_config_t* config)
         }
         s_state->fb_bytes_per_pixel = 1;       // frame buffer stores Y8
     } else if (pix_format == PIXFORMAT_YUV422 || pix_format == PIXFORMAT_RGB565) {
-        s_state->fb_size = s_state->width * s_state->height * 2;
-        if (is_hs_mode() && s_state->sensor.id.PID != OV7725_PID) {
-            s_state->sampling_mode = SM_0A00_0B00;
-            s_state->dma_filter = &dma_filter_yuyv_highspeed;
-        } else {
-            s_state->sampling_mode = SM_0A0B_0C0D;
-            s_state->dma_filter = &dma_filter_yuyv;
-        }
-        s_state->in_bytes_per_pixel = 2;       // camera sends YU/YV
-        s_state->fb_bytes_per_pixel = 2;       // frame buffer stores YU/YV/RGB565
+            s_state->fb_size = s_state->width * s_state->height * 2;
+            if (is_hs_mode() && s_state->sensor.id.PID != OV7725_PID) {
+                if(s_state->sensor.id.PID == OV7670_PID) {
+                    s_state->sampling_mode = SM_0A0B_0B0C;
+                }else{
+                    s_state->sampling_mode = SM_0A00_0B00;
+                }
+                s_state->dma_filter = &dma_filter_yuyv_highspeed;
+            } else {
+                s_state->sampling_mode = SM_0A0B_0C0D;
+                s_state->dma_filter = &dma_filter_yuyv;
+            }
+            s_state->in_bytes_per_pixel = 2;       // camera sends YU/YV
+            s_state->fb_bytes_per_pixel = 2;       // frame buffer stores YU/YV/RGB565
     } else if (pix_format == PIXFORMAT_RGB888) {
         s_state->fb_size = s_state->width * s_state->height * 3;
         if (is_hs_mode()) {
-            s_state->sampling_mode = SM_0A00_0B00;
+            if(s_state->sensor.id.PID == OV7670_PID) {
+                s_state->sampling_mode = SM_0A0B_0B0C;
+            }else{
+                s_state->sampling_mode = SM_0A00_0B00;
+            }
             s_state->dma_filter = &dma_filter_rgb888_highspeed;
         } else {
             s_state->sampling_mode = SM_0A0B_0C0D;
@@ -1177,7 +1236,7 @@ esp_err_t camera_init(const camera_config_t* config)
         s_state->in_bytes_per_pixel = 2;       // camera sends RGB565
         s_state->fb_bytes_per_pixel = 3;       // frame buffer stores RGB888
     } else if (pix_format == PIXFORMAT_JPEG) {
-        if (s_state->sensor.id.PID != OV2640_PID && s_state->sensor.id.PID != OV3660_PID && s_state->sensor.id.PID != OV5640_PID) {
+        if (s_state->sensor.id.PID != OV2640_PID && s_state->sensor.id.PID != OV3660_PID && s_state->sensor.id.PID != OV5640_PID  && s_state->sensor.id.PID != NT99141_PID) {
             ESP_LOGE(TAG, "JPEG format is only supported for ov2640, ov3660 and ov5640");
             err = ESP_ERR_NOT_SUPPORTED;
             goto fail;
@@ -1262,10 +1321,15 @@ esp_err_t camera_init(const camera_config_t* config)
     }
 
     vsync_intr_disable();
-    err = gpio_install_isr_service(ESP_INTR_FLAG_LEVEL1 | ESP_INTR_FLAG_IRAM);
+    err = gpio_install_isr_service(ESP_INTR_FLAG_LOWMED | ESP_INTR_FLAG_IRAM);
     if (err != ESP_OK) {
-        ESP_LOGE(TAG, "gpio_install_isr_service failed (%x)", err);
-        goto fail;
+    	if (err != ESP_ERR_INVALID_STATE) {
+    		ESP_LOGE(TAG, "gpio_install_isr_service failed (%x)", err);
+        	goto fail;
+    	}
+    	else {
+    		ESP_LOGW(TAG, "gpio_install_isr_service already installed");
+    	}
     }
     err = gpio_isr_handler_add(s_state->config.pin_vsync, &vsync_isr, NULL);
     if (err != ESP_OK) {
@@ -1309,6 +1373,7 @@ fail:
 esp_err_t esp_camera_init(const camera_config_t* config)
 {
     camera_model_t camera_model = CAMERA_NONE;
+    i2s_gpio_init(config);
     esp_err_t err = camera_probe(config, &camera_model);
     if (err != ESP_OK) {
         ESP_LOGE(TAG, "Camera probe failed with error 0x%x", err);
@@ -1327,6 +1392,10 @@ esp_err_t esp_camera_init(const camera_config_t* config)
         ESP_LOGI(TAG, "Detected OV3660 camera");
     } else if (camera_model == CAMERA_OV5640) {
         ESP_LOGI(TAG, "Detected OV5640 camera");
+    } else if (camera_model == CAMERA_OV7670) {
+        ESP_LOGI(TAG, "Detected OV7670 camera");
+    } else if (camera_model == CAMERA_NT99141) {
+        ESP_LOGI(TAG, "Detected NT99141 camera");
     } else {
         ESP_LOGI(TAG, "Camera not supported");
         err = ESP_ERR_CAMERA_NOT_SUPPORTED;
@@ -1373,9 +1442,12 @@ esp_err_t esp_camera_deinit()
     }
     dma_desc_deinit();
     camera_fb_deinit();
+
+    if(s_state->config.pin_xclk >= 0) {
+      camera_disable_out_clock();
+    }
     free(s_state);
     s_state = NULL;
-    camera_disable_out_clock();
     periph_module_disable(PERIPH_I2S0_MODULE);
     return ESP_OK;
 }

code/components/esp32-camera-master/driver/include/esp_camera.h

@@ -65,9 +65,6 @@
 
 #pragma once
 
-#ifndef ESPCAMERADEF
-#define ESPCAMERADEF
-
 #include "esp_err.h"
 #include "driver/ledc.h"
 #include "sensor.h"
@@ -196,5 +193,3 @@ esp_err_t esp_camera_load_from_nvs(const char *key);
 
 #include "img_converters.h"
 
-#endif
-

code/components/esp32-camera-master/driver/include/sensor.h

@@ -11,11 +11,13 @@
 #include <stdint.h>
 #include <stdbool.h>
 
+#define NT99141_PID     (0x14)
 #define OV9650_PID     (0x96)
 #define OV7725_PID     (0x77)
 #define OV2640_PID     (0x26)
 #define OV3660_PID     (0x36)
 #define OV5640_PID     (0x56)
+#define OV7670_PID     (0x76)
 
 typedef enum {
     PIXFORMAT_RGB565,    // 2BPP/RGB565

code/components/esp32-camera-master/driver/sccb.c

@@ -7,6 +7,7 @@
  *
  */
 #include <stdbool.h>
+#include <string.h>
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>
 #include "sccb.h"
@@ -19,11 +20,8 @@
 static const char* TAG = "sccb";
 #endif
 
-//#undef CONFIG_SCCB_HARDWARE_I2C
-
 #define LITTLETOBIG(x)          ((x<<8)|(x>>8))
 
-#ifdef CONFIG_SCCB_HARDWARE_I2C
 #include "driver/i2c.h"
 
 #define SCCB_FREQ               100000           /*!< I2C master frequency*/
@@ -39,16 +37,13 @@ const int SCCB_I2C_PORT         = 1;
 const int SCCB_I2C_PORT         = 0;
 #endif
 static uint8_t ESP_SLAVE_ADDR   = 0x3c;
-#else
-#include "twi.h"
-#endif
 
 int SCCB_Init(int pin_sda, int pin_scl)
 {
     ESP_LOGI(TAG, "pin_sda %d pin_scl %d\n", pin_sda, pin_scl);
-#ifdef CONFIG_SCCB_HARDWARE_I2C
     //log_i("SCCB_Init start");
     i2c_config_t conf;
+    memset(&conf, 0, sizeof(i2c_config_t));
     conf.mode = I2C_MODE_MASTER;
     conf.sda_io_num = pin_sda;
     conf.sda_pullup_en = GPIO_PULLUP_ENABLE;
@@ -58,15 +53,11 @@ int SCCB_Init(int pin_sda, int pin_scl)
 
     i2c_param_config(SCCB_I2C_PORT, &conf);
     i2c_driver_install(SCCB_I2C_PORT, conf.mode, 0, 0, 0);
-#else
-    twi_init(pin_sda, pin_scl);
-#endif
     return 0;
 }
 
 uint8_t SCCB_Probe()
 {
-#ifdef CONFIG_SCCB_HARDWARE_I2C
     uint8_t slave_addr = 0x0;
     while(slave_addr < 0x7f) {
         i2c_cmd_handle_t cmd = i2c_cmd_link_create();
@@ -82,28 +73,10 @@ uint8_t SCCB_Probe()
         slave_addr++;
     }
     return ESP_SLAVE_ADDR;
-#else
-    uint8_t reg = 0x00;
-    uint8_t slv_addr = 0x00;
-
-    ESP_LOGI(TAG, "SCCB_Probe start");
-    for (uint8_t i = 0; i < 127; i++) {
-        if (twi_writeTo(i, &reg, 1, true) == 0) {
-            slv_addr = i;
-            break;
-        }
-
-        if (i!=126) {
-            vTaskDelay(10 / portTICK_PERIOD_MS); // Necessary for OV7725 camera (not for OV2640).
-        }
-    }
-    return slv_addr;
-#endif
 }
 
 uint8_t SCCB_Read(uint8_t slv_addr, uint8_t reg)
 {
-#ifdef CONFIG_SCCB_HARDWARE_I2C
     uint8_t data=0;
     esp_err_t ret = ESP_FAIL;
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
@@ -125,28 +98,10 @@ uint8_t SCCB_Read(uint8_t slv_addr, uint8_t reg)
         ESP_LOGE(TAG, "SCCB_Read Failed addr:0x%02x, reg:0x%02x, data:0x%02x, ret:%d", slv_addr, reg, data, ret);
     }
     return data;
-#else
-    uint8_t data=0;
-
-    int rc = twi_writeTo(slv_addr, &reg, 1, true);
-    if (rc != 0) {
-        data = 0xff;
-    } else {
-        rc = twi_readFrom(slv_addr, &data, 1, true);
-        if (rc != 0) {
-            data=0xFF;
-        }
-    }
-    if (rc != 0) {
-        ESP_LOGE(TAG, "SCCB_Read [%02x] failed rc=%d\n", reg, rc);
-    }
-    return data;
-#endif
 }
 
 uint8_t SCCB_Write(uint8_t slv_addr, uint8_t reg, uint8_t data)
 {
-#ifdef CONFIG_SCCB_HARDWARE_I2C
     esp_err_t ret = ESP_FAIL;
     i2c_cmd_handle_t cmd = i2c_cmd_link_create();
     i2c_master_start(cmd);
@@ -160,23 +115,10 @@ uint8_t SCCB_Write(uint8_t slv_addr, uint8_t reg, uint8_t data)
         ESP_LOGE(TAG, "SCCB_Write Failed addr:0x%02x, reg:0x%02x, data:0x%02x, ret:%d", slv_addr, reg, data, ret);
     }
     return ret == ESP_OK ? 0 : -1;
-#else
-    uint8_t ret=0;
-    uint8_t buf[] = {reg, data};
-
-    if(twi_writeTo(slv_addr, buf, 2, true) != 0) {
-        ret=0xFF;
-    }
-    if (ret != 0) {
-        ESP_LOGE(TAG, "SCCB_Write [%02x]=%02x failed\n", reg, data);
-    }
-    return ret;
-#endif
 }
 
 uint8_t SCCB_Read16(uint8_t slv_addr, uint16_t reg)
 {
-#ifdef CONFIG_SCCB_HARDWARE_I2C
     uint8_t data=0;
     esp_err_t ret = ESP_FAIL;
     uint16_t reg_htons = LITTLETOBIG(reg);
@@ -201,32 +143,11 @@ uint8_t SCCB_Read16(uint8_t slv_addr, uint16_t reg)
         ESP_LOGE(TAG, "W [%04x]=%02x fail\n", reg, data);
     }
     return data;
-#else
-    uint8_t data=0;
-    uint16_t reg_htons = LITTLETOBIG(reg);
-    uint8_t *reg_u8 = (uint8_t *)&reg_htons;
-    uint8_t buf[] = {reg_u8[0], reg_u8[1]};
-
-    int rc = twi_writeTo(slv_addr, buf, 2, true);
-    if (rc != 0) {
-        data = 0xff;
-    } else {
-        rc = twi_readFrom(slv_addr, &data, 1, true);
-        if (rc != 0) {
-            data=0xFF;
-        }
-    }
-    if (rc != 0) {
-        ESP_LOGE(TAG, "R [%04x] fail rc=%d\n", reg, rc);
-    }
-    return data;
-#endif
 }
 
 uint8_t SCCB_Write16(uint8_t slv_addr, uint16_t reg, uint8_t data)
 {
     static uint16_t i = 0;
-#ifdef CONFIG_SCCB_HARDWARE_I2C
     esp_err_t ret = ESP_FAIL;
     uint16_t reg_htons = LITTLETOBIG(reg);
     uint8_t *reg_u8 = (uint8_t *)&reg_htons;
@@ -243,18 +164,4 @@ uint8_t SCCB_Write16(uint8_t slv_addr, uint16_t reg, uint8_t data)
         ESP_LOGE(TAG, "W [%04x]=%02x %d fail\n", reg, data, i++);
     }
     return ret == ESP_OK ? 0 : -1;
-#else
-    uint8_t ret=0;
-    uint16_t reg_htons = LITTLETOBIG(reg);
-    uint8_t *reg_u8 = (uint8_t *)&reg_htons;
-    uint8_t buf[] = {reg_u8[0], reg_u8[1], data};
-
-    if(twi_writeTo(slv_addr, buf, 3, true) != 0) {
-        ret = 0xFF;
-    }
-    if (ret != 0) {
-        ESP_LOGE(TAG, "W [%04x]=%02x %d fail\n", reg, data, i++);
-    }
-    return ret;
-#endif
 }

code/components/esp32-camera-master/driver/xclk.c

@@ -18,12 +18,9 @@ esp_err_t xclk_timer_conf(int ledc_timer, int xclk_freq_hz)
     timer_conf.duty_resolution = 2;
     timer_conf.freq_hz = xclk_freq_hz;
     timer_conf.speed_mode = LEDC_HIGH_SPEED_MODE;
-
 #if ESP_IDF_VERSION_MAJOR >= 4
     timer_conf.clk_cfg = LEDC_AUTO_CLK;
 #endif
-//    timer_conf.clk_cfg = LEDC_USE_APB_CLK;
-
     timer_conf.timer_num = (ledc_timer_t)ledc_timer;
     esp_err_t err = ledc_timer_config(&timer_conf);
     if (err != ESP_OK) {

code/components/esp32-camera-master/examples/take_picture.c

@@ -0,0 +1,150 @@
+/**
+ * This example takes a picture every 5s and print its size on serial monitor.
+ */
+
+// =============================== SETUP ======================================
+
+// 1. Board setup (Uncomment):
+// #define BOARD_WROVER_KIT
+// #define BOARD_ESP32CAM_AITHINKER
+
+/**
+ * 2. Kconfig setup
+ * 
+ * If you have a Kconfig file, copy the content from
+ *  https://github.com/espressif/esp32-camera/blob/master/Kconfig into it.
+ * In case you haven't, copy and paste this Kconfig file inside the src directory.
+ * This Kconfig file has definitions that allows more control over the camera and
+ * how it will be initialized.
+ */
+
+/**
+ * 3. Enable PSRAM on sdkconfig:
+ * 
+ * CONFIG_ESP32_SPIRAM_SUPPORT=y
+ * 
+ * More info on
+ * https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-esp32-spiram-support
+ */
+
+// ================================ CODE ======================================
+
+#include <esp_event.h>
+#include <esp_log.h>
+#include <esp_system.h>
+#include <nvs_flash.h>
+#include <sys/param.h>
+#include <string.h>
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+#include "esp_camera.h"
+
+// WROVER-KIT PIN Map
+#ifdef BOARD_WROVER_KIT
+
+#define CAM_PIN_PWDN -1  //power down is not used
+#define CAM_PIN_RESET -1 //software reset will be performed
+#define CAM_PIN_XCLK 21
+#define CAM_PIN_SIOD 26
+#define CAM_PIN_SIOC 27
+
+#define CAM_PIN_D7 35
+#define CAM_PIN_D6 34
+#define CAM_PIN_D5 39
+#define CAM_PIN_D4 36
+#define CAM_PIN_D3 19
+#define CAM_PIN_D2 18
+#define CAM_PIN_D1 5
+#define CAM_PIN_D0 4
+#define CAM_PIN_VSYNC 25
+#define CAM_PIN_HREF 23
+#define CAM_PIN_PCLK 22
+
+#endif
+
+// ESP32Cam (AiThinker) PIN Map
+#ifdef BOARD_ESP32CAM_AITHINKER
+
+#define CAM_PIN_PWDN 32
+#define CAM_PIN_RESET -1 //software reset will be performed
+#define CAM_PIN_XCLK 0
+#define CAM_PIN_SIOD 26
+#define CAM_PIN_SIOC 27
+
+#define CAM_PIN_D7 35
+#define CAM_PIN_D6 34
+#define CAM_PIN_D5 39
+#define CAM_PIN_D4 36
+#define CAM_PIN_D3 21
+#define CAM_PIN_D2 19
+#define CAM_PIN_D1 18
+#define CAM_PIN_D0 5
+#define CAM_PIN_VSYNC 25
+#define CAM_PIN_HREF 23
+#define CAM_PIN_PCLK 22
+
+#endif
+
+static const char *TAG = "example:take_picture";
+
+static camera_config_t camera_config = {
+    .pin_pwdn = CAM_PIN_PWDN,
+    .pin_reset = CAM_PIN_RESET,
+    .pin_xclk = CAM_PIN_XCLK,
+    .pin_sscb_sda = CAM_PIN_SIOD,
+    .pin_sscb_scl = CAM_PIN_SIOC,
+
+    .pin_d7 = CAM_PIN_D7,
+    .pin_d6 = CAM_PIN_D6,
+    .pin_d5 = CAM_PIN_D5,
+    .pin_d4 = CAM_PIN_D4,
+    .pin_d3 = CAM_PIN_D3,
+    .pin_d2 = CAM_PIN_D2,
+    .pin_d1 = CAM_PIN_D1,
+    .pin_d0 = CAM_PIN_D0,
+    .pin_vsync = CAM_PIN_VSYNC,
+    .pin_href = CAM_PIN_HREF,
+    .pin_pclk = CAM_PIN_PCLK,
+
+    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
+    .xclk_freq_hz = 20000000,
+    .ledc_timer = LEDC_TIMER_0,
+    .ledc_channel = LEDC_CHANNEL_0,
+
+    .pixel_format = PIXFORMAT_JPEG, //YUV422,GRAYSCALE,RGB565,JPEG
+    .frame_size = FRAMESIZE_VGA,    //QQVGA-UXGA Do not use sizes above QVGA when not JPEG
+
+    .jpeg_quality = 12, //0-63 lower number means higher quality
+    .fb_count = 1       //if more than one, i2s runs in continuous mode. Use only with JPEG
+};
+
+static esp_err_t init_camera()
+{
+    //initialize the camera
+    esp_err_t err = esp_camera_init(&camera_config);
+    if (err != ESP_OK)
+    {
+        ESP_LOGE(TAG, "Camera Init Failed");
+        return err;
+    }
+
+    return ESP_OK;
+}
+
+void app_main()
+{
+    init_camera();
+
+    while (1)
+    {
+        ESP_LOGI(TAG, "Taking picture...");
+        camera_fb_t *pic = esp_camera_fb_get();
+
+        // use pic->buf to access the image
+        ESP_LOGI(TAG, "Picture taken! Its size was: %zu bytes", pic->len);
+
+        vTaskDelay(5000 / portTICK_RATE_MS);
+    }
+}

code/components/esp32-camera-master/idf_component.yml

@@ -0,0 +1,3 @@
+version: "1.0.0"
+description: This package hosts ESP32 compatible driver for OV2640 image sensors. Additionally it provides a few tools, which allow converting the captured frame data to the more common BMP and JPEG formats.
+url: https://github.com/espressif/esp32-camera

code/components/esp32-camera-master/library.json

@@ -0,0 +1,25 @@
+{
+  "name": "esp32-camera",
+  "version": "1.0.0",
+  "keywords": "esp32, camera, espressif, esp32-cam",
+  "description": "ESP32 compatible driver for OV2640, OV3660, OV5640, OV7670 and OV7725 image sensors.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/espressif/esp32-camera"
+  },
+  "frameworks": "espidf",
+  "platforms": "*",
+  "build": {
+    "flags": [
+      "-Idriver/include",
+      "-Iconversions/include",
+      "-Idriver/private_include",
+      "-Iconversions/private_include",
+      "-Isensors/private_include",
+      "-fno-rtti"
+    ],
+    "includeDir": ".",
+    "srcDir": ".",
+    "srcFilter": ["-<*>", "+<driver>", "+<conversions>", "+<sensors>"]
+  }
+}

code/components/esp32-camera-master/sensors/ov7670.c

@@ -0,0 +1,439 @@
+/*
+ * This file is part of the OpenMV project.
+ * author: Juan Schiavoni <juanjoseschiavoni@hotmail.com>
+ * This work is licensed under the MIT license, see the file LICENSE for details.
+ *
+ * OV7725 driver.
+ *
+ */
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include "sccb.h"
+#include "ov7670.h"
+#include "ov7670_regs.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <stdio.h>
+
+#if defined(ARDUINO_ARCH_ESP32) && defined(CONFIG_ARDUHAL_ESP_LOG)
+#include "esp32-hal-log.h"
+#else
+#include "esp_log.h"
+static const char* TAG = "ov7760";
+#endif
+
+static int ov7670_clkrc = 0x01;
+
+/*
+ * The default register settings, as obtained from OmniVision.  There
+ * is really no making sense of most of these - lots of "reserved" values
+ * and such.
+ *
+ * These settings give VGA YUYV.
+ */
+struct regval_list {
+	uint8_t reg_num;
+	uint8_t value;
+};
+
+static struct regval_list ov7670_default_regs[] = {
+    /* Sensor automatically sets output window when resolution changes. */    
+    {TSLB, 0x04}, 
+    
+    /* Frame rate 30 fps at 12 Mhz clock */    
+	{CLKRC, 0x00},  
+	{DBLV,  0x4A},  
+
+    {COM10, COM10_VSYNC_NEG | COM10_PCLK_MASK},
+
+    /* Improve white balance */ 
+	{COM4, 0x40},  
+    
+    /* Improve color */   
+    {RSVD_B0, 0x84},  
+
+    /* Enable 50/60 Hz auto detection */
+    {COM11, COM11_EXP|COM11_HZAUTO}, 
+
+    /* Disable some delays */
+	{HSYST, 0},
+    {HSYEN, 0},   
+
+    {MVFP, MVFP_SUN}, 
+
+	/* More reserved magic, some of which tweaks white balance */
+	{AWBC1, 0x0a},		
+    {AWBC2, 0xf0},
+	{AWBC3, 0x34},		
+    {AWBC4, 0x58},
+	{AWBC5, 0x28},		
+    {AWBC6, 0x3a},
+	
+    {AWBCTR3, 0x0a},		
+    {AWBCTR2, 0x55},
+	{AWBCTR1, 0x11},		
+    {AWBCTR0, 0x9e}, 
+
+    {COM8, COM8_FAST_AUTO|COM8_STEP_UNLIMIT|COM8_AGC_EN|COM8_AEC_EN|COM8_AWB_EN},
+
+    /* End marker is FF because in ov7670 the address of GAIN 0 and default value too. */
+    {0xFF, 0xFF},  
+};
+
+static struct regval_list ov7670_fmt_yuv422[] = {
+	{ COM7,     0x0                         },  /* Selects YUV mode */
+	{ RGB444,   0                           },  /* No RGB444 please */
+	{ COM1,     0                           },  /* CCIR601 */
+	{ COM15,    COM15_R00FF                 },
+    { MVFP,     MVFP_SUN                    }, 
+	{ COM9,     0x6A                        },  /* 128x gain ceiling; 0x8 is reserved bit */
+	{ MTX1,     0x80                        },  /* "matrix coefficient 1" */
+	{ MTX2,     0x80                        }, 	/* "matrix coefficient 2" */
+	{ MTX3,     0                           },  /* vb */
+	{ MTX4,     0x22                        }, 	/* "matrix coefficient 4" */
+	{ MTX5,     0x5e                        },  /* "matrix coefficient 5" */
+	{ MTX6,     0x80                        },  /* "matrix coefficient 6" */
+	{ COM13,    COM13_UVSAT                 },
+	{ 0xff,     0xff                        },  /* END MARKER */
+};
+
+static struct regval_list ov7670_fmt_rgb565[] = {
+	{ COM7,     COM7_FMT_RGB565             },	/* Selects RGB mode */
+	{ RGB444,   0                           },	/* No RGB444 please */
+	{ COM1,     0x0                         },	/* CCIR601 */
+	{ COM15,    COM15_RGB565 |COM15_R00FF   },
+    { MVFP,     MVFP_SUN                    },   
+	{ COM9,     0x6A                        }, 	/* 128x gain ceiling; 0x8 is reserved bit */
+	{ MTX1,     0xb3                        }, 	/* "matrix coefficient 1" */
+	{ MTX2,     0xb3                        }, 	/* "matrix coefficient 2" */
+	{ MTX3,     0                           },	/* vb */
+	{ MTX4,     0x3d                        }, 	/* "matrix coefficient 4" */
+	{ MTX5,     0xa7                        }, 	/* "matrix coefficient 5" */
+	{ MTX6,     0xe4                        }, 	/* "matrix coefficient 6" */
+	{ COM13,    COM13_UVSAT                 },
+	{ 0xff,     0xff                        },  /* END MARKER */
+};
+
+
+static struct regval_list ov7670_vga[] = {
+    { COM3,                 0x00 },
+    { COM14,                0x00 },
+    { SCALING_XSC,          0x3A },
+    { SCALING_YSC,          0x35 },
+    { SCALING_DCWCTR,       0x11 },
+    { SCALING_PCLK_DIV,     0xF0 },
+    { SCALING_PCLK_DELAY,   0x02 },
+    { 0xff, 0xff },
+};
+
+static struct regval_list ov7670_qvga[] = {
+    { COM3,                 0x04 },
+    { COM14,                0x19 },
+    { SCALING_XSC,          0x3A },
+    { SCALING_YSC,          0x35 },
+    { SCALING_DCWCTR,       0x11 },
+    { SCALING_PCLK_DIV,     0xF1 },
+    { SCALING_PCLK_DELAY,   0x02 },
+    { 0xff, 0xff },
+};
+
+static struct regval_list ov7670_qqvga[] = {
+	{ COM3,                 0x04 }, //DCW enable	
+	{ COM14,                0x1a }, //pixel clock divided by 4, manual scaling enable, DCW and PCLK controlled by register	
+	{ SCALING_XSC,          0x3a },	
+	{ SCALING_YSC,          0x35 },
+	{ SCALING_DCWCTR,       0x22 }, //downsample by 4	
+	{ SCALING_PCLK_DIV,     0xf2 }, //pixel clock divided by 4	
+	{ SCALING_PCLK_DELAY,   0x02 },
+    { 0xff, 0xff },
+};
+
+/*
+ * Write a list of register settings; ff/ff stops the process.
+ */
+static int ov7670_write_array(sensor_t *sensor, struct regval_list *vals)
+{
+int ret = 0;
+	
+	while ( (vals->reg_num != 0xff || vals->value != 0xff) && (ret == 0) ) {
+        ret = SCCB_Write(sensor->slv_addr, vals->reg_num, vals->value);
+
+	    ESP_LOGD(TAG, "reset reg %02X, W(%02X) R(%02X)", vals->reg_num, 
+                        vals->value, SCCB_Read(sensor->slv_addr, vals->reg_num) );
+		
+		vals++;
+	}
+
+    return ret;
+}
+
+/*
+ * Calculate the frame control registers.
+ */
+static int ov7670_frame_control(sensor_t *sensor, int hstart, int hstop, int vstart, int vstop)
+{
+struct regval_list frame[7];
+
+    frame[0].reg_num = HSTART;
+    frame[0].value = (hstart >> 3);
+
+    frame[1].reg_num = HSTOP;
+    frame[1].value = (hstop >> 3);
+
+    frame[2].reg_num = HREF;
+    frame[2].value = (((hstop & 0x07) << 3) | (hstart & 0x07));
+    
+    frame[3].reg_num = VSTART;
+    frame[3].value = (vstart >> 2);
+    
+    frame[4].reg_num = VSTOP;
+    frame[4].value = (vstop >> 2);
+
+    frame[5].reg_num = VREF;
+    frame[5].value = (((vstop & 0x02) << 2) | (vstart & 0x02));
+
+    /* End mark */
+    frame[5].reg_num = 0xFF;
+    frame[5].value = 0xFF;
+
+    return ov7670_write_array(sensor, frame);
+}
+
+static int reset(sensor_t *sensor)
+{
+    int ret;
+
+    // Reset all registers
+    SCCB_Write(sensor->slv_addr, COM7, COM7_RESET);
+
+    // Delay 10 ms
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+
+    ret = ov7670_write_array(sensor, ov7670_default_regs);
+
+    // Delay
+    vTaskDelay(30 / portTICK_PERIOD_MS);
+
+    return ret;
+}
+
+static int set_pixformat(sensor_t *sensor, pixformat_t pixformat)
+{
+int ret;
+
+    switch (pixformat) {
+        case PIXFORMAT_RGB565:
+        case PIXFORMAT_RGB888:
+            ret = ov7670_write_array(sensor, ov7670_fmt_rgb565);
+        break;
+ 
+        case PIXFORMAT_YUV422:
+        case PIXFORMAT_GRAYSCALE:
+	    default:
+            ret = ov7670_write_array(sensor, ov7670_fmt_yuv422);
+        break;
+    }
+
+    vTaskDelay(30 / portTICK_PERIOD_MS);
+
+    /*
+	 * If we're running RGB565, we must rewrite clkrc after setting
+	 * the other parameters or the image looks poor.  If we're *not*
+	 * doing RGB565, we must not rewrite clkrc or the image looks
+	 * *really* poor.
+	 *
+	 * (Update) Now that we retain clkrc state, we should be able
+	 * to write it unconditionally, and that will make the frame
+	 * rate persistent too.
+	 */
+    if (pixformat == PIXFORMAT_RGB565) {
+        ret = SCCB_Write(sensor->slv_addr, CLKRC, ov7670_clkrc); 
+    }
+
+    return ret;
+}
+
+static int set_framesize(sensor_t *sensor, framesize_t framesize)
+{
+   int ret;
+
+    // store clkrc before changing window settings...
+    ov7670_clkrc =  SCCB_Read(sensor->slv_addr, CLKRC);
+     
+	switch (framesize){
+        case FRAMESIZE_VGA:
+            if( (ret = ov7670_write_array(sensor, ov7670_vga)) == 0 ) {
+                /* These values from Omnivision */
+                ret = ov7670_frame_control(sensor, 158, 14, 10, 490);
+            }
+        break;
+	    case FRAMESIZE_QVGA:
+            if( (ret = ov7670_write_array(sensor, ov7670_qvga)) == 0 ) {
+                /* These values from Omnivision */
+                ret = ov7670_frame_control(sensor, 158, 14, 10, 490);
+            }
+        break;
+	    case FRAMESIZE_QQVGA:
+            if( (ret = ov7670_write_array(sensor, ov7670_qqvga)) == 0 ) {
+                /* These values from Omnivision */
+                ret = ov7670_frame_control(sensor, 158, 14, 10, 490);
+            }
+        break; 
+
+        default:
+            ret = -1;   
+    }
+
+    vTaskDelay(30 / portTICK_PERIOD_MS);
+
+    if (ret == 0) {
+        sensor->status.framesize = framesize;
+    }
+
+	return ret;
+}
+
+static int set_colorbar(sensor_t *sensor, int enable)
+{
+    uint8_t ret = 0;
+    // Read register scaling_xsc
+    uint8_t reg = SCCB_Read(sensor->slv_addr, SCALING_XSC);
+
+    // Pattern to set color bar bit[0]=0 in every case
+    reg = SCALING_XSC_CBAR(reg);
+
+    // Write pattern to SCALING_XSC
+    ret = SCCB_Write(sensor->slv_addr, SCALING_XSC, reg);
+
+    // Read register scaling_ysc
+    reg = SCCB_Read(sensor->slv_addr, SCALING_YSC);
+
+    // Pattern to set color bar bit[0]=0 in every case
+    reg = SCALING_YSC_CBAR(reg, enable);
+
+    // Write pattern to SCALING_YSC
+    ret = ret | SCCB_Write(sensor->slv_addr, SCALING_YSC, reg);
+
+    // return 0 or 0xFF
+    return ret;
+}
+
+static int set_whitebal(sensor_t *sensor, int enable)
+{
+    // Read register COM8
+    uint8_t reg = SCCB_Read(sensor->slv_addr, COM8);
+
+    // Set white bal on/off
+    reg = COM8_SET_AWB(reg, enable);
+
+    // Write back register COM8
+    return SCCB_Write(sensor->slv_addr, COM8, reg);
+}
+
+static int set_gain_ctrl(sensor_t *sensor, int enable)
+{
+    // Read register COM8
+    uint8_t reg = SCCB_Read(sensor->slv_addr, COM8);
+
+    // Set white bal on/off
+    reg = COM8_SET_AGC(reg, enable);
+
+    // Write back register COM8
+    return SCCB_Write(sensor->slv_addr, COM8, reg);
+}
+
+static int set_exposure_ctrl(sensor_t *sensor, int enable)
+{
+    // Read register COM8
+    uint8_t reg = SCCB_Read(sensor->slv_addr, COM8);
+
+    // Set white bal on/off
+    reg = COM8_SET_AEC(reg, enable);
+
+    // Write back register COM8
+    return SCCB_Write(sensor->slv_addr, COM8, reg);
+}
+
+static int set_hmirror(sensor_t *sensor, int enable)
+{
+    // Read register MVFP
+    uint8_t reg = SCCB_Read(sensor->slv_addr, MVFP);
+
+    // Set mirror on/off
+    reg = MVFP_SET_MIRROR(reg, enable);
+
+    // Write back register MVFP
+    return SCCB_Write(sensor->slv_addr, MVFP, reg);
+}
+
+static int set_vflip(sensor_t *sensor, int enable)
+{
+    // Read register MVFP
+    uint8_t reg = SCCB_Read(sensor->slv_addr, MVFP);
+
+    // Set mirror on/off
+    reg = MVFP_SET_FLIP(reg, enable);
+
+    // Write back register MVFP
+    return SCCB_Write(sensor->slv_addr, MVFP, reg);
+}
+
+static int init_status(sensor_t *sensor)
+{
+    sensor->status.awb = 0;
+    sensor->status.aec = 0;
+    sensor->status.agc = 0;
+    sensor->status.hmirror = 0;
+    sensor->status.vflip = 0;
+    sensor->status.colorbar = 0;
+    return 0;
+}
+
+static int set_dummy(sensor_t *sensor, int val){ return -1; }
+static int set_gainceiling_dummy(sensor_t *sensor, gainceiling_t val){ return -1; }
+
+int ov7670_init(sensor_t *sensor)
+{
+    // Set function pointers
+    sensor->reset = reset;
+    sensor->init_status = init_status;
+    sensor->set_pixformat = set_pixformat;
+    sensor->set_framesize = set_framesize;
+    sensor->set_colorbar = set_colorbar;
+    sensor->set_whitebal = set_whitebal;
+    sensor->set_gain_ctrl = set_gain_ctrl;
+    sensor->set_exposure_ctrl = set_exposure_ctrl;
+    sensor->set_hmirror = set_hmirror;
+    sensor->set_vflip = set_vflip;
+
+    //not supported
+    sensor->set_brightness= set_dummy;
+    sensor->set_saturation= set_dummy;
+    sensor->set_quality = set_dummy;
+    sensor->set_gainceiling = set_gainceiling_dummy;
+    sensor->set_aec2 = set_dummy;
+    sensor->set_aec_value = set_dummy;
+    sensor->set_special_effect = set_dummy;
+    sensor->set_wb_mode = set_dummy;
+    sensor->set_ae_level = set_dummy;
+    sensor->set_dcw = set_dummy;
+    sensor->set_bpc = set_dummy;
+    sensor->set_wpc = set_dummy;
+    sensor->set_awb_gain = set_dummy;
+    sensor->set_agc_gain = set_dummy;
+    sensor->set_raw_gma = set_dummy;
+    sensor->set_lenc = set_dummy;
+    sensor->set_sharpness = set_dummy;
+    sensor->set_denoise = set_dummy;
+
+    // Retrieve sensor's signature
+    sensor->id.MIDH = SCCB_Read(sensor->slv_addr, REG_MIDH);
+    sensor->id.MIDL = SCCB_Read(sensor->slv_addr, REG_MIDL);
+    sensor->id.PID = SCCB_Read(sensor->slv_addr, REG_PID);
+    sensor->id.VER = SCCB_Read(sensor->slv_addr, REG_VER);
+    
+    ESP_LOGD(TAG, "OV7670 Attached");
+    
+    return 0;
+}

code/components/esp32-camera-master/sensors/private_include/nt99141.h

@@ -0,0 +1,16 @@
+/*
+ * This file is part of the OpenMV project.
+ * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
+ * This work is licensed under the MIT license, see the file LICENSE for details.
+ *
+ * NT99141 driver.
+ *
+ */
+#ifndef __NT99141_H__
+#define __NT99141_H__
+
+#include "sensor.h"
+
+int NT99141_init(sensor_t *sensor);
+
+#endif // __NT99141_H__

code/components/esp32-camera-master/sensors/private_include/nt99141_regs.h

@@ -0,0 +1,211 @@
+/*
+ * NT99141 register definitions.
+ */
+#ifndef __NT99141_REG_REGS_H__
+#define __NT99141_REG_REGS_H__
+
+/* system control registers */
+#define SYSTEM_CTROL0   0x3021  // Bit[7]: Software reset 
+                                // Bit[6]: Software power down 
+                                // Bit[5]: Reserved 
+                                // Bit[4]: SRB clock SYNC enable 
+                                // Bit[3]: Isolation suspend select 
+                                // Bit[2:0]: Not used
+
+/* output format control registers */
+#define FORMAT_CTRL     0x501F // Format select
+                                // Bit[2:0]:
+                                //  000: YUV422						
+                                //  001: RGB
+                                //  010: Dither
+                                //  011: RAW after DPC
+                                //  101: RAW after CIP
+
+/* format control registers */
+#define FORMAT_CTRL00   0x4300
+
+/* frame control registers */
+#define FRAME_CTRL01    0x4201  // Control Passed Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
+                                // Bit[7:4]: Not used
+                                // Bit[3:0]: Frame ON number
+#define FRAME_CTRL02    0x4202  // Control Masked Frame Number When both ON and OFF number set to 0x00,frame control is in bypass mode
+                                // Bit[7:4]: Not used
+                                // BIT[3:0]: Frame OFF number
+
+/* ISP top control registers */
+#define PRE_ISP_TEST_SETTING_1  0x3025  // Bit[7]: Test enable
+                                        //         0: Test disable
+                                        //         1: Color bar enable
+                                        // Bit[6]: Rolling
+                                        // Bit[5]: Transparent
+                                        // Bit[4]: Square black and white
+                                        // Bit[3:2]: Color bar style
+                                        //         00: Standard 8 color bar
+                                        //         01: Gradual change at vertical mode 1
+                                        //         10: Gradual change at horizontal
+                                        //         11: Gradual change at vertical mode 2
+                                        // Bit[1:0]: Test select
+                                        //         00: Color bar
+                                        //         01: Random data
+                                        //         10: Square data
+                                        //         11: Black image
+
+//exposure = {0x3500[3:0], 0x3501[7:0], 0x3502[7:0]} / 16 × tROW
+
+/* AEC/AGC control functions */
+#define AEC_PK_MANUAL   0x3201  // AEC Manual Mode Control
+                                // Bit[7:6]: Reserved
+                                // Bit[5]: Gain delay option
+                                //         Valid when 0x3503[4]=1’b0
+                                //         0: Delay one frame latch
+                                //         1: One frame latch
+                                // Bit[4:2]: Reserved
+                                // Bit[1]: AGC manual
+                                //         0: Auto enable
+                                //         1: Manual enable
+                                // Bit[0]: AEC manual
+                                //         0: Auto enable
+                                //         1: Manual enable
+
+//gain = {0x350A[1:0], 0x350B[7:0]} / 16
+
+/* mirror and flip registers */
+#define TIMING_TC_REG20 0x3022  // Timing Control Register
+                                // Bit[2:1]: Vertical flip enable
+                                //         00: Normal
+                                //         11: Vertical flip
+                                // Bit[0]: Vertical binning enable
+#define TIMING_TC_REG21 0x3022  // Timing Control Register
+                                // Bit[5]: Compression Enable
+                                // Bit[2:1]: Horizontal mirror enable
+                                //         00: Normal
+                                //         11: Horizontal mirror
+                                // Bit[0]: Horizontal binning enable
+
+#define CLOCK_POL_CONTROL 0x3024// Bit[5]: PCLK polarity 0: active low
+                                //          1: active high
+                                // Bit[3]: Gate PCLK under VSYNC
+                                // Bit[2]: Gate PCLK under HREF
+                                // Bit[1]: HREF polarity
+                                //          0: active low
+                                //          1: active high
+                                // Bit[0] VSYNC polarity
+                                //          0: active low
+                                //          1: active high
+#define DRIVE_CAPABILITY 0x306a // Bit[7:6]:
+                                //          00: 1x
+                                //          01: 2x
+                                //          10: 3x
+                                //          11: 4x
+
+
+#define X_ADDR_ST_H     0x3800 //Bit[3:0]: X address start[11:8]
+#define X_ADDR_ST_L     0x3801 //Bit[7:0]: X address start[7:0]
+#define Y_ADDR_ST_H     0x3802 //Bit[2:0]: Y address start[10:8]
+#define Y_ADDR_ST_L     0x3803 //Bit[7:0]: Y address start[7:0]
+#define X_ADDR_END_H    0x3804 //Bit[3:0]: X address end[11:8]
+#define X_ADDR_END_L    0x3805 //Bit[7:0]:
+#define Y_ADDR_END_H    0x3806 //Bit[2:0]: Y address end[10:8]
+#define Y_ADDR_END_L    0x3807 //Bit[7:0]:
+// Size after scaling
+#define X_OUTPUT_SIZE_H 0x3808 //Bit[3:0]: DVP output horizontal width[11:8]
+#define X_OUTPUT_SIZE_L 0x3809 //Bit[7:0]:
+#define Y_OUTPUT_SIZE_H 0x380a //Bit[2:0]: DVP output vertical height[10:8]
+#define Y_OUTPUT_SIZE_L 0x380b //Bit[7:0]:
+#define X_TOTAL_SIZE_H  0x380c //Bit[3:0]: Total horizontal size[11:8]
+#define X_TOTAL_SIZE_L  0x380d //Bit[7:0]:
+#define Y_TOTAL_SIZE_H  0x380e //Bit[7:0]: Total vertical size[15:8]
+#define Y_TOTAL_SIZE_L  0x380f //Bit[7:0]:
+#define X_OFFSET_H      0x3810 //Bit[3:0]: ISP horizontal offset[11:8]
+#define X_OFFSET_L      0x3811 //Bit[7:0]:
+#define Y_OFFSET_H      0x3812 //Bit[2:0]: ISP vertical offset[10:8]
+#define Y_OFFSET_L      0x3813 //Bit[7:0]:
+#define X_INCREMENT     0x3814 //Bit[7:4]: Horizontal odd subsample increment
+                               //Bit[3:0]: Horizontal even subsample increment
+#define Y_INCREMENT     0x3815 //Bit[7:4]: Vertical odd subsample increment
+                               //Bit[3:0]: Vertical even subsample increment
+// Size before scaling
+//#define X_INPUT_SIZE    (X_ADDR_END - X_ADDR_ST + 1 - (2 * X_OFFSET))
+//#define Y_INPUT_SIZE    (Y_ADDR_END - Y_ADDR_ST + 1 - (2 * Y_OFFSET))
+
+#define ISP_CONTROL_01   0x3021 // Bit[5]: Scale enable
+                                //          0: Disable
+                                //          1: Enable
+
+#define SCALE_CTRL_1     0x5601 // Bit[6:4]: HDIV RW
+                                //          DCW scale times
+                                //          000: DCW 1 time
+                                //          001: DCW 2 times
+                                //          010: DCW 4 times
+                                //          100: DCW 8 times
+                                //          101: DCW 16 times
+                                //          Others: DCW 16 times
+                                // Bit[2:0]: VDIV RW
+                                //          DCW scale times
+                                //          000: DCW 1 time
+                                //          001: DCW 2 times
+                                //          010: DCW 4 times
+                                //          100: DCW 8 times
+                                //          101: DCW 16 times
+                                //          Others: DCW 16 times
+
+#define SCALE_CTRL_2     0x5602 // X_SCALE High Bits
+#define SCALE_CTRL_3     0x5603 // X_SCALE Low Bits
+#define SCALE_CTRL_4     0x5604 // Y_SCALE High Bits
+#define SCALE_CTRL_5     0x5605 // Y_SCALE Low Bits
+#define SCALE_CTRL_6     0x5606 // Bit[3:0]: V Offset
+
+#define PCLK_RATIO       0x3824 // Bit[4:0]: PCLK ratio manual
+#define VFIFO_CTRL0C     0x460C // Bit[1]: PCLK manual enable
+                                //          0: Auto
+                                //          1: Manual by PCLK_RATIO
+
+#define VFIFO_X_SIZE_H   0x4602
+#define VFIFO_X_SIZE_L   0x4603
+#define VFIFO_Y_SIZE_H   0x4604
+#define VFIFO_Y_SIZE_L   0x4605
+
+#define SC_PLLS_CTRL0    0x303a // Bit[7]: PLLS bypass
+#define SC_PLLS_CTRL1    0x303b // Bit[4:0]: PLLS multiplier
+#define SC_PLLS_CTRL2    0x303c // Bit[6:4]: PLLS charge pump control
+                                // Bit[3:0]: PLLS system divider
+#define SC_PLLS_CTRL3    0x303d // Bit[5:4]: PLLS pre-divider
+                                //          00: 1
+                                //          01: 1.5
+                                //          10: 2
+                                //          11: 3
+                                // Bit[2]: PLLS root-divider - 1
+                                // Bit[1:0]: PLLS seld5
+                                //          00: 1
+                                //          01: 1
+                                //          10: 2
+                                //          11: 2.5
+
+#define COMPRESSION_CTRL00 0x4400 //
+#define COMPRESSION_CTRL01 0x4401 //
+#define COMPRESSION_CTRL02 0x4402 //
+#define COMPRESSION_CTRL03 0x4403 //
+#define COMPRESSION_CTRL04 0x4404 //
+#define COMPRESSION_CTRL05 0x4405 //
+#define COMPRESSION_CTRL06 0x4406 //
+#define COMPRESSION_CTRL07 0x3401 // Bit[5:0]: QS
+#define COMPRESSION_ISI_CTRL 0x4408 //
+#define COMPRESSION_CTRL09 0x4409 //
+#define COMPRESSION_CTRL0a 0x440a //
+#define COMPRESSION_CTRL0b 0x440b //
+#define COMPRESSION_CTRL0c 0x440c //
+#define COMPRESSION_CTRL0d 0x440d //
+#define COMPRESSION_CTRL0E 0x440e //
+
+/**
+ * @brief register value
+ */
+#define TEST_COLOR_BAR  0x02    /* Enable Color Bar roling Test */
+
+#define AEC_PK_MANUAL_AGC_MANUALEN  0x02    /* Enable AGC Manual enable */
+#define AEC_PK_MANUAL_AEC_MANUALEN  0x01    /* Enable AEC Manual enable */
+
+#define TIMING_TC_REG20_VFLIP   0x01 /* Vertical flip enable */
+#define TIMING_TC_REG21_HMIRROR 0x02 /* Horizontal mirror enable */
+
+#endif // __NT99141_REG_REGS_H__

code/components/esp32-camera-master/sensors/private_include/nt99141_settings.h

@@ -0,0 +1,825 @@
+#ifndef _NT99141_SETTINGS_H_
+#define _NT99141_SETTINGS_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "esp_attr.h"
+#include "nt99141_regs.h"
+
+static const ratio_settings_t ratio_table[] = {
+    //  mw,   mh,  sx,  sy,   ex,   ey, ox, oy,   tx,   ty
+    { 1280, 720,   0,   4, 1283, 723, 0, 4, 1660, 963 }, 
+
+};
+
+#define REG_DLY 0xffff
+#define REGLIST_TAIL 0x0000
+
+static const DRAM_ATTR uint16_t sensor_default_regs[][2] = {
+ //initial
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x3109, 0x04},
+{0x3040, 0x04},
+{0x3041, 0x02},
+{0x3042, 0xFF},
+{0x3043, 0x08},
+{0x3052, 0xE0},
+{0x305F, 0x33},
+{0x3100, 0x07},
+{0x3106, 0x03},
+{0x3105, 0x01},
+{0x3108, 0x05},
+{0x3110, 0x22},
+{0x3111, 0x57},
+{0x3112, 0x22},
+{0x3113, 0x55},
+{0x3114, 0x05},
+{0x3135, 0x00},
+{0x32F0, 0x01},
+{0x3290, 0x01},
+{0x3291, 0x80},
+{0x3296, 0x01},
+{0x3297, 0x73},
+{0x3250, 0x80},
+{0x3251, 0x03},
+{0x3252, 0xFF},
+{0x3253, 0x00},
+{0x3254, 0x03},
+{0x3255, 0xFF},
+{0x3256, 0x00},
+{0x3257, 0x50},
+{0x3270, 0x00},
+{0x3271, 0x0C},
+{0x3272, 0x18},
+{0x3273, 0x32},
+{0x3274, 0x44},
+{0x3275, 0x54},
+{0x3276, 0x70},
+{0x3277, 0x88},
+{0x3278, 0x9D},
+{0x3279, 0xB0},
+{0x327A, 0xCF},
+{0x327B, 0xE2},
+{0x327C, 0xEF},
+{0x327D, 0xF7},
+{0x327E, 0xFF},
+{0x3302, 0x00},
+{0x3303, 0x40},
+{0x3304, 0x00},
+{0x3305, 0x96},
+{0x3306, 0x00},
+{0x3307, 0x29},
+{0x3308, 0x07},
+{0x3309, 0xBA},
+{0x330A, 0x06},
+{0x330B, 0xF5},
+{0x330C, 0x01},
+{0x330D, 0x51},
+{0x330E, 0x01},
+{0x330F, 0x30},
+{0x3310, 0x07},
+{0x3311, 0x16},
+{0x3312, 0x07},
+{0x3313, 0xBA},
+{0x3326, 0x02},
+{0x32F6, 0x0F},
+{0x32F9, 0x42},
+{0x32FA, 0x24},
+{0x3325, 0x4A},
+{0x3330, 0x00},
+{0x3331, 0x0A},
+{0x3332, 0xFF},
+{0x3338, 0x30},
+{0x3339, 0x84},
+{0x333A, 0x48},
+{0x333F, 0x07},
+{0x3360, 0x10},
+{0x3361, 0x18},
+{0x3362, 0x1f},
+{0x3363, 0x37},
+{0x3364, 0x80},
+{0x3365, 0x80},
+{0x3366, 0x68},
+{0x3367, 0x60},
+{0x3368, 0x30},
+{0x3369, 0x28},
+{0x336A, 0x20},
+{0x336B, 0x10},
+{0x336C, 0x00},
+{0x336D, 0x20},
+{0x336E, 0x1C},
+{0x336F, 0x18},
+{0x3370, 0x10},
+{0x3371, 0x38},
+{0x3372, 0x3C},
+{0x3373, 0x3F},
+{0x3374, 0x3F},
+{0x338A, 0x34},
+{0x338B, 0x7F},
+{0x338C, 0x10},
+{0x338D, 0x23},
+{0x338E, 0x7F},
+{0x338F, 0x14},
+{0x3375, 0x08},
+{0x3376, 0x0C},
+{0x3377, 0x18},
+{0x3378, 0x20},
+{0x3012, 0x02},
+{0x3013, 0xD0},
+{0x3025, 0x02}, //colorbar
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_fmt_jpeg[][2] = {
+    {0x32F0, 0x70}, // YUV422
+    {REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_fmt_raw[][2] = {
+    {0x32F0, 0x50}, // RAW
+    {REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_fmt_grayscale[][2] = {
+    {0x32F1, 0x01},
+    {REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_fmt_yuv422[][2] = {
+    {0x32F0, 0x00}, // YUV422
+    {REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_fmt_rgb565[][2] = {
+    {0x32F0, 0x01}, // RGB
+    {REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint8_t sensor_saturation_levels[9][1] = {
+    {0x60},//-4
+    {0x68},//-3
+    {0x70},//-2
+    {0x78},//-1
+    {0x80},//0
+    {0x88},//+1
+    {0x90},//+2
+    {0x98},//+3
+    {0xA0},//+4
+};
+
+static const DRAM_ATTR uint8_t sensor_special_effects[7][4] = {
+    {0x00, 0x80, 0x80, 0x01},//Normal
+    {0x03, 0x80, 0x80, 0x01},//Negative
+    {0x01, 0x80, 0x80, 0x01},//Grayscale
+    {0x05, 0x2A, 0xF0, 0x01},//Red Tint
+    {0x05, 0x60, 0x20, 0x01},//Green Tint
+    {0x05, 0xF0, 0x80, 0x01},//Blue Tint
+    {0x02, 0x80, 0x80, 0x01},//Sepia
+	
+};
+
+// AE LEVEL
+static const DRAM_ATTR uint16_t sensor_ae_level[][2] = {
+
+// 1. [AE_Target : 0x24]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x29 },
+ {0x32B9, 0x1F },
+ {0x32BC, 0x24 },
+ {0x32BD, 0x27 },
+ {0x32BE, 0x21 },
+//------------------------------------------------------------------------
+// 2. [AE_Target : 0x28]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x2D },
+ {0x32B9, 0x23 },
+ {0x32BC, 0x28 },
+ {0x32BD, 0x2B },
+ {0x32BE, 0x25 },
+//------------------------------------------------------------------------
+// 3. [AE_Target : 0x2C]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x32 },
+ {0x32B9, 0x26 },
+ {0x32BC, 0x2C },
+ {0x32BD, 0x2F },
+ {0x32BE, 0x29 },
+//------------------------------------------------------------------------
+// 4, [AE_Target : 0x30]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x36 },
+ {0x32B9, 0x2A },
+ {0x32BC, 0x30 },
+ {0x32BD, 0x33 },
+ {0x32BE, 0x2D },
+//------------------------------------------------------------------------
+// 5. [AE_Target : 0x34]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x3B },
+ {0x32B9, 0x2D },
+ {0x32BC, 0x34 },
+ {0x32BD, 0x38 },
+ {0x32BE, 0x30 },
+//------------------------------------------------------------------------
+// 6. [AE_Target : 0x38]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x3F },
+ {0x32B9, 0x31 },
+ {0x32BC, 0x38 },
+ {0x32BD, 0x3C },
+ {0x32BE, 0x34 },
+//------------------------------------------------------------------------
+// 7. [AE_Target : 0x3D]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x44 },
+ {0x32B9, 0x34 },
+ {0x32BC, 0x3C },
+ {0x32BD, 0x40 },
+ {0x32BE, 0x38 },
+//------------------------------------------------------------------------
+// 8. [AE_Target : 0x40]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x48 },
+ {0x32B9, 0x38 },
+ {0x32BC, 0x40 },
+ {0x32BD, 0x44 },
+ {0x32BE, 0x3C },
+//------------------------------------------------------------------------
+// 9. [AE_Target : 0x44]
+// Set_Device_Format = FORMAT_16_8
+// SET_Device_Addr = 0x54
+ {0x32B8, 0x4D },
+ {0x32B9, 0x3B },
+ {0x32BC, 0x44 },
+ {0x32BD, 0x49 },
+ {0x32BE, 0x3F },
+};
+
+static const DRAM_ATTR uint16_t sensor_framesize_HD[][2] = {
+//[JPEG_1280x720_8.18_8.18_Fps]
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x32BF, 0x60}, 
+{0x32C0, 0x5A}, 
+{0x32C1, 0x5A}, 
+{0x32C2, 0x5A}, 
+{0x32C3, 0x00}, 
+{0x32C4, 0x20}, 
+{0x32C5, 0x20}, 
+{0x32C6, 0x20}, 
+{0x32C7, 0x00}, 
+{0x32C8, 0x3C}, 
+{0x32C9, 0x5A}, 
+{0x32CA, 0x7A}, 
+{0x32CB, 0x7A}, 
+{0x32CC, 0x7A}, 
+{0x32CD, 0x7A}, 
+{0x32DB, 0x5E}, 
+{0x32F0, 0x70}, 
+{0x3400, 0x08}, 
+{0x3400, 0x00}, 
+{0x3401, 0x4E}, 
+{0x3404, 0x00}, 
+{0x3405, 0x00}, 
+{0x3410, 0x00}, 
+{0x3200, 0x3E}, 
+{0x3201, 0x0F}, 
+{0x3028, 0x0F}, 
+{0x3029, 0x00}, 
+{0x302A, 0x08}, 
+{0x3022, 0x24}, 
+{0x3023, 0x24}, 
+{0x3002, 0x00}, 
+{0x3003, 0x04}, 
+{0x3004, 0x00}, 
+{0x3005, 0x04}, 
+{0x3006, 0x05}, 
+{0x3007, 0x03}, 
+{0x3008, 0x02}, 
+{0x3009, 0xD3}, 
+{0x300A, 0x06}, 
+{0x300B, 0x7C}, 
+{0x300C, 0x02}, 
+{0x300D, 0xE0}, 
+{0x300E, 0x05}, 
+{0x300F, 0x00}, 
+{0x3010, 0x02}, 
+{0x3011, 0xD0}, 
+{0x32B8, 0x3F}, 
+{0x32B9, 0x31}, 
+{0x32BB, 0x87}, 
+{0x32BC, 0x38}, 
+{0x32BD, 0x3C}, 
+{0x32BE, 0x34}, 
+{0x3201, 0x3F}, 
+{0x3021, 0x06},
+{0x3025, 0x00}, //normal 
+{0x3400, 0x01}, 
+{0x3060, 0x01}, 
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_framesize_VGA[][2] = {
+//[JPEG_640x480_10.14_10.14_Fps]
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x32BF, 0x60}, 
+{0x32C0, 0x5A}, 
+{0x32C1, 0x5A}, 
+{0x32C2, 0x5A}, 
+{0x32C3, 0x00}, 
+{0x32C4, 0x20}, 
+{0x32C5, 0x20}, 
+{0x32C6, 0x20}, 
+{0x32C7, 0x00}, 
+{0x32C8, 0x4B}, 
+{0x32C9, 0x5A}, 
+{0x32CA, 0x7A}, 
+{0x32CB, 0x7A}, 
+{0x32CC, 0x7A}, 
+{0x32CD, 0x7A}, 
+{0x32DB, 0x62}, 
+{0x32F0, 0x70}, 
+{0x3400, 0x08}, 
+{0x3400, 0x00}, 
+{0x3401, 0x4E}, 
+{0x3404, 0x00}, 
+{0x3405, 0x00}, 
+{0x3410, 0x00}, 
+{0x32E0, 0x02}, 
+{0x32E1, 0x80}, 
+{0x32E2, 0x01}, 
+{0x32E3, 0xE0}, 
+{0x32E4, 0x00}, 
+{0x32E5, 0x80}, 
+{0x32E6, 0x00}, 
+{0x32E7, 0x80}, 
+{0x3200, 0x3E}, 
+{0x3201, 0x0F}, 
+{0x3028, 0x0F}, 
+{0x3029, 0x00}, 
+{0x302A, 0x08}, 
+{0x3022, 0x24}, 
+{0x3023, 0x24}, 
+{0x3002, 0x00}, 
+{0x3003, 0xA4}, 
+{0x3004, 0x00}, 
+{0x3005, 0x04}, 
+{0x3006, 0x04}, 
+{0x3007, 0x63}, 
+{0x3008, 0x02}, 
+{0x3009, 0xD3}, 
+{0x300A, 0x05}, 
+{0x300B, 0x3C}, 
+{0x300C, 0x02}, 
+{0x300D, 0xE0}, 
+{0x300E, 0x03}, 
+{0x300F, 0xC0}, 
+{0x3010, 0x02}, 
+{0x3011, 0xD0}, 
+{0x32B8, 0x3F}, 
+{0x32B9, 0x31}, 
+{0x32BB, 0x87}, 
+{0x32BC, 0x38}, 
+{0x32BD, 0x3C}, 
+{0x32BE, 0x34}, 
+{0x3201, 0x7F}, 
+{0x3021, 0x06},
+{0x3025, 0x00}, //normal 
+{0x3400, 0x01}, 
+{0x3060, 0x01}, 
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_framesize_QVGA[][2] = {
+//[JPEG_320x240_10.14_10.14_Fps] 
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x32BF, 0x60}, 
+{0x32C0, 0x5A}, 
+{0x32C1, 0x5A}, 
+{0x32C2, 0x5A}, 
+{0x32C3, 0x00}, 
+{0x32C4, 0x20}, 
+{0x32C5, 0x20}, 
+{0x32C6, 0x20}, 
+{0x32C7, 0x00}, 
+{0x32C8, 0x4B}, 
+{0x32C9, 0x5A}, 
+{0x32CA, 0x7A}, 
+{0x32CB, 0x7A}, 
+{0x32CC, 0x7A}, 
+{0x32CD, 0x7A}, 
+{0x32DB, 0x62}, 
+{0x32F0, 0x70}, 
+{0x3400, 0x08}, 
+{0x3400, 0x00}, 
+{0x3401, 0x4E}, 
+{0x3404, 0x00}, 
+{0x3405, 0x00}, 
+{0x3410, 0x00}, 
+{0x32E0, 0x01}, 
+{0x32E1, 0x40}, 
+{0x32E2, 0x00}, 
+{0x32E3, 0xF0}, 
+{0x32E4, 0x02}, 
+{0x32E5, 0x02}, 
+{0x32E6, 0x02}, 
+{0x32E7, 0x03}, 
+{0x3200, 0x3E}, 
+{0x3201, 0x0F}, 
+{0x3028, 0x0F}, 
+{0x3029, 0x00}, 
+{0x302A, 0x08}, 
+{0x3022, 0x24}, 
+{0x3023, 0x24}, 
+{0x3002, 0x00}, 
+{0x3003, 0xA4}, 
+{0x3004, 0x00}, 
+{0x3005, 0x04}, 
+{0x3006, 0x04}, 
+{0x3007, 0x63}, 
+{0x3008, 0x02}, 
+{0x3009, 0xD3}, 
+{0x300A, 0x05}, 
+{0x300B, 0x3C}, 
+{0x300C, 0x02}, 
+{0x300D, 0xE0}, 
+{0x300E, 0x03}, 
+{0x300F, 0xC0}, 
+{0x3010, 0x02}, 
+{0x3011, 0xD0}, 
+{0x32B8, 0x3F}, 
+{0x32B9, 0x31}, 
+{0x32BB, 0x87}, 
+{0x32BC, 0x38}, 
+{0x32BD, 0x3C}, 
+{0x32BE, 0x34}, 
+{0x3201, 0x7F}, 
+{0x3021, 0x06},
+{0x3025, 0x00}, //normal
+{0x3400, 0x01}, 
+{0x3060, 0x01}, 
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_framesize_VGA_xyskip[][2] = {
+// [JPEG_640x360_20.00_25.01_Fps_XY_Skip]
+// Set_Device_Format = FORMAT_16_8 
+// SET_Device_Addr = 0x54 
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x32BF, 0x60 },
+{0x320A, 0xB2 },
+{0x32C0, 0x64 },
+{0x32C1, 0x64 },
+{0x32C2, 0x64 },
+{0x32C3, 0x00 },
+{0x32C4, 0x20 },
+{0x32C5, 0x20 },
+{0x32C6, 0x20 },
+{0x32C7, 0x00 },
+{0x32C8, 0x62 },
+{0x32C9, 0x64 },
+{0x32CA, 0x84 },
+{0x32CB, 0x84 },
+{0x32CC, 0x84 },
+{0x32CD, 0x84 },
+{0x32DB, 0x68 },
+{0x32F0, 0x70 },
+{0x3400, 0x08 },
+{0x3400, 0x00 },
+{0x3401, 0x4E },
+{0x3404, 0x00 },
+{0x3405, 0x00 },
+{0x3410, 0x00 },
+{0x3200, 0x3E },
+{0x3201, 0x0F },
+{0x3028, 0x0F },
+{0x3029, 0x00 },
+{0x302A, 0x08 },
+{0x3022, 0x24 },
+{0x3023, 0x6C },
+{0x3002, 0x00 },
+{0x3003, 0x04 },
+{0x3004, 0x00 },
+{0x3005, 0x04 },
+{0x3006, 0x05 },
+{0x3007, 0x03 },
+{0x3008, 0x02 },
+{0x3009, 0xD3 },
+{0x300A, 0x03 },
+{0x300B, 0xFC },
+{0x300C, 0x01 },
+{0x300D, 0x88 },
+{0x300E, 0x02 },
+{0x300F, 0x80 },
+{0x3010, 0x01 },
+{0x3011, 0x68 },
+{0x32B8, 0x3F },
+{0x32B9, 0x31 },
+{0x32BB, 0x87 },
+{0x32BC, 0x38 },
+{0x32BD, 0x3C },
+{0x32BE, 0x34 },
+{0x3201, 0x3F },
+{0x3025, 0x00 }, //normal
+{0x3021, 0x06 },
+{0x3400, 0x01 },
+{0x3060, 0x01 },
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_framesize_VGA_xskip[][2] = {
+//[JPEG_640x480_Xskip_13.32_13.32_Fps]
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x32BF, 0x60}, 
+{0x32C0, 0x5A}, 
+{0x32C1, 0x5A}, 
+{0x32C2, 0x5A}, 
+{0x32C3, 0x00}, 
+{0x32C4, 0x20}, 
+{0x32C5, 0x20}, 
+{0x32C6, 0x20}, 
+{0x32C7, 0x00}, 
+{0x32C8, 0x62}, 
+{0x32C9, 0x5A}, 
+{0x32CA, 0x7A}, 
+{0x32CB, 0x7A}, 
+{0x32CC, 0x7A}, 
+{0x32CD, 0x7A}, 
+{0x32DB, 0x68}, 
+{0x32F0, 0x70}, 
+{0x3400, 0x08}, 
+{0x3400, 0x00}, 
+{0x3401, 0x4E}, 
+{0x3404, 0x00}, 
+{0x3405, 0x00}, 
+{0x3410, 0x00}, 
+{0x32E0, 0x02}, 
+{0x32E1, 0x80}, 
+{0x32E2, 0x01}, 
+{0x32E3, 0xE0}, 
+{0x32E4, 0x00}, 
+{0x32E5, 0x00}, 
+{0x32E6, 0x00}, 
+{0x32E7, 0x80}, 
+{0x3200, 0x3E}, 
+{0x3201, 0x0F}, 
+{0x3028, 0x0F}, 
+{0x3029, 0x00}, 
+{0x302A, 0x08}, 
+{0x3022, 0x24}, 
+{0x3023, 0x2C}, 
+{0x3002, 0x00}, 
+{0x3003, 0x04}, 
+{0x3004, 0x00}, 
+{0x3005, 0x04}, 
+{0x3006, 0x05}, 
+{0x3007, 0x03}, 
+{0x3008, 0x02}, 
+{0x3009, 0xD3}, 
+{0x300A, 0x03}, 
+{0x300B, 0xFC}, 
+{0x300C, 0x02}, 
+{0x300D, 0xE0}, 
+{0x300E, 0x02}, 
+{0x300F, 0x80}, 
+{0x3010, 0x02}, 
+{0x3011, 0xD0}, 
+{0x32B8, 0x3F}, 
+{0x32B9, 0x31}, 
+{0x32BB, 0x87}, 
+{0x32BC, 0x38}, 
+{0x32BD, 0x3C}, 
+{0x32BE, 0x34}, 
+{0x3201, 0x7F}, 
+{0x3021, 0x06},
+{0x3025, 0x00}, //normal 
+{0x3400, 0x01}, 
+{0x3060, 0x01}, 
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_framesize_QVGA_xskip[][2] = {
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+//[JPEG_320x240_Xskip_13.32_13.32_Fps]
+{0x32BF, 0x60}, 
+{0x32C0, 0x5A}, 
+{0x32C1, 0x5A}, 
+{0x32C2, 0x5A}, 
+{0x32C3, 0x00}, 
+{0x32C4, 0x20}, 
+{0x32C5, 0x20}, 
+{0x32C6, 0x20}, 
+{0x32C7, 0x00}, 
+{0x32C8, 0x62}, 
+{0x32C9, 0x5A}, 
+{0x32CA, 0x7A}, 
+{0x32CB, 0x7A}, 
+{0x32CC, 0x7A}, 
+{0x32CD, 0x7A}, 
+{0x32DB, 0x68}, 
+{0x32F0, 0x70}, 
+{0x3400, 0x08}, 
+{0x3400, 0x00}, 
+{0x3401, 0x4E}, 
+{0x3404, 0x00}, 
+{0x3405, 0x00}, 
+{0x3410, 0x00}, 
+{0x32E0, 0x01}, 
+{0x32E1, 0x40}, 
+{0x32E2, 0x00}, 
+{0x32E3, 0xF0}, 
+{0x32E4, 0x01}, 
+{0x32E5, 0x01}, 
+{0x32E6, 0x02}, 
+{0x32E7, 0x03}, 
+{0x3200, 0x3E}, 
+{0x3201, 0x0F}, 
+{0x3028, 0x0F}, 
+{0x3029, 0x00}, 
+{0x302A, 0x08}, 
+{0x3022, 0x24}, 
+{0x3023, 0x2C}, 
+{0x3002, 0x00}, 
+{0x3003, 0x04}, 
+{0x3004, 0x00}, 
+{0x3005, 0x04}, 
+{0x3006, 0x05}, 
+{0x3007, 0x03}, 
+{0x3008, 0x02}, 
+{0x3009, 0xD3}, 
+{0x300A, 0x03}, 
+{0x300B, 0xFC}, 
+{0x300C, 0x02}, 
+{0x300D, 0xE0}, 
+{0x300E, 0x02}, 
+{0x300F, 0x80}, 
+{0x3010, 0x02}, 
+{0x3011, 0xD0}, 
+{0x32B8, 0x3F}, 
+{0x32B9, 0x31}, 
+{0x32BB, 0x87}, 
+{0x32BC, 0x38}, 
+{0x32BD, 0x3C}, 
+{0x32BE, 0x34}, 
+{0x3201, 0x7F}, 
+{0x3021, 0x06},
+{0x3025, 0x00}, //normal 
+{0x3400, 0x01}, 
+{0x3060, 0x01},
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+
+static const DRAM_ATTR uint16_t sensor_framesize_VGA_crop[][2] = {
+//[JPEG_640x480_Crop_19.77_19.77_Fps]
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x32BF, 0x60}, 
+{0x32C0, 0x5A}, 
+{0x32C1, 0x5A}, 
+{0x32C2, 0x5A}, 
+{0x32C3, 0x00}, 
+{0x32C4, 0x20}, 
+{0x32C5, 0x20}, 
+{0x32C6, 0x20}, 
+{0x32C7, 0x00}, 
+{0x32C8, 0x62}, 
+{0x32C9, 0x5A}, 
+{0x32CA, 0x7A}, 
+{0x32CB, 0x7A}, 
+{0x32CC, 0x7A}, 
+{0x32CD, 0x7A}, 
+{0x32DB, 0x68}, 
+{0x32F0, 0x70}, 
+{0x3400, 0x08}, 
+{0x3400, 0x00}, 
+{0x3401, 0x4E}, 
+{0x3404, 0x00}, 
+{0x3405, 0x00}, 
+{0x3410, 0x00}, 
+{0x3200, 0x3E}, 
+{0x3201, 0x0F}, 
+{0x3028, 0x0F}, 
+{0x3029, 0x00}, 
+{0x302A, 0x08}, 
+{0x3022, 0x24}, 
+{0x3023, 0x24}, 
+{0x3002, 0x01}, 
+{0x3003, 0x44}, 
+{0x3004, 0x00}, 
+{0x3005, 0x7C}, 
+{0x3006, 0x03}, 
+{0x3007, 0xC3}, 
+{0x3008, 0x02}, 
+{0x3009, 0x5B}, 
+{0x300A, 0x03}, 
+{0x300B, 0xFC}, 
+{0x300C, 0x01}, 
+{0x300D, 0xF0}, 
+{0x300E, 0x02}, 
+{0x300F, 0x80}, 
+{0x3010, 0x01}, 
+{0x3011, 0xE0}, 
+{0x32B8, 0x3F}, 
+{0x32B9, 0x31}, 
+{0x32BB, 0x87}, 
+{0x32BC, 0x38}, 
+{0x32BD, 0x3C}, 
+{0x32BE, 0x34}, 
+{0x3201, 0x3F}, 
+{0x3021, 0x06},
+{0x3025, 0x00}, //normal 
+{0x3400, 0x01}, 
+{0x3060, 0x01}, 
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+static const DRAM_ATTR uint16_t sensor_framesize_QVGA_crop[][2] = {
+//[JPEG_320x240_Crop_19.77_19.77_Fps]
+{0x3021, 0x00},
+{REG_DLY, 100}, // delay 100ms
+{0x32BF, 0x60}, 
+{0x32C0, 0x5A}, 
+{0x32C1, 0x5A}, 
+{0x32C2, 0x5A}, 
+{0x32C3, 0x00}, 
+{0x32C4, 0x20}, 
+{0x32C5, 0x20}, 
+{0x32C6, 0x20}, 
+{0x32C7, 0x00}, 
+{0x32C8, 0x62}, 
+{0x32C9, 0x5A}, 
+{0x32CA, 0x7A}, 
+{0x32CB, 0x7A}, 
+{0x32CC, 0x7A}, 
+{0x32CD, 0x7A}, 
+{0x32DB, 0x68}, 
+{0x32F0, 0x70}, 
+{0x3400, 0x08}, 
+{0x3400, 0x00}, 
+{0x3401, 0x4E}, 
+{0x3404, 0x00}, 
+{0x3405, 0x00}, 
+{0x3410, 0x00}, 
+{0x32E0, 0x01}, 
+{0x32E1, 0x40}, 
+{0x32E2, 0x00}, 
+{0x32E3, 0xF0}, 
+{0x32E4, 0x01}, 
+{0x32E5, 0x01}, 
+{0x32E6, 0x01}, 
+{0x32E7, 0x02}, 
+{0x3200, 0x3E}, 
+{0x3201, 0x0F}, 
+{0x3028, 0x0F}, 
+{0x3029, 0x00}, 
+{0x302A, 0x08}, 
+{0x3022, 0x24}, 
+{0x3023, 0x24}, 
+{0x3002, 0x01}, 
+{0x3003, 0x44}, 
+{0x3004, 0x00}, 
+{0x3005, 0x7C}, 
+{0x3006, 0x03}, 
+{0x3007, 0xC3}, 
+{0x3008, 0x02}, 
+{0x3009, 0x5B}, 
+{0x300A, 0x03}, 
+{0x300B, 0xFC}, 
+{0x300C, 0x01}, 
+{0x300D, 0xF0}, 
+{0x300E, 0x02}, 
+{0x300F, 0x80}, 
+{0x3010, 0x01}, 
+{0x3011, 0xE0}, 
+{0x32B8, 0x3F}, 
+{0x32B9, 0x31}, 
+{0x32BB, 0x87}, 
+{0x32BC, 0x38}, 
+{0x32BD, 0x3C}, 
+{0x32BE, 0x34}, 
+{0x3201, 0x7F}, 
+{0x3021, 0x06},
+{0x3025, 0x00}, //normal 
+{0x3400, 0x01}, 
+{0x3060, 0x01}, 
+{REGLIST_TAIL, 0x00}, // tail
+};
+
+#endif
+
+

code/components/esp32-camera-master/sensors/private_include/ov7670.h

@@ -0,0 +1,14 @@
+/*
+ * This file is part of the OpenMV project.
+ * author: Juan Schiavoni <juanjoseschiavoni@hotmail.com>
+ * This work is licensed under the MIT license, see the file LICENSE for details.
+ *
+ * OV7670 driver.
+ *
+ */
+#ifndef __OV7670_H__
+#define __OV7670_H__
+#include "sensor.h"
+
+int ov7670_init(sensor_t *sensor);
+#endif // __OV7670_H__

code/components/esp32-camera-master/sensors/private_include/ov7670_regs.h

@@ -0,0 +1,354 @@
+/*
+ * This file is for the OpenMV project so the OV7670 can be used
+ * author: Juan Schiavoni <juanjoseschiavoni@hotmail.com>
+ *
+ * OV7670 register definitions.
+ */
+#ifndef __OV7670_REG_REGS_H__
+#define __OV7670_REG_REGS_H__
+#define GAIN                    0x00 /* AGC – Gain control gain setting  */
+#define BLUE                    0x01 /* AWB – Blue channel gain setting  */
+#define RED                     0x02 /* AWB – Red channel gain setting   */
+#define VREF                    0x03 /* AWB – Green channel gain setting */
+#define COM1			        0x04 /* Common Control 1 */
+#define BAVG                    0x05 /* U/B Average Level   */
+#define GAVG                    0x06 /* Y/Gb Average Level  */
+#define AECH                    0x07 /* Exposure VAlue - AEC MSB 5 bits  */
+#define RAVG                    0x08 /* V/R Average Level */
+
+#define COM2                    0x09 /* Common Control 2 */
+#define COM2_SOFT_SLEEP         0x10 /* Soft sleep mode  */
+#define COM2_OUT_DRIVE_1x       0x00 /* Output drive capability 1x */
+#define COM2_OUT_DRIVE_2x       0x01 /* Output drive capability 2x */
+#define COM2_OUT_DRIVE_3x       0x02 /* Output drive capability 3x */
+#define COM2_OUT_DRIVE_4x       0x03 /* Output drive capability 4x */
+
+#define REG_PID                 0x0A /* Product ID Number MSB */
+#define REG_VER                 0x0B /* Product ID Number LSB */
+
+#define COM3                    0x0C /* Common Control 3 		 */
+#define COM3_SWAP_OUT           0x40 /* Output data MSB/LSB swap */
+#define COM3_TRI_CLK            0x20 /* Tri-state output clock   */
+#define COM3_TRI_DATA           0x10 /* Tri-state option output  */
+#define COM3_SCALE_EN           0x08 /* Scale enable             */
+#define COM3_DCW                0x04 /* DCW enable               */
+
+#define COM4                    0x0D /* Common Control 4         */
+#define COM4_PLL_BYPASS         0x00 /* Bypass PLL               */
+#define COM4_PLL_4x             0x40 /* PLL frequency 4x         */
+#define COM4_PLL_6x             0x80 /* PLL frequency 6x         */
+#define COM4_PLL_8x             0xc0 /* PLL frequency 8x         */
+#define COM4_AEC_FULL           0x00 /* AEC evaluate full window */
+#define COM4_AEC_1_2            0x10 /* AEC evaluate 1/2 window  */
+#define COM4_AEC_1_4            0x20 /* AEC evaluate 1/4 window  */
+#define COM4_AEC_2_3            0x30 /* AEC evaluate 2/3 window  */
+
+#define COM5                    0x0E /* Common Control 5 */
+#define COM5_AFR                0x80 /* Auto frame rate control ON/OFF selection (night mode) */
+#define COM5_AFR_SPEED          0x40 /* Auto frame rate control speed selection */
+#define COM5_AFR_0              0x00 /* No reduction of frame rate          */
+#define COM5_AFR_1_2            0x10 /* Max reduction to 1/2 frame rate     */
+#define COM5_AFR_1_4            0x20 /* Max reduction to 1/4 frame rate     */
+#define COM5_AFR_1_8            0x30 /* Max reduction to 1/8 frame rate     */
+#define COM5_AFR_4x             0x04 /* Add frame when AGC reaches 4x gain  */
+#define COM5_AFR_8x             0x08 /* Add frame when AGC reaches 8x gain  */
+#define COM5_AFR_16x            0x0c /* Add frame when AGC reaches 16x gain */
+#define COM5_AEC_NO_LIMIT       0x01 /* No limit to AEC increase step       */
+
+#define COM6                    0x0F /* Common Control 6 */
+#define COM6_AUTO_WINDOW        0x01 /* Auto window setting ON/OFF selection when format changes */
+
+#define AEC                     0x10 /* AEC[7:0] (see register AECH for AEC[15:8]) */
+#define CLKRC                   0x11 /* Internal Clock */
+
+#define COM7                    0x12 /* Common Control 7         */
+#define COM7_RESET              0x80 /* SCCB Register Reset      */
+#define COM7_RES_VGA            0x00 /* Resolution VGA           */
+#define COM7_RES_QVGA           0x40 /* Resolution QVGA          */
+#define COM7_BT656              0x20 /* BT.656 protocol ON/OFF   */
+#define COM7_SENSOR_RAW         0x10 /* Sensor RAW               */
+#define COM7_FMT_GBR422         0x00 /* RGB output format GBR422 */
+#define COM7_FMT_RGB565         0x04 /* RGB output format RGB565 */
+#define COM7_FMT_RGB555         0x08 /* RGB output format RGB555 */
+#define COM7_FMT_RGB444         0x0C /* RGB output format RGB444 */
+#define COM7_FMT_YUV            0x00 /* Output format YUV        */
+#define COM7_FMT_P_BAYER        0x01 /* Output format Processed Bayer RAW */
+#define COM7_FMT_RGB            0x04 /* Output format RGB        */
+#define COM7_FMT_R_BAYER        0x03 /* Output format Bayer RAW  */
+#define COM7_SET_FMT(r, x)      ((r&0xFC)|((x&0x5)<<0))
+
+#define COM8                    0x13 /* Common Control 8                */
+#define COM8_FAST_AUTO          0x80 /* Enable fast AGC/AEC algorithm   */
+#define COM8_STEP_VSYNC         0x00 /* AEC - Step size limited to vertical blank */
+#define COM8_STEP_UNLIMIT       0x40 /* AEC - Step size unlimited step size       */
+#define COM8_BANDF_EN           0x20 /* Banding filter ON/OFF */
+#define COM8_AEC_BANDF          0x10 /* Enable AEC below banding value */
+#define COM8_AEC_FINE_EN        0x08 /* Fine AEC ON/OFF control */
+#define COM8_AGC_EN             0x04 /* AGC Enable */
+#define COM8_AWB_EN             0x02 /* AWB Enable */
+#define COM8_AEC_EN             0x01 /* AEC Enable */
+#define COM8_SET_AGC(r, x)      ((r&0xFB)|((x&0x1)<<2))
+#define COM8_SET_AWB(r, x)      ((r&0xFD)|((x&0x1)<<1))
+#define COM8_SET_AEC(r, x)      ((r&0xFE)|((x&0x1)<<0))
+
+#define COM9                    0x14 /* Common Control 9 */
+#define COM9_HISTO_AVG          0x80 /* Histogram or average based AEC/AGC selection */
+#define COM9_AGC_GAIN_2x        0x00 /* Automatic Gain Ceiling 2x  */
+#define COM9_AGC_GAIN_4x        0x10 /* Automatic Gain Ceiling 4x  */
+#define COM9_AGC_GAIN_8x        0x20 /* Automatic Gain Ceiling 8x  */
+#define COM9_AGC_GAIN_16x       0x30 /* Automatic Gain Ceiling 16x */
+#define COM9_AGC_GAIN_32x       0x40 /* Automatic Gain Ceiling 32x */
+#define COM9_DROP_VSYNC         0x04 /* Drop VSYNC output of corrupt frame */
+#define COM9_DROP_HREF          0x02 /* Drop HREF output of corrupt frame  */
+#define COM9_SET_AGC(r, x)      ((r&0x8F)|((x&0x07)<<4))
+
+#define COM10                   0x15 /* Common Control 10 */
+#define COM10_NEGATIVE          0x80 /* Output negative data */
+#define COM10_HSYNC_EN          0x40 /* HREF changes to HSYNC */
+#define COM10_PCLK_FREE         0x00 /* PCLK output option: free running PCLK */
+#define COM10_PCLK_MASK         0x20 /* PCLK output option: masked during horizontal blank  */
+#define COM10_PCLK_REV          0x10 /* PCLK reverse */
+#define COM10_HREF_REV          0x08 /* HREF reverse */
+#define COM10_VSYNC_FALLING     0x00 /* VSYNC changes on falling edge of PCLK */
+#define COM10_VSYNC_RISING      0x04 /* VSYNC changes on rising edge of PCLK */
+#define COM10_VSYNC_NEG         0x02 /* VSYNC negative */
+#define COM10_OUT_RANGE_8       0x01 /* Output data range: Full range */
+#define COM10_OUT_RANGE_10      0x00 /* Output data range: Data from [10] to [F0] (8 MSBs) */
+
+#define RSVD_16                 0x16 /* Reserved register */
+
+#define HSTART                  0x17  /* Horizontal Frame (HREF column) Start high 8-bit(low 3 bits are at HREF[2:0]) */
+#define HSTOP                   0x18  /* Horizontal Frame (HREF column) end high 8-bit (low 3 bits are at HREF[5:3])  */
+#define VSTART                  0x19  /* Vertical Frame (row) Start high 8-bit (low 2 bits are at VREF[1:0]) */
+#define VSTOP                   0x1A  /* Vertical Frame (row) End high 8-bit (low 2 bits are at VREF[3:2]) */
+#define PSHFT                   0x1B  /* Data Format - Pixel Delay Select */
+#define REG_MIDH                0x1C  /* Manufacturer ID Byte – High */
+#define REG_MIDL                0x1D  /* Manufacturer ID Byte – Low */
+
+#define MVFP			        0x1E  /* Mirror/Vflip Enable */
+#define   MVFP_MIRROR	        0x20  /* Mirror image */
+#define   MVFP_FLIP	            0x10  /* Vertical flip */
+#define   MVFP_SUN	            0x02  /* Black sun enable */
+#define MVFP_SET_MIRROR(r,x)	((r&0xDF)|((x&1)<<5)) /* change only bit5 according to x */
+#define MVFP_SET_FLIP(r,x)	    ((r&0xEF)|((x&1)<<4)) /* change only bit4 according to x */
+
+#define LAEC                    0x1F /* Fine AEC Value - defines exposure value less than one row period (Reserved?) */
+#define ADCCTR0                 0x20 /* ADC control */
+#define ADCCTR1			        0x21 /* reserved */
+#define ADCCTR2                 0x22 /* reserved */
+#define ADCCTR3                 0x23 /* reserved */
+#define AEW                     0x24 /* AGC/AEC - Stable Operating Region (Upper Limit) */
+#define AEB                     0x25 /* AGC/AEC - Stable Operating Region (Lower Limit) */
+#define VPT                     0x26 /* AGC/AEC Fast Mode Operating Region */
+#define BBIAS 			        0x27 /* B channel signal output bias (effective only when COM6[3]=1) */
+#define GbBIAS                  0x28 /* Gb channel signal output bias (effective only when COM6[3]=1) */
+#define RSVD_29                 0x29 /* reserved */
+#define EXHCH                   0x2A /* Dummy Pixel Insert MSB */
+#define EXHCL                   0x2B /* Dummy Pixel Insert LSB */
+#define RBIAS                   0x2C /* R channel signal output bias (effective only when COM6[3]=1) */
+#define ADVFL                   0x2D /* LSB of Insert Dummy Rows in Vertical Sync (1 bit equals 1 row)  */
+#define ADVFH                   0x2E /* MSB of Insert Dummy Rows in Vertical Sync */
+#define YAVE                    0x2F /* Y/G Channel Average Value */
+#define HSYST                   0x30 /* HSync rising edge delay */
+#define HSYEN                   0x31 /* HSync falling edge delay  */
+#define HREF                    0x32 /* Image Start and Size Control DIFFERENT CONTROL SEQUENCE	 */
+#define CHLF                    0x33 /* Array Current control  */
+#define ARBLM                   0x34 /* Array reference control */
+#define RSVD_35                 0x35 /* Reserved */
+#define RSVD_36                 0x36 /* Reserved */
+#define ADC                     0x37 /* ADC control */
+#define ACOM                    0x38 /* ADC and analog common mode control */
+#define OFON                    0x39 /* ADC offset control */
+#define TSLB                    0x3A /* Line buffer test option  */
+
+#define COM11                   0x3B /* Common control 11 */
+#define   COM11_EXP		        0x02
+#define   COM11_HZAUTO		    0x10 /* Auto detect 50/60 Hz */
+
+#define COM12                   0x3C /* Common control 12 */
+
+#define COM13                   0x3D /* Common control 13 */
+#define   COM13_GAMMA	        0x80 /* Gamma enable */
+#define	  COM13_UVSAT	        0x40 /* UV saturation auto adjustment */
+
+#define COM14                   0x3E /* Common Control 14 */
+
+#define EDGE                    0x3F /* edge enhancement adjustment */
+#define COM15                   0x40 /* Common Control 15 DIFFERENT CONTROLS */
+#define COM15_SET_RGB565(r,x)	((r&0xEF)|((x&1)<<4)) /* set rgb565 mode */
+#define   COM15_RGB565	        0x10 /* RGB565 output */
+#define   COM15_R00FF           0xC0 /* Output range: [00] to [FF] */
+
+#define COM16                   0x41 /* Common Control 16 DIFFERENT CONTROLS */
+#define COM16_AWBGAIN		    0x08 /* AWB gain enable */
+#define COM17                   0x42 /* Common Control 17   */
+
+#define AWBC1                   0x43 /* Reserved */
+#define AWBC2                  	0x44 /* Reserved */
+#define AWBC3                  	0x45 /* Reserved */
+#define AWBC4                   0x46 /* Reserved */
+#define AWBC5                  	0x47 /* Reserved */
+#define AWBC6                  	0x48 /* Reserved */
+
+#define RSVD_49			        0x49 /* Reserved */
+#define RSVD_4A			        0x4A /* Reserved */
+
+#define REG4B                   0x4B /* Register 4B */
+#define DNSTH                   0x4C /* Denoise strength */
+
+#define RSVD_4D			        0x4D /* Reserved */
+#define RSVD_4E			        0x4E /* Reserved */
+
+#define MTX1                    0x4F /* Matrix coefficient 1 */
+#define MTX2                    0x50 /* Matrix coefficient 2 */
+#define MTX3                    0x51 /* Matrix coefficient 3 */
+#define MTX4                    0x52 /* Matrix coefficient 4 */
+#define MTX5                    0x53 /* Matrix coefficient 5 */
+#define MTX6                    0x54 /* Matrix coefficient 6 */
+#define BRIGHTNESS              0x55 /* Brightness control */
+#define CONTRAST		        0x56 /* Contrast control */
+#define CONTRASCENTER           0x57 /* Contrast center */
+#define MTXS			        0x58 /* Matrix coefficient sign for coefficient 5 to 0*/
+
+#define RSVD_59			        0x59 /* Reserved */
+#define RSVD_5A			        0x5A /* Reserved */
+#define RSVD_5B			        0x5B /* Reserved */
+#define RSVD_5C			        0x5C /* Reserved */
+#define RSVD_5D			        0x5D /* Reserved */
+#define RSVD_5E			        0x5E /* Reserved */
+#define RSVD_5F			        0x5F /* Reserved */
+#define RSVD_60			        0x60 /* Reserved */
+#define RSVD_61			        0x61 /* Reserved */
+
+#define LCC1                    0x62 /* Lens correction option 1  */
+
+#define LCC2                    0x63 /* Lens correction option 2 */
+#define LCC3 			        0x64 /* Lens correction option 3 */
+#define LCC4			        0x65 /* Lens correction option 4 */
+#define LCC5			        0x66 /* Lens correction option 5 */
+
+#define MANU       		        0x67 /* Manual U Value      */
+#define MANV      		        0x68 /* Manual V Value */
+#define GFIX                    0x69 /* Fix gain control */
+#define GGAIN                   0x6A /* G channel AWB gain */
+
+#define DBLV               	    0x6B /* PLL and clock ? */
+
+#define AWBCTR3               	0x6C /* AWB Control 3  */
+#define AWBCTR2	                0x6D /* AWB Control 2  */
+#define AWBCTR1                 0x6E /* AWB Control 1  */
+#define AWBCTR0                 0x6F /* AWB Control 0  */
+#define SCALING_XSC             0x70 /* test pattern and horizontal scaling factor */
+#define SCALING_XSC_CBAR(r)	(r&0x7F) /* make sure bit7 is 0 for color bar */
+#define SCALING_YSC             0x71 /* test pattern and vertical scaling factor */
+#define SCALING_YSC_CBAR(r,x)	((r&0x7F)|((x&1)<<7)) /* change bit7 for color bar on/off */
+#define SCALING_DCWCTR          0x72 /* DCW control */
+#define SCALING_PCLK_DIV        0x73 /*  */
+#define REG74                   0x74 /*  */
+#define REG75                   0x75 /*  */
+#define REG76                   0x76 /*  */
+#define REG77	             	0x77 /*  */
+
+#define RSVD_78      		    0x78 /* Reserved */
+#define RSVD_79              	0x79 /* Reserved */
+
+#define SLOP	                0x7A /* Gamma curve highest segment slope */
+#define GAM1	                0x7B /* Gamma Curve 1st Segment Input End Point 0x04 Output Value */
+#define GAM2	                0x7C /* Gamma Curve 2nd Segment Input End Point 0x08 Output Value */
+#define GAM3                    0x7D /* Gamma Curve 3rd Segment Input End Point 0x10 Output Value */
+#define GAM4                    0x7E /* Gamma Curve 4th Segment Input End Point 0x20 Output Value */
+#define GAM5                    0x7F /* Gamma Curve 5th Segment Input End Point 0x28 Output Value */
+#define GAM6                    0x80 /* Gamma Curve 6rd Segment Input End Point 0x30 Output Value */
+#define GAM7                    0x81 /* Gamma Curve 7th Segment Input End Point 0x38 Output Value */
+#define GAM8                    0x82 /* Gamma Curve 8th Segment Input End Point 0x40 Output Value */
+#define GAM9                    0x83 /* Gamma Curve 9th Segment Input End Point 0x48 Output Value */
+#define GAM10                   0x84 /* Gamma Curve 10th Segment Input End Point 0x50 Output Value */
+#define GAM11                   0x85 /* Gamma Curve 11th Segment Input End Point 0x60 Output Value */
+#define GAM12                   0x86 /* Gamma Curve 12th Segment Input End Point 0x70 Output Value */
+#define GAM13                   0x87 /* Gamma Curve 13th Segment Input End Point 0x90 Output Value */
+#define GAM14                   0x88 /* Gamma Curve 14th Segment Input End Point 0xB0 Output Value */
+#define GAM15                   0x89 /* Gamma Curve 15th Segment Input End Point 0xD0 Output Value */
+
+#define RSVD_8A      		    0x8A /* Reserved */
+#define RSVD_8B              	0x8B /* Reserved */
+
+#define RGB444                  0x8C /*  */
+
+#define RSVD_8D      		    0x8D /* Reserved */
+#define RSVD_8E              	0x8E /* Reserved */
+#define RSVD_8F      		    0x8F /* Reserved */
+#define RSVD_90              	0x90 /* Reserved */
+#define RSVD_91      		    0x91 /* Reserved */
+
+#define DM_LNL                  0x92 /* Dummy line low 8 bit */
+#define DM_LNH                  0x93 /* Dummy line high 8 bit */
+#define LCC6                    0x94 /* Lens correction option 6 */
+#define LCC7                    0x95 /* Lens correction option 7 */
+
+#define RSVD_96      		    0x96 /* Reserved */
+#define RSVD_97              	0x97 /* Reserved */
+#define RSVD_98      		    0x98 /* Reserved */
+#define RSVD_99              	0x99 /* Reserved */
+#define RSVD_9A      		    0x9A /* Reserved */
+#define RSVD_9B              	0x9B /* Reserved */
+#define RSVD_9C      		    0x9C /* Reserved */
+
+#define BD50ST			        0x9D /* 50 Hz banding filter value */
+#define BD60ST                  0x9E /* 60 Hz banding filter value */
+#define HAECC1                  0x9F /* Histogram-based AEC/AGC control 1 */
+#define HAECC2                  0xA0 /* Histogram-based AEC/AGC control 2 */
+
+#define RSVD_A1      		    0xA1 /* Reserved */
+
+#define SCALING_PCLK_DELAY      0xA2 /* Pixel clock delay */
+
+#define RSVD_A3      		    0xA3 /* Reserved */
+
+#define NT_CNTRL                0xA4 /*  */
+#define BD50MAX			        0xA5 /* 50 Hz banding step limit */
+#define HAECC3                  0xA6 /* Histogram-based AEC/AGC control 3  */
+#define HAECC4 	   	            0xA7 /* Histogram-based AEC/AGC control 4           */
+#define HAECC5		            0xA8 /* Histogram-based AEC/AGC control 5         */
+#define HAECC6		            0xA9 /* Histogram-based AEC/AGC control 6           */
+
+#define HAECC7		            0xAA /* Histogram-based AEC/AGC control 7           */
+#define 	HAECC_EN      	    0x80 /* Histogram-based AEC algorithm enable      */
+
+#define BD60MAX                 0xAB /* 60 Hz banding step limit */
+
+#define STR_OPT                 0xAC /* Register AC */
+#define STR_R			        0xAD /* R gain for led output frame */
+#define STR_G			        0xAE /* G gain for led output frame */
+#define STR_B			        0xAF /* B gain for led output frame */
+#define RSVD_B0      		    0xB0 /* Reserved */
+#define ABLC1			        0xB1 /* */
+#define RSVD_B2      		    0xB2 /* Reserved */
+#define THL_ST			        0xB3 /* ABLC target */
+#define THL_DLT			        0xB5 /* ABLC stable range */
+
+#define RSVD_B6      		    0xB6 /* Reserved */
+#define RSVD_B7      		    0xB7 /* Reserved */
+#define RSVD_B8      		    0xB8 /* Reserved */
+#define RSVD_B9      		    0xB9 /* Reserved */
+#define RSVD_BA      		    0xBA /* Reserved */
+#define RSVD_BB      		    0xBB /* Reserved */
+#define RSVD_BC      		    0xBC /* Reserved */
+#define RSVD_BD      	    	0xBD /* Reserved */
+
+#define AD_CHB			        0xBE /* blue channel black level compensation */
+#define AD_CHR			        0xBF /* Red channel black level compensation */
+#define AD_CHGb			        0xC0 /* Gb channel black level compensation */
+#define AD_CHGr			        0xC1 /* Gr channel black level compensation */
+
+#define RSVD_C2      		    0xC2 /* Reserved */
+#define RSVD_C3      		    0xC3 /* Reserved */
+#define RSVD_C4      		    0xC4 /* Reserved */
+#define RSVD_C5      		    0xC5 /* Reserved */
+#define RSVD_C6      		    0xC6 /* Reserved */
+#define RSVD_C7      		    0xC7 /* Reserved */
+#define RSVD_C8      		    0xC8 /* Reserved */
+
+#define SATCTR			        0xC9 /* Saturation control */
+#define SET_REG(reg, x)         (##reg_DEFAULT|x)
+
+#endif //__OV7670_REG_REGS_H__

code/components/jomjol_configfile/CMakeLists.txt

@@ -0,0 +1,7 @@
+FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)
+
+idf_component_register(SRCS ${app_sources}
+                    INCLUDE_DIRS "."
+                    REQUIRES jomjol_logfile)
+
+

code/components/jomjol_configfile/configFile.cpp

@@ -0,0 +1,96 @@
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+#include "Helper.h"
+#include "configFile.h"
+
+//static const char *TAGCONFIGFILE = "configFile";
+
+ConfigFile::ConfigFile(std::string filePath)
+{
+    std::string config = FormatFileName(filePath);
+    pFile = OpenFileAndWait(config.c_str(), "r");
+}
+
+ConfigFile::~ConfigFile()
+{
+    fclose(pFile);
+}
+
+bool ConfigFile::isNewParagraph(std::string input)
+{
+	if ((input[0] == '[') || ((input[0] == ';') && (input[1] == '[')))
+	{
+		return true;
+	}
+	return false;
+}
+
+bool ConfigFile::GetNextParagraph(std::string& aktparamgraph, bool &disabled, bool &eof)
+{
+	while (getNextLine(&aktparamgraph, disabled, eof) && !isNewParagraph(aktparamgraph));
+
+	if (isNewParagraph(aktparamgraph))
+		return true;
+	return false;
+}
+
+bool ConfigFile::getNextLine(std::string *rt, bool &disabled, bool &eof)
+{
+    eof = false;
+	char zw[1024];
+	if (pFile == NULL)
+	{
+		*rt = "";
+		return false;
+	}
+	fgets(zw, 1024, pFile);
+	printf("%s", zw);
+	if ((strlen(zw) == 0) && feof(pFile))
+	{
+		*rt = "";
+        eof = true;
+		return false;
+	}
+	*rt = zw;
+	*rt = trim(*rt);
+	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))			// Kommentarzeilen (; oder #) und Leerzeilen überspringen, es sei denn es ist ein neuer auskommentierter Paragraph
+	{
+		fgets(zw, 1024, pFile);
+		printf("%s", zw);		
+		if (feof(pFile))
+		{
+			*rt = "";
+            eof = true;
+			return false;
+		}
+		*rt = zw;
+		*rt = trim(*rt);
+	}
+
+    disabled = ((*rt)[0] == ';');
+	return true;
+}
+
+std::vector<string> ConfigFile::ZerlegeZeile(std::string input, std::string delimiter)
+{
+	std::vector<string> Output;
+//	std::string delimiter = " =,";
+
+	input = trim(input, delimiter);
+	size_t pos = findDelimiterPos(input, delimiter);
+	std::string token;
+	while (pos != std::string::npos) {
+		token = input.substr(0, pos);
+		token = trim(token, delimiter);
+		Output.push_back(token);
+		input.erase(0, pos + 1);
+		input = trim(input, delimiter);
+		pos = findDelimiterPos(input, delimiter);
+	}
+	Output.push_back(input);
+
+	return Output;
+
+}

code/components/jomjol_configfile/configFile.h

@@ -0,0 +1,16 @@
+#include <string>
+#include <vector>
+
+class ConfigFile {
+public:
+    ConfigFile(std::string filePath);
+    ~ConfigFile();
+
+    bool isNewParagraph(std::string input);
+    bool GetNextParagraph(std::string& aktparamgraph, bool &disabled, bool &eof);
+	bool getNextLine(std::string* rt, bool &disabled, bool &eof);
+    std::vector<std::string> ZerlegeZeile(std::string input, std::string delimiter = " =, \t");
+    
+private:
+    FILE* pFile;
+};

code/components/jomjol_controlGPIO/CMakeLists.txt

@@ -0,0 +1,9 @@
+FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)
+
+list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
+
+idf_component_register(SRCS ${app_sources}
+                    INCLUDE_DIRS "." "../../include"
+                    REQUIRES esp_http_server jomjol_logfile jomjol_configfile jomjol_mqtt jomjol_flowcontroll)
+
+

code/components/jomjol_controlGPIO/server_GPIO.cpp

@@ -0,0 +1,575 @@
+#include <string>
+#include <functional>
+#include "string.h"
+
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_event.h"
+
+//#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
+#include "esp_log.h"
+//#include "errno.h"
+
+#include <sys/stat.h>
+#include <vector>
+//#include <regex>
+
+#include "defines.h"
+
+#include "server_GPIO.h"
+
+#include "ClassLogFile.h"
+#include "configFile.h"
+#include "Helper.h"
+#include "interface_mqtt.h"
+
+static const char *TAG_SERVERGPIO = "server_GPIO";
+QueueHandle_t gpio_queue_handle = NULL;
+
+#define DEBUG_DETAIL_ON 
+
+GpioPin::GpioPin(gpio_num_t gpio, const char* name, gpio_pin_mode_t mode, gpio_int_type_t interruptType, uint8_t dutyResolution, std::string mqttTopic, bool httpEnable) 
+{
+    _gpio = gpio;
+    _name = name; 
+    _mode = mode;
+    _interruptType = interruptType;    
+    _mqttTopic = mqttTopic;
+}
+
+GpioPin::~GpioPin()
+{
+    ESP_LOGD(TAG_SERVERGPIO,"reset GPIO pin %d", _gpio);
+    if (_interruptType != GPIO_INTR_DISABLE) {
+        //hook isr handler for specific gpio pin
+        gpio_isr_handler_remove(_gpio);
+    }
+    gpio_reset_pin(_gpio);
+}
+
+static void IRAM_ATTR gpio_isr_handler(void* arg)
+{
+    GpioResult gpioResult;
+    gpioResult.gpio = *(gpio_num_t*) arg;
+    gpioResult.value = gpio_get_level(gpioResult.gpio);
+    BaseType_t ContextSwitchRequest = pdFALSE;
+ 
+    xQueueSendToBackFromISR(gpio_queue_handle,(void*)&gpioResult,&ContextSwitchRequest);
+   
+    if(ContextSwitchRequest){
+        taskYIELD();
+    }
+}
+
+static void gpioHandlerTask(void *arg) {
+    ESP_LOGD(TAG_SERVERGPIO,"start interrupt task");
+    while(1){
+        if(uxQueueMessagesWaiting(gpio_queue_handle)){
+            while(uxQueueMessagesWaiting(gpio_queue_handle)){
+                GpioResult gpioResult;
+                xQueueReceive(gpio_queue_handle,(void*)&gpioResult,10);
+                ESP_LOGD(TAG_SERVERGPIO,"gpio: %d state: %d", gpioResult.gpio, gpioResult.value);
+                ((GpioHandler*)arg)->gpioInterrupt(&gpioResult);
+            }  
+        }
+
+        ((GpioHandler*)arg)->taskHandler();
+        vTaskDelay(pdMS_TO_TICKS(1000));
+    }
+}
+
+void GpioPin::gpioInterrupt(int value) {
+    if (_mqttTopic != "") {
+        ESP_LOGD(TAG_SERVERGPIO, "gpioInterrupt %s %d", _mqttTopic.c_str(), value);
+
+        MQTTPublish(_mqttTopic, value ? "true" : "false");
+        currentState = value;
+    }
+}
+
+void GpioPin::init()
+{
+    gpio_config_t io_conf;
+    //set interrupt
+    io_conf.intr_type = _interruptType;
+    //set as output mode
+    io_conf.mode = (_mode == GPIO_PIN_MODE_OUTPUT) || (_mode == GPIO_PIN_MODE_BUILT_IN_FLASH_LED) ? gpio_mode_t::GPIO_MODE_OUTPUT : gpio_mode_t::GPIO_MODE_INPUT;
+    //bit mask of the pins that you want to set,e.g.GPIO18/19
+    io_conf.pin_bit_mask = (1ULL << _gpio);
+    //set pull-down mode
+    io_conf.pull_down_en = _mode == GPIO_PIN_MODE_INPUT_PULLDOWN ? gpio_pulldown_t::GPIO_PULLDOWN_ENABLE : gpio_pulldown_t::GPIO_PULLDOWN_DISABLE;
+    //set pull-up mode
+    io_conf.pull_up_en = _mode == GPIO_PIN_MODE_INPUT_PULLDOWN ? gpio_pullup_t::GPIO_PULLUP_ENABLE : gpio_pullup_t::GPIO_PULLUP_DISABLE;
+    //configure GPIO with the given settings
+    gpio_config(&io_conf);
+
+    if (_interruptType != GPIO_INTR_DISABLE) {
+        //hook isr handler for specific gpio pin
+        ESP_LOGD(TAG_SERVERGPIO, "GpioPin::init add isr handler for GPIO %d\r\n", _gpio);
+        gpio_isr_handler_add(_gpio, gpio_isr_handler, (void*)&_gpio);
+    }
+
+    if ((_mqttTopic != "") && ((_mode == GPIO_PIN_MODE_OUTPUT) || (_mode == GPIO_PIN_MODE_OUTPUT_PWM) || (_mode == GPIO_PIN_MODE_BUILT_IN_FLASH_LED))) {
+        std::function<bool(std::string, char*, int)> f = std::bind(&GpioPin::handleMQTT, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
+        MQTTregisterSubscribeFunction(_mqttTopic, f);
+    }
+}
+
+bool GpioPin::getValue(std::string* errorText)
+{   
+    if ((_mode != GPIO_PIN_MODE_INPUT) && (_mode != GPIO_PIN_MODE_INPUT_PULLUP) && (_mode != GPIO_PIN_MODE_INPUT_PULLDOWN)) {
+        (*errorText) = "GPIO is not in input mode";
+    }
+
+    return gpio_get_level(_gpio) == 1;
+}
+
+void GpioPin::setValue(bool value, gpio_set_source setSource, std::string* errorText)
+{
+    ESP_LOGD(TAG_SERVERGPIO, "GpioPin::setValue %d\r\n", value);
+
+    if ((_mode != GPIO_PIN_MODE_OUTPUT) && (_mode != GPIO_PIN_MODE_OUTPUT_PWM) && (_mode != GPIO_PIN_MODE_BUILT_IN_FLASH_LED)) {
+        (*errorText) = "GPIO is not in output mode";
+    } else {
+        gpio_set_level(_gpio, value);
+
+        if ((_mqttTopic != "") && (setSource != GPIO_SET_SOURCE_MQTT)) {
+            MQTTPublish(_mqttTopic, value ? "true" : "false");
+        }
+    }
+}
+
+void GpioPin::publishState() {
+    int newState = gpio_get_level(_gpio);
+    if (newState != currentState) {
+        ESP_LOGD(TAG_SERVERGPIO,"publish state of GPIO %d new state %d", _gpio, newState);
+        MQTTPublish(_mqttTopic, newState ? "true" : "false");
+        currentState = newState;
+    }
+}
+
+bool GpioPin::handleMQTT(std::string, char* data, int data_len) {
+    ESP_LOGD(TAG_SERVERGPIO, "GpioPin::handleMQTT data %.*s\r\n", data_len, data);
+
+    std::string dataStr(data, data_len);
+    dataStr = toLower(dataStr);
+    std::string errorText = "";
+    if ((dataStr == "true") || (dataStr == "1")) {
+        setValue(true, GPIO_SET_SOURCE_MQTT, &errorText);
+    } else if ((dataStr == "false") || (dataStr == "0")) {
+        setValue(false, GPIO_SET_SOURCE_MQTT, &errorText);    
+    } else {
+        errorText = "wrong value ";
+        errorText.append(data, data_len);
+    }
+
+    if (errorText != "") {
+        ESP_LOGE(TAG_SERVERGPIO, "%s", errorText.c_str());
+    }
+
+    return (errorText == "");
+}
+
+
+esp_err_t callHandleHttpRequest(httpd_req_t *req)
+{
+    ESP_LOGD(TAG_SERVERGPIO,"callHandleHttpRequest");
+
+    GpioHandler *gpioHandler = (GpioHandler*)req->user_ctx;
+    return gpioHandler->handleHttpRequest(req);
+}
+
+void taskGpioHandler(void *pvParameter)
+{
+    ESP_LOGD(TAG_SERVERGPIO,"taskGpioHandler");
+    ((GpioHandler*)pvParameter)->init();
+}
+
+GpioHandler::GpioHandler(std::string configFile, httpd_handle_t httpServer) 
+{
+    ESP_LOGI(TAG_SERVERGPIO,"start GpioHandler");
+    _configFile = configFile;
+    _httpServer = httpServer;
+
+    ESP_LOGI(TAG_SERVERGPIO, "register GPIO Uri");
+    registerGpioUri();
+}
+
+GpioHandler::~GpioHandler()  {
+    if (gpioMap != NULL) {
+        clear();
+        delete gpioMap;
+    }
+}
+
+void GpioHandler::init()
+{
+    // TickType_t xDelay = 60000 / portTICK_PERIOD_MS;
+    // printf("wait before start %ldms\r\n", (long) xDelay);
+    // vTaskDelay( xDelay );
+
+    if (gpioMap == NULL) {
+        gpioMap = new std::map<gpio_num_t, GpioPin*>();
+    } else {
+        clear();
+    }
+    
+    ESP_LOGI(TAG_SERVERGPIO, "read GPIO config and init GPIO");
+    if (!readConfig()) {
+        clear();
+        delete gpioMap;
+        gpioMap = NULL;
+        ESP_LOGI(TAG_SERVERGPIO, "GPIO init comleted, handler is disabled");
+        return;
+    }
+
+    for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) {
+        it->second->init();
+    }
+
+    std::function<void()> f = std::bind(&GpioHandler::handleMQTTconnect, this);
+    MQTTregisterConnectFunction("gpio-handler", f);
+
+    if (xHandleTaskGpio == NULL) {
+        gpio_queue_handle = xQueueCreate(10,sizeof(GpioResult));
+        BaseType_t  xReturned = xTaskCreate(&gpioHandlerTask, "gpio_int", configMINIMAL_STACK_SIZE * 8, (void *)this, tskIDLE_PRIORITY + 2, &xHandleTaskGpio);
+        if(xReturned == pdPASS ) {
+            ESP_LOGD(TAG_SERVERGPIO, "xHandletaskGpioHandler started");
+        } else {
+            ESP_LOGD(TAG_SERVERGPIO, "xHandletaskGpioHandler not started %d ", (int)xHandleTaskGpio);
+        }
+    }
+
+    ESP_LOGI(TAG_SERVERGPIO, "GPIO init comleted, is enabled");
+}
+
+void GpioHandler::taskHandler() {
+    if (gpioMap != NULL) {
+        for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) {
+            if ((it->second->getInterruptType() == GPIO_INTR_DISABLE))
+                it->second->publishState();
+        }
+    }
+}
+
+
+void GpioHandler::handleMQTTconnect()
+{
+    if (gpioMap != NULL) {
+        for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) {
+            if ((it->second->getMode() == GPIO_PIN_MODE_INPUT) || (it->second->getMode() == GPIO_PIN_MODE_INPUT_PULLDOWN) || (it->second->getMode() == GPIO_PIN_MODE_INPUT_PULLUP))
+                it->second->publishState();
+        }
+    }
+}
+
+void GpioHandler::deinit() {
+    MQTTunregisterConnectFunction("gpio-handler");
+    clear();
+    if (xHandleTaskGpio != NULL) {
+        vTaskDelete(xHandleTaskGpio);
+        xHandleTaskGpio = NULL;
+    }
+}
+
+void GpioHandler::gpioInterrupt(GpioResult* gpioResult) {
+    if ((gpioMap != NULL) && (gpioMap->find(gpioResult->gpio) != gpioMap->end())) {
+        (*gpioMap)[gpioResult->gpio]->gpioInterrupt(gpioResult->value);
+    }
+}
+
+bool GpioHandler::readConfig() 
+{
+    if (!gpioMap->empty())
+        clear();
+
+    ConfigFile configFile = ConfigFile(_configFile); 
+
+    std::vector<std::string> zerlegt;
+    std::string line = "";
+    bool disabledLine = false;
+    bool eof = false;
+        
+    while ((!configFile.GetNextParagraph(line, disabledLine, eof) || (line.compare("[GPIO]") != 0)) && !disabledLine && !eof) {}
+    if (eof)
+        return false;
+    
+    _isEnabled = !disabledLine;
+
+    if (!_isEnabled)
+        return false;
+
+    std::string mainTopicMQTT = "";
+    bool registerISR = false;
+    while (configFile.getNextLine(&line, disabledLine, eof) && !configFile.isNewParagraph(line))
+    {
+        zerlegt = configFile.ZerlegeZeile(line);
+        // const std::regex pieces_regex("IO([0-9]{1,2})");
+        // std::smatch pieces_match;
+        // if (std::regex_match(zerlegt[0], pieces_match, pieces_regex) && (pieces_match.size() == 2))
+        // {
+        //     std::string gpioStr = pieces_match[1];
+        ESP_LOGD(TAG_SERVERGPIO, "conf param %s\r\n", toUpper(zerlegt[0]).c_str());
+        if (toUpper(zerlegt[0]) == "MAINTOPICMQTT") {
+            ESP_LOGD(TAG_SERVERGPIO, "MAINTOPICMQTT found\r\n");
+            mainTopicMQTT = zerlegt[1];
+        } else if ((zerlegt[0].rfind("IO", 0) == 0) && (zerlegt.size() >= 6))
+        {
+            ESP_LOGI(TAG_SERVERGPIO,"Enable GP%s in %s mode", zerlegt[0].c_str(), zerlegt[1].c_str());
+            std::string gpioStr = zerlegt[0].substr(2, 2);
+            gpio_num_t gpioNr = (gpio_num_t)atoi(gpioStr.c_str());
+            gpio_pin_mode_t pinMode = resolvePinMode(toLower(zerlegt[1]));
+            gpio_int_type_t intType = resolveIntType(toLower(zerlegt[2]));
+            uint16_t dutyResolution = (uint8_t)atoi(zerlegt[3].c_str());
+            bool mqttEnabled = toLower(zerlegt[4]) == "true";
+            bool httpEnabled = toLower(zerlegt[5]) == "true";
+            char gpioName[100];
+            if (zerlegt.size() >= 7) {
+                strcpy(gpioName, trim(zerlegt[6]).c_str());
+            } else {
+                sprintf(gpioName, "GPIO%d", gpioNr);
+            }
+            std::string mqttTopic = mqttEnabled ? (mainTopicMQTT + "/" + gpioName) : "";
+            GpioPin* gpioPin = new GpioPin(gpioNr, gpioName, pinMode, intType,dutyResolution, mqttTopic, httpEnabled);
+            (*gpioMap)[gpioNr] = gpioPin;
+
+            if (intType != GPIO_INTR_DISABLE) {
+                registerISR = true;
+            }
+        }
+    }
+
+    if (registerISR) {
+        //install gpio isr service
+        gpio_install_isr_service(ESP_INTR_FLAG_LOWMED | ESP_INTR_FLAG_IRAM);
+    }
+
+    return true;
+}
+
+void GpioHandler::clear() 
+{
+    ESP_LOGD(TAG_SERVERGPIO, "GpioHandler::clear\r\n");
+
+    if (gpioMap != NULL) {
+        for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) {
+            delete it->second;
+        }
+        gpioMap->clear();
+    }
+
+    // gpio_uninstall_isr_service(); can't uninstall, isr service is used by camera
+}
+ 
+void GpioHandler::registerGpioUri() 
+{
+    ESP_LOGI(TAG_SERVERGPIO, "server_GPIO - Registering URI handlers");
+    
+    httpd_uri_t camuri = { };
+    camuri.method    = HTTP_GET;
+    camuri.uri       = "/GPIO";
+    camuri.handler   = callHandleHttpRequest;
+    camuri.user_ctx  = (void*)this;    
+    httpd_register_uri_handler(_httpServer, &camuri);
+}
+
+esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
+{
+    ESP_LOGD(TAG_SERVERGPIO, "handleHttpRequest");
+
+    if (gpioMap == NULL) {
+        std::string resp_str = "GPIO handler not initialized";
+        httpd_resp_send(req, resp_str.c_str(), resp_str.length());    
+        return ESP_OK;
+    }
+
+#ifdef DEBUG_DETAIL_ON 
+    LogFile.WriteHeapInfo("handler_switch_GPIO - Start");    
+#endif
+
+    LogFile.WriteToFile("handler_switch_GPIO");    
+    char _query[200];
+    char _valueGPIO[30];    
+    char _valueStatus[30];    
+    std::string gpio, status;
+
+    if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK) {
+        ESP_LOGD(TAG_SERVERGPIO, "Query: %s", _query);
+        
+        if (httpd_query_key_value(_query, "GPIO", _valueGPIO, 30) == ESP_OK)
+        {
+            ESP_LOGD(TAG_SERVERGPIO, "GPIO is found %s", _valueGPIO); 
+            gpio = std::string(_valueGPIO);
+        } else {
+            std::string resp_str = "GPIO No is not defined";
+            httpd_resp_send(req, resp_str.c_str(), resp_str.length());    
+            return ESP_OK;
+        }
+        if (httpd_query_key_value(_query, "Status", _valueStatus, 30) == ESP_OK)
+        {
+            ESP_LOGD(TAG_SERVERGPIO, "Status is found %s", _valueStatus); 
+            status = std::string(_valueStatus);
+        }
+    } else {
+        const char* resp_str = "Error in call. Use /GPIO?GPIO=12&Status=high";
+        httpd_resp_send(req, resp_str, strlen(resp_str));    
+        return ESP_OK;
+    }
+
+    status = toUpper(status);
+    if ((status != "HIGH") && (status != "LOW") && (status != "TRUE") && (status != "FALSE") && (status != "0") && (status != "1") && (status != ""))
+    {
+        std::string zw = "Status not valid: " + status;
+        httpd_resp_sendstr_chunk(req, zw.c_str());
+        httpd_resp_sendstr_chunk(req, NULL);          
+        return ESP_OK;    
+    }
+
+    int gpionum = stoi(gpio);
+
+    // frei: 16; 12-15; 2; 4  // nur 12 und 13 funktionieren 2: reboot, 4: BlitzLED, 15: PSRAM, 14/15: DMA für SDKarte ???
+    gpio_num_t gpio_num = resolvePinNr(gpionum);
+    if (gpio_num == GPIO_NUM_NC)
+    {
+        std::string zw = "GPIO" + std::to_string(gpionum) + " not support - only 12 & 13 free";
+            httpd_resp_sendstr_chunk(req, zw.c_str());
+            httpd_resp_sendstr_chunk(req, NULL);          
+            return ESP_OK;
+    }
+
+    if (gpioMap->count(gpio_num) == 0) {
+        char resp_str [30];
+        sprintf(resp_str, "GPIO%d is not registred", gpio_num);
+        httpd_resp_send(req, resp_str, strlen(resp_str));  
+        return ESP_OK;     
+    }
+    
+    if (status == "") 
+    {
+        std::string resp_str = "";
+        status = (*gpioMap)[gpio_num]->getValue(&resp_str) ? "HIGH" : "LOW";
+        if (resp_str == "") {
+            resp_str = status;
+        }
+        httpd_resp_sendstr_chunk(req, resp_str.c_str());
+        httpd_resp_sendstr_chunk(req, NULL);
+    }
+    else
+    {
+        std::string resp_str = "";
+        (*gpioMap)[gpio_num]->setValue((status == "HIGH") || (status == "TRUE") || (status == "1"), GPIO_SET_SOURCE_HTTP, &resp_str);
+        if (resp_str == "") {
+            resp_str = "GPIO" + std::to_string(gpionum) + " switched to " + status;
+        }
+        httpd_resp_sendstr_chunk(req, resp_str.c_str());
+        httpd_resp_sendstr_chunk(req, NULL);
+    }
+          
+    return ESP_OK;    
+};
+
+void GpioHandler::flashLightEnable(bool value) 
+{
+    ESP_LOGD(TAG_SERVERGPIO, "GpioHandler::flashLightEnable %s\r\n", value ? "true" : "false");
+
+    if (gpioMap != NULL) {
+        for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) 
+        {
+            if (it->second->getMode() == GPIO_PIN_MODE_BUILT_IN_FLASH_LED) //|| (it->second->getMode() == GPIO_PIN_MODE_EXTERNAL_FLASH_PWM) || (it->second->getMode() == GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X))
+            {
+                std::string resp_str = "";
+                it->second->setValue(value, GPIO_SET_SOURCE_INTERNAL, &resp_str);
+
+                if (resp_str == "") {
+                    ESP_LOGD(TAG_SERVERGPIO, "Flash light pin GPIO %d switched to %s\r\n", (int)it->first, (value ? "on" : "off"));
+                } else {
+                    ESP_LOGE(TAG_SERVERGPIO, "Can't set flash light pin GPIO %d.  Error: %s\r\n", (int)it->first, resp_str.c_str());
+                }
+            }
+        }
+    }
+}
+
+gpio_num_t GpioHandler::resolvePinNr(uint8_t pinNr) 
+{
+    switch(pinNr)  {
+        case 0:
+            return GPIO_NUM_0;
+        case 1:
+            return GPIO_NUM_1;
+        case 3:
+            return GPIO_NUM_3;
+        case 4:
+            return GPIO_NUM_4;
+        case 12:
+            return GPIO_NUM_12;
+        case 13:
+            return GPIO_NUM_13;
+        default: 
+            return GPIO_NUM_NC;   
+    }
+}
+
+gpio_pin_mode_t GpioHandler::resolvePinMode(std::string input) 
+{
+    if( input == "disabled" ) return GPIO_PIN_MODE_DISABLED;
+    if( input == "input" ) return GPIO_PIN_MODE_INPUT;
+    if( input == "input-pullup" ) return GPIO_PIN_MODE_INPUT_PULLUP;
+    if( input == "input-pulldown" ) return GPIO_PIN_MODE_INPUT_PULLDOWN;
+    if( input == "output" ) return GPIO_PIN_MODE_OUTPUT;
+    if( input == "built-in-led" ) return GPIO_PIN_MODE_BUILT_IN_FLASH_LED;
+    if( input == "output-pwm" ) return GPIO_PIN_MODE_OUTPUT_PWM;
+    if( input == "external-flash-pwm" ) return GPIO_PIN_MODE_EXTERNAL_FLASH_PWM;
+    if( input == "external-flash-ws281x" ) return GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X;
+
+    return GPIO_PIN_MODE_DISABLED;
+}
+
+gpio_int_type_t GpioHandler::resolveIntType(std::string input) 
+{
+    if( input == "disabled" ) return GPIO_INTR_DISABLE;
+    if( input == "rising-edge" ) return GPIO_INTR_POSEDGE;
+    if( input == "falling-edge" ) return GPIO_INTR_NEGEDGE;
+    if( input == "rising-and-falling" ) return GPIO_INTR_ANYEDGE ;
+    if( input == "low-level-trigger" ) return GPIO_INTR_LOW_LEVEL;
+    if( input == "high-level-trigger" ) return GPIO_INTR_HIGH_LEVEL;
+
+
+    return GPIO_INTR_DISABLE;
+}
+
+static GpioHandler *gpioHandler = NULL;
+
+void gpio_handler_create(httpd_handle_t server) 
+{
+    if (gpioHandler == NULL)
+        gpioHandler = new GpioHandler(CONFIG_FILE, server);
+}
+
+void gpio_handler_init() 
+{
+    if (gpioHandler != NULL) {
+        gpioHandler->init();
+    }
+}
+
+void gpio_handler_deinit() {
+    if (gpioHandler != NULL) {
+        gpioHandler->deinit();
+   }
+}
+
+void gpio_handler_destroy()
+{
+    if (gpioHandler != NULL) {
+        delete gpioHandler;
+        gpioHandler = NULL;
+    }
+}
+
+GpioHandler* gpio_handler_get()
+{
+    return gpioHandler;
+}

code/components/jomjol_controlGPIO/server_GPIO.h

@@ -0,0 +1,99 @@
+#ifndef SERVER_GPIO_H
+#define SERVER_GPIO_H
+
+#include <esp_log.h>
+
+#include <esp_http_server.h>
+#include <map>
+#include "driver/gpio.h"
+
+//#include "ClassControllCamera.h"
+
+typedef enum {
+    GPIO_PIN_MODE_DISABLED              = 0x0,
+    GPIO_PIN_MODE_INPUT                 = 0x1,
+    GPIO_PIN_MODE_INPUT_PULLUP          = 0x2,
+    GPIO_PIN_MODE_INPUT_PULLDOWN        = 0x3,
+    GPIO_PIN_MODE_OUTPUT                = 0x4,
+    GPIO_PIN_MODE_BUILT_IN_FLASH_LED    = 0x5,
+    GPIO_PIN_MODE_OUTPUT_PWM            = 0x6,
+    GPIO_PIN_MODE_EXTERNAL_FLASH_PWM    = 0x7,
+    GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X = 0x8,
+} gpio_pin_mode_t;
+
+struct GpioResult {
+    gpio_num_t gpio;
+    int value;
+};
+
+typedef enum {
+    GPIO_SET_SOURCE_INTERNAL  = 0,
+    GPIO_SET_SOURCE_MQTT  = 1,
+    GPIO_SET_SOURCE_HTTP  = 2,
+} gpio_set_source;
+
+class GpioPin {
+public:
+    GpioPin(gpio_num_t gpio, const char* name, gpio_pin_mode_t mode, gpio_int_type_t interruptType, uint8_t dutyResolution, std::string mqttTopic, bool httpEnable);
+    ~GpioPin();
+
+    void init();
+    bool getValue(std::string* errorText);
+    void setValue(bool value, gpio_set_source setSource, std::string* errorText);
+    bool handleMQTT(std::string, char* data, int data_len);
+    void publishState();
+    void gpioInterrupt(int value);
+    gpio_int_type_t getInterruptType() { return _interruptType; }
+    gpio_pin_mode_t getMode() { return _mode; }
+
+private:
+    gpio_num_t _gpio;
+    const char* _name;
+    gpio_pin_mode_t _mode;
+    gpio_int_type_t _interruptType;
+    std::string _mqttTopic;
+    int currentState = -1;
+};
+
+esp_err_t callHandleHttpRequest(httpd_req_t *req);
+void taskGpioHandler(void *pvParameter);
+
+class GpioHandler {
+public:
+    GpioHandler(std::string configFile, httpd_handle_t httpServer);
+    ~GpioHandler();
+    
+    void init();
+    void deinit();
+    void registerGpioUri();
+    esp_err_t handleHttpRequest(httpd_req_t *req);
+    void taskHandler();
+    void gpioInterrupt(GpioResult* gpioResult);  
+    void flashLightEnable(bool value);
+    bool isEnabled() { return _isEnabled; }
+    void handleMQTTconnect();
+
+private:
+    std::string _configFile;
+    httpd_handle_t _httpServer;
+    std::map<gpio_num_t, GpioPin*> *gpioMap = NULL;
+    TaskHandle_t xHandleTaskGpio = NULL;
+    bool _isEnabled = false;
+
+    bool readConfig();
+    void clear();
+    
+    gpio_num_t resolvePinNr(uint8_t pinNr);
+    gpio_pin_mode_t resolvePinMode(std::string input);
+    gpio_int_type_t resolveIntType(std::string input);
+};
+
+void gpio_handler_create(httpd_handle_t server);
+void gpio_handler_init();
+void gpio_handler_deinit();
+void gpio_handler_destroy();
+GpioHandler* gpio_handler_get();
+
+
+
+#endif //SERVER_GPIO_H

code/components/jomjol_controlcamera/CMakeLists.txt

@@ -0,0 +1,9 @@
+FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)
+
+list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
+
+idf_component_register(SRCS ${app_sources}
+                    INCLUDE_DIRS "."
+                    REQUIRES esp32-camera-master esp_http_server jomjol_logfile jomjol_image_proc nvs_flash jomjol_fileserver_ota jomjol_controlGPIO)
+
+

code/components/jomjol_controlcamera/ClassControllCamera.cpp

@@ -0,0 +1,626 @@
+#include "ClassControllCamera.h"
+#include "ClassLogFile.h"
+
+#include <stdio.h>
+#include "driver/gpio.h"
+#include "esp_timer.h"
+#include "esp_log.h"
+
+#include "Helper.h"
+#include "CImageBasis.h"
+
+#include "server_ota.h"
+#include "server_GPIO.h"
+
+
+#define BOARD_ESP32CAM_AITHINKER
+
+
+#include <esp_event.h>
+#include <esp_log.h>
+#include <esp_system.h>
+#include <nvs_flash.h>
+#include <sys/param.h>
+#include <string.h>
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+#include "esp_camera.h"
+
+// #define DEBUG_DETAIL_ON
+
+
+// ESP32Cam (AiThinker) PIN Map
+
+#define CAM_PIN_PWDN (gpio_num_t) 32
+#define CAM_PIN_RESET -1 //software reset will be performed
+#define CAM_PIN_XCLK 0
+#define CAM_PIN_SIOD 26
+#define CAM_PIN_SIOC 27
+
+#define CAM_PIN_D7 35
+#define CAM_PIN_D6 34
+#define CAM_PIN_D5 39
+#define CAM_PIN_D4 36
+#define CAM_PIN_D3 21
+#define CAM_PIN_D2 19
+#define CAM_PIN_D1 18
+#define CAM_PIN_D0 5
+#define CAM_PIN_VSYNC 25
+#define CAM_PIN_HREF 23
+#define CAM_PIN_PCLK 22
+
+static const char *TAGCAMERACLASS = "server_part_camera"; 
+
+static camera_config_t camera_config = {
+    .pin_pwdn = CAM_PIN_PWDN,
+    .pin_reset = CAM_PIN_RESET,
+    .pin_xclk = CAM_PIN_XCLK,
+    .pin_sscb_sda = CAM_PIN_SIOD,
+    .pin_sscb_scl = CAM_PIN_SIOC,
+
+    .pin_d7 = CAM_PIN_D7,
+    .pin_d6 = CAM_PIN_D6,
+    .pin_d5 = CAM_PIN_D5,
+    .pin_d4 = CAM_PIN_D4,
+    .pin_d3 = CAM_PIN_D3,
+    .pin_d2 = CAM_PIN_D2,
+    .pin_d1 = CAM_PIN_D1,
+    .pin_d0 = CAM_PIN_D0,
+    .pin_vsync = CAM_PIN_VSYNC,
+    .pin_href = CAM_PIN_HREF,
+    .pin_pclk = CAM_PIN_PCLK,
+
+    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
+//    .xclk_freq_hz = 20000000,             // Orginalwert
+    .xclk_freq_hz = 5000000,               // Test, um die Bildfehler los zu werden !!!!
+    .ledc_timer = LEDC_TIMER_0,
+    .ledc_channel = LEDC_CHANNEL_0,
+
+    .pixel_format = PIXFORMAT_JPEG, //YUV422,GRAYSCALE,RGB565,JPEG
+    .frame_size = FRAMESIZE_VGA,    //QQVGA-UXGA Do not use sizes above QVGA when not JPEG
+//    .frame_size = FRAMESIZE_UXGA,    //QQVGA-UXGA Do not use sizes above QVGA when not JPEG
+
+    
+
+    .jpeg_quality = 5, //0-63 lower number means higher quality
+    .fb_count = 1       //if more than one, i2s runs in continuous mode. Use only with JPEG
+};
+
+
+#include "driver/ledc.h"
+
+CCamera Camera;
+
+#define FLASH_GPIO GPIO_NUM_4
+#define BLINK_GPIO GPIO_NUM_33
+
+typedef struct {
+        httpd_req_t *req;
+        size_t len;
+} jpg_chunking_t;
+
+
+#define LEDC_LS_CH2_GPIO       (4)
+#define LEDC_LS_CH2_CHANNEL    LEDC_CHANNEL_2
+#define LEDC_LS_TIMER          LEDC_TIMER_1
+#define LEDC_LS_MODE           LEDC_LOW_SPEED_MODE
+#define LEDC_TEST_DUTY         (4000)
+
+void test(){
+    ledc_channel_config_t ledc_channel = { };
+
+    ledc_channel.channel = LEDC_LS_CH2_CHANNEL;
+    ledc_channel.duty       = 0;
+    ledc_channel.gpio_num   = FLASH_GPIO;
+    ledc_channel.speed_mode = LEDC_LS_MODE;
+    ledc_channel.hpoint     = 0;
+    ledc_channel.timer_sel  = LEDC_LS_TIMER;
+
+    ledc_channel_config(&ledc_channel);
+
+    ledc_set_duty(ledc_channel.speed_mode, ledc_channel.channel, LEDC_TEST_DUTY);
+    ledc_update_duty(ledc_channel.speed_mode, ledc_channel.channel);
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+};
+
+
+
+static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){
+    jpg_chunking_t *j = (jpg_chunking_t *)arg;
+    if(!index){
+        j->len = 0;
+    }
+    if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){
+        return 0;
+    }
+    j->len += len;
+    return len;
+}
+
+bool CCamera::SetBrightnessContrastSaturation(int _brightness, int _contrast, int _saturation)
+{
+    bool result = false;
+    sensor_t * s = esp_camera_sensor_get(); 
+    if (_brightness > -100)
+        _brightness = min(2, max(-2, _brightness));
+    if (_contrast > -100)
+        _contrast = min(2, max(-2, _contrast));
+//    _saturation = min(2, max(-2, _saturation));
+
+//    s->set_saturation(s, _saturation);
+    if (_contrast > -100)
+        s->set_contrast(s, _contrast);
+    if (_brightness > -100)
+        s->set_brightness(s, _brightness);
+
+    if ((_brightness != brightness) && (_brightness > -100))
+        result = true;
+    if ((_contrast != contrast) && (_contrast > -100))
+        result = true;
+    if ((_saturation != saturation) && (_saturation > -100))
+        result = true;
+    
+    if (_brightness > -100)
+        brightness = _brightness;
+    if (_contrast > -100)
+        contrast = _contrast;
+    if (_saturation > -100)
+       saturation = _saturation;
+
+    if (result && isFixedExposure)
+        EnableAutoExposure(waitbeforepicture_org);
+
+    return result;
+}
+
+
+void CCamera::SetQualitySize(int qual, framesize_t resol)
+{
+    sensor_t * s = esp_camera_sensor_get();   
+    s->set_quality(s, qual);    
+    s->set_framesize(s, resol); 
+    ActualResolution = resol;
+    ActualQuality = qual;
+
+    if (resol == FRAMESIZE_QVGA)
+    {
+        image_height = 240;
+        image_width = 320;             
+    }
+    if (resol == FRAMESIZE_VGA)
+    {
+        image_height = 480;
+        image_width = 640;             
+    }
+    // No higher Mode than VGA, damit der Kameraspeicher ausreicht.
+/*
+    if (resol == FRAMESIZE_SVGA)
+    {
+        image_height = 600;
+        image_width = 800;             
+    }
+    if (resol == FRAMESIZE_XGA)
+    {
+        image_height = 768;
+        image_width = 1024;             
+    }
+    if (resol == FRAMESIZE_SXGA)
+    {
+        image_height = 1024;
+        image_width = 1280;             
+    }
+    if (resol == FRAMESIZE_UXGA)
+    {
+        image_height = 1200;
+        image_width = 1600;             
+    }
+*/
+}
+
+
+void CCamera::EnableAutoExposure(int flashdauer)
+{
+    LEDOnOff(true);
+    if (flashdauer > 0)
+        LightOnOff(true);
+    const TickType_t xDelay = flashdauer / portTICK_PERIOD_MS;
+    vTaskDelay( xDelay );
+
+    camera_fb_t * fb = esp_camera_fb_get();
+    if (!fb) {
+        ESP_LOGE(TAGCAMERACLASS, "Camera Capture Failed");
+        LEDOnOff(false);
+        LightOnOff(false);
+        doReboot();
+    }
+    esp_camera_fb_return(fb);        
+
+    sensor_t * s = esp_camera_sensor_get(); 
+    s->set_gain_ctrl(s, 0);
+    s->set_exposure_ctrl(s, 0);
+
+
+    LEDOnOff(false);  
+    LightOnOff(false);
+    isFixedExposure = true;
+    waitbeforepicture_org = flashdauer;
+}
+
+
+
+esp_err_t CCamera::CaptureToBasisImage(CImageBasis *_Image, int delay)
+{
+    string ftype;
+
+    uint8_t *zwischenspeicher = NULL;
+
+
+    LEDOnOff(true);
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - Start");
+#endif
+
+    if (delay > 0) 
+    {
+        LightOnOff(true);
+        const TickType_t xDelay = delay / portTICK_PERIOD_MS;
+        vTaskDelay( xDelay );
+    }
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After LightOn");
+#endif
+
+    camera_fb_t * fb = esp_camera_fb_get();
+    if (!fb) {
+        ESP_LOGE(TAGCAMERACLASS, "CaptureToBasisImage: Camera Capture Failed");
+        LEDOnOff(false);
+        LightOnOff(false);
+        doReboot();
+
+        return ESP_FAIL;
+    }
+
+    int _size = fb->len;
+    zwischenspeicher = (uint8_t*) malloc(_size);
+    for (int i = 0; i < _size; ++i)
+        *(zwischenspeicher + i) = *(fb->buf + i);
+    esp_camera_fb_return(fb);        
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After fb_get");
+#endif
+
+    LEDOnOff(false);  
+
+    if (delay > 0) 
+        LightOnOff(false);
+ 
+//    TickType_t xDelay = 1000 / portTICK_PERIOD_MS;     
+//    vTaskDelay( xDelay );  // wait for power to recover
+    
+    uint8_t * buf = NULL;
+
+    CImageBasis _zwImage;
+    _zwImage.LoadFromMemory(zwischenspeicher, _size);
+    free(zwischenspeicher);
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After LoadFromMemory");
+#endif
+
+    stbi_uc* p_target;
+    stbi_uc* p_source;    
+    int channels = 3;
+    int width = image_width;
+    int height = image_height;
+
+#ifdef DEBUG_DETAIL_ON
+    std::string _zw = "Targetimage: " + std::to_string((int) _Image->rgb_image) + " Size: " + std::to_string(_Image->width) + ", " + std::to_string(_Image->height);
+    _zw = _zw + " _zwImage: " + std::to_string((int) _zwImage.rgb_image)  + " Size: " + std::to_string(_zwImage.width) + ", " + std::to_string(_zwImage.height);
+    LogFile.WriteToFile(_zw);
+#endif
+
+    for (int x = 0; x < width; ++x)
+        for (int y = 0; y < height; ++y)
+        {
+            p_target = _Image->rgb_image + (channels * (y * width + x));
+            p_source = _zwImage.rgb_image + (channels * (y * width + x));
+            p_target[0] = p_source[0];
+            p_target[1] = p_source[1];
+            p_target[2] = p_source[2];
+        }
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After Copy To Target");
+#endif
+
+    free(buf);
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - Done");
+#endif
+
+    return ESP_OK;    
+}
+
+
+esp_err_t CCamera::CaptureToFile(std::string nm, int delay)
+{
+    string ftype;
+
+     LEDOnOff(true);              // Abgeschaltet, um Strom zu sparen !!!!!!
+
+    if (delay > 0) 
+    {
+        LightOnOff(true);
+        const TickType_t xDelay = delay / portTICK_PERIOD_MS;
+        vTaskDelay( xDelay );
+    }
+
+    camera_fb_t * fb = esp_camera_fb_get();
+    if (!fb) {
+        ESP_LOGE(TAGCAMERACLASS, "CaptureToFile: Camera Capture Failed");
+        LEDOnOff(false);
+        LightOnOff(false);
+        doReboot();
+
+        return ESP_FAIL;
+    }
+    LEDOnOff(false);    
+
+#ifdef DEBUG_DETAIL_ON    
+    printf("w %d, h %d, size %d\n", fb->width, fb->height, fb->len);
+#endif
+
+    nm = FormatFileName(nm);
+
+#ifdef DEBUG_DETAIL_ON
+    printf("Save Camera to : %s\n", nm.c_str());
+#endif
+
+    ftype = toUpper(getFileType(nm));
+
+#ifdef DEBUG_DETAIL_ON
+    printf("Filetype: %s\n", ftype.c_str());
+#endif
+
+    uint8_t * buf = NULL;
+    size_t buf_len = 0;   
+    bool converted = false; 
+
+    if (ftype.compare("BMP") == 0)
+    {
+        frame2bmp(fb, &buf, &buf_len);
+        converted = true;
+    }
+    if (ftype.compare("JPG") == 0)
+    {
+        if(fb->format != PIXFORMAT_JPEG){
+            bool jpeg_converted = frame2jpg(fb, ActualQuality, &buf, &buf_len);
+            converted = true;
+            if(!jpeg_converted){
+                ESP_LOGE(TAGCAMERACLASS, "JPEG compression failed");
+            }
+        } else {
+            buf_len = fb->len;
+            buf = fb->buf;
+        }
+    }
+
+    FILE * fp = OpenFileAndWait(nm.c_str(), "wb");
+    if (fp == NULL)  /* If an error occurs during the file creation */
+    {
+        fprintf(stderr, "fopen() failed for '%s'\n", nm.c_str());
+    }
+    else
+    {
+        fwrite(buf, sizeof(uint8_t), buf_len, fp); 
+        fclose(fp);
+    }    
+    if (converted)
+        free(buf);
+
+    esp_camera_fb_return(fb);
+
+    if (delay > 0) 
+    {
+        LightOnOff(false);
+    }
+
+    return ESP_OK;    
+}
+
+
+esp_err_t CCamera::CaptureToHTTP(httpd_req_t *req, int delay)
+{
+    camera_fb_t * fb = NULL;
+    esp_err_t res = ESP_OK;
+    size_t fb_len = 0;
+    int64_t fr_start = esp_timer_get_time();
+
+
+    LEDOnOff(true);
+
+    if (delay > 0) 
+    {
+        LightOnOff(true);
+        const TickType_t xDelay = delay / portTICK_PERIOD_MS;
+        vTaskDelay( xDelay );
+    }
+
+
+    fb = esp_camera_fb_get();
+    if (!fb) {
+        ESP_LOGE(TAGCAMERACLASS, "Camera capture failed");
+        LEDOnOff(false);
+        LightOnOff(false);
+        httpd_resp_send_500(req);
+//        doReboot();
+
+        return ESP_FAIL;
+    }
+
+    LEDOnOff(false); 
+    
+    res = httpd_resp_set_type(req, "image/jpeg");
+    if(res == ESP_OK){
+        res = httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=raw.jpg");
+    }
+
+    if(res == ESP_OK){
+        if(fb->format == PIXFORMAT_JPEG){
+            fb_len = fb->len;
+            res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
+        } else {
+            jpg_chunking_t jchunk = {req, 0};
+            res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
+            httpd_resp_send_chunk(req, NULL, 0);
+            fb_len = jchunk.len;
+        }
+    }
+    esp_camera_fb_return(fb);
+    int64_t fr_end = esp_timer_get_time();
+    
+    ESP_LOGI(TAGCAMERACLASS, "JPG: %uKB %ums", (uint32_t)(fb_len/1024), (uint32_t)((fr_end - fr_start)/1000));
+
+    if (delay > 0) 
+    {
+        LightOnOff(false);
+    }
+
+    return res;
+}
+
+void CCamera::LightOnOff(bool status)
+{
+    GpioHandler* gpioHandler = gpio_handler_get();
+    if ((gpioHandler != NULL) && (gpioHandler->isEnabled())) {
+        gpioHandler->flashLightEnable(status);
+    }  else {
+        // Init the GPIO
+        gpio_pad_select_gpio(FLASH_GPIO);
+        /* Set the GPIO as a push/pull output */
+        gpio_set_direction(FLASH_GPIO, GPIO_MODE_OUTPUT);  
+
+        if (status)  
+            gpio_set_level(FLASH_GPIO, 1);
+        else
+            gpio_set_level(FLASH_GPIO, 0);
+    }
+}
+
+void CCamera::LEDOnOff(bool status)
+{
+	// Init the GPIO
+    gpio_pad_select_gpio(BLINK_GPIO);
+    /* Set the GPIO as a push/pull output */
+    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);  
+
+    if (!status)  
+        gpio_set_level(BLINK_GPIO, 1);
+    else
+        gpio_set_level(BLINK_GPIO, 0);      
+}
+
+
+void CCamera::GetCameraParameter(httpd_req_t *req, int &qual, framesize_t &resol)
+{
+    char _query[100];
+    char _qual[10];
+    char _size[10];
+
+    resol = ActualResolution;
+    qual = ActualQuality;
+
+
+    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    {
+        printf("Query: "); printf(_query); printf("\n");
+        if (httpd_query_key_value(_query, "size", _size, 10) == ESP_OK)
+        {
+#ifdef DEBUG_DETAIL_ON   
+            printf("Size: "); printf(_size); printf("\n");            
+#endif
+            if (strcmp(_size, "QVGA") == 0)
+                resol = FRAMESIZE_QVGA;       // 320x240
+            if (strcmp(_size, "VGA") == 0)
+                resol = FRAMESIZE_VGA;      // 640x480
+            if (strcmp(_size, "SVGA") == 0)
+                resol = FRAMESIZE_SVGA;     // 800x600
+            if (strcmp(_size, "XGA") == 0)
+                resol = FRAMESIZE_XGA;      // 1024x768
+            if (strcmp(_size, "SXGA") == 0)
+                resol = FRAMESIZE_SXGA;     // 1280x1024
+            if (strcmp(_size, "UXGA") == 0)
+                 resol = FRAMESIZE_UXGA;     // 1600x1200   
+        }
+        if (httpd_query_key_value(_query, "quality", _qual, 10) == ESP_OK)
+        {
+#ifdef DEBUG_DETAIL_ON   
+            printf("Quality: "); printf(_qual); printf("\n");
+#endif
+            qual = atoi(_qual);
+                
+            if (qual > 63)
+                qual = 63;
+            if (qual < 0)
+                qual = 0;
+        }
+    };
+}
+
+framesize_t CCamera::TextToFramesize(const char * _size)
+{
+    if (strcmp(_size, "QVGA") == 0)
+        return FRAMESIZE_QVGA;       // 320x240
+    if (strcmp(_size, "VGA") == 0)
+        return FRAMESIZE_VGA;      // 640x480
+    if (strcmp(_size, "SVGA") == 0)
+        return FRAMESIZE_SVGA;     // 800x600
+    if (strcmp(_size, "XGA") == 0)
+        return FRAMESIZE_XGA;      // 1024x768
+    if (strcmp(_size, "SXGA") == 0)
+        return FRAMESIZE_SXGA;     // 1280x1024
+    if (strcmp(_size, "UXGA") == 0)
+        return FRAMESIZE_UXGA;     // 1600x1200   
+    return ActualResolution;
+}
+
+
+CCamera::CCamera()
+{
+#ifdef DEBUG_DETAIL_ON    
+    printf("CreateClassCamera\n");
+#endif
+    brightness = -5;
+    contrast = -5;
+    saturation = -5;
+    isFixedExposure = false;
+}
+
+esp_err_t CCamera::InitCam()
+{
+    if(CAM_PIN_PWDN != -1){
+        // Init the GPIO
+        gpio_pad_select_gpio(CAM_PIN_PWDN);
+        /* Set the GPIO as a push/pull output */
+        gpio_set_direction(CAM_PIN_PWDN, GPIO_MODE_OUTPUT);
+        gpio_set_level(CAM_PIN_PWDN, 0);
+    }
+
+    printf("Init Camera\n");
+    ActualQuality = camera_config.jpeg_quality;
+    ActualResolution = camera_config.frame_size;
+    //initialize the camera
+    esp_err_t err = esp_camera_init(&camera_config);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAGCAMERACLASS, "Camera Init Failed");
+        return err;
+    }
+
+    return ESP_OK;
+}

code/components/jomjol_controlcamera/ClassControllCamera.h

@@ -9,38 +9,44 @@
 
 #include "esp_camera.h"
 #include <string>
-#include "esp_http_server.h"
+#include <esp_http_server.h>
+#include "CImageBasis.h"
 
 
 #define CAMERA_MODEL_AI_THINKER
 
 
-static const char *TAGCAMERACLASS = "server_part_camera";
-
-
 class CCamera {
     protected:
         int ActualQuality;
         framesize_t ActualResolution;
+        int brightness, contrast, saturation;
+        bool isFixedExposure;
+        int waitbeforepicture_org;
 
     public:
+        int image_height, image_width;
+        
         CCamera();
         esp_err_t InitCam();
 
         void LightOnOff(bool status);
+        void LEDOnOff(bool status);
         esp_err_t CaptureToHTTP(httpd_req_t *req, int delay = 0);
         void SetQualitySize(int qual, framesize_t resol);
+        bool SetBrightnessContrastSaturation(int _brightness, int _contrast, int _saturation);
         void GetCameraParameter(httpd_req_t *req, int &qual, framesize_t &resol);
 
+        void EnableAutoExposure(int flashdauer);
+        
+
         framesize_t TextToFramesize(const char * text);
 
-
         esp_err_t CaptureToFile(std::string nm, int delay = 0);
-        
+        esp_err_t CaptureToBasisImage(CImageBasis *_Image, int delay = 0);
 };
 
 
 extern CCamera Camera;
 
-
 #endif

code/components/jomjol_controlcamera/server_camera.cpp

@@ -11,12 +11,18 @@
 #define SCRATCH_BUFSIZE2  8192 
 char scratch2[SCRATCH_BUFSIZE2];
 
+//#define DEBUG_DETAIL_ON   
+static const char *TAGPARTCAMERA = "server_camera";
+
 
 void PowerResetCamera(){
         ESP_LOGD(TAGPARTCAMERA, "Resetting camera by power down line");
-        gpio_config_t conf = { 0 };
+        gpio_config_t conf;
+        conf.intr_type = GPIO_INTR_DISABLE;
         conf.pin_bit_mask = 1LL << GPIO_NUM_32;
         conf.mode = GPIO_MODE_OUTPUT;
+        conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
+        conf.pull_up_en = GPIO_PULLUP_DISABLE;
         gpio_config(&conf);
 
         // carefull, logic is inverted compared to reset pin
@@ -29,43 +35,72 @@ void PowerResetCamera(){
 
 esp_err_t handler_lightOn(httpd_req_t *req)
 {
-    LogFile.WriteToFile("handler_lightOn");
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_lightOn - Start");
     printf("handler_lightOn uri:\n"); printf(req->uri); printf("\n");
+#endif
+
     Camera.LightOnOff(true);
     const char* resp_str = (const char*) req->user_ctx;
-    httpd_resp_send(req, resp_str, strlen(resp_str));      
+    httpd_resp_send(req, resp_str, strlen(resp_str));  
+
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_lightOn - Done");
+#endif
+
     return ESP_OK;
 };
 
 esp_err_t handler_lightOff(httpd_req_t *req)
 {
-    LogFile.WriteToFile("handler_lightOff");
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_lightOff - Start");
     printf("handler_lightOff uri:\n"); printf(req->uri); printf("\n");
+#endif
     Camera.LightOnOff(false);
     const char* resp_str = (const char*) req->user_ctx;
     httpd_resp_send(req, resp_str, strlen(resp_str));       
+
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_lightOff - Done");
+#endif
+
     return ESP_OK;
 };
 
 esp_err_t handler_capture(httpd_req_t *req)
 {
-    LogFile.WriteToFile("handler_capture");
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_capture - Start");
+#endif
+
     int quality;
     framesize_t res;
 
     Camera.GetCameraParameter(req, quality, res);
+
+#ifdef DEBUG_DETAIL_ON   
     printf("Size: %d", res); printf(" Quality: %d\n", quality);
+#endif
+
     Camera.SetQualitySize(quality, res);
 
     esp_err_t ressult;
     ressult = Camera.CaptureToHTTP(req);
+
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_capture - Done");
+#endif
+
     return ressult;
 };
 
 
 esp_err_t handler_capture_with_ligth(httpd_req_t *req)
 {
-    LogFile.WriteToFile("handler_capture_with_ligth");
+#ifdef DEBUG_DETAIL_ON  
+    LogFile.WriteHeapInfo("handler_capture_with_ligth - Start");
+#endif
     char _query[100];
     char _delay[10];
 
@@ -78,7 +113,9 @@ esp_err_t handler_capture_with_ligth(httpd_req_t *req)
         printf("Query: "); printf(_query); printf("\n");
         if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
         {
-            printf("Delay: "); printf(_delay); printf("\n");            
+#ifdef DEBUG_DETAIL_ON   
+            printf("Delay: "); printf(_delay); printf("\n");    
+#endif        
             delay = atoi(_delay);
 
             if (delay < 0)
@@ -87,9 +124,12 @@ esp_err_t handler_capture_with_ligth(httpd_req_t *req)
     };
 
     Camera.GetCameraParameter(req, quality, res);
-    printf("Size: %d", res); printf(" Quality: %d\n", quality);
-    Camera.SetQualitySize(quality, res);
 
+#ifdef DEBUG_DETAIL_ON   
+    printf("Size: %d", res); printf(" Quality: %d\n", quality);
+#endif
+
+    Camera.SetQualitySize(quality, res);
     Camera.LightOnOff(true);
     const TickType_t xDelay = delay / portTICK_PERIOD_MS;
     vTaskDelay( xDelay );
@@ -98,7 +138,11 @@ esp_err_t handler_capture_with_ligth(httpd_req_t *req)
     ressult = Camera.CaptureToHTTP(req);  
 
     Camera.LightOnOff(false);
-   
+
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_capture_with_ligth - Done");
+#endif
+
     return ressult;
 };
 
@@ -106,7 +150,10 @@ esp_err_t handler_capture_with_ligth(httpd_req_t *req)
 
 esp_err_t handler_capture_save_to_file(httpd_req_t *req)
 {
-    LogFile.WriteToFile("handler_capture_save_to_file");
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_capture_save_to_file - Start");
+#endif
+
     char _query[100];
     char _delay[10];
     int delay = 0;
@@ -123,14 +170,18 @@ esp_err_t handler_capture_save_to_file(httpd_req_t *req)
         if (httpd_query_key_value(_query, "filename", filename, 100) == ESP_OK)
         {
             fn.append(filename);
+#ifdef DEBUG_DETAIL_ON   
             printf("Filename: "); printf(fn.c_str()); printf("\n");            
+#endif
         }
         else
             fn.append("noname.jpg");
 
         if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
         {
+#ifdef DEBUG_DETAIL_ON   
             printf("Delay: "); printf(_delay); printf("\n");            
+#endif
             delay = atoi(_delay);
 
             if (delay < 0)
@@ -142,7 +193,9 @@ esp_err_t handler_capture_save_to_file(httpd_req_t *req)
         fn.append("noname.jpg");
 
     Camera.GetCameraParameter(req, quality, res);
+#ifdef DEBUG_DETAIL_ON   
     printf("Size: %d", res); printf(" Quality: %d\n", quality);
+#endif
     Camera.SetQualitySize(quality, res);
 
     esp_err_t ressult;
@@ -151,6 +204,10 @@ esp_err_t handler_capture_save_to_file(httpd_req_t *req)
     const char* resp_str = (const char*) fn.c_str();
     httpd_resp_send(req, resp_str, strlen(resp_str));  
   
+#ifdef DEBUG_DETAIL_ON   
+    LogFile.WriteHeapInfo("handler_capture_save_to_file - Done");
+#endif
+
     return ressult;
 };
 
@@ -158,8 +215,10 @@ esp_err_t handler_capture_save_to_file(httpd_req_t *req)
 
 void register_server_camera_uri(httpd_handle_t server)
 {
+#ifdef DEBUG_DETAIL_ON   
     ESP_LOGI(TAGPARTCAMERA, "server_part_camera - Registering URI handlers");
-    
+#endif
+
     httpd_uri_t camuri = { };
     camuri.method    = HTTP_GET;
 

code/components/jomjol_controlcamera/server_camera.h

@@ -7,8 +7,6 @@
 
 //#include "ClassControllCamera.h"
 
-static const char *TAGPARTCAMERA = "server_camera";
-
 void register_server_camera_uri(httpd_handle_t server);
 
 void PowerResetCamera();

code/components/jomjol_fileserver_ota/CMakeLists.txt

@@ -0,0 +1,7 @@
+FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)
+
+idf_component_register(SRCS ${app_sources}
+                    INCLUDE_DIRS "." "../../include"
+                    REQUIRES tfmicro esp_http_server app_update esp_http_client nvs_flash jomjol_tfliteclass jomjol_flowcontroll spiffs jomjol_helper jomjol_controlGPIO)
+
+

code/components/jomjol_fileserver_ota/server_file.cpp

@@ -23,12 +23,15 @@
 #include "esp_log.h"
 
 #include "esp_vfs.h"
-#include "esp_spiffs.h"
+#include <esp_spiffs.h>
 #include "esp_http_server.h"
 
+#include "defines.h"
 #include "ClassLogFile.h"
 
 #include "server_help.h"
+#include "interface_mqtt.h"
+#include "server_GPIO.h"
 
 #include "Helper.h"
 #include "miniz.h"
@@ -53,38 +56,23 @@ struct file_server_data {
     char scratch[SCRATCH_BUFSIZE];
 };
 
-static const char *TAG = "file_server";
+static const char *TAG_FILESERVER = "file_server";
 
 /* Handler to redirect incoming GET request for /index.html to /
  * This can be overridden by uploading file with same name */
-static esp_err_t index_html_get_handler(httpd_req_t *req)
-{
-    httpd_resp_set_status(req, "307 Temporary Redirect");
-    httpd_resp_set_hdr(req, "Location", "/");
-    httpd_resp_send(req, NULL, 0);  // Response body can be empty
-    return ESP_OK;
-}
-
-/* Handler to respond with an icon file embedded in flash.
- * Browsers expect to GET website icon at URI /favicon.ico.
- * This can be overridden by uploading file with same name */
-static esp_err_t favicon_get_handler(httpd_req_t *req)
-{
-    extern const unsigned char favicon_ico_start[] asm("_binary_favicon_ico_start");
-    extern const unsigned char favicon_ico_end[]   asm("_binary_favicon_ico_end");
-    const size_t favicon_ico_size = (favicon_ico_end - favicon_ico_start);
-    httpd_resp_set_type(req, "image/x-icon");
-    httpd_resp_send(req, (const char *)favicon_ico_start, favicon_ico_size);
-    /* Respond with an empty chunk to signal HTTP response completion */
-    httpd_resp_send_chunk(req, NULL, 0);       
-    return ESP_OK;
-}
+// static esp_err_t index_html_get_handler(httpd_req_t *req)
+// {
+//     httpd_resp_set_status(req, "307 Temporary Redirect");
+//     httpd_resp_set_hdr(req, "Location", "/");
+//     httpd_resp_send(req, NULL, 0);  // Response body can be empty
+//     return ESP_OK;
+// }
 
 /* Send HTTP response with a run-time generated html consisting of
  * a list of all files and folders under the requested path.
  * In case of SPIFFS this returns empty list when path is any
  * string other than '/', since SPIFFS doesn't support directories */
-static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
+static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const char* uripath, bool readonly)
 {
     char entrypath[FILE_PATH_MAX];
     char entrysize[16];
@@ -110,7 +98,7 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
     printf("entrypath: <%s>\n", entrypath);    
 
     if (!dir) {
-        ESP_LOGE(TAG, "Failed to stat dir : %s", dirpath);
+        ESP_LOGE(TAG_FILESERVER, "Failed to stat dir : %s", dirpath);
         /* Respond with 404 Not Found */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "Directory does not exist");
         return ESP_FAIL;
@@ -120,24 +108,24 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
     httpd_resp_sendstr_chunk(req, "<!DOCTYPE html><html><body>");
 
 /////////////////////////////////////////////////
-
-    FILE *fd = fopen("/sdcard/html/upload_script.html", "r");
-    char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
-    size_t chunksize;
-    do {
-        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
-//        printf("Chunksize %d\n", chunksize);
-        if (chunksize > 0){
-            if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
-            fclose(fd);
-            ESP_LOGE(TAG, "File sending failed!");
-            return ESP_FAIL;
+    if (!readonly) {
+        FILE *fd = OpenFileAndWait("/sdcard/html/upload_script.html", "r");
+        char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
+        size_t chunksize;
+        do {
+            chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+            //        printf("Chunksize %d\n", chunksize);
+            if (chunksize > 0){
+                if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
+                fclose(fd);
+                ESP_LOGE(TAG_FILESERVER, "File sending failed!");
+                return ESP_FAIL;
+                }
             }
-        }
-    } while (chunksize != 0);
-    fclose(fd);
-//    ESP_LOGI(TAG, "File sending complete");
-
+        } while (chunksize != 0);
+        fclose(fd);
+        //    ESP_LOGI(TAG, "File sending complete");
+    }
 ///////////////////////////////
 
     std::string _zw = std::string(dirpath);
@@ -149,12 +137,16 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
     httpd_resp_sendstr_chunk(req,
         "<table class=\"fixed\" border=\"1\">"
         "<col width=\"800px\" /><col width=\"300px\" /><col width=\"300px\" /><col width=\"100px\" />"
-        "<thead><tr><th>Name</th><th>Type</th><th>Size (Bytes)</th><th>Delete<br>"
-        "<form method=\"post\" action=\"");
-    httpd_resp_sendstr_chunk(req, _zw.c_str());
-    httpd_resp_sendstr_chunk(req,          
-        "\"><button type=\"submit\">DELETE ALL!</button></form>"
-        "</th></tr></thead><tbody>\n");
+        "<thead><tr><th>Name</th><th>Type</th><th>Size (Bytes)</th>");
+    if (!readonly) {
+        httpd_resp_sendstr_chunk(req, "<th>Delete<br>"
+            "<form method=\"post\" action=\"");
+        httpd_resp_sendstr_chunk(req, _zw.c_str());
+        httpd_resp_sendstr_chunk(req,
+            "\"><button type=\"submit\">DELETE ALL!</button></form>"
+            "</th></tr>");
+    }
+    httpd_resp_sendstr_chunk(req, "</thead><tbody>\n");
 
     /* Iterate over all files / folders and fetch their names and sizes */
     while ((entry = readdir(dir)) != NULL) {
@@ -165,15 +157,16 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
             strlcpy(entrypath + dirpath_len, entry->d_name, sizeof(entrypath) - dirpath_len);
             printf("Entrypath: %s\n", entrypath);
             if (stat(entrypath, &entry_stat) == -1) {
-                ESP_LOGE(TAG, "Failed to stat %s : %s", entrytype, entry->d_name);
+                ESP_LOGE(TAG_FILESERVER, "Failed to stat %s : %s", entrytype, entry->d_name);
                 continue;
             }
             sprintf(entrysize, "%ld", entry_stat.st_size);
-            ESP_LOGI(TAG, "Found %s : %s (%s bytes)", entrytype, entry->d_name, entrysize);
+            ESP_LOGI(TAG_FILESERVER, "Found %s : %s (%s bytes)", entrytype, entry->d_name, entrysize);
 
             /* Send chunk of HTML file containing table entries with file name and size */
             httpd_resp_sendstr_chunk(req, "<tr><td><a href=\"");
-            httpd_resp_sendstr_chunk(req, req->uri);
+            httpd_resp_sendstr_chunk(req, "/fileserver");
+            httpd_resp_sendstr_chunk(req, uripath);
             httpd_resp_sendstr_chunk(req, entry->d_name);
             if (entry->d_type == DT_DIR) {
                 httpd_resp_sendstr_chunk(req, "/");
@@ -184,11 +177,13 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
             httpd_resp_sendstr_chunk(req, entrytype);
             httpd_resp_sendstr_chunk(req, "</td><td>");
             httpd_resp_sendstr_chunk(req, entrysize);
-            httpd_resp_sendstr_chunk(req, "</td><td>");
-            httpd_resp_sendstr_chunk(req, "<form method=\"post\" action=\"/delete");
-            httpd_resp_sendstr_chunk(req, req->uri + strlen("/fileserver"));
-            httpd_resp_sendstr_chunk(req, entry->d_name);
-            httpd_resp_sendstr_chunk(req, "\"><button type=\"submit\">Delete</button></form>");
+            if (!readonly) {
+                httpd_resp_sendstr_chunk(req, "</td><td>");
+                httpd_resp_sendstr_chunk(req, "<form method=\"post\" action=\"/delete");
+                httpd_resp_sendstr_chunk(req, uripath);
+                httpd_resp_sendstr_chunk(req, entry->d_name);
+                httpd_resp_sendstr_chunk(req, "\"><button type=\"submit\">Delete</button></form>");
+            }
             httpd_resp_sendstr_chunk(req, "</td></tr>\n");
         }
     }
@@ -209,6 +204,70 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
     (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)
 
 
+static esp_err_t logfileact_get_handler(httpd_req_t *req)
+{
+    LogFile.WriteToFile("logfileact_get_handler");
+    char filepath[FILE_PATH_MAX];
+    FILE *fd = NULL;
+    //struct stat file_stat;
+    printf("uri: %s\n", req->uri);
+
+    const char* filename = "log_current.txt"; 
+
+    printf("uri: %s, filename: %s, filepath: %s\n", req->uri, filename, filepath);
+
+    std::string currentfilename = LogFile.GetCurrentFileName();
+
+
+    fd = OpenFileAndWait(currentfilename.c_str(), "r");
+    if (!fd) {
+        ESP_LOGE(TAG_FILESERVER, "Failed to read existing file : %s", filepath);
+        /* Respond with 500 Internal Server Error */
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read existing file");
+        return ESP_FAIL;
+    }
+
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+
+//    ESP_LOGI(TAG_FILESERVER, "Sending file : %s (%ld bytes)...", &filename, file_stat.st_size);
+    set_content_type_from_file(req, filename);
+
+    /* Retrieve the pointer to scratch buffer for temporary storage */
+    char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
+    size_t chunksize;
+    do {
+        /* Read file in chunks into the scratch buffer */
+        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+
+        /* Send the buffer contents as HTTP response chunk */
+        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
+            fclose(fd);
+            ESP_LOGE(TAG_FILESERVER, "File sending failed!");
+            /* Abort sending file */
+            httpd_resp_sendstr_chunk(req, NULL);
+            /* Respond with 500 Internal Server Error */
+            httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to send file");
+            return ESP_FAIL;
+        }
+
+        /* Keep looping till the whole file is sent */
+    } while (chunksize != 0);
+
+    /* Close file after sending complete */
+    fclose(fd);
+    ESP_LOGI(TAG_FILESERVER, "File sending complete");
+
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_send_chunk(req, NULL, 0);
+    return ESP_OK;
+}
+
+
+
+
+
+
+
 /* Handler to download a file kept on the server */
 static esp_err_t download_get_handler(httpd_req_t *req)
 {
@@ -226,8 +285,9 @@ static esp_err_t download_get_handler(httpd_req_t *req)
 //    filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
 //                                             req->uri, sizeof(filepath));
 
+
     if (!filename) {
-        ESP_LOGE(TAG, "Filename is too long");
+        ESP_LOGE(TAG_FILESERVER, "Filename is too long");
         /* Respond with 500 Internal Server Error */
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filename too long");
         return ESP_FAIL;
@@ -235,7 +295,22 @@ static esp_err_t download_get_handler(httpd_req_t *req)
 
     /* If name has trailing '/', respond with directory contents */
     if (filename[strlen(filename) - 1] == '/') {
-        return http_resp_dir_html(req, filepath);
+        bool readonly = false;
+        size_t buf_len = httpd_req_get_url_query_len(req) + 1;
+        if (buf_len > 1) {
+            char buf[buf_len];
+            if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
+                ESP_LOGI(TAG_FILESERVER, "Found URL query => %s", buf);
+                char param[32];
+                /* Get value of expected key from query string */
+                if (httpd_query_key_value(buf, "readonly", param, sizeof(param)) == ESP_OK) {
+                    ESP_LOGI(TAG_FILESERVER, "Found URL query parameter => readonly=%s", param);
+                    readonly = param && strcmp(param,"true")==0;
+                }
+            }
+        }
+
+        return http_resp_dir_html(req, filepath, filename, readonly);
     }
 
     std::string testwlan = toUpper(std::string(filename));
@@ -244,23 +319,23 @@ static esp_err_t download_get_handler(httpd_req_t *req)
 
         /* If file not present on SPIFFS check if URI
          * corresponds to one of the hardcoded paths */
-        ESP_LOGE(TAG, "Failed to stat file : %s", filepath);
+        ESP_LOGE(TAG_FILESERVER, "Failed to stat file : %s", filepath);
         /* Respond with 404 Not Found */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File does not exist");
         return ESP_FAIL;
     }
 
-    fd = fopen(filepath, "r");
+    fd = OpenFileAndWait(filepath, "r");
     if (!fd) {
-        ESP_LOGE(TAG, "Failed to read existing file : %s", filepath);
+        ESP_LOGE(TAG_FILESERVER, "Failed to read existing file : %s", filepath);
         /* Respond with 500 Internal Server Error */
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read existing file");
         return ESP_FAIL;
     }
 
-    esp_err_t res = httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
 
-    ESP_LOGI(TAG, "Sending file : %s (%ld bytes)...", filename, file_stat.st_size);
+    ESP_LOGI(TAG_FILESERVER, "Sending file : %s (%ld bytes)...", filename, file_stat.st_size);
     set_content_type_from_file(req, filename);
 
     /* Retrieve the pointer to scratch buffer for temporary storage */
@@ -273,7 +348,7 @@ static esp_err_t download_get_handler(httpd_req_t *req)
         /* Send the buffer contents as HTTP response chunk */
         if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
             fclose(fd);
-            ESP_LOGE(TAG, "File sending failed!");
+            ESP_LOGE(TAG_FILESERVER, "File sending failed!");
             /* Abort sending file */
             httpd_resp_sendstr_chunk(req, NULL);
             /* Respond with 500 Internal Server Error */
@@ -286,7 +361,7 @@ static esp_err_t download_get_handler(httpd_req_t *req)
 
     /* Close file after sending complete */
     fclose(fd);
-    ESP_LOGI(TAG, "File sending complete");
+    ESP_LOGI(TAG_FILESERVER, "File sending complete");
 
     /* Respond with an empty chunk to signal HTTP response completion */
     httpd_resp_send_chunk(req, NULL, 0);
@@ -313,13 +388,13 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
     /* Filename cannot have a trailing '/' */
     if (filename[strlen(filename) - 1] == '/') {
-        ESP_LOGE(TAG, "Invalid filename : %s", filename);
+        ESP_LOGE(TAG_FILESERVER, "Invalid filename : %s", filename);
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Invalid filename");
         return ESP_FAIL;
     }
 
     if (stat(filepath, &file_stat) == 0) {
-        ESP_LOGE(TAG, "File already exists : %s", filepath);
+        ESP_LOGE(TAG_FILESERVER, "File already exists : %s", filepath);
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "File already exists");
         return ESP_FAIL;
@@ -327,7 +402,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
     /* File cannot be larger than a limit */
     if (req->content_len > MAX_FILE_SIZE) {
-        ESP_LOGE(TAG, "File too large : %d bytes", req->content_len);
+        ESP_LOGE(TAG_FILESERVER, "File too large : %d bytes", req->content_len);
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
                             "File size must be less than "
@@ -337,15 +412,15 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
         return ESP_FAIL;
     }
 
-    fd = fopen(filepath, "w");
+    fd = OpenFileAndWait(filepath, "w");
     if (!fd) {
-        ESP_LOGE(TAG, "Failed to create file : %s", filepath);
+        ESP_LOGE(TAG_FILESERVER, "Failed to create file : %s", filepath);
         /* Respond with 500 Internal Server Error */
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to create file");
         return ESP_FAIL;
     }
 
-    ESP_LOGI(TAG, "Receiving file : %s...", filename);
+    ESP_LOGI(TAG_FILESERVER, "Receiving file : %s...", filename);
 
     /* Retrieve the pointer to scratch buffer for temporary storage */
     char *buf = ((struct file_server_data *)req->user_ctx)->scratch;
@@ -357,7 +432,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
     while (remaining > 0) {
 
-        ESP_LOGI(TAG, "Remaining size : %d", remaining);
+        ESP_LOGI(TAG_FILESERVER, "Remaining size : %d", remaining);
         /* Receive the file part by part into a buffer */
         if ((received = httpd_req_recv(req, buf, MIN(remaining, SCRATCH_BUFSIZE))) <= 0) {
             if (received == HTTPD_SOCK_ERR_TIMEOUT) {
@@ -370,7 +445,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
             fclose(fd);
             unlink(filepath);
 
-            ESP_LOGE(TAG, "File reception failed!");
+            ESP_LOGE(TAG_FILESERVER, "File reception failed!");
             /* Respond with 500 Internal Server Error */
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
             return ESP_FAIL;
@@ -383,7 +458,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
             fclose(fd);
             unlink(filepath);
 
-            ESP_LOGE(TAG, "File write failed!");
+            ESP_LOGE(TAG_FILESERVER, "File write failed!");
             /* Respond with 500 Internal Server Error */
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write file to storage");
             return ESP_FAIL;
@@ -396,7 +471,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
     /* Close file upon upload completion */
     fclose(fd);
-    ESP_LOGI(TAG, "File reception complete");
+    ESP_LOGI(TAG_FILESERVER, "File reception complete");
 
     std::string directory = std::string(filepath);
 	size_t zw = directory.find("/");
@@ -411,10 +486,10 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
     int start_fn = strlen(((struct file_server_data *)req->user_ctx)->base_path);
     printf("Directory: %s, start_fn: %d, found: %d\n", directory.c_str(), start_fn, found);
 	directory = directory.substr(start_fn, found - start_fn + 1);
-    printf("Directory danach: %s\n", directory.c_str());    
+    printf("Directory danach 1: %s\n", directory.c_str());    
 
     directory = "/fileserver" + directory;
-    printf("Directory danach: %s\n", directory.c_str());   
+    printf("Directory danach 2: %s\n", directory.c_str());   
 
     /* Redirect onto root to see the updated file list */
     httpd_resp_set_status(req, "303 See Other");
@@ -424,6 +499,15 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
     httpd_resp_set_status(req, "303 See Other");
     httpd_resp_set_hdr(req, "Location", directory.c_str());
     httpd_resp_sendstr(req, "File uploaded successfully");
+
+/*
+    if (strcmp(filepath, CONFIG_FILE) == 0) {
+        printf("New config found. Reload handler.");
+        gpio_handler_deinit();
+        MQTTdestroy();
+    }
+*/
+
     return ESP_OK;
 }
 
@@ -437,7 +521,6 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
 
 //////////////////////////////////////////////////////////////
     char _query[200];
-    char _filename[30];
     char _valuechar[30];    
     std::string fn = "/sdcard/firmware/";
     std::string _task;
@@ -496,19 +579,19 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
 
         /* Filename cannot have a trailing '/' */
         if (filename[strlen(filename) - 1] == '/') {
-            ESP_LOGE(TAG, "Invalid filename : %s", filename);
+            ESP_LOGE(TAG_FILESERVER, "Invalid filename : %s", filename);
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Invalid filename");
             return ESP_FAIL;
         }
 
         if (stat(filepath, &file_stat) == -1) {
-            ESP_LOGE(TAG, "File does not exist : %s", filename);
+            ESP_LOGE(TAG_FILESERVER, "File does not exist : %s", filename);
             /* Respond with 400 Bad Request */
             httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "File does not exist");
             return ESP_FAIL;
         }
 
-        ESP_LOGI(TAG, "Deleting file : %s", filename);
+        ESP_LOGI(TAG_FILESERVER, "Deleting file : %s", filename);
         /* Delete file */
         unlink(filepath);
 
@@ -525,10 +608,10 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
         int start_fn = strlen(((struct file_server_data *)req->user_ctx)->base_path);
         printf("Directory: %s, start_fn: %d, found: %d\n", directory.c_str(), start_fn, found);
         directory = directory.substr(start_fn, found - start_fn + 1);
-        printf("Directory danach: %s\n", directory.c_str());    
+        printf("Directory danach 3: %s\n", directory.c_str());    
 
         directory = "/fileserver" + directory;
-        printf("Directory danach: %s\n", directory.c_str());   
+        printf("Directory danach 4: %s\n", directory.c_str());   
     }
     
 
@@ -552,7 +635,7 @@ void delete_all_in_directory(std::string _directory)
     std::string filename;
 
     if (!dir) {
-        ESP_LOGE(TAG, "Failed to stat dir : %s", _directory.c_str());
+        ESP_LOGE(TAG_FILESERVER, "Failed to stat dir : %s", _directory.c_str());
         return;
     }
 
@@ -561,7 +644,7 @@ void delete_all_in_directory(std::string _directory)
         if (!(entry->d_type == DT_DIR)){
             if (strcmp("wlan.ini", entry->d_name) != 0){                    // auf wlan.ini soll nicht zugegriffen werden !!!
                 filename = _directory + "/" + std::string(entry->d_name);
-                ESP_LOGI(TAG, "Deleting file : %s", filename.c_str());
+                ESP_LOGI(TAG_FILESERVER, "Deleting file : %s", filename.c_str());
                 /* Delete file */
                 unlink(filename.c_str());    
             }
@@ -576,8 +659,6 @@ void unzip(std::string _in_zip_file, std::string _target_directory){
     size_t uncomp_size;
     mz_zip_archive zip_archive;
     void* p;
-    const int N = 50;
-    char data[2048];
     char archive_filename[64];
     std::string zw;
 //    static const char* s_Test_archive_filename = "testhtml.zip";
@@ -626,7 +707,7 @@ void unzip(std::string _in_zip_file, std::string _target_directory){
             zw = std::string(archive_filename);
             zw = _target_directory + zw;
             printf("Filename to extract: %s", zw.c_str());
-            FILE* fpTargetFile = fopen(zw.c_str(), "wb");
+            FILE* fpTargetFile = OpenFileAndWait(zw.c_str(), "wb");
             fwrite(p, 1, (uint)uncomp_size, fpTargetFile);
             fclose(fpTargetFile);
 
@@ -653,19 +734,19 @@ void register_server_file_uri(httpd_handle_t server, const char *base_path)
     /* Validate file storage base path */
     if (!base_path) {
 //    if (!base_path || strcmp(base_path, "/spiffs") != 0) {
-        ESP_LOGE(TAG, "File server base_path not set");
+        ESP_LOGE(TAG_FILESERVER, "File server base_path not set");
 //        return ESP_ERR_INVALID_ARG;
     }
 
     if (server_data) {
-        ESP_LOGE(TAG, "File server already started");
+        ESP_LOGE(TAG_FILESERVER, "File server already started");
 //        return ESP_ERR_INVALID_STATE;
     }
 
     /* Allocate memory for server data */
     server_data = (file_server_data *) calloc(1, sizeof(struct file_server_data));
     if (!server_data) {
-        ESP_LOGE(TAG, "Failed to allocate memory for server data");
+        ESP_LOGE(TAG_FILESERVER, "Failed to allocate memory for server data");
 //        return ESP_ERR_NO_MEM;
     }
     strlcpy(server_data->base_path, base_path,
@@ -687,6 +768,17 @@ void register_server_file_uri(httpd_handle_t server, const char *base_path)
     };
     httpd_register_uri_handler(server, &file_download);
 
+
+
+    httpd_uri_t file_logfileact = {
+        .uri       = "/logfileact",  // Match all URIs of type /path/to/file
+        .method    = HTTP_GET,
+        .handler   = logfileact_get_handler,
+        .user_ctx  = server_data    // Pass server data as context
+    };
+    httpd_register_uri_handler(server, &file_logfileact);
+
+
     /* URI handler for uploading files to server */
     httpd_uri_t file_upload = {
         .uri       = "/upload/*",   // Match all URIs of type /upload/path/to/file

code/components/jomjol_fileserver_ota/server_help.cpp

@@ -10,6 +10,8 @@
 #include "esp_err.h"
 #include "esp_log.h"
 
+#include "Helper.h"
+
 #include "esp_http_server.h"
 
 
@@ -23,9 +25,9 @@ char scratch[SCRATCH_BUFSIZE];
     (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)
 
 
-esp_err_t send_file(httpd_req_t *req, std::string filename,  struct stat * file_stat)
+esp_err_t send_file(httpd_req_t *req, std::string filename)
 {
-    FILE *fd = fopen(filename.c_str(), "r");
+    FILE *fd = OpenFileAndWait(filename.c_str(), "r");
     if (!fd) {
         ESP_LOGE(TAG, "Failed to read existing file : %s", filename.c_str());
         /* Respond with 500 Internal Server Error */
@@ -33,7 +35,7 @@ esp_err_t send_file(httpd_req_t *req, std::string filename,  struct stat * file_
         return ESP_FAIL;
     }
 
-    ESP_LOGI(TAG, "Sending file : %s (%ld bytes)...", filename.c_str(), file_stat->st_size);
+    ESP_LOGI(TAG, "Sending file : %s ...", filename.c_str());
     set_content_type_from_file(req, filename.c_str());
 
     /* Retrieve the pointer to scratch buffer for temporary storage */
@@ -65,6 +67,7 @@ esp_err_t send_file(httpd_req_t *req, std::string filename,  struct stat * file_
 
 
 
+
 /* Copies the full path into destination buffer and returns
  * pointer to path (skipping the preceding base path) */
 const char* get_path_from_uri(char *dest, const char *base_path, const char *uri, size_t destsize)
@@ -104,6 +107,8 @@ esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename)
         return httpd_resp_set_type(req, "text/html");
     } else if (IS_FILE_EXT(filename, ".jpeg")) {
         return httpd_resp_set_type(req, "image/jpeg");
+    } else if (IS_FILE_EXT(filename, ".jpg")) {
+        return httpd_resp_set_type(req, "image/jpeg");
     } else if (IS_FILE_EXT(filename, ".ico")) {
         return httpd_resp_set_type(req, "image/x-icon");
     }

code/components/jomjol_fileserver_ota/server_help.h

@@ -5,6 +5,6 @@
 
 const char* get_path_from_uri(char *dest, const char *base_path, const char *uri, size_t destsize);
 
-esp_err_t send_file(httpd_req_t *req, std::string filename, struct stat * file_stat);
+esp_err_t send_file(httpd_req_t *req, std::string filename);
 
 esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename);

code/components/jomjol_fileserver_ota/server_ota.cpp

@@ -12,25 +12,30 @@
 #include "freertos/task.h"
 #include "esp_system.h"
 #include "esp_event.h"
-#include "esp_event_loop.h"
+#include "esp_event.h"
 #include "esp_log.h"
-#include "esp_ota_ops.h"
+#include <esp_ota_ops.h>
 #include "esp_http_client.h"
 #include "esp_flash_partitions.h"
 #include "esp_partition.h"
-#include "nvs.h"
+#include <nvs.h>
 #include "nvs_flash.h"
 #include "driver/gpio.h"
-#include "protocol_examples_common.h"
+// #include "protocol_examples_common.h"
 #include "errno.h"
 
 #include <sys/stat.h>
 
 #include "server_tflite.h"
 #include "server_file.h"
+#include "server_GPIO.h"
 
 #include "ClassLogFile.h"
 
+#include "Helper.h"
+
+
+// #define DEBUG_DETAIL_ON 
 
 
 #define BUFFSIZE 1024
@@ -42,6 +47,7 @@ static char ota_write_data[BUFFSIZE + 1] = { 0 };
 
 
 #define OTA_URL_SIZE 256
+static const char *TAGPARTOTA = "server_ota";
 
 
 static void infinite_loop(void)
@@ -56,14 +62,14 @@ static void infinite_loop(void)
 
 
 
-static bool ota_example_task(std::string fn)
+static bool ota_update_task(std::string fn)
 {
     esp_err_t err;
     /* update handle : set by esp_ota_begin(), must be freed via esp_ota_end() */
     esp_ota_handle_t update_handle = 0 ;
     const esp_partition_t *update_partition = NULL;
 
-    ESP_LOGI(TAGPARTOTA, "Starting OTA example");
+    ESP_LOGI(TAGPARTOTA, "Starting OTA update");
 
     const esp_partition_t *configured = esp_ota_get_boot_partition();
     const esp_partition_t *running = esp_ota_get_running_partition();
@@ -89,7 +95,7 @@ static bool ota_example_task(std::string fn)
 
     int data_read;     
 
-    FILE* f = fopen(fn.c_str(), "rb");     // vorher  nur "r"
+    FILE* f = OpenFileAndWait(fn.c_str(), "rb");     // vorher  nur "r"
     data_read = fread(ota_write_data, 1, BUFFSIZE, f);
 
     while (data_read > 0) {
@@ -301,6 +307,10 @@ void CheckOTAUpdate(void)
 
 esp_err_t handler_ota_update(httpd_req_t *req)
 {
+#ifdef DEBUG_DETAIL_ON     
+    LogFile.WriteHeapInfo("handler_ota_update - Start");    
+#endif
+
     LogFile.WriteToFile("handler_ota_update");    
     char _query[200];
     char _filename[30];
@@ -366,7 +376,9 @@ esp_err_t handler_ota_update(httpd_req_t *req)
 
     const char* resp_str;    
 
-    if (ota_example_task(fn))
+    KillTFliteTasks();
+    gpio_handler_deinit();
+    if (ota_update_task(fn))
     {
         resp_str = "Firmware Update Successfull!<br><br>You can restart now.";
     }
@@ -376,7 +388,11 @@ esp_err_t handler_ota_update(httpd_req_t *req)
     }
 
     httpd_resp_send(req, resp_str, strlen(resp_str));  
-    
+
+#ifdef DEBUG_DETAIL_ON 
+    LogFile.WriteHeapInfo("handler_ota_update - Done");    
+#endif
+
     return ESP_OK;
 };
 
@@ -388,8 +404,6 @@ void hard_restart() {
 
 void task_reboot(void *pvParameter)
 {
-
-
     while(1)
     {
         vTaskDelay(5000 / portTICK_PERIOD_MS);
@@ -401,14 +415,23 @@ void task_reboot(void *pvParameter)
 }
 
 void doReboot(){
-    LogFile.WriteToFile("Reboot - now");
-    KillTFliteTasks();
+    ESP_LOGI(TAGPARTOTA, "Reboot in 5sec");
+    LogFile.WriteToFile("Reboot in 5sec");
     xTaskCreate(&task_reboot, "reboot", configMINIMAL_STACK_SIZE * 64, NULL, 10, NULL);
+    // KillTFliteTasks(); // kills itself 
+    gpio_handler_destroy();
+    vTaskDelay(5000 / portTICK_PERIOD_MS);
+    esp_restart();
+    hard_restart();
 }
 
 
 esp_err_t handler_reboot(httpd_req_t *req)
 {
+#ifdef DEBUG_DETAIL_ON     
+    LogFile.WriteHeapInfo("handler_reboot - Start");
+#endif    
+
     LogFile.WriteToFile("handler_reboot");
     ESP_LOGI(TAGPARTOTA, "!!! System will restart within 5 sec!!!");
     const char* resp_str = "!!! System will restart within 5 sec!!!";
@@ -416,6 +439,10 @@ esp_err_t handler_reboot(httpd_req_t *req)
     
     doReboot();
 
+#ifdef DEBUG_DETAIL_ON 
+    LogFile.WriteHeapInfo("handler_reboot - Done");    
+#endif
+
     return ESP_OK;
 }
 

code/components/jomjol_fileserver_ota/server_ota.h

@@ -4,8 +4,8 @@
 
 //#include "ClassControllCamera.h"
 
-static const char *TAGPARTOTA = "server_ota";
-
 void register_server_ota_sdcard_uri(httpd_handle_t server);
 void CheckOTAUpdate();
-void doReboot();
+void doReboot();
+void hard_restart();
+

code/components/jomjol_flowcontroll/CMakeLists.txt

@@ -0,0 +1,7 @@
+FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)
+
+idf_component_register(SRCS ${app_sources}
+                    INCLUDE_DIRS "."
+                    REQUIRES jomjol_tfliteclass jomjol_helper jomjol_controlcamera jomjol_mqtt jomjol_fileserver_ota jomjol_image_proc jomjol_wlan)
+
+

code/components/jomjol_flowcontroll/ClassFlow.cpp

@@ -9,12 +9,17 @@
 void ClassFlow::SetInitialParameter(void)
 {
 	ListFlowControll = NULL;
+	previousElement = NULL;	
+	disabled = false;
 }
 
-std::vector<string> ClassFlow::ZerlegeZeile(std::string input)
+
+
+
+std::vector<string> ClassFlow::ZerlegeZeile(std::string input, std::string delimiter)
 {
 	std::vector<string> Output;
-	std::string delimiter = " =,";
+//	std::string delimiter = " =,";
 
 	input = trim(input, delimiter);
 	size_t pos = findDelimiterPos(input, delimiter);
@@ -35,16 +40,18 @@ std::vector<string> ClassFlow::ZerlegeZeile(std::string input)
 
 bool ClassFlow::isNewParagraph(string input)
 {
-	if (input[0] == '[')
+	if ((input[0] == '[') || ((input[0] == ';') && (input[1] == '[')))
+	{
 		return true;
+	}
 	return false;
 }
 
 bool ClassFlow::GetNextParagraph(FILE* pfile, string& aktparamgraph)
 {
-	while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph));
+	while (getNextLine(pfile, &aktparamgraph) && !isNewParagraph(aktparamgraph));
 
-	if (this->isNewParagraph(aktparamgraph))
+	if (isNewParagraph(aktparamgraph))
 		return true;
 	return false;
 }
@@ -53,7 +60,6 @@ bool ClassFlow::GetNextParagraph(FILE* pfile, string& aktparamgraph)
 ClassFlow::ClassFlow(void)
 {
 	SetInitialParameter();
-	ListFlowControll = NULL;
 }
 
 ClassFlow::ClassFlow(std::vector<ClassFlow*> * lfc)
@@ -62,6 +68,13 @@ ClassFlow::ClassFlow(std::vector<ClassFlow*> * lfc)
 	ListFlowControll = lfc;
 }
 
+ClassFlow::ClassFlow(std::vector<ClassFlow*> * lfc, ClassFlow *_prev)
+{
+	SetInitialParameter();	
+	ListFlowControll = lfc;
+	previousElement = _prev;
+}	
+
 bool ClassFlow::ReadParameter(FILE* pfile, string &aktparamgraph)
 {
 	return false;
@@ -81,6 +94,23 @@ string ClassFlow::getReadout()
 	return string();
 }
 
+std::string ClassFlow::GetParameterName(std::string _input)
+{
+    string _param;
+    int _pospunkt = _input.find_first_of(".");
+    if (_pospunkt > -1)
+    {
+        _param = _input.substr(_pospunkt+1, _input.length() - _pospunkt - 1);
+    }
+    else
+    {
+        _param = _input;
+    }
+//    printf("Parameter: %s, Pospunkt: %d\n", _param.c_str(), _pospunkt);
+	return _param;
+}
+
+
 bool ClassFlow::getNextLine(FILE* pfile, string *rt)
 {
 	char zw[1024];
@@ -89,24 +119,23 @@ bool ClassFlow::getNextLine(FILE* pfile, string *rt)
 		*rt = "";
 		return false;
 	}
-	fgets(zw, 1024, pfile);
-	printf("%s", zw);
-	if ((strlen(zw) == 0) && feof(pfile))
+	if (!fgets(zw, 1024, pfile))
 	{
 		*rt = "";
+		printf("END OF FILE\n");
 		return false;
 	}
+	printf("%s", zw);
 	*rt = zw;
 	*rt = trim(*rt);
-	while (zw[0] == '#' || (rt->size() == 0))			// Kommentarzeilen und Leerzeilen überspringen
+	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))			// Kommentarzeilen (; oder #) und Leerzeilen überspringen, es sei denn es ist ein neuer auskommentierter Paragraph
 	{
-		fgets(zw, 1024, pfile);
-		printf("%s", zw);		
-		if (feof(pfile))
+		if (!fgets(zw, 1024, pfile))
 		{
 			*rt = "";
 			return false;
 		}
+		printf("%s", zw);		
 		*rt = zw;
 		*rt = trim(*rt);
 	}

code/components/jomjol_flowcontroll/ClassFlow.h

@@ -5,32 +5,47 @@
 #include <vector>
 
 #include "Helper.h"
-#include "CFindTemplate.h"
+#include "CImageBasis.h"
 
 using namespace std;
 
+#define LOGFILE_TIME_FORMAT "%Y%m%d-%H%M%S"
+#define LOGFILE_TIME_FORMAT_DATE_EXTR substr(0, 8)
+#define LOGFILE_TIME_FORMAT_HOUR_EXTR substr(9, 2)
+
 struct HTMLInfo
 {
 	float val;
+	CImageBasis *image = NULL;
+	CImageBasis *image_org = NULL;
 	std::string filename;
+	std::string filename_org;	
 };
 
 
 class ClassFlow
 {
 protected:
-	std::vector<string> ZerlegeZeile(string input);
+//	std::vector<string> ZerlegeZeile(string input);
+	std::vector<string> ZerlegeZeile(string input, string delimiter = " =, \t");
 	bool isNewParagraph(string input);
 	bool GetNextParagraph(FILE* pfile, string& aktparamgraph);
 	bool getNextLine(FILE* pfile, string* rt);
 
 	std::vector<ClassFlow*>* ListFlowControll;
+	ClassFlow *previousElement;
 
 	virtual void SetInitialParameter(void);
 
+	std::string GetParameterName(std::string _input);
+
+	bool disabled;
+
 public:
 	ClassFlow(void);
 	ClassFlow(std::vector<ClassFlow*> * lfc);
+	ClassFlow(std::vector<ClassFlow*> * lfc, ClassFlow *_prev);	
+	
 	virtual bool ReadParameter(FILE* pfile, string &aktparamgraph);
 	virtual bool doFlow(string time);
 	virtual string getHTMLSingleStep(string host);

code/components/jomjol_flowcontroll/ClassFlowAlignment.cpp

@@ -0,0 +1,341 @@
+#include "ClassFlowAlignment.h"
+#include "ClassFlowMakeImage.h"
+#include "ClassFlow.h"
+
+#include "CRotateImage.h"
+
+
+#include "ClassLogFile.h"
+
+
+
+bool AlignmentExtendedDebugging = true;
+
+// #define DEBUG_DETAIL_ON  
+
+
+void ClassFlowAlignment::SetInitialParameter(void)
+{
+    initalrotate = 0;
+    anz_ref = 0;
+    initialmirror = false;
+    initialflip = false;
+    SaveAllFiles = false;
+    namerawimage =  "/sdcard/img_tmp/raw.jpg";
+    FileStoreRefAlignment = "/sdcard/config/align.txt";
+    ListFlowControll = NULL;
+    AlignAndCutImage = NULL;
+    ImageBasis = NULL;
+    ImageTMP = NULL;
+    previousElement = NULL;
+    disabled = false;
+    SAD_criteria = 0.05;
+}
+
+ClassFlowAlignment::ClassFlowAlignment(std::vector<ClassFlow*>* lfc)
+{
+    SetInitialParameter();
+    ListFlowControll = lfc;
+
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowMakeImage") == 0)
+        {
+            ImageBasis = ((ClassFlowMakeImage*) (*ListFlowControll)[i])->rawImage;
+        }
+    }
+
+    if (!ImageBasis)            // die Funktion Bilder aufnehmen existiert nicht --> muss erst erzeugt werden NUR ZU TESTZWECKEN
+    {
+        if (AlignmentExtendedDebugging) printf("CImageBasis musste erzeugt werden\n");
+        ImageBasis = new CImageBasis(namerawimage);
+    }
+}
+
+
+bool ClassFlowAlignment::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> zerlegt;
+    int suchex = 40;
+    int suchey = 40;
+    int alg_algo = 0;
+
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+    if (aktparamgraph.compare("[Alignment]") != 0)       // Paragraph passt nich zu MakeImage
+        return false;
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        zerlegt = ZerlegeZeile(aktparamgraph);
+        if ((toUpper(zerlegt[0]) == "FLIPIMAGESIZE") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                initialflip = true;
+        }
+        if ((toUpper(zerlegt[0]) == "INITIALMIRROR") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                initialmirror = true;
+        }
+        if (((toUpper(zerlegt[0]) == "INITALROTATE") || (toUpper(zerlegt[0]) == "INITIALROTATE")) && (zerlegt.size() > 1))
+        {
+            this->initalrotate = std::stod(zerlegt[1]);
+        }
+        if ((toUpper(zerlegt[0]) == "SEARCHFIELDX") && (zerlegt.size() > 1))
+        {
+            suchex = std::stod(zerlegt[1]);
+        }   
+        if ((toUpper(zerlegt[0]) == "SEARCHFIELDY") && (zerlegt.size() > 1))
+        {
+            suchey = std::stod(zerlegt[1]);
+        }               
+        if ((zerlegt.size() == 3) && (anz_ref < 2))
+        {
+            References[anz_ref].image_file = FormatFileName("/sdcard" + zerlegt[0]);
+            References[anz_ref].target_x = std::stod(zerlegt[1]);
+            References[anz_ref].target_y = std::stod(zerlegt[2]);
+            anz_ref++;
+        }
+
+        if ((toUpper(zerlegt[0]) == "SAVEALLFILES") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                SaveAllFiles = true;
+        }
+        if ((toUpper(zerlegt[0]) == "ALIGNMENTALGO") && (zerlegt.size() > 1))
+        {
+#ifdef DEBUG_DETAIL_ON
+            std::string zw2 = "Alignmentmodus gewählt: " + zerlegt[1];
+            LogFile.WriteToFile(zw2);
+#endif
+            if (toUpper(zerlegt[1]) == "HIGHACCURACY")
+                alg_algo = 1;
+            if (toUpper(zerlegt[1]) == "FAST")
+                alg_algo = 2;
+        }
+    }
+
+    for (int i = 0; i < anz_ref; ++i)
+    {
+        References[i].search_x = suchex;
+        References[i].search_y = suchey;
+        References[i].fastalg_SAD_criteria = SAD_criteria;
+        References[i].alignment_algo = alg_algo;
+#ifdef DEBUG_DETAIL_ON
+        std::string zw2 = "Alignmentmodus geschrieben: " + std::to_string(alg_algo);
+        LogFile.WriteToFile(zw2);
+#endif
+    }
+
+    LoadReferenceAlignmentValues();
+    
+    return true;
+
+}
+
+string ClassFlowAlignment::getHTMLSingleStep(string host)
+{
+    string result;
+
+    result =          "<p>Rotated Image: </p> <p><img src=\"" + host + "/img_tmp/rot.jpg\"></p>\n";
+    result = result + "<p>Found Alignment: </p> <p><img src=\"" + host + "/img_tmp/rot_roi.jpg\"></p>\n";
+    result = result + "<p>Aligned Image: </p> <p><img src=\"" + host + "/img_tmp/alg.jpg\"></p>\n";
+    return result;
+}
+
+
+bool ClassFlowAlignment::doFlow(string time) 
+{
+    if (!ImageTMP) 
+        ImageTMP = new CImageBasis(ImageBasis, 5);
+
+    if (AlignAndCutImage)
+        delete AlignAndCutImage;
+    AlignAndCutImage = new CAlignAndCutImage(ImageBasis, ImageTMP);   
+
+    CRotateImage rt(AlignAndCutImage, ImageTMP, initialflip);
+    if (initialflip)
+    {
+        int _zw = ImageBasis->height;
+        ImageBasis->height = ImageBasis->width;
+        ImageBasis->width = _zw;
+    }
+
+    if (initialmirror){
+        printf("do mirror\n");
+        rt.Mirror();
+        if (SaveAllFiles) AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/mirror.jpg"));
+    }
+ 
+    if ((initalrotate != 0) || initialflip)
+    {
+        rt.Rotate(initalrotate);
+        if (SaveAllFiles) AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/rot.jpg"));
+    }
+
+    if (!AlignAndCutImage->Align(&References[0], &References[1])) 
+    {
+        SaveReferenceAlignmentValues();
+    }
+
+    if (SaveAllFiles) AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/alg.jpg"));
+
+    if (SaveAllFiles)
+    {
+        if (initialflip)
+        {
+            int _zw = ImageTMP->width;
+            ImageTMP->width = ImageTMP->height;
+            ImageTMP->height = _zw;
+        }
+        DrawRef(ImageTMP);
+        ImageTMP->SaveToFile(FormatFileName("/sdcard/img_tmp/alg_roi.jpg"));
+    }
+
+    if (ImageTMP)       // nuss gelöscht werden, um Speicherplatz für das Laden von tflite zu haben
+    {
+        delete ImageTMP;
+        ImageTMP = NULL;
+    }  
+
+    LoadReferenceAlignmentValues();
+
+    return true;
+}
+
+
+
+void ClassFlowAlignment::SaveReferenceAlignmentValues()
+{
+    FILE* pFile;
+    std::string zwtime, zwvalue;
+
+    pFile = fopen(FileStoreRefAlignment.c_str(), "w");
+
+    if (strlen(zwtime.c_str()) == 0)
+    {
+        time_t rawtime;
+        struct tm* timeinfo;
+        char buffer[80];
+
+        time(&rawtime);
+        timeinfo = localtime(&rawtime);
+
+        strftime(buffer, 80, "%Y-%m-%dT%H:%M:%S", timeinfo);
+        zwtime = std::string(buffer);
+    }
+
+    fputs(zwtime.c_str(), pFile);
+    fputs("\n", pFile);
+
+    zwvalue = std::to_string(References[0].fastalg_x) + "\t" + std::to_string(References[0].fastalg_y);
+    zwvalue = zwvalue + "\t" +std::to_string(References[0].fastalg_SAD)+ "\t" +std::to_string(References[0].fastalg_min); 
+    zwvalue = zwvalue + "\t" +std::to_string(References[0].fastalg_max)+ "\t" +std::to_string(References[0].fastalg_avg); 
+    fputs(zwvalue.c_str(), pFile);
+    fputs("\n", pFile);
+
+    zwvalue = std::to_string(References[1].fastalg_x) + "\t" + std::to_string(References[1].fastalg_y);
+    zwvalue = zwvalue + "\t" +std::to_string(References[1].fastalg_SAD)+ "\t" +std::to_string(References[1].fastalg_min); 
+    zwvalue = zwvalue + "\t" +std::to_string(References[1].fastalg_max)+ "\t" +std::to_string(References[1].fastalg_avg); 
+    fputs(zwvalue.c_str(), pFile);
+    fputs("\n", pFile);
+
+    fclose(pFile);
+}
+
+
+
+
+
+bool ClassFlowAlignment::LoadReferenceAlignmentValues(void)
+{
+    FILE* pFile;
+    char zw[1024];
+    string zwvalue;
+    std::vector<string> zerlegt;  
+
+
+//    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", "LoadReferenceAlignmentValues01");      
+
+    pFile = fopen(FileStoreRefAlignment.c_str(), "r");
+    if (pFile == NULL)
+        return false;
+
+//    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", "LoadReferenceAlignmentValues01");      
+
+    fgets(zw, 1024, pFile);
+    printf("%s", zw);
+
+//    zwvalue = "LoadReferenceAlignmentValues Time: " + std::string(zw);
+
+//    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", zwvalue);      
+
+//    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", "LoadReferenceAlignmentValues02");      
+
+    fgets(zw, 1024, pFile);
+    zerlegt = ZerlegeZeile(std::string(zw), " \t");
+    if (zerlegt.size() < 6)
+    {
+//        LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", "Exit 01");      
+        fclose(pFile);
+        return false;
+    }
+
+//    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", "LoadReferenceAlignmentValues03");      
+
+    References[0].fastalg_x = stoi(zerlegt[0]);
+    References[0].fastalg_y = stoi(zerlegt[1]);
+    References[0].fastalg_SAD = stof(zerlegt[2]);
+    References[0].fastalg_min = stoi(zerlegt[3]);
+    References[0].fastalg_max = stoi(zerlegt[4]);
+    References[0].fastalg_avg = stof(zerlegt[5]);
+
+    fgets(zw, 1024, pFile);
+    zerlegt = ZerlegeZeile(std::string(zw));
+    if (zerlegt.size() < 6)
+    {
+//        LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", "Exit 02");      
+        fclose(pFile);
+        return false;
+    }
+
+//    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", "LoadReferenceAlignmentValues03");      
+
+    References[1].fastalg_x = stoi(zerlegt[0]);
+    References[1].fastalg_y = stoi(zerlegt[1]);
+    References[1].fastalg_SAD = stof(zerlegt[2]);
+    References[1].fastalg_min = stoi(zerlegt[3]);
+    References[1].fastalg_max = stoi(zerlegt[4]);
+    References[1].fastalg_avg = stof(zerlegt[5]);
+
+    fclose(pFile);
+
+
+#ifdef DEBUG_DETAIL_ON  
+    std::string _zw = "\tLoadReferences[0]\tx,y:\t" + std::to_string(References[0].fastalg_x) + "\t" + std::to_string(References[0].fastalg_x);
+    _zw = _zw + "\tSAD, min, max, avg:\t" + std::to_string(References[0].fastalg_SAD) + "\t" + std::to_string(References[0].fastalg_min);
+    _zw = _zw + "\t" + std::to_string(References[0].fastalg_max) + "\t" + std::to_string(References[0].fastalg_avg);
+    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", _zw);
+    _zw = "\tLoadReferences[1]\tx,y:\t" + std::to_string(References[1].fastalg_x) + "\t" + std::to_string(References[1].fastalg_x);
+    _zw = _zw + "\tSAD, min, max, avg:\t" + std::to_string(References[1].fastalg_SAD) + "\t" + std::to_string(References[1].fastalg_min);
+    _zw = _zw + "\t" + std::to_string(References[1].fastalg_max) + "\t" + std::to_string(References[1].fastalg_avg);
+    LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", _zw);
+#endif
+
+    return true;
+}
+
+
+
+void ClassFlowAlignment::DrawRef(CImageBasis *_zw)
+{
+    _zw->drawRect(References[0].target_x, References[0].target_y, References[0].width, References[0].height, 255, 0, 0, 2);
+    _zw->drawRect(References[1].target_x, References[1].target_y, References[1].width, References[1].height, 255, 0, 0, 2);
+}
+

code/components/jomjol_flowcontroll/ClassFlowAlignment.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "ClassFlow.h"
+#include "Helper.h"
+#include "CAlignAndCutImage.h"
+#include "CFindTemplate.h"
+
+#include <string>
+
+using namespace std;
+
+class ClassFlowAlignment :
+    public ClassFlow
+{
+protected:
+    float initalrotate;
+    bool initialmirror;
+    bool initialflip;
+    RefInfo References[2];
+    int anz_ref;
+    string namerawimage;
+    bool SaveAllFiles;
+    CAlignAndCutImage *AlignAndCutImage;
+    std::string FileStoreRefAlignment;
+    float SAD_criteria;
+
+    void SetInitialParameter(void);
+    bool LoadReferenceAlignmentValues(void);
+    void SaveReferenceAlignmentValues();
+
+public:
+    CImageBasis *ImageBasis, *ImageTMP;
+    
+    ClassFlowAlignment(std::vector<ClassFlow*>* lfc);
+
+    CAlignAndCutImage* GetAlignAndCutImage(){return AlignAndCutImage;};
+
+    void DrawRef(CImageBasis *_zw);
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string getHTMLSingleStep(string host);
+    string name(){return "ClassFlowAlignment";};
+};
+

code/components/jomjol_flowcontroll/ClassFlowAnalog.cpp

@@ -0,0 +1,487 @@
+#include "ClassFlowAnalog.h"
+
+#include <math.h>
+#include <iomanip> 
+#include <sys/types.h>
+#include <sstream>      // std::stringstream
+
+  
+// #define OHNETFLITE
+
+#ifndef OHNETFLITE
+#include "CTfLiteClass.h"
+#endif
+
+#include "ClassLogFile.h"
+
+static const char* TAG = "flow_analog";
+
+bool debugdetailanalog = false;
+
+void ClassFlowAnalog::SetInitialParameter(void)
+{
+    string cnnmodelfile = "";
+    modelxsize = 1;
+    modelysize = 1;
+    ListFlowControll = NULL;
+    previousElement = NULL;   
+    SaveAllFiles = false; 
+    disabled = false;
+    extendedResolution = false;
+}   
+
+ClassFlowAnalog::ClassFlowAnalog(std::vector<ClassFlow*>* lfc) : ClassFlowImage(lfc, TAG)
+{
+    SetInitialParameter();
+    ListFlowControll = lfc;
+
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowAlignment") == 0)
+        {
+            flowpostalignment = (ClassFlowAlignment*) (*ListFlowControll)[i];
+        }
+    }
+
+}
+
+
+int ClassFlowAnalog::AnzahlROIs(int _analog = 0)
+{
+    int zw = ANALOG[_analog]->ROI.size();
+    if (extendedResolution)
+        zw++;
+    
+    return zw;
+} 
+
+
+string ClassFlowAnalog::getReadout(int _analog = 0)
+{
+    string result = "";    
+    if (ANALOG[_analog]->ROI.size() == 0)
+        return result;
+
+
+    float zahl = ANALOG[_analog]->ROI[ANALOG[_analog]->ROI.size() - 1]->result;
+    int ergebnis_nachkomma = ((int) floor(zahl * 10)) % 10;
+
+    int prev = -1;
+
+    prev = ZeigerEval(ANALOG[_analog]->ROI[ANALOG[_analog]->ROI.size() - 1]->result, prev);
+    result = std::to_string(prev);
+
+    if (extendedResolution)
+        result = result + std::to_string(ergebnis_nachkomma);
+
+    for (int i = ANALOG[_analog]->ROI.size() - 2; i >= 0; --i)
+    {
+        prev = ZeigerEval(ANALOG[_analog]->ROI[i]->result, prev);
+        result = std::to_string(prev) + result;
+    }
+
+    return result;
+}
+
+int ClassFlowAnalog::ZeigerEval(float zahl, int ziffer_vorgaenger)
+{
+    int ergebnis_nachkomma = ((int) floor(zahl * 10)) % 10;
+    int ergebnis_vorkomma = ((int) floor(zahl)) % 10;
+    int ergebnis, ergebnis_rating;
+
+    if (ziffer_vorgaenger == -1)
+        return ergebnis_vorkomma % 10;
+
+    ergebnis_rating = ergebnis_nachkomma - ziffer_vorgaenger;
+    if (ergebnis_nachkomma >= 5)
+        ergebnis_rating-=5;
+    else
+        ergebnis_rating+=5;
+    ergebnis = (int) round(zahl);
+    if (ergebnis_rating < 0)
+        ergebnis-=1;
+    if (ergebnis == -1)
+        ergebnis+=10;
+
+    ergebnis = ergebnis % 10;
+    return ergebnis;
+}
+
+bool ClassFlowAnalog::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> zerlegt;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+
+    if ((aktparamgraph.compare("[Analog]") != 0) && (aktparamgraph.compare(";[Analog]") != 0))       // Paragraph passt nich zu MakeImage
+        return false;
+
+    if (aktparamgraph[0] == ';')
+    {
+        disabled = true;
+        while (getNextLine(pfile, &aktparamgraph) && !isNewParagraph(aktparamgraph));
+        printf("[Analog] is disabled !!!\n");
+        return true;
+    }
+
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        zerlegt = this->ZerlegeZeile(aktparamgraph);
+        if ((zerlegt[0] == "LogImageLocation") && (zerlegt.size() > 1))
+        {
+            this->LogImageLocation = "/sdcard" + zerlegt[1];
+            this->isLogImage = true;
+        }
+        if ((toUpper(zerlegt[0]) == "LOGFILERETENTIONINDAYS") && (zerlegt.size() > 1))
+        {
+            this->logfileRetentionInDays = std::stoi(zerlegt[1]);
+        }
+        if ((zerlegt[0] == "Model") && (zerlegt.size() > 1))
+        {
+            this->cnnmodelfile = zerlegt[1];
+        }
+        if ((zerlegt[0] == "ModelInputSize") && (zerlegt.size() > 2))
+        {
+            this->modelxsize = std::stoi(zerlegt[1]);
+            this->modelysize = std::stoi(zerlegt[2]);
+        }
+        if (zerlegt.size() >= 5)
+        {
+            analog* _analog = GetANALOG(zerlegt[0], true);
+            roianalog* neuroi = _analog->ROI[_analog->ROI.size()-1];
+            neuroi->posx = std::stoi(zerlegt[1]);
+            neuroi->posy = std::stoi(zerlegt[2]);
+            neuroi->deltax = std::stoi(zerlegt[3]);
+            neuroi->deltay = std::stoi(zerlegt[4]);
+            neuroi->result = -1;
+            neuroi->image = NULL;
+            neuroi->image_org = NULL;
+//            ROI.push_back(neuroi);
+        }
+
+        if ((toUpper(zerlegt[0]) == "SAVEALLFILES") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                SaveAllFiles = true;
+        }
+
+        if ((toUpper(zerlegt[0]) == "EXTENDEDRESOLUTION") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                extendedResolution = true;
+        }
+    }
+
+   for (int _ana = 0; _ana < ANALOG.size(); ++_ana)
+        for (int i = 0; i < ANALOG[_ana]->ROI.size(); ++i)
+        {
+            ANALOG[_ana]->ROI[i]->image = new CImageBasis(modelxsize, modelysize, 3);
+            ANALOG[_ana]->ROI[i]->image_org = new CImageBasis(ANALOG[_ana]->ROI[i]->deltax, ANALOG[_ana]->ROI[i]->deltay, 3);
+        }
+
+    return true;
+}
+
+analog* ClassFlowAnalog::FindANALOG(string _name_number)
+{
+
+    for (int i = 0; i < ANALOG.size(); ++i)
+    {
+        if (ANALOG[i]->name == _name_number)
+            return ANALOG[i];
+    }
+
+    return NULL;
+}
+
+
+
+analog* ClassFlowAnalog::GetANALOG(string _name, bool _create = true)
+{
+    string _analog, _roi;
+    int _pospunkt = _name.find_first_of(".");
+//    printf("Name: %s, Pospunkt: %d\n", _name.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+    {
+        _analog = _name.substr(0, _pospunkt);
+        _roi = _name.substr(_pospunkt+1, _name.length() - _pospunkt - 1);
+    }
+    else
+    {
+        _analog = "default";
+        _roi = _name;
+    }
+
+    analog *_ret = NULL;
+
+    for (int i = 0; i < ANALOG.size(); ++i)
+    {
+        if (ANALOG[i]->name == _analog)
+            _ret = ANALOG[i];
+    }
+
+    if (!_create)         // nicht gefunden und soll auch nicht erzeugt werden
+        return _ret;
+
+
+    if (_ret == NULL)
+    {
+        _ret = new analog;
+        _ret->name = _analog;
+        ANALOG.push_back(_ret);
+    }
+
+    roianalog* neuroi = new roianalog;
+    neuroi->name = _roi;
+    _ret->ROI.push_back(neuroi);
+
+    printf("GetANALOG - ANALOG %s - roi %s\n", _analog.c_str(), _roi.c_str());
+
+    return _ret;
+}
+
+
+
+string ClassFlowAnalog::getHTMLSingleStep(string host)
+{
+    string result, zw;
+    std::vector<HTMLInfo*> htmlinfo;
+
+    result = "<p>Found ROIs: </p> <p><img src=\"" + host + "/img_tmp/alg_roi.jpg\"></p>\n";
+    result = result + "Analog Pointers: <p> ";
+
+    htmlinfo = GetHTMLInfo();
+    for (int i = 0; i < htmlinfo.size(); ++i)
+    {
+        std::stringstream stream;
+        stream << std::fixed << std::setprecision(1) << htmlinfo[i]->val;
+        zw = stream.str();
+
+        result = result + "<img src=\"" + host + "/img_tmp/" +  htmlinfo[i]->filename + "\"> " + zw;
+        delete htmlinfo[i];
+    }
+    htmlinfo.clear();         
+
+    return result;
+}
+
+
+
+bool ClassFlowAnalog::doFlow(string time)
+{
+    if (disabled)
+      return true;
+
+    if (!doAlignAndCut(time)){
+        return false;
+    };
+
+    if (debugdetailanalog) LogFile.WriteToFile("ClassFlowAnalog::doFlow nach Alignment");
+
+    doNeuralNetwork(time);
+
+    RemoveOldLogs();
+
+    return true;
+}
+
+bool ClassFlowAnalog::doAlignAndCut(string time)
+{
+    if (disabled)
+        return true;
+
+    CAlignAndCutImage *caic = flowpostalignment->GetAlignAndCutImage();    
+
+    for (int _ana = 0; _ana < ANALOG.size(); ++_ana)
+        for (int i = 0; i < ANALOG[_ana]->ROI.size(); ++i)
+        {
+            printf("Analog %d - Align&Cut\n", i);
+            
+            caic->CutAndSave(ANALOG[_ana]->ROI[i]->posx, ANALOG[_ana]->ROI[i]->posy, ANALOG[_ana]->ROI[i]->deltax, ANALOG[_ana]->ROI[i]->deltay, ANALOG[_ana]->ROI[i]->image_org);
+            if (SaveAllFiles)
+            {
+                if (ANALOG[_ana]->name == "default")
+                    ANALOG[_ana]->ROI[i]->image_org->SaveToFile(FormatFileName("/sdcard/img_tmp/" + ANALOG[_ana]->ROI[i]->name + ".jpg"));
+                else
+                    ANALOG[_ana]->ROI[i]->image_org->SaveToFile(FormatFileName("/sdcard/img_tmp/" + ANALOG[_ana]->name + "_" + ANALOG[_ana]->ROI[i]->name + ".jpg"));
+            } 
+
+            ANALOG[_ana]->ROI[i]->image_org->Resize(modelxsize, modelysize, ANALOG[_ana]->ROI[i]->image);
+            if (SaveAllFiles)
+            {
+                if (ANALOG[_ana]->name == "default")
+                    ANALOG[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + ANALOG[_ana]->ROI[i]->name + ".bmp"));
+                else
+                    ANALOG[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + ANALOG[_ana]->name + "_" + ANALOG[_ana]->ROI[i]->name + ".bmp"));
+            } 
+        }
+
+    return true;
+} 
+
+void ClassFlowAnalog::DrawROI(CImageBasis *_zw)
+{
+    int r = 0;
+    int g = 255;
+    int b = 0;
+
+    for (int _ana = 0; _ana < ANALOG.size(); ++_ana)
+        for (int i = 0; i < ANALOG[_ana]->ROI.size(); ++i)
+        {
+            _zw->drawRect(ANALOG[_ana]->ROI[i]->posx, ANALOG[_ana]->ROI[i]->posy, ANALOG[_ana]->ROI[i]->deltax, ANALOG[_ana]->ROI[i]->deltay, r, g, b, 1);
+            _zw->drawCircle((int) (ANALOG[_ana]->ROI[i]->posx + ANALOG[_ana]->ROI[i]->deltax/2), (int)  (ANALOG[_ana]->ROI[i]->posy + ANALOG[_ana]->ROI[i]->deltay/2), (int) (ANALOG[_ana]->ROI[i]->deltax/2), r, g, b, 2);
+            _zw->drawLine((int) (ANALOG[_ana]->ROI[i]->posx + ANALOG[_ana]->ROI[i]->deltax/2), (int) ANALOG[_ana]->ROI[i]->posy, (int) (ANALOG[_ana]->ROI[i]->posx + ANALOG[_ana]->ROI[i]->deltax/2), (int) (ANALOG[_ana]->ROI[i]->posy + ANALOG[_ana]->ROI[i]->deltay), r, g, b, 2);
+            _zw->drawLine((int) ANALOG[_ana]->ROI[i]->posx, (int) (ANALOG[_ana]->ROI[i]->posy + ANALOG[_ana]->ROI[i]->deltay/2), (int) ANALOG[_ana]->ROI[i]->posx + ANALOG[_ana]->ROI[i]->deltax, (int) (ANALOG[_ana]->ROI[i]->posy + ANALOG[_ana]->ROI[i]->deltay/2), r, g, b, 2);
+        }
+} 
+
+bool ClassFlowAnalog::doNeuralNetwork(string time)
+{
+    if (disabled)
+        return true;
+
+    string logPath = CreateLogFolder(time);
+    
+    string input = "/sdcard/img_tmp/alg.jpg";
+    string ioresize = "/sdcard/img_tmp/resize.bmp";
+    string output;
+    input = FormatFileName(input);
+
+#ifndef OHNETFLITE
+    CTfLiteClass *tflite = new CTfLiteClass;  
+    string zwcnn = "/sdcard" + cnnmodelfile;
+    zwcnn = FormatFileName(zwcnn);
+    printf(zwcnn.c_str());printf("\n");
+    if (!tflite->LoadModel(zwcnn)) {
+        printf("Can't read model file /sdcard%s\n", cnnmodelfile.c_str());
+        delete tflite;
+        return false;
+    } 
+    tflite->MakeAllocate();
+#endif
+
+    for (int _ana = 0; _ana < ANALOG.size(); ++_ana)
+    {
+        for (int i = 0; i < ANALOG[_ana]->ROI.size(); ++i)
+        {
+            printf("Analog %d - TfLite\n", i);
+
+            float f1, f2;
+            f1 = 0; f2 = 0;
+
+    #ifndef OHNETFLITE
+            tflite->LoadInputImageBasis(ANALOG[_ana]->ROI[i]->image);        
+            tflite->Invoke();
+            if (debugdetailanalog) LogFile.WriteToFile("Nach Invoke");
+
+
+            f1 = tflite->GetOutputValue(0);
+            f2 = tflite->GetOutputValue(1);
+    #endif
+
+            float result = fmod(atan2(f1, f2) / (M_PI * 2) + 2, 1);
+    //        printf("Result sin, cos, ziffer: %f, %f, %f\n", f1, f2, result);  
+            ANALOG[_ana]->ROI[i]->result = result * 10;
+
+            printf("Result Analog%i: %f\n", i, ANALOG[_ana]->ROI[i]->result); 
+
+            if (isLogImage)
+            {
+                LogImage(logPath, ANALOG[_ana]->ROI[i]->name, &ANALOG[_ana]->ROI[i]->result, NULL, time, ANALOG[_ana]->ROI[i]->image_org);
+            }
+        }
+    }
+
+#ifndef OHNETFLITE
+        delete tflite;
+#endif    
+
+    return true;
+}
+
+
+std::vector<HTMLInfo*> ClassFlowAnalog::GetHTMLInfo()
+{
+    std::vector<HTMLInfo*> result;
+
+    for (int _ana = 0; _ana < ANALOG.size(); ++_ana)
+        for (int i = 0; i < ANALOG[_ana]->ROI.size(); ++i)
+        {
+                if (ANALOG[_ana]->name == "default")
+                    ANALOG[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + ANALOG[_ana]->ROI[i]->name + ".bmp"));
+                else
+                    ANALOG[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + ANALOG[_ana]->name + "_" + ANALOG[_ana]->ROI[i]->name + ".bmp"));
+
+
+            HTMLInfo *zw = new HTMLInfo;
+            if (ANALOG[_ana]->name == "default")
+            {
+                zw->filename = ANALOG[_ana]->ROI[i]->name + ".bmp";
+                zw->filename_org = ANALOG[_ana]->ROI[i]->name + ".jpg";
+            }
+            else
+            {
+                zw->filename = ANALOG[_ana]->name + "_" + ANALOG[_ana]->ROI[i]->name + ".bmp";
+                zw->filename_org = ANALOG[_ana]->name + "_" + ANALOG[_ana]->ROI[i]->name + ".jpg";
+            }
+
+            zw->val = ANALOG[_ana]->ROI[i]->result;
+            zw->image = ANALOG[_ana]->ROI[i]->image;
+            zw->image_org = ANALOG[_ana]->ROI[i]->image_org;
+
+            result.push_back(zw);
+        }
+
+    return result;
+}
+
+
+
+int ClassFlowAnalog::getAnzahlANALOG()
+{
+    return ANALOG.size();
+}
+
+string ClassFlowAnalog::getNameANALOG(int _analog)
+{
+    if (_analog < ANALOG.size())
+        return ANALOG[_analog]->name;
+
+    return "ANALOG DOES NOT EXIST";
+}
+
+analog* ClassFlowAnalog::GetANALOG(int _analog)
+{
+    if (_analog < ANALOG.size())
+        return ANALOG[_analog];
+
+    return NULL;
+}
+
+
+
+void ClassFlowAnalog::UpdateNameNumbers(std::vector<std::string> *_name_numbers)
+{
+    for (int _dig = 0; _dig < ANALOG.size(); _dig++)
+    {
+        std::string _name = ANALOG[_dig]->name;
+        bool found = false;
+        for (int i = 0; i < (*_name_numbers).size(); ++i)
+        {
+            if ((*_name_numbers)[i] == _name)
+                found = true;
+        }
+        if (!found)
+            (*_name_numbers).push_back(_name);
+    }
+}
+
+
+
+

code/components/jomjol_flowcontroll/ClassFlowAnalog.h

@@ -0,0 +1,65 @@
+#pragma once
+#include "ClassFlowImage.h"
+#include "ClassFlowAlignment.h"
+// #include "CTfLiteClass.h"
+
+struct roianalog {
+    int posx, posy, deltax, deltay;
+    float result;
+    CImageBasis *image, *image_org;
+    string name;
+};
+
+struct analog {
+    string name;
+    std::vector<roianalog*> ROI;
+};
+
+
+class ClassFlowAnalog :
+    public ClassFlowImage
+{
+protected:
+//    std::vector<roianalog*> ROI;
+    std::vector<analog*> ANALOG;
+
+    string cnnmodelfile;
+    int modelxsize, modelysize;
+    int ZeigerEval(float zahl, int ziffer_vorgaenger);
+    bool SaveAllFiles;    
+
+
+    ClassFlowAlignment* flowpostalignment;
+
+	void SetInitialParameter(void);   
+
+
+public:
+    bool extendedResolution;
+
+    ClassFlowAnalog(std::vector<ClassFlow*>* lfc);
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string getHTMLSingleStep(string host);
+    string getReadout(int _analog);   
+
+    void DrawROI(CImageBasis *_zw); 
+
+    bool doNeuralNetwork(string time); 
+    bool doAlignAndCut(string time);
+   	std::vector<HTMLInfo*> GetHTMLInfo();   
+    int AnzahlROIs(int _analog);
+
+    int getAnzahlANALOG();
+    analog* GetANALOG(int _analog);
+    analog* GetANALOG(string _name, bool _create);
+    analog* FindANALOG(string _name_number);    
+    string getNameANALOG(int _analog);     
+
+    void UpdateNameNumbers(std::vector<std::string> *_name_numbers);
+
+
+    string name(){return "ClassFlowAnalog";}; 
+};
+

code/components/jomjol_flowcontroll/ClassFlowControll.cpp

@@ -0,0 +1,564 @@
+#include "ClassFlowControll.h"
+
+#include "connect_wlan.h"
+#include "read_wlanini.h"
+
+#include "freertos/task.h"
+
+#include <sys/stat.h>
+#include <dirent.h>
+#include "ClassLogFile.h"
+#include "time_sntp.h"
+#include "Helper.h"
+#include "server_ota.h"
+
+#include "server_help.h"
+
+//#define DEBUG_DETAIL_ON  
+
+static const char* TAG = "flow_controll";
+
+
+std::string ClassFlowControll::doSingleStep(std::string _stepname, std::string _host){
+    std::string _classname = "";
+    std::string result = "";
+//    printf("_stepname: %s\n", _stepname.c_str());
+    if ((_stepname.compare("[MakeImage]") == 0) || (_stepname.compare(";[MakeImage]") == 0)){
+        _classname = "ClassFlowMakeImage";
+    }
+    if ((_stepname.compare("[Alignment]") == 0) || (_stepname.compare(";[Alignment]") == 0)){
+        _classname = "ClassFlowAlignment";
+    }
+    if ((_stepname.compare(0, 7, "[Digits") == 0) || (_stepname.compare(0, 8, ";[Digits") == 0)) {
+//    if ((_stepname.compare("[Digits]") == 0) || (_stepname.compare(";[Digits]") == 0)){
+//        printf("Digits!!!\n");
+        _classname = "ClassFlowDigit";
+    }
+    if ((_stepname.compare("[Analog]") == 0) || (_stepname.compare(";[Analog]") == 0)){
+        _classname = "ClassFlowAnalog";
+    }
+    if ((_stepname.compare("[MQTT]") == 0) || (_stepname.compare(";[MQTT]") == 0)){
+        _classname = "ClassFlowMQTT";
+    }
+
+    for (int i = 0; i < FlowControll.size(); ++i)
+        if (FlowControll[i]->name().compare(_classname) == 0){
+            if (!(FlowControll[i]->name().compare("ClassFlowMakeImage") == 0))      // falls es ein MakeImage ist, braucht das Bild nicht extra aufgenommen zu werden, dass passiert bei html-Abfrage automatisch
+                FlowControll[i]->doFlow("");
+            result = FlowControll[i]->getHTMLSingleStep(_host);
+        }
+
+    return result;
+}
+
+std::vector<HTMLInfo*> ClassFlowControll::GetAllDigital()
+{
+    for (int i = 0; i < FlowControll.size(); ++i)
+        if (FlowControll[i]->name().compare("ClassFlowDigit") == 0)
+            return ((ClassFlowDigit*) (FlowControll[i]))->GetHTMLInfo();
+
+    std::vector<HTMLInfo*> empty;
+    return empty;
+}
+
+std::vector<HTMLInfo*> ClassFlowControll::GetAllAnalog()
+{
+    for (int i = 0; i < FlowControll.size(); ++i)
+        if (FlowControll[i]->name().compare("ClassFlowAnalog") == 0)
+            return ((ClassFlowAnalog*) (FlowControll[i]))->GetHTMLInfo();
+
+    std::vector<HTMLInfo*> empty;
+    return empty;
+}
+
+
+void ClassFlowControll::SetInitialParameter(void)
+{
+    AutoStart = false;
+    SetupModeActive = false;
+    AutoIntervall = 10;
+    flowdigit = NULL;
+    flowanalog = NULL;
+    flowpostprocessing = NULL;
+    disabled = false;
+    aktRunNr = 0;
+    aktstatus = "Startup";
+
+}
+
+bool ClassFlowControll::isAutoStart(long &_intervall)
+{
+    _intervall = AutoIntervall * 60 * 1000; // AutoIntervall: Minuten -> ms
+    return AutoStart;
+}
+
+ClassFlow* ClassFlowControll::CreateClassFlow(std::string _type)
+{
+    ClassFlow* cfc = NULL;
+
+    _type = trim(_type);
+
+    if (toUpper(_type).compare("[MAKEIMAGE]") == 0)
+    {
+        cfc = new ClassFlowMakeImage(&FlowControll);
+        flowmakeimage = (ClassFlowMakeImage*) cfc;
+    }
+    if (toUpper(_type).compare("[ALIGNMENT]") == 0)
+    {
+        cfc = new ClassFlowAlignment(&FlowControll);
+        flowalignment = (ClassFlowAlignment*) cfc;
+    }
+    if (toUpper(_type).compare("[ANALOG]") == 0)
+    {
+        cfc = new ClassFlowAnalog(&FlowControll);
+        flowanalog = (ClassFlowAnalog*) cfc;
+    }
+    if (toUpper(_type).compare(0, 7, "[DIGITS") == 0)
+    {
+        cfc = new ClassFlowDigit(&FlowControll);
+        flowdigit = (ClassFlowDigit*) cfc;
+    }
+    if (toUpper(_type).compare("[MQTT]") == 0)
+        cfc = new ClassFlowMQTT(&FlowControll);
+        
+    if (toUpper(_type).compare("[POSTPROCESSING]") == 0)
+    {
+        cfc = new ClassFlowPostProcessing(&FlowControll); 
+        flowpostprocessing = (ClassFlowPostProcessing*) cfc;
+    }
+
+    if (cfc)                            // Wird nur angehangen, falls es nicht [AutoTimer] ist, denn dieses ist für FlowControll
+        FlowControll.push_back(cfc);
+
+    if (toUpper(_type).compare("[AUTOTIMER]") == 0)
+        cfc = this;    
+
+    if (toUpper(_type).compare("[DEBUG]") == 0)
+        cfc = this;  
+
+    if (toUpper(_type).compare("[SYSTEM]") == 0)
+        cfc = this;          
+
+    return cfc;
+}
+
+void ClassFlowControll::InitFlow(std::string config)
+{
+    string line;
+
+    flowpostprocessing = NULL;
+
+    ClassFlow* cfc;
+    FILE* pFile;
+    config = FormatFileName(config);
+    pFile = OpenFileAndWait(config.c_str(), "r");
+
+    line = "";
+
+    char zw[1024];
+    if (pFile != NULL)
+    {
+        fgets(zw, 1024, pFile);
+        printf("%s", zw);
+        line = std::string(zw);
+    }
+
+    while ((line.size() > 0) && !(feof(pFile)))
+    {
+        cfc = CreateClassFlow(line);
+        if (cfc)
+        {
+            printf("Start ReadParameter\n");
+            cfc->ReadParameter(pFile, line);
+        }
+        else
+        {
+            fgets(zw, 1024, pFile);
+            printf("%s", zw);
+            line = std::string(zw);
+        }
+    }
+
+    fclose(pFile);
+
+}
+
+std::string ClassFlowControll::getActStatus(){
+    return aktstatus;
+}
+
+void ClassFlowControll::doFlowMakeImageOnly(string time){
+    std::string zw_time;
+
+    for (int i = 0; i < FlowControll.size(); ++i)
+    {
+        if (FlowControll[i]->name() == "ClassFlowMakeImage") {
+            zw_time = gettimestring("%Y%m%d-%H%M%S");
+            aktstatus = zw_time + ": " + FlowControll[i]->name();
+            string zw = "FlowControll.doFlowMakeImageOnly - " + FlowControll[i]->name();
+            FlowControll[i]->doFlow(time);
+        }
+    }
+}
+
+bool ClassFlowControll::doFlow(string time)
+{
+//    CleanTempFolder();            // dazu muss man noch eine Rolling einführen
+
+    bool result = true;
+    std::string zw_time;
+    int repeat = 0;
+
+#ifdef DEBUG_DETAIL_ON 
+    LogFile.WriteHeapInfo("ClassFlowControll::doFlow - Start");
+#endif
+
+    for (int i = 0; i < FlowControll.size(); ++i)
+    {
+        zw_time = gettimestring("%Y%m%d-%H%M%S");
+        aktstatus = zw_time + ": " + FlowControll[i]->name();
+        
+       
+        string zw = "FlowControll.doFlow - " + FlowControll[i]->name();
+        LogFile.WriteHeapInfo(zw);
+
+        if (!FlowControll[i]->doFlow(time)){
+            repeat++;
+            LogFile.WriteToFile("Fehler im vorheriger Schritt - wird zum " + to_string(repeat) + ". Mal wiederholt");
+            i = -1;    // vorheriger Schritt muss wiederholt werden (vermutlich Bilder aufnehmen)
+            result = false;
+            if (repeat > 5) {
+                LogFile.WriteToFile("Wiederholung 5x nicht erfolgreich --> reboot");
+                doReboot();
+                // Schritt wurde 5x wiederholt --> reboot
+            }
+        }
+        else
+        {
+            result = true;
+        }
+        
+#ifdef DEBUG_DETAIL_ON  
+        LogFile.WriteHeapInfo("ClassFlowControll::doFlow");
+#endif
+
+    }
+    zw_time = gettimestring("%Y%m%d-%H%M%S");    
+    aktstatus = zw_time + ": Flow is done";
+    return result;
+}
+
+void ClassFlowControll::UpdateAktStatus(std::string _flow)
+{
+    aktstatus = gettimestring("%Y%m%d-%H%M%S");
+    aktstatus = aktstatus + "\t" + std::to_string(aktRunNr) + "\t";
+    
+    if (_flow == "ClassFlowMakeImage")
+        aktstatus = aktstatus + "Taking Raw Image";
+    else
+        if (_flow == "ClassFlowAlignment")
+            aktstatus = aktstatus + "Aligning Image";
+
+
+}
+
+
+string ClassFlowControll::getReadoutAll(int _type)
+{
+    std::vector<NumberPost*> numbers = flowpostprocessing->GetNumbers();
+    std::string out = "";
+
+    for (int i = 0; i < numbers.size(); ++i)
+    {
+        out = out + numbers[i]->name + "\t";
+        switch (_type) {
+            case READOUT_TYPE_VALUE:
+                out = out + numbers[i]->ReturnValue;
+                break;
+            case READOUT_TYPE_PREVALUE:
+                out = out + numbers[i]->ReturnPreValue;
+                break;
+            case READOUT_TYPE_RAWVALUE:
+                out = out + numbers[i]->ReturnRawValue;
+                break;
+            case READOUT_TYPE_ERROR:
+                out = out + numbers[i]->ErrorMessageText;
+                break;
+        }
+        if (i < numbers.size()-1)
+            out = out + "\r\n";
+    }
+
+//    printf("OUT: %s", out.c_str());
+
+    return out;
+}	
+
+
+string ClassFlowControll::getReadout(bool _rawvalue = false, bool _noerror = false)
+{
+    if (flowpostprocessing)
+        return flowpostprocessing->getReadoutParam(_rawvalue, _noerror);
+
+    string zw = "";
+    string result = "";
+
+    for (int i = 0; i < FlowControll.size(); ++i)
+    {
+        zw = FlowControll[i]->getReadout();
+        if (zw.length() > 0)
+        {
+            if (result.length() == 0)
+                result = zw;
+            else
+                result = result + "\t" + zw;
+        }
+    }
+
+    return result;
+}
+
+string ClassFlowControll::GetPrevalue(std::string _number)	
+{
+    if (flowpostprocessing)
+    {
+        return flowpostprocessing->GetPreValue(_number);   
+    }
+
+    return std::string();    
+}
+
+std::string ClassFlowControll::UpdatePrevalue(std::string _newvalue, std::string _numbers)
+{
+    float zw;
+    char* p;
+
+    _newvalue = trim(_newvalue);
+//    printf("Input UpdatePreValue: %s\n", _newvalue.c_str());
+
+    if (_newvalue.compare("0.0") == 0)
+    {
+        zw = 0;
+    }
+    else
+    {
+        zw = strtof(_newvalue.c_str(), &p);
+        if (zw == 0)
+            return "- Error in String to Value Conversion!!! Must be of format value=123.456";
+    }
+    
+
+    if (flowpostprocessing)
+    {
+        flowpostprocessing->SetPreValue(zw, _numbers);
+        return _newvalue;    
+    }
+
+    return std::string();
+}
+
+bool ClassFlowControll::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> zerlegt;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+
+    if ((toUpper(aktparamgraph).compare("[AUTOTIMER]") != 0) && (toUpper(aktparamgraph).compare("[DEBUG]") != 0) && (toUpper(aktparamgraph).compare("[SYSTEM]") != 0))      // Paragraph passt nicht zu MakeImage
+        return false;
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        zerlegt = this->ZerlegeZeile(aktparamgraph, " =");
+        if ((toUpper(zerlegt[0]) == "AUTOSTART") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+            {
+                AutoStart = true;
+            }
+        }
+        if ((toUpper(zerlegt[0]) == "INTERVALL") && (zerlegt.size() > 1))
+        {
+            AutoIntervall = std::stof(zerlegt[1]);
+        }
+        if ((toUpper(zerlegt[0]) == "LOGFILE") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+            {
+                LogFile.SwitchOnOff(true);
+            }
+            if (toUpper(zerlegt[1]) == "FALSE")
+            {
+                LogFile.SwitchOnOff(false);
+            }
+        }
+        if ((toUpper(zerlegt[0]) == "LOGFILERETENTIONINDAYS") && (zerlegt.size() > 1))
+        {
+            LogFile.SetRetention(std::stoi(zerlegt[1]));
+        }      
+
+        if ((toUpper(zerlegt[0]) == "TIMEZONE") && (zerlegt.size() > 1))
+        {
+            string zw = "Set TimeZone: " + zerlegt[1];
+            setTimeZone(zerlegt[1]);
+        }      
+
+        if ((toUpper(zerlegt[0]) == "TIMESERVER") && (zerlegt.size() > 1))
+        {
+            string zw = "Set TimeZone: " + zerlegt[1];
+            reset_servername(zerlegt[1]);
+        }  
+
+        if ((toUpper(zerlegt[0]) == "HOSTNAME") && (zerlegt.size() > 1))
+        {
+            if (ChangeHostName("/sdcard/wlan.ini", zerlegt[1]))
+            {
+                // reboot notwendig damit die neue wlan.ini auch benutzt wird !!!
+                fclose(pfile);
+                printf("do reboot\n");
+                esp_restart();
+                hard_restart();                   
+                doReboot();
+            }
+        }
+
+        if ((toUpper(zerlegt[0]) == "SETUPMODE") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+            {
+                SetupModeActive = true;
+            }        
+        }      
+
+        if ((toUpper(zerlegt[0]) == "LOGLEVEL") && (zerlegt.size() > 1))
+        {
+            LogFile.setLogLevel(stoi(zerlegt[1]));
+        }      
+    }
+    return true;
+}
+
+int ClassFlowControll::CleanTempFolder() {
+    const char* folderPath = "/sdcard/img_tmp";
+    
+    ESP_LOGI(TAG, "Clean up temporary folder to avoid damage of sdcard sectors : %s", folderPath);
+    DIR *dir = opendir(folderPath);
+    if (!dir) {
+        ESP_LOGE(TAG, "Failed to stat dir : %s", folderPath);
+        return -1;
+    }
+
+    struct dirent *entry;
+    int deleted = 0;
+    while ((entry = readdir(dir)) != NULL) {
+        std::string path = string(folderPath) + "/" + entry->d_name;
+		if (entry->d_type == DT_REG) {
+			if (unlink(path.c_str()) == 0) {
+				deleted ++;
+			} else {
+				ESP_LOGE(TAG, "can't delete file : %s", path.c_str());
+			}
+        } else if (entry->d_type == DT_DIR) {
+			deleted += removeFolder(path.c_str(), TAG);
+		}
+    }
+    closedir(dir);
+    ESP_LOGI(TAG, "%d files deleted", deleted);
+    
+    return 0;
+}
+
+
+esp_err_t ClassFlowControll::SendRawJPG(httpd_req_t *req)
+{
+    return flowmakeimage != NULL ? flowmakeimage->SendRawJPG(req) : ESP_FAIL;
+}
+
+
+esp_err_t ClassFlowControll::GetJPGStream(std::string _fn, httpd_req_t *req)
+{
+    printf("ClassFlowControll::GetJPGStream %s\n", _fn.c_str());
+
+    CImageBasis *_send = NULL;
+    esp_err_t result = ESP_FAIL;
+    bool Dodelete = false;    
+
+    if (flowalignment == NULL)
+    {
+        printf("Can't continue, flowalignment is NULL\n");
+        return ESP_FAIL;
+    }
+
+    if (_fn == "alg.jpg")
+    {
+        _send = flowalignment->ImageBasis;  
+    }
+
+
+
+    if (_fn == "alg_roi.jpg")
+    {
+        CImageBasis* _imgzw = new CImageBasis(flowalignment->ImageBasis);
+        flowalignment->DrawRef(_imgzw);
+        if (flowdigit) flowdigit->DrawROI(_imgzw);
+        if (flowanalog) flowanalog->DrawROI(_imgzw);
+        _send = _imgzw;
+        Dodelete = true;
+    }
+
+    std::vector<HTMLInfo*> htmlinfo;
+    htmlinfo = GetAllDigital();
+    for (int i = 0; i < htmlinfo.size(); ++i)
+    {
+        if (_fn == htmlinfo[i]->filename)
+        {
+            if (htmlinfo[i]->image)
+                _send = htmlinfo[i]->image;
+        }
+        if (_fn == htmlinfo[i]->filename_org)
+        {
+            if (htmlinfo[i]->image_org)
+                _send = htmlinfo[i]->image_org;        
+        }
+        delete htmlinfo[i];
+    }
+    htmlinfo.clear();
+
+    htmlinfo = GetAllAnalog();
+    for (int i = 0; i < htmlinfo.size(); ++i)
+    {
+        if (_fn == htmlinfo[i]->filename)
+        {
+            if (htmlinfo[i]->image)
+                _send = htmlinfo[i]->image;
+        }
+        if (_fn == htmlinfo[i]->filename_org)
+        {
+            if (htmlinfo[i]->image_org)
+                _send = htmlinfo[i]->image_org;        
+        }
+        delete htmlinfo[i];
+    }
+    htmlinfo.clear();
+
+    if (_send)
+    {
+        ESP_LOGI(TAG, "Sending file : %s ...", _fn.c_str());
+        set_content_type_from_file(req, _fn.c_str());
+        result = _send->SendJPGtoHTTP(req);
+        ESP_LOGI(TAG, "File sending complete");    
+        /* Respond with an empty chunk to signal HTTP response completion */
+        httpd_resp_send_chunk(req, NULL, 0);
+    }
+
+    if (Dodelete) 
+    {
+        delete _send;
+    }
+
+    return result;
+}

code/components/jomjol_flowcontroll/ClassFlowControll.h

@@ -8,6 +8,13 @@
 #include "ClassFlowDigit.h"
 #include "ClassFlowAnalog.h"
 #include "ClassFlowPostProcessing.h"
+#include "ClassFlowMQTT.h"
+
+
+#define READOUT_TYPE_VALUE 0
+#define READOUT_TYPE_PREVALUE 1
+#define READOUT_TYPE_RAWVALUE 2
+#define READOUT_TYPE_ERROR 3
 
 
 class ClassFlowControll :
@@ -16,22 +23,35 @@ class ClassFlowControll :
 protected:
 	std::vector<ClassFlow*> FlowControll;
 	ClassFlowPostProcessing* flowpostprocessing;
+	ClassFlowAlignment* flowalignment;	
+	ClassFlowAnalog* flowanalog;
+	ClassFlowDigit* flowdigit;
+	ClassFlowMakeImage* flowmakeimage;
 	ClassFlow* CreateClassFlow(std::string _type);
 
 	bool AutoStart;
 	float AutoIntervall;
+	bool SetupModeActive;
 	void SetInitialParameter(void);	
 	std::string aktstatus;
+	int aktRunNr;
 
+	void UpdateAktStatus(std::string _flow);
 
 public:
 	void InitFlow(std::string config);
 	bool doFlow(string time);
+	void doFlowMakeImageOnly(string time);
+	bool getStatusSetupModus(){return SetupModeActive;};
 	string getReadout(bool _rawvalue, bool _noerror);
-	string UpdatePrevalue(std::string _newvalue);
-	string GetPrevalue();	
+	string getReadoutAll(int _type);	
+	string UpdatePrevalue(std::string _newvalue, std::string _numbers);
+	string GetPrevalue(std::string _number = "");	
 	bool ReadParameter(FILE* pfile, string& aktparamgraph);	
 
+	esp_err_t GetJPGStream(std::string _fn, httpd_req_t *req);
+	esp_err_t SendRawJPG(httpd_req_t *req);
+
 	std::string doSingleStep(std::string _stepname, std::string _host);
 
 	bool isAutoStart(long &_intervall);
@@ -41,6 +61,9 @@ public:
 	std::vector<HTMLInfo*> GetAllDigital();
 	std::vector<HTMLInfo*> GetAllAnalog();	
 
+	int CleanTempFolder();
+
 	string name(){return "ClassFlowControll";};
 };
 
+

code/components/jomjol_flowcontroll/ClassFlowDigit.cpp

@@ -0,0 +1,420 @@
+#include "ClassFlowDigit.h"
+
+
+//#include "CFindTemplate.h"
+//#include "CTfLiteClass.h"
+
+// #define OHNETFLITE
+
+#ifndef OHNETFLITE
+#include "CTfLiteClass.h"
+#endif
+
+// #include "bitmap_image.hpp"
+
+#include "ClassLogFile.h"
+
+static const char* TAG = "flow_digital";
+
+
+void ClassFlowDigit::SetInitialParameter(void)
+{
+    string cnnmodelfile = "";
+    modelxsize = 1;
+    modelysize = 1;
+    ListFlowControll = NULL;
+    previousElement = NULL;    
+    SaveAllFiles = false;
+    disabled = false;
+    DecimalShift = 0;
+    DecimalShiftEnabled = false;
+}    
+
+ClassFlowDigit::ClassFlowDigit() : ClassFlowImage(TAG)
+{
+    SetInitialParameter();
+}
+
+ClassFlowDigit::ClassFlowDigit(std::vector<ClassFlow*>* lfc) : ClassFlowImage(lfc, TAG)
+{
+    SetInitialParameter();
+    ListFlowControll = lfc;
+
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowAlignment") == 0)
+        {
+            flowpostalignment = (ClassFlowAlignment*) (*ListFlowControll)[i];
+        }
+    }
+}
+
+ClassFlowDigit::ClassFlowDigit(std::vector<ClassFlow*>* lfc, ClassFlow *_prev) : ClassFlowImage(lfc, _prev, TAG)
+{
+    SetInitialParameter();
+    ListFlowControll = lfc;
+    previousElement = _prev;
+
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowAlignment") == 0)
+        {
+            flowpostalignment = (ClassFlowAlignment*) (*ListFlowControll)[i];
+        }
+    }    
+}
+
+string ClassFlowDigit::getReadout(int _digit = 0)
+{
+    string rst = "";
+
+    for (int i = 0; i < DIGIT[_digit]->ROI.size(); ++i)
+    {
+        if (DIGIT[_digit]->ROI[i]->resultklasse == 10)
+            rst = rst + "N";
+        else
+            rst = rst + std::to_string(DIGIT[_digit]->ROI[i]->resultklasse);
+    }
+
+    return rst;
+}
+
+bool ClassFlowDigit::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> zerlegt;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph)) 
+            return false;
+
+    printf("aktparamgraph: %s\n", aktparamgraph.c_str());
+
+    if ((aktparamgraph.compare(0, 7, "[Digits") != 0) && (aktparamgraph.compare(0, 8, ";[Digits") != 0))       // Paragraph passt nich zu MakeImage
+        return false;
+
+    int _pospkt = aktparamgraph.find_first_of(".");
+    int _posklammerzu = aktparamgraph.find_first_of("]");
+    if (_pospkt > -1)
+        NameDigit = aktparamgraph.substr(_pospkt+1, _posklammerzu - _pospkt-1);
+    else
+        NameDigit = "";
+    printf("Name Digit: %s\n", NameDigit.c_str());
+
+    if (aktparamgraph[0] == ';')
+    {
+        disabled = true;
+        while (getNextLine(pfile, &aktparamgraph) && !isNewParagraph(aktparamgraph));
+        printf("[Digits] is disabled !!!\n");
+        return true;
+    }
+
+
+    while (getNextLine(pfile, &aktparamgraph) && !isNewParagraph(aktparamgraph))
+    {
+        zerlegt = this->ZerlegeZeile(aktparamgraph);
+        if ((zerlegt[0] == "LogImageLocation") && (zerlegt.size() > 1))
+        {
+            LogImageLocation = "/sdcard" + zerlegt[1];
+            isLogImage = true;            
+        }
+        if ((zerlegt[0] == "Model") && (zerlegt.size() > 1))
+        {
+            cnnmodelfile = zerlegt[1];
+        }
+        if ((zerlegt[0] == "ModelInputSize") && (zerlegt.size() > 2))
+        {
+            modelxsize = std::stoi(zerlegt[1]);
+            modelysize = std::stoi(zerlegt[2]);
+        }
+        if (zerlegt.size() >= 5)
+        {
+            digit* _digit = GetDIGIT(zerlegt[0], true);
+            roi* neuroi = _digit->ROI[_digit->ROI.size()-1];
+            neuroi->posx = std::stoi(zerlegt[1]);
+            neuroi->posy = std::stoi(zerlegt[2]);
+            neuroi->deltax = std::stoi(zerlegt[3]);
+            neuroi->deltay = std::stoi(zerlegt[4]);
+            neuroi->resultklasse = -1;
+            neuroi->image = NULL;
+            neuroi->image_org = NULL;            
+        }
+
+        if ((toUpper(zerlegt[0]) == "SAVEALLFILES") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                SaveAllFiles = true;
+        }
+
+    }
+
+   for (int _dig = 0; _dig < DIGIT.size(); ++_dig)
+        for (int i = 0; i < DIGIT[_dig]->ROI.size(); ++i)
+        {
+            DIGIT[_dig]->ROI[i]->image = new CImageBasis(modelxsize, modelysize, 3);
+            DIGIT[_dig]->ROI[i]->image_org = new CImageBasis(DIGIT[_dig]->ROI[i]->deltax, DIGIT[_dig]->ROI[i]->deltay, 3);
+        }
+
+    return true;
+}
+
+digit* ClassFlowDigit::FindDIGIT(string _name_number)
+{
+    for (int i = 0; i < DIGIT.size(); ++i)
+    {
+        if (DIGIT[i]->name == _name_number)
+            return DIGIT[i];
+    }
+
+    return NULL;
+}
+
+
+digit* ClassFlowDigit::GetDIGIT(string _name, bool _create = true)
+{
+    string _digit, _roi;
+    int _pospunkt = _name.find_first_of(".");
+//    printf("Name: %s, Pospunkt: %d\n", _name.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+    {
+        _digit = _name.substr(0, _pospunkt);
+        _roi = _name.substr(_pospunkt+1, _name.length() - _pospunkt - 1);
+    }
+    else
+    {
+        _digit = "default";
+        _roi = _name;
+    }
+
+    digit *_ret = NULL;
+
+    for (int i = 0; i < DIGIT.size(); ++i)
+    {
+        if (DIGIT[i]->name == _digit)
+            _ret = DIGIT[i];
+    }
+
+    if (!_create)         // nicht gefunden und soll auch nicht erzeugt werden, ggf. geht eine NULL zurück
+        return _ret;
+
+    if (_ret == NULL)
+    {
+        _ret = new digit;
+        _ret->name = _digit;
+        DIGIT.push_back(_ret);
+    }
+
+    roi* neuroi = new roi;
+    neuroi->name = _roi;
+    _ret->ROI.push_back(neuroi);
+
+    printf("GetDIGIT - digit %s - roi %s\n", _digit.c_str(), _roi.c_str());
+
+    return _ret;
+}
+
+
+
+string ClassFlowDigit::getHTMLSingleStep(string host)
+{
+    string result, zw;
+    std::vector<HTMLInfo*> htmlinfo;
+
+    result = "<p>Found ROIs: </p> <p><img src=\"" + host + "/img_tmp/alg_roi.jpg\"></p>\n";
+    result = result + "Digital Counter: <p> ";
+
+    htmlinfo = GetHTMLInfo();
+    for (int i = 0; i < htmlinfo.size(); ++i)
+    {
+        if (htmlinfo[i]->val == 10)
+            zw = "NaN";
+        else
+        {
+            zw = to_string((int) htmlinfo[i]->val);
+        }
+        result = result + "<img src=\"" + host + "/img_tmp/" +  htmlinfo[i]->filename + "\"> " + zw;
+        delete htmlinfo[i];
+    }
+    htmlinfo.clear();    
+
+    return result;
+}
+
+
+bool ClassFlowDigit::doFlow(string time)
+{
+    if (disabled)
+        return true;
+        
+    if (!doAlignAndCut(time)){
+        return false;
+    };
+
+    doNeuralNetwork(time);
+
+    RemoveOldLogs();
+
+    return true;
+}
+
+bool ClassFlowDigit::doAlignAndCut(string time)
+{
+    if (disabled)
+        return true;
+
+    CAlignAndCutImage *caic = flowpostalignment->GetAlignAndCutImage();
+
+    for (int _dig = 0; _dig < DIGIT.size(); ++_dig)
+    {
+        printf("DIGIT[_dig]->ROI.size() %d\n", DIGIT[_dig]->ROI.size());
+        for (int i = 0; i < DIGIT[_dig]->ROI.size(); ++i)
+        {
+            printf("DigitalDigit %d - Align&Cut\n", i);
+            
+            caic->CutAndSave(DIGIT[_dig]->ROI[i]->posx, DIGIT[_dig]->ROI[i]->posy, DIGIT[_dig]->ROI[i]->deltax, DIGIT[_dig]->ROI[i]->deltay, DIGIT[_dig]->ROI[i]->image_org);
+            if (SaveAllFiles)
+            {
+                if (DIGIT[_dig]->name == "default")
+                    DIGIT[_dig]->ROI[i]->image_org->SaveToFile(FormatFileName("/sdcard/img_tmp/" + DIGIT[_dig]->ROI[i]->name + ".jpg"));
+                else
+                    DIGIT[_dig]->ROI[i]->image_org->SaveToFile(FormatFileName("/sdcard/img_tmp/" + DIGIT[_dig]->name + "_" + DIGIT[_dig]->ROI[i]->name + ".jpg"));
+            } 
+
+            DIGIT[_dig]->ROI[i]->image_org->Resize(modelxsize, modelysize, DIGIT[_dig]->ROI[i]->image);
+            if (SaveAllFiles)
+            {
+                if (DIGIT[_dig]->name == "default")
+                    DIGIT[_dig]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + DIGIT[_dig]->ROI[i]->name + ".bmp"));
+                else
+                    DIGIT[_dig]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + DIGIT[_dig]->name + "_" + DIGIT[_dig]->ROI[i]->name + ".bmp"));
+            } 
+        }
+    }
+    return true;
+} 
+
+bool ClassFlowDigit::doNeuralNetwork(string time)
+{
+    if (disabled)
+        return true;
+            
+    string logPath = CreateLogFolder(time);
+
+#ifndef OHNETFLITE
+    CTfLiteClass *tflite = new CTfLiteClass;  
+    string zwcnn =  FormatFileName("/sdcard" + cnnmodelfile);
+    printf(zwcnn.c_str());printf("\n");
+    if (!tflite->LoadModel(zwcnn)) {
+        printf("Can't read model file /sdcard%s\n", cnnmodelfile.c_str());
+        delete tflite;
+        return false;
+    } 
+
+    tflite->MakeAllocate();
+#endif
+
+    for (int _dig = 0; _dig < DIGIT.size(); ++_dig)
+        for (int i = 0; i < DIGIT[_dig]->ROI.size(); ++i)
+        {
+            printf("DigitalDigit %d - TfLite\n", i);
+
+            DIGIT[_dig]->ROI[i]->resultklasse = 0;
+    #ifndef OHNETFLITE
+            DIGIT[_dig]->ROI[i]->resultklasse = tflite->GetClassFromImageBasis(DIGIT[_dig]->ROI[i]->image);
+
+    #endif
+            printf("Result Digit%i: %d\n", i, DIGIT[_dig]->ROI[i]->resultklasse);
+
+            if (isLogImage)
+            {
+                LogImage(logPath, DIGIT[_dig]->ROI[i]->name, NULL, &DIGIT[_dig]->ROI[i]->resultklasse, time, DIGIT[_dig]->ROI[i]->image_org);
+            }
+        }
+#ifndef OHNETFLITE
+        delete tflite;
+#endif
+    return true;
+}
+
+void ClassFlowDigit::DrawROI(CImageBasis *_zw)
+{
+    for (int _dig = 0; _dig < DIGIT.size(); ++_dig)
+        for (int i = 0; i < DIGIT[_dig]->ROI.size(); ++i)
+            _zw->drawRect(DIGIT[_dig]->ROI[i]->posx, DIGIT[_dig]->ROI[i]->posy, DIGIT[_dig]->ROI[i]->deltax, DIGIT[_dig]->ROI[i]->deltay, 0, 0, (255 - _dig*100), 2);
+}     
+
+std::vector<HTMLInfo*> ClassFlowDigit::GetHTMLInfo()
+{
+    std::vector<HTMLInfo*> result;
+
+    for (int _dig = 0; _dig < DIGIT.size(); ++_dig)
+        for (int i = 0; i < DIGIT[_dig]->ROI.size(); ++i)
+        {
+                if (DIGIT[_dig]->name == "default")
+                    DIGIT[_dig]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + DIGIT[_dig]->ROI[i]->name + ".bmp"));
+                else
+                    DIGIT[_dig]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + DIGIT[_dig]->name + "_" + DIGIT[_dig]->ROI[i]->name + ".bmp"));
+
+
+            HTMLInfo *zw = new HTMLInfo;
+            if (DIGIT[_dig]->name == "default")
+            {
+                zw->filename = DIGIT[_dig]->ROI[i]->name + ".bmp";
+                zw->filename_org = DIGIT[_dig]->ROI[i]->name + ".jpg";
+            }
+            else
+            {
+                zw->filename = DIGIT[_dig]->name + "_" + DIGIT[_dig]->ROI[i]->name + ".bmp";
+                zw->filename_org = DIGIT[_dig]->name + "_" + DIGIT[_dig]->ROI[i]->name + ".jpg";
+            }
+
+            zw->val = DIGIT[_dig]->ROI[i]->resultklasse;
+            zw->image = DIGIT[_dig]->ROI[i]->image;
+            zw->image_org = DIGIT[_dig]->ROI[i]->image_org;
+            result.push_back(zw);
+        }
+
+    return result;
+}
+
+int ClassFlowDigit::getAnzahlDIGIT()
+{
+    return DIGIT.size();
+}
+
+string ClassFlowDigit::getNameDIGIT(int _digit)
+{
+    if (_digit < DIGIT.size())
+        return DIGIT[_digit]->name;
+
+    return "DIGIT DOES NOT EXIST";
+}
+
+digit* ClassFlowDigit::GetDIGIT(int _digit)
+{
+    if (_digit < DIGIT.size())
+        return DIGIT[_digit];
+
+    return NULL;
+}
+
+void ClassFlowDigit::UpdateNameNumbers(std::vector<std::string> *_name_numbers)
+{
+    for (int _dig = 0; _dig < DIGIT.size(); _dig++)
+    {
+        std::string _name = DIGIT[_dig]->name;
+        bool found = false;
+        for (int i = 0; i < (*_name_numbers).size(); ++i)
+        {
+            if ((*_name_numbers)[i] == _name)
+                found = true;
+        }
+        if (!found)
+            (*_name_numbers).push_back(_name);
+    }
+}
+
+
+
+

code/components/jomjol_flowcontroll/ClassFlowDigit.h

@@ -0,0 +1,68 @@
+#pragma once
+#include "ClassFlowImage.h"
+#include "ClassFlowAlignment.h"
+#include "Helper.h"
+
+#include <string>
+
+
+
+struct roi {
+    int posx, posy, deltax, deltay;
+    int resultklasse;
+    string name;
+    CImageBasis *image, *image_org;
+    roi* next;
+};
+
+struct digit {
+    string name;
+    std::vector<roi*> ROI;
+};
+
+class ClassFlowDigit :
+    public ClassFlowImage
+{
+protected:
+//    std::vector<roi*> ROI;
+    std::vector<digit*> DIGIT;
+    string cnnmodelfile;
+    int modelxsize, modelysize;
+    bool SaveAllFiles;
+    string NameDigit;
+    int DecimalShift;
+    bool DecimalShiftEnabled;
+
+
+    ClassFlowAlignment* flowpostalignment;
+ 
+    bool doNeuralNetwork(string time); 
+    bool doAlignAndCut(string time); 
+
+
+	void SetInitialParameter(void);    
+
+public:
+    ClassFlowDigit();
+    ClassFlowDigit(std::vector<ClassFlow*>* lfc);
+    ClassFlowDigit(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string getHTMLSingleStep(string host); 
+    string getReadout(int _digit);
+   	std::vector<HTMLInfo*> GetHTMLInfo();
+
+    int getAnzahlDIGIT();
+    digit* GetDIGIT(int _digit);
+    digit* GetDIGIT(string _name, bool _create);
+    digit* FindDIGIT(string _name_number);
+
+    string getNameDIGIT(int _digit);
+
+    void UpdateNameNumbers(std::vector<std::string> *_name_numbers);
+
+    void DrawROI(CImageBasis *_zw);        
+
+    string name(){return "ClassFlowDigit";};
+};
+

code/components/jomjol_flowcontroll/ClassFlowImage.cpp

@@ -0,0 +1,114 @@
+#include "ClassFlowImage.h"
+#include <string>
+#include <string.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include "time_sntp.h"
+#include "ClassLogFile.h"
+#include "CImageBasis.h"
+
+ClassFlowImage::ClassFlowImage(const char* logTag)
+{
+	this->logTag = logTag;
+	isLogImage = false;
+    disabled = false;
+
+}
+
+ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, const char* logTag) : ClassFlow(lfc)
+{
+	this->logTag = logTag;
+	isLogImage = false;
+    disabled = false;
+}
+
+ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, ClassFlow *_prev, const char* logTag) :  ClassFlow(lfc, _prev)
+{
+	this->logTag = logTag;
+	isLogImage = false;
+    disabled = false;
+}
+
+
+string ClassFlowImage::CreateLogFolder(string time) {
+	if (!isLogImage)
+		return "";
+
+	string logPath = LogImageLocation + "/" + time.LOGFILE_TIME_FORMAT_DATE_EXTR + "/" + time.LOGFILE_TIME_FORMAT_HOUR_EXTR;
+    isLogImage = mkdir_r(logPath.c_str(), S_IRWXU) == 0;
+    if (!isLogImage) {
+        ESP_LOGW(logTag, "Can't create log foolder for analog images. Path %s", logPath.c_str());
+        LogFile.WriteToFile("Can't create log foolder for analog images. Path " + logPath);
+    }
+
+	return logPath;
+}
+
+void ClassFlowImage::LogImage(string logPath, string name, float *resultFloat, int *resultInt, string time, CImageBasis *_img) {
+	if (!isLogImage)
+		return;
+	
+	char buf[10];
+	if (resultFloat != NULL) {
+		sprintf(buf, "%.1f_", *resultFloat);
+	} else if (resultInt != NULL) {
+		sprintf(buf, "%d_", *resultInt);
+	} else {
+		buf[0] = '\0';
+	}
+
+	string nm = logPath + "/" + buf + name + "_" + time + ".jpg";
+	nm = FormatFileName(nm);
+	string output = "/sdcard/img_tmp/" + name + ".jpg";
+	output = FormatFileName(output);
+	printf("save to file: %s\n", nm.c_str());
+	_img->SaveToFile(nm);
+//	CopyFile(output, nm);
+}
+
+void ClassFlowImage::RemoveOldLogs()
+{
+	if (!isLogImage)
+		return;
+	
+	ESP_LOGI(logTag, "remove old log images");
+    if (logfileRetentionInDays == 0) {
+        return;
+    }
+
+    time_t rawtime;
+    struct tm* timeinfo;
+    char cmpfilename[30];
+
+    time(&rawtime);
+    rawtime = addDays(rawtime, -logfileRetentionInDays);
+    timeinfo = localtime(&rawtime);
+    
+    strftime(cmpfilename, 30, LOGFILE_TIME_FORMAT, timeinfo);
+    //ESP_LOGE(TAG, "log file name to compare: %s", cmpfilename);
+	string folderName = string(cmpfilename).LOGFILE_TIME_FORMAT_DATE_EXTR;
+
+    DIR *dir = opendir(LogImageLocation.c_str());
+    if (!dir) {
+        ESP_LOGI(logTag, "Failed to stat dir : %s", LogImageLocation.c_str());
+        return;
+    }
+
+    struct dirent *entry;
+    int deleted = 0;
+    int notDeleted = 0;
+    while ((entry = readdir(dir)) != NULL) {
+        string folderPath = LogImageLocation + "/" + entry->d_name;
+		if (entry->d_type == DT_DIR) {
+			//ESP_LOGI(logTag, "Compare %s %s", entry->d_name, folderName.c_str());	
+			if ((strlen(entry->d_name) == folderName.length()) && (strcmp(entry->d_name, folderName.c_str()) < 0)) {
+                deleted += removeFolder(folderPath.c_str(), logTag);
+			} else {
+                notDeleted ++;
+            }
+		}
+    }
+    ESP_LOGI(logTag, "%d older log files deleted. %d current log files not deleted.", deleted, notDeleted);
+    closedir(dir);
+}
+

code/components/jomjol_flowcontroll/ClassFlowImage.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "ClassFlow.h"
+
+using namespace std;
+
+class ClassFlowImage : public ClassFlow
+{
+protected:
+	string LogImageLocation;
+    bool isLogImage;
+    unsigned short logfileRetentionInDays;
+	const char* logTag;
+
+	string CreateLogFolder(string time);
+	void LogImage(string logPath, string name, float *resultFloat, int *resultInt, string time, CImageBasis *_img);
+
+
+public:
+	ClassFlowImage(const char* logTag);
+	ClassFlowImage(std::vector<ClassFlow*> * lfc, const char* logTag);
+	ClassFlowImage(std::vector<ClassFlow*> * lfc, ClassFlow *_prev, const char* logTag);
+	
+	void RemoveOldLogs();
+};

code/components/jomjol_flowcontroll/ClassFlowMQTT.cpp

@@ -0,0 +1,207 @@
+#include <sstream>
+#include "ClassFlowMQTT.h"
+#include "Helper.h"
+
+#include "time_sntp.h"
+#include "interface_mqtt.h"
+#include "ClassFlowPostProcessing.h"
+
+#include <time.h>
+
+void ClassFlowMQTT::SetInitialParameter(void)
+{
+    uri = "";
+    topic = "";
+    topicError = "";
+    topicRate = "";
+    topicTimeStamp = "";
+    maintopic = "";
+    mainerrortopic = ""; 
+
+    topicUptime = "";
+    topicFreeMem = "";
+    clientname = "watermeter";
+    OldValue = "";
+    flowpostprocessing = NULL;  
+    user = "";
+    password = "";   
+    previousElement = NULL;
+    ListFlowControll = NULL; 
+    disabled = false;
+    MQTTenable = false;
+    
+    
+
+}       
+
+ClassFlowMQTT::ClassFlowMQTT()
+{
+    SetInitialParameter();
+}
+
+ClassFlowMQTT::ClassFlowMQTT(std::vector<ClassFlow*>* lfc)
+{
+    SetInitialParameter();
+
+    ListFlowControll = lfc;
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowPostProcessing") == 0)
+        {
+            flowpostprocessing = (ClassFlowPostProcessing*) (*ListFlowControll)[i];
+        }
+    }
+}
+
+ClassFlowMQTT::ClassFlowMQTT(std::vector<ClassFlow*>* lfc, ClassFlow *_prev)
+{
+    SetInitialParameter();
+
+    previousElement = _prev;
+    ListFlowControll = lfc;
+
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowPostProcessing") == 0)
+        {
+            flowpostprocessing = (ClassFlowPostProcessing*) (*ListFlowControll)[i];
+        }
+    }
+}
+
+
+bool ClassFlowMQTT::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> zerlegt;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+    if (toUpper(aktparamgraph).compare("[MQTT]") != 0)       // Paragraph passt nich zu MakeImage
+        return false;
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        zerlegt = this->ZerlegeZeile(aktparamgraph);
+        if ((toUpper(zerlegt[0]) == "USER") && (zerlegt.size() > 1))
+        {
+            this->user = zerlegt[1];
+        }  
+        if ((toUpper(zerlegt[0]) == "PASSWORD") && (zerlegt.size() > 1))
+        {
+            this->password = zerlegt[1];
+        }               
+        if ((toUpper(zerlegt[0]) == "URI") && (zerlegt.size() > 1))
+        {
+            this->uri = zerlegt[1];
+        }
+
+        if ((toUpper(zerlegt[0]) == "CLIENTID") && (zerlegt.size() > 1))
+        {
+            this->clientname = zerlegt[1];
+        }
+
+        if (((toUpper(zerlegt[0]) == "TOPIC") || (toUpper(zerlegt[0]) == "MAINTOPIC")) && (zerlegt.size() > 1))
+        {
+            maintopic = zerlegt[1];
+        }
+    }
+
+    if (!MQTTisConnected() && (uri.length() > 0) && (maintopic.length() > 0)) 
+    {
+        mainerrortopic = maintopic + "/connection";
+        MQTTInit(uri, clientname, user, password, mainerrortopic, 60); 
+        MQTTPublish(mainerrortopic, "connected");
+        MQTTenable = true;
+    }
+   
+    return true;
+}
+
+
+bool ClassFlowMQTT::doFlow(string zwtime)
+{
+    if (!MQTTenable)
+        return true;
+
+    std::string result;
+    std::string resulterror = "";
+    std::string resultrate = "";
+    std::string resulttimestamp = "";
+    string zw = "";
+    string namenumber = "";
+
+    MQTTPublish(mainerrortopic, "connected");
+    
+    zw = maintopic + "/" + "uptime";
+    char uptimeStr[11];
+    sprintf(uptimeStr, "%ld", (long)getUpTime());
+    MQTTPublish(zw, uptimeStr);
+
+    zw = maintopic + "/" + "freeMem";
+    char freeheapmem[11];
+    sprintf(freeheapmem, "%zu", esp_get_free_heap_size());
+    MQTTPublish(zw, freeheapmem);
+
+    if (flowpostprocessing)
+    {
+        std::vector<NumberPost*> NUMBERS = flowpostprocessing->GetNumbers();
+
+        for (int i = 0; i < NUMBERS.size(); ++i)
+        {
+            result =  NUMBERS[i]->ReturnValueNoError;
+            resulterror = NUMBERS[i]->ErrorMessageText;
+            resultrate = std::to_string(NUMBERS[i]->FlowRateAct);
+            resulttimestamp = NUMBERS[i]->timeStamp;
+
+            namenumber = NUMBERS[i]->name;
+            if (namenumber == "default")
+                namenumber = maintopic + "/";
+            else
+                namenumber = maintopic + "/" + namenumber + "/";
+
+            zw = namenumber + "value";    
+            MQTTPublish(zw, result);
+
+            zw = namenumber + "error";    
+            MQTTPublish(zw, resulterror, 1);
+
+            zw = namenumber + "rate";    
+            MQTTPublish(zw, resultrate);
+
+            zw = namenumber + "timestamp";
+            MQTTPublish(zw, resulttimestamp);
+
+
+            std::string json="{\"value\":"+result;
+            json += ",\"error\":\""+resulterror;
+            json += "\",\"rate\":"+resultrate;
+            json += ",\"timestamp\":\""+resulttimestamp+"\"}";
+
+            zw = namenumber + "json";
+            MQTTPublish(zw, json);
+        }
+    }
+    else
+    {
+        for (int i = 0; i < ListFlowControll->size(); ++i)
+        {
+            zw = (*ListFlowControll)[i]->getReadout();
+            if (zw.length() > 0)
+            {
+                if (result.length() == 0)
+                    result = zw;
+                else
+                    result = result + "\t" + zw;
+            }
+        }
+        MQTTPublish(topic, result);
+    }
+    
+    OldValue = result;
+    
+    return true;
+}

code/components/jomjol_flowcontroll/ClassFlowMQTT.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "ClassFlow.h"
+
+#include "ClassFlowPostProcessing.h"
+
+#include <string>
+
+class ClassFlowMQTT :
+    public ClassFlow
+{
+protected:
+    std::string uri, topic, topicError, clientname, topicRate, topicTimeStamp, topicUptime, topicFreeMem;
+    std::string OldValue;
+	ClassFlowPostProcessing* flowpostprocessing;  
+    std::string user, password; 
+    bool MQTTenable;
+
+    std::string maintopic, mainerrortopic; 
+	void SetInitialParameter(void);        
+
+public:
+    ClassFlowMQTT();
+    ClassFlowMQTT(std::vector<ClassFlow*>* lfc);
+    ClassFlowMQTT(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string name(){return "ClassFlowMQTT";};
+};
+

code/components/jomjol_flowcontroll/ClassFlowMakeImage.cpp

@@ -0,0 +1,215 @@
+#include "ClassFlowMakeImage.h"
+#include "Helper.h"
+#include "ClassLogFile.h"
+
+#include "CImageBasis.h"
+#include "ClassControllCamera.h"
+
+#include <time.h>
+
+// #define DEBUG_DETAIL_ON 
+
+static const char* TAG = "flow_make_image";
+
+esp_err_t ClassFlowMakeImage::camera_capture(){
+    string nm =  namerawimage;
+    Camera.CaptureToFile(nm);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    return ESP_OK;
+}
+
+void ClassFlowMakeImage::takePictureWithFlash(int flashdauer)
+{
+    // für den Fall, dass das Bild geflippt wird, muss es hier zurück gesetzt werden ////
+    rawImage->width = image_width;          
+    rawImage->height = image_height;
+    /////////////////////////////////////////////////////////////////////////////////////
+    printf("Flashdauer: %d\n", flashdauer);
+    Camera.CaptureToBasisImage(rawImage, flashdauer);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    if (SaveAllFiles) rawImage->SaveToFile(namerawimage);
+}
+
+void ClassFlowMakeImage::SetInitialParameter(void)
+{
+    waitbeforepicture = 5;
+    isImageSize = false;
+    ImageQuality = -1;    
+    TimeImageTaken = 0;
+    ImageQuality = 5;
+    rawImage = NULL;
+    ImageSize = FRAMESIZE_VGA;
+    SaveAllFiles = false;
+    disabled = false;
+    FixedExposure = false;
+    namerawimage =  "/sdcard/img_tmp/raw.jpg";
+}     
+
+
+ClassFlowMakeImage::ClassFlowMakeImage(std::vector<ClassFlow*>* lfc) : ClassFlowImage(lfc, TAG)
+{
+    SetInitialParameter();
+}
+
+bool ClassFlowMakeImage::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> zerlegt;
+
+    aktparamgraph = trim(aktparamgraph);
+    int _brightness = -100;
+    int _contrast = -100;
+    int _saturation = -100;
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+    if (aktparamgraph.compare("[MakeImage]") != 0)       // Paragraph passt nich zu MakeImage
+        return false;
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        zerlegt = this->ZerlegeZeile(aktparamgraph);
+        if ((zerlegt[0] ==  "LogImageLocation") && (zerlegt.size() > 1))
+        {
+            LogImageLocation = "/sdcard" + zerlegt[1];
+            isLogImage = true;
+        }
+        if ((zerlegt[0] == "ImageQuality") && (zerlegt.size() > 1))
+            ImageQuality = std::stod(zerlegt[1]);
+
+        if ((zerlegt[0] == "ImageSize") && (zerlegt.size() > 1))
+        {
+            ImageSize = Camera.TextToFramesize(zerlegt[1].c_str());
+            isImageSize = true;
+        }
+
+        if ((toUpper(zerlegt[0]) == "SAVEALLFILES") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                SaveAllFiles = true;
+        }
+        
+        if ((toUpper(zerlegt[0]) == "WAITBEFORETAKINGPICTURE") && (zerlegt.size() > 1))
+        {
+            waitbeforepicture = stoi(zerlegt[1]);
+        }
+
+
+        if ((toUpper(zerlegt[0]) == "BRIGHTNESS") && (zerlegt.size() > 1))
+        {
+            _brightness = stoi(zerlegt[1]);
+        }
+
+        if ((toUpper(zerlegt[0]) == "CONTRAST") && (zerlegt.size() > 1))
+        {
+            _contrast = stoi(zerlegt[1]);
+        }
+
+        if ((toUpper(zerlegt[0]) == "SATURATION") && (zerlegt.size() > 1))
+        {
+            _saturation = stoi(zerlegt[1]);
+        }
+
+        if ((toUpper(zerlegt[0]) == "FIXEDEXPOSURE") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                FixedExposure = true;
+        }
+    }
+
+    Camera.SetBrightnessContrastSaturation(_brightness, _contrast, _saturation);
+    Camera.SetQualitySize(ImageQuality, ImageSize);
+
+    image_width = Camera.image_width;
+    image_height = Camera.image_height;
+    rawImage = new CImageBasis();
+    rawImage->CreateEmptyImage(image_width, image_height, 3);
+
+    waitbeforepicture_store = waitbeforepicture;
+    if (FixedExposure && (waitbeforepicture > 0))
+    {
+//        printf("Fixed Exposure enabled!\n");
+        int flashdauer = (int) (waitbeforepicture * 1000);
+        Camera.EnableAutoExposure(flashdauer);
+        waitbeforepicture = 0.2;
+//        flashdauer = (int) (waitbeforepicture * 1000);
+//        takePictureWithFlash(flashdauer);
+//        rawImage->SaveToFile("/sdcard/init2.jpg");
+    }
+
+    return true;
+}
+
+string ClassFlowMakeImage::getHTMLSingleStep(string host)
+{
+    string result;
+    result = "Raw Image: <br>\n<img src=\"" + host + "/img_tmp/raw.jpg\">\n";
+    return result;
+}
+
+bool ClassFlowMakeImage::doFlow(string zwtime)
+{
+    string logPath = CreateLogFolder(zwtime);
+
+    int flashdauer = (int) (waitbeforepicture * 1000);
+ 
+ #ifdef DEBUG_DETAIL_ON  
+    LogFile.WriteHeapInfo("ClassFlowMakeImage::doFlow - Before takePictureWithFlash");
+#endif
+
+    takePictureWithFlash(flashdauer);
+
+#ifdef DEBUG_DETAIL_ON  
+    LogFile.WriteHeapInfo("ClassFlowMakeImage::doFlow - After takePictureWithFlash");
+#endif
+
+    LogImage(logPath, "raw", NULL, NULL, zwtime, rawImage);
+
+    RemoveOldLogs();
+
+#ifdef DEBUG_DETAIL_ON  
+    LogFile.WriteHeapInfo("ClassFlowMakeImage::doFlow - After RemoveOldLogs");
+#endif
+
+    return true;
+}
+
+esp_err_t ClassFlowMakeImage::SendRawJPG(httpd_req_t *req)
+{
+    int flashdauer = (int) (waitbeforepicture * 1000);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    return Camera.CaptureToHTTP(req, flashdauer);
+}
+
+
+ImageData* ClassFlowMakeImage::SendRawImage()
+{
+    CImageBasis *zw = new CImageBasis(rawImage);
+    ImageData *id;
+    int flashdauer = (int) (waitbeforepicture * 1000);
+    Camera.CaptureToBasisImage(zw, flashdauer);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    id = zw->writeToMemoryAsJPG();    
+    delete zw;
+    return id;  
+}
+
+time_t ClassFlowMakeImage::getTimeImageTaken()
+{
+    return TimeImageTaken;
+}
+
+ClassFlowMakeImage::~ClassFlowMakeImage(void)
+{
+    delete rawImage;
+}
+

code/components/jomjol_flowcontroll/ClassFlowMakeImage.h

@@ -1,11 +1,9 @@
 #pragma once
-#include "ClassFlow.h"
+#include "ClassFlowImage.h"
 #include "ClassControllCamera.h"
 
 #include <string>
 
-static const char* TAG2 = "example";
-
 #define BLINK_GPIO GPIO_NUM_4
 
 #define CAMERA_MODEL_AI_THINKER
@@ -13,30 +11,45 @@ static const char* TAG2 = "example";
 
 
 class ClassFlowMakeImage :
-    public ClassFlow
+    public ClassFlowImage
 {
 protected:
-    string LogImageLocation;
-    bool isLogImage;
     float waitbeforepicture;
+    float waitbeforepicture_store;
     framesize_t ImageSize;
     bool isImageSize;
     int ImageQuality;
     time_t TimeImageTaken;
     string namerawimage;
+    int image_height, image_width;
+    bool SaveAllFiles;
+    bool FixedExposure;
+
+
 
     void CopyFile(string input, string output);
 
     esp_err_t camera_capture();
-    void takePictureWithFlash(int flashdauer);   
+    void takePictureWithFlash(int flashdauer);
+
+
+    void SetInitialParameter(void);       
 
 public:
-    ClassFlowMakeImage();
+    CImageBasis *rawImage;
+
     ClassFlowMakeImage(std::vector<ClassFlow*>* lfc);
+
     bool ReadParameter(FILE* pfile, string& aktparamgraph);
     bool doFlow(string time);
     string getHTMLSingleStep(string host);
     time_t getTimeImageTaken();
     string name(){return "ClassFlowMakeImage";};
+
+    ImageData* SendRawImage();
+    esp_err_t SendRawJPG(httpd_req_t *req);
+
+    ~ClassFlowMakeImage(void);
 };
 
+

code/components/jomjol_flowcontroll/ClassFlowPostProcessing.cpp

@@ -0,0 +1,766 @@
+#include "ClassFlowPostProcessing.h"
+
+#include "Helper.h"
+#include "ClassFlowMakeImage.h"
+#include "ClassLogFile.h"
+
+#include <iomanip>
+#include <sstream>
+
+#include <time.h>
+
+#include "time_sntp.h"
+
+
+#define PREVALUE_TIME_FORMAT_OUTPUT "%Y-%m-%dT%H:%M:%S"
+#define PREVALUE_TIME_FORMAT_INPUT "%d-%d-%dT%d:%d:%d"
+
+
+string ClassFlowPostProcessing::GetPreValue(std::string _number)
+{
+    std::string result;
+    int index = -1;
+
+    if (_number == "")
+        _number = "default";
+
+    for (int i = 0; i < NUMBERS.size(); ++i)
+        if (NUMBERS[i]->name == _number)
+            index = i;
+
+//    result = RundeOutput(NUMBERS[index]->PreValue, -NUMBERS[index]->DecimalShift);
+    result = RundeOutput(NUMBERS[index]->PreValue, NUMBERS[index]->Nachkomma);
+
+//    if (NUMBERS[index]->digit_roi && NUMBERS[index]->analog_roi)
+//        result = RundeOutput(NUMBERS[index]->PreValue, NUMBERS[index]->AnzahlAnalog - NUMBERS[index]->DecimalShift);
+
+    return result;
+}
+
+void ClassFlowPostProcessing::SetPreValue(float zw, string _numbers)
+{
+    for (int j = 0; j < NUMBERS.size(); ++j)
+    {
+        if (NUMBERS[j]->name == _numbers)
+            NUMBERS[j]->PreValue = zw;
+    }
+    UpdatePreValueINI = true;
+    SavePreValue();
+}
+
+
+bool ClassFlowPostProcessing::LoadPreValue(void)
+{
+    std::vector<string> zerlegt;
+    FILE* pFile;
+    char zw[1024];
+    string zwtime, zwvalue, name;
+    bool _done = false;
+
+    UpdatePreValueINI = false;       // Konvertierung ins neue Format
+
+
+    pFile = fopen(FilePreValue.c_str(), "r");
+    if (pFile == NULL)
+        return false;
+
+    fgets(zw, 1024, pFile);
+    printf("Read Zeile Prevalue.ini: %s", zw);
+    zwtime = trim(std::string(zw));
+    if (zwtime.length() == 0)
+        return false;
+
+    zerlegt = HelperZerlegeZeile(zwtime, "\t");
+    if (zerlegt.size() > 1)     // neues Format
+    {
+        while ((zerlegt.size() > 1) && !_done)
+        {
+            name = trim(zerlegt[0]);
+            zwtime = trim(zerlegt[1]);
+            zwvalue = trim(zerlegt[2]);
+
+            for (int j = 0; j < NUMBERS.size(); ++j)
+            {
+                if (NUMBERS[j]->name == name)
+                {
+                    NUMBERS[j]->PreValue = stof(zwvalue.c_str());
+                    NUMBERS[j]->ReturnPreValue = RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma);
+
+                    time_t tStart;
+                    int yy, month, dd, hh, mm, ss;
+                    struct tm whenStart;
+
+                    sscanf(zwtime.c_str(), PREVALUE_TIME_FORMAT_INPUT, &yy, &month, &dd, &hh, &mm, &ss);
+                    whenStart.tm_year = yy - 1900;
+                    whenStart.tm_mon = month - 1;
+                    whenStart.tm_mday = dd;
+                    whenStart.tm_hour = hh;
+                    whenStart.tm_min = mm;
+                    whenStart.tm_sec = ss;
+                    whenStart.tm_isdst = -1;
+
+                    NUMBERS[j]->lastvalue = mktime(&whenStart);
+
+                    time(&tStart);
+                    localtime(&tStart);
+                    double difference = difftime(tStart, NUMBERS[j]->lastvalue);
+                    difference /= 60;
+                    if (difference > PreValueAgeStartup)
+                    {
+                        NUMBERS[j]->PreValueOkay = false;
+                    }
+                    else
+                    {
+                        NUMBERS[j]->PreValueOkay = true;
+                        NUMBERS[j]->Value = NUMBERS[j]->PreValue;
+                        NUMBERS[j]->ReturnValue = to_string(NUMBERS[j]->Value);
+                        NUMBERS[j]->ReturnValueNoError = NUMBERS[j]->ReturnValue; 
+
+                        if (NUMBERS[j]->digit_roi || NUMBERS[j]->analog_roi)
+                        {
+                            NUMBERS[j]->ReturnValue = RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->AnzahlAnalog - NUMBERS[j]->DecimalShift);
+                            NUMBERS[j]->ReturnValueNoError = NUMBERS[j]->ReturnValue;
+                        }
+                    }
+
+                }
+            }
+
+            if (!fgets(zw, 1024, pFile))
+                _done = true;
+            else
+            {
+                printf("Read Zeile Prevalue.ini: %s", zw);
+                zerlegt = HelperZerlegeZeile(trim(std::string(zw)), "\t");
+                if (zerlegt.size() > 1)
+                {
+                    name = trim(zerlegt[0]);
+                    zwtime = trim(zerlegt[1]);
+                    zwvalue = trim(zerlegt[2]);
+                }
+            }
+        }
+        fclose(pFile);
+    }   
+    else        // altes Format
+    {
+        fgets(zw, 1024, pFile);
+        fclose(pFile);
+        printf("%s", zw);
+        zwvalue = trim(std::string(zw));
+        NUMBERS[0]->PreValue = stof(zwvalue.c_str());
+
+        time_t tStart;
+        int yy, month, dd, hh, mm, ss;
+        struct tm whenStart;
+
+        sscanf(zwtime.c_str(), PREVALUE_TIME_FORMAT_INPUT, &yy, &month, &dd, &hh, &mm, &ss);
+        whenStart.tm_year = yy - 1900;
+        whenStart.tm_mon = month - 1;
+        whenStart.tm_mday = dd;
+        whenStart.tm_hour = hh;
+        whenStart.tm_min = mm;
+        whenStart.tm_sec = ss;
+        whenStart.tm_isdst = -1;
+
+        printf("TIME: %d, %d, %d, %d, %d, %d\n", whenStart.tm_year, whenStart.tm_mon, whenStart.tm_wday, whenStart.tm_hour, whenStart.tm_min, whenStart.tm_sec);
+
+        NUMBERS[0]->lastvalue = mktime(&whenStart);
+
+        time(&tStart);
+        localtime(&tStart);
+        double difference = difftime(tStart, NUMBERS[0]->lastvalue);
+        difference /= 60;
+        if (difference > PreValueAgeStartup)
+            return false;
+
+        NUMBERS[0]->Value = NUMBERS[0]->PreValue;
+        NUMBERS[0]->ReturnValue = to_string(NUMBERS[0]->Value);
+        NUMBERS[0]->ReturnValueNoError = NUMBERS[0]->ReturnValue; 
+
+        if (NUMBERS[0]->digit_roi || NUMBERS[0]->analog_roi)
+        {
+            NUMBERS[0]->ReturnValue = RundeOutput(NUMBERS[0]->Value, NUMBERS[0]->AnzahlAnalog - NUMBERS[0]->DecimalShift);
+            NUMBERS[0]->ReturnValueNoError = NUMBERS[0]->ReturnValue;
+        }
+
+        UpdatePreValueINI = true;       // Konvertierung ins neue Format
+        SavePreValue();
+    } 
+
+    return true;
+}
+
+void ClassFlowPostProcessing::SavePreValue()
+{
+    FILE* pFile;
+    string _zw;
+
+    if (!UpdatePreValueINI)         // PreValues unverändert --> File muss nicht neu geschrieben werden
+        return;
+
+    pFile = fopen(FilePreValue.c_str(), "w");
+
+    for (int j = 0; j < NUMBERS.size(); ++j)
+    {
+        char buffer[80];
+        struct tm* timeinfo = localtime(&NUMBERS[j]->lastvalue);
+        strftime(buffer, 80, PREVALUE_TIME_FORMAT_OUTPUT, timeinfo);
+        NUMBERS[j]->timeStamp = std::string(buffer);
+
+        _zw = NUMBERS[j]->name + "\t" + NUMBERS[j]->timeStamp + "\t" + RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->Nachkomma) + "\n";
+        printf("Write PreValue Zeile: %s\n", _zw.c_str());
+
+        fputs(_zw.c_str(), pFile);
+    }
+
+    UpdatePreValueINI = false;
+
+    fclose(pFile);
+}
+
+
+ClassFlowPostProcessing::ClassFlowPostProcessing(std::vector<ClassFlow*>* lfc)
+{
+//    FlowRateAct = 0;
+    PreValueUse = false;
+    PreValueAgeStartup = 30;
+    ErrorMessage = false;
+    ListFlowControll = NULL;
+//    PreValueOkay = false;
+//    DecimalShift = 0;    
+//    ErrorMessageText = "";
+//    timeStamp = "";
+    FilePreValue = FormatFileName("/sdcard/config/prevalue.ini");
+    ListFlowControll = lfc;
+    flowMakeImage = NULL;
+    UpdatePreValueINI = false;
+
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowMakeImage") == 0)
+        {
+            flowMakeImage = (ClassFlowMakeImage*) (*ListFlowControll)[i];
+        }
+    }
+}
+
+void ClassFlowPostProcessing::handleDecimalSeparator(string _decsep, string _value)
+{
+    string _digit, _decpos;
+    int _pospunkt = _decsep.find_first_of(".");
+//    printf("Name: %s, Pospunkt: %d\n", _decsep.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+        _digit = _decsep.substr(0, _pospunkt);
+    else
+        _digit = "default";
+
+    for (int j = 0; j < NUMBERS.size(); ++j)
+    {
+        int _zwdc = 0;
+
+        try
+        {
+            _zwdc = stoi(_value);
+        }
+        catch(const std::exception& e)
+        {
+            printf("ERROR - Decimalshift is not a number: %s\n", _value.c_str());
+        }
+        
+        if (_digit == "default")                        // erstmal auf default setzen (falls sonst nichts gesetzt)
+            NUMBERS[j]->DecimalShift = _zwdc;
+
+        if (NUMBERS[j]->name == _digit)
+            NUMBERS[j]->DecimalShift = _zwdc;
+
+        NUMBERS[j]->Nachkomma = NUMBERS[j]->AnzahlAnalog - NUMBERS[j]->DecimalShift;
+    }
+}
+
+void ClassFlowPostProcessing::handleMaxRateValue(string _decsep, string _value)
+{
+    string _digit, _decpos;
+    int _pospunkt = _decsep.find_first_of(".");
+//    printf("Name: %s, Pospunkt: %d\n", _decsep.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+        _digit = _decsep.substr(0, _pospunkt);
+    else
+        _digit = "default";
+
+    for (int j = 0; j < NUMBERS.size(); ++j)
+    {
+        float _zwdc = 1;
+
+        try
+        {
+            _zwdc = stof(_value);
+        }
+        catch(const std::exception& e)
+        {
+            printf("ERROR - MaxRateValue is not a number: %s\n", _value.c_str());
+        }
+
+
+        if (_digit == "default")                        // erstmal auf default setzen (falls sonst nichts gesetzt)
+        {
+            NUMBERS[j]->useMaxRateValue = true;
+            NUMBERS[j]->MaxRateValue = _zwdc;
+        }
+
+        if (NUMBERS[j]->name == _digit)
+        {
+            NUMBERS[j]->useMaxRateValue = true;
+            NUMBERS[j]->MaxRateValue = _zwdc;
+        }
+    }
+}
+
+
+bool ClassFlowPostProcessing::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> zerlegt;
+    int _n;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+
+    if (aktparamgraph.compare("[PostProcessing]") != 0)       // Paragraph passt nich zu MakeImage
+        return false;
+
+    InitNUMBERS();
+
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        zerlegt = this->ZerlegeZeile(aktparamgraph);
+        std::string _param = GetParameterName(zerlegt[0]);
+
+        if ((toUpper(_param) == "DECIMALSHIFT") && (zerlegt.size() > 1))
+        {
+            handleDecimalSeparator(zerlegt[0], zerlegt[1]);
+        }
+        if ((toUpper(_param) == "MAXRATEVALUE") && (zerlegt.size() > 1))
+        {
+            handleMaxRateValue(zerlegt[0], zerlegt[1]);
+        }
+
+        if ((toUpper(_param) == "PREVALUEUSE") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+            {
+                PreValueUse = true;
+            }
+        }
+        if ((toUpper(_param) == "CHECKDIGITINCREASECONSISTENCY") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                for (_n = 0; _n < NUMBERS.size(); ++_n)
+                    NUMBERS[_n]->checkDigitIncreaseConsistency = true;
+        }        
+        if ((toUpper(_param) == "ALLOWNEGATIVERATES") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                for (_n = 0; _n < NUMBERS.size(); ++_n)
+                    NUMBERS[_n]->AllowNegativeRates = true;
+        }
+        if ((toUpper(_param) == "ERRORMESSAGE") && (zerlegt.size() > 1))
+        {
+            if (toUpper(zerlegt[1]) == "TRUE")
+                ErrorMessage = true;
+        }
+        if ((toUpper(_param) == "PREVALUEAGESTARTUP") && (zerlegt.size() > 1))
+        {
+            PreValueAgeStartup = std::stoi(zerlegt[1]);
+        }
+    }
+
+    if (PreValueUse) {
+        LoadPreValue();
+    }
+
+    return true;
+}
+
+void ClassFlowPostProcessing::InitNUMBERS()
+{
+//    ClassFlowDigit* _cdigit = NULL;
+//    ClassFlowAnalog* _canalog = NULL;
+    int anzDIGIT = 0;
+    int anzANALOG = 0;
+    std::vector<std::string> name_numbers;
+
+    flowAnalog = NULL;
+    flowDigit = NULL;
+
+    for (int i = 0; i < ListFlowControll->size(); ++i)
+    {
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowDigit") == 0)
+        {
+            flowDigit = (ClassFlowDigit*) (*ListFlowControll)[i];
+            anzDIGIT = flowDigit->getAnzahlDIGIT();
+        }
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowAnalog") == 0)
+        {
+            flowAnalog = (ClassFlowAnalog*)(*ListFlowControll)[i];
+            anzANALOG = flowAnalog->getAnzahlANALOG();
+        }
+    }
+
+    if (flowDigit)
+        flowDigit->UpdateNameNumbers(&name_numbers);
+    if (flowAnalog)
+        flowAnalog->UpdateNameNumbers(&name_numbers);
+
+    printf("Anzahl NUMBERS: %d - DIGITS: %d, ANALOG: %d\n", name_numbers.size(), anzDIGIT, anzANALOG);
+
+    for (int _num = 0; _num < name_numbers.size(); ++_num)
+    {
+        NumberPost *_number = new NumberPost;
+
+        _number->name = name_numbers[_num];
+        
+        _number->digit_roi = NULL;
+        if (flowDigit)
+            _number->digit_roi = flowDigit->FindDIGIT(name_numbers[_num]);
+        
+        if (_number->digit_roi)
+            _number->AnzahlDigital = _number->digit_roi->ROI.size();
+        else
+            _number->AnzahlDigital = 0;
+
+        _number->analog_roi = NULL;
+        if (flowAnalog)
+            _number->analog_roi = flowAnalog->FindANALOG(name_numbers[_num]);
+
+
+        if (_number->analog_roi)
+            _number->AnzahlAnalog = _number->analog_roi->ROI.size();
+        else
+            _number->AnzahlAnalog = 0;
+
+        _number->ReturnRawValue = "";      // Rohwert (mit N & führenden 0)    
+        _number->ReturnValue = "";         // korrigierter Rückgabewert, ggf. mit Fehlermeldung
+        _number->ReturnValueNoError = "";  // korrigierter Rückgabewert ohne Fehlermeldung
+        _number->ErrorMessageText = "";        // Fehlermeldung bei Consistency Check
+        _number->ReturnPreValue = "";
+        _number->PreValueOkay = false;
+        _number->AllowNegativeRates = false;
+        _number->MaxRateValue = 0.1;
+        _number->useMaxRateValue = false;
+        _number->checkDigitIncreaseConsistency = false;
+        _number->PreValueOkay = false;
+        _number->useMaxRateValue = false;
+        _number->DecimalShift = 0;
+
+        _number->FlowRateAct = 0;          // m3 / min
+        _number->PreValue = 0;             // letzter Wert, der gut ausgelesen wurde
+        _number->Value = 0;                // letzer ausgelesener Wert, inkl. Korrekturen
+        _number->ReturnRawValue = "";      // Rohwert (mit N & führenden 0)    
+        _number->ReturnValue = "";         // korrigierter Rückgabewert, ggf. mit Fehlermeldung
+        _number->ReturnValueNoError = "";  // korrigierter Rückgabewert ohne Fehlermeldung
+        _number->ErrorMessageText = "";        // Fehlermeldung bei Consistency Check
+
+        _number->Nachkomma = _number->AnzahlAnalog;
+
+        NUMBERS.push_back(_number);
+    }
+
+    for (int i = 0; i < NUMBERS.size(); ++i)
+        printf("Number %s, Anz DIG: %d, Anz ANA %d\n", NUMBERS[i]->name.c_str(), NUMBERS[i]->AnzahlDigital, NUMBERS[i]->AnzahlAnalog);
+}
+
+string ClassFlowPostProcessing::ShiftDecimal(string in, int _decShift){
+
+    if (_decShift == 0){
+        return in;
+    }
+
+    int _pos_dec_org, _pos_dec_neu;
+
+    _pos_dec_org = findDelimiterPos(in, ".");
+    if (_pos_dec_org == std::string::npos) {
+        _pos_dec_org = in.length();
+    }
+    else
+    {
+        in = in.erase(_pos_dec_org, 1);
+    }
+    
+    _pos_dec_neu = _pos_dec_org + _decShift;
+
+    if (_pos_dec_neu <= 0) {        // Komma ist vor der ersten Ziffer
+        for (int i = 0; i > _pos_dec_neu; --i){
+            in = in.insert(0, "0");
+        }
+        in = "0." + in;
+        return in;
+    }
+
+    if (_pos_dec_neu > in.length()){    // Komma soll hinter String (123 --> 1230)
+        for (int i = in.length(); i < _pos_dec_neu; ++i){
+            in = in.insert(in.length(), "0");
+        }  
+        return in;      
+    }
+
+    string zw;
+    zw = in.substr(0, _pos_dec_neu);
+    zw = zw + ".";
+    zw = zw + in.substr(_pos_dec_neu, in.length() - _pos_dec_neu);
+
+    return zw;
+}
+
+bool ClassFlowPostProcessing::doFlow(string zwtime)
+{
+    string result = "";
+    string digit = "";
+    string analog = "";
+    string zwvalue;
+    string zw;
+    time_t imagetime = 0;
+    string rohwert;
+
+//    ErrorMessageText = "";
+
+    imagetime = flowMakeImage->getTimeImageTaken();
+    if (imagetime == 0)
+        time(&imagetime);
+
+    struct tm* timeinfo;
+    timeinfo = localtime(&imagetime);
+    char strftime_buf[64];
+    strftime(strftime_buf, sizeof(strftime_buf), "%Y-%m-%dT%H:%M:%S", timeinfo);
+    zwtime = std::string(strftime_buf);
+
+    printf("Anzahl NUMBERS: %d\n", NUMBERS.size());
+
+    for (int j = 0; j < NUMBERS.size(); ++j)
+    {
+        NUMBERS[j]->ReturnRawValue = "";
+        NUMBERS[j]->ErrorMessageText = "";
+
+        if (NUMBERS[j]->digit_roi)
+            NUMBERS[j]->ReturnRawValue = flowDigit->getReadout(j);
+        if (NUMBERS[j]->digit_roi && NUMBERS[j]->analog_roi)
+            NUMBERS[j]->ReturnRawValue = NUMBERS[j]->ReturnRawValue + ".";
+        if (NUMBERS[j]->analog_roi)
+            NUMBERS[j]->ReturnRawValue = NUMBERS[j]->ReturnRawValue + flowAnalog->getReadout(j); 
+
+        NUMBERS[j]->ReturnRawValue = ShiftDecimal(NUMBERS[j]->ReturnRawValue, NUMBERS[j]->DecimalShift);   
+
+        rohwert = NUMBERS[j]->ReturnRawValue;
+
+        if (!PreValueUse || !NUMBERS[j]->PreValueOkay)
+        {
+            NUMBERS[j]->ReturnValue = NUMBERS[j]->ReturnRawValue;
+            NUMBERS[j]->ReturnValueNoError = NUMBERS[j]->ReturnRawValue;
+
+            if ((findDelimiterPos(NUMBERS[j]->ReturnValue, "N") == std::string::npos) && (NUMBERS[j]->ReturnValue.length() > 0))
+            {
+                while ((NUMBERS[j]->ReturnValue.length() > 1) && (NUMBERS[j]->ReturnValue[0] == '0'))
+                {
+                    NUMBERS[j]->ReturnValue.erase(0, 1);
+                }
+                NUMBERS[j]->Value = std::stof(NUMBERS[j]->ReturnValue);
+                NUMBERS[j]->ReturnValueNoError = NUMBERS[j]->ReturnValue;
+
+                NUMBERS[j]->PreValueOkay = true;
+                NUMBERS[j]->PreValue = NUMBERS[j]->Value;
+                NUMBERS[j]->ReturnPreValue = RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma);
+                NUMBERS[j]->lastvalue = flowMakeImage->getTimeImageTaken();
+                zwtime = ConvertTimeToString(NUMBERS[j]->lastvalue, PREVALUE_TIME_FORMAT_OUTPUT);
+
+                UpdatePreValueINI = true;
+                SavePreValue();
+            }
+        }
+        else
+        {
+            zw = ErsetzteN(NUMBERS[j]->ReturnRawValue, NUMBERS[j]->PreValue); 
+
+            NUMBERS[j]->Value = std::stof(zw);
+            if (NUMBERS[j]->checkDigitIncreaseConsistency)
+            {
+                NUMBERS[j]->Value = checkDigitConsistency(NUMBERS[j]->Value, NUMBERS[j]->DecimalShift, NUMBERS[j]->analog_roi != NULL, NUMBERS[j]->PreValue);
+            }
+
+            zwvalue = RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->AnzahlAnalog - NUMBERS[j]->DecimalShift);
+
+            if ((!NUMBERS[j]->AllowNegativeRates) && (NUMBERS[j]->Value < NUMBERS[j]->PreValue))
+            {
+                NUMBERS[j]->ErrorMessageText = NUMBERS[j]->ErrorMessageText + "Neg. Rate - Read: " + zwvalue + " - Raw: " + NUMBERS[j]->ReturnRawValue + " - Pre: " + RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma) + " "; 
+                NUMBERS[j]->Value = NUMBERS[j]->PreValue;
+                zwvalue = RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->AnzahlAnalog - NUMBERS[j]->DecimalShift);
+            }
+
+            if (NUMBERS[j]->useMaxRateValue && (abs(NUMBERS[j]->Value - NUMBERS[j]->PreValue) > NUMBERS[j]->MaxRateValue))
+            {
+                NUMBERS[j]->ErrorMessageText = NUMBERS[j]->ErrorMessageText + "Rate too high - Read: " + RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->Nachkomma) + " - Pre: " + RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma);
+                NUMBERS[j]->Value = NUMBERS[j]->PreValue;
+                zwvalue = RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->Nachkomma);
+            }
+
+            NUMBERS[j]->ReturnValueNoError = zwvalue;
+            NUMBERS[j]->ReturnValue = zwvalue;
+            if (NUMBERS[j]->ErrorMessage && (NUMBERS[j]->ErrorMessageText.length() > 0))
+                NUMBERS[j]->ReturnValue = NUMBERS[j]->ReturnValue + "\t" + NUMBERS[j]->ErrorMessageText;
+
+
+            double difference = difftime(imagetime, NUMBERS[j]->lastvalue);      // in Sekunden
+            difference /= 60;                                          // in Minuten
+            NUMBERS[j]->FlowRateAct = (NUMBERS[j]->Value - NUMBERS[j]->PreValue) / difference;
+            NUMBERS[j]->lastvalue = imagetime;
+
+            if (NUMBERS[j]->ErrorMessageText.length() == 0)
+            {
+                NUMBERS[j]->PreValue = NUMBERS[j]->Value;
+                NUMBERS[j]->ReturnPreValue = RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma);
+                NUMBERS[j]->ErrorMessageText = "no error";
+                UpdatePreValueINI = true;
+            }
+        }
+    }
+
+    SavePreValue();
+    return true;
+}
+
+string ClassFlowPostProcessing::getReadout(int _number)
+{
+    return NUMBERS[_number]->ReturnValue;
+}
+
+string ClassFlowPostProcessing::getReadoutParam(bool _rawValue, bool _noerror, int _number)
+{
+    if (_rawValue)
+        return NUMBERS[_number]->ReturnRawValue;
+    if (_noerror)
+        return NUMBERS[_number]->ReturnValueNoError;
+    return NUMBERS[_number]->ReturnValue;
+}
+
+string ClassFlowPostProcessing::RundeOutput(float _in, int _anzNachkomma){
+    std::stringstream stream;
+    int _zw = _in;    
+//    printf("AnzNachkomma: %d\n", _anzNachkomma);
+
+    if (_anzNachkomma < 0) {
+        _anzNachkomma = 0;
+    }
+
+    if (_anzNachkomma > 0)
+    {
+        stream << std::fixed << std::setprecision(_anzNachkomma) << _in;
+        return stream.str();          
+    }
+    else
+    {
+        stream << _zw;
+    }
+
+
+    return stream.str();  
+}
+
+
+string ClassFlowPostProcessing::ErsetzteN(string input, float _prevalue)
+{
+    int posN, posPunkt;
+    int pot, ziffer;
+    float zw;
+
+    posN = findDelimiterPos(input, "N");
+    posPunkt = findDelimiterPos(input, ".");
+    if (posPunkt == std::string::npos){
+        posPunkt = input.length();
+    }
+
+    while (posN != std::string::npos)
+    {
+        if (posN < posPunkt) {
+            pot = posPunkt - posN - 1;
+        }
+        else {
+            pot = posPunkt - posN;
+        }
+
+        zw =_prevalue / pow(10, pot);
+        ziffer = ((int) zw) % 10;
+        input[posN] = ziffer + 48;
+
+        posN = findDelimiterPos(input, "N");
+    }
+
+    return input;
+}
+
+float ClassFlowPostProcessing::checkDigitConsistency(float input, int _decilamshift, bool _isanalog, float _preValue){
+    int aktdigit, olddigit;
+    int aktdigit_before, olddigit_before;
+    int pot, pot_max;
+    float zw;
+    bool no_nulldurchgang = false;
+
+    pot = _decilamshift;
+    if (!_isanalog)             // falls es keine analogwerte gibt, kann die letzte nicht bewertet werden
+    {
+        pot++;
+    }
+    pot_max = ((int) log10(input)) + 1;
+
+    while (pot <= pot_max)
+    {
+        zw = input / pow(10, pot-1);
+        aktdigit_before = ((int) zw) % 10;
+        zw = _preValue / pow(10, pot-1);
+        olddigit_before = ((int) zw) % 10;
+
+        zw = input / pow(10, pot);
+        aktdigit = ((int) zw) % 10;
+        zw = _preValue / pow(10, pot);
+        olddigit = ((int) zw) % 10;
+
+        no_nulldurchgang = (olddigit_before <= aktdigit_before);
+
+        if (no_nulldurchgang)
+        {
+            if (aktdigit != olddigit) 
+            {
+                input = input + ((float) (olddigit - aktdigit)) * pow(10, pot);     // Neue Digit wird durch alte Digit ersetzt;
+            }
+        }
+        else
+        {
+            if (aktdigit == olddigit)                   // trotz Nulldurchgang wurde Stelle nicht hochgezählt --> addiere 1
+            {
+                input = input + ((float) (1)) * pow(10, pot);   // addiere 1 an der Stelle
+            }
+        }
+
+        pot++;
+    }
+
+    return input;
+}
+
+string ClassFlowPostProcessing::getReadoutRate(int _number)
+{
+    return std::to_string(NUMBERS[_number]->FlowRateAct);
+}
+
+string ClassFlowPostProcessing::getReadoutTimeStamp(int _number)
+{
+   return NUMBERS[_number]->timeStamp; 
+}
+
+
+string ClassFlowPostProcessing::getReadoutError(int _number) 
+{
+    return NUMBERS[_number]->ErrorMessageText;
+}

code/components/jomjol_flowcontroll/ClassFlowPostProcessing.h

@@ -0,0 +1,95 @@
+#pragma once
+#include "ClassFlow.h"
+#include "ClassFlowMakeImage.h"
+#include "ClassFlowAnalog.h"
+#include "ClassFlowDigit.h"
+
+
+#include <string>
+
+
+struct NumberPost {
+//    int PreValueAgeStartup; 
+    float MaxRateValue;
+    bool useMaxRateValue;
+    bool ErrorMessage;
+    bool PreValueOkay;
+    bool AllowNegativeRates;
+    bool checkDigitIncreaseConsistency;
+    time_t lastvalue;
+    string timeStamp;
+    float FlowRateAct;          // m3 / min
+    float PreValue;             // letzter Wert, der gut ausgelesen wurde
+    float Value;                // letzer ausgelesener Wert, inkl. Korrekturen
+    string ReturnRawValue;      // Rohwert (mit N & führenden 0)    
+    string ReturnValue;         // korrigierter Rückgabewert, ggf. mit Fehlermeldung
+    string ReturnPreValue;  // korrigierter Rückgabewert ohne Fehlermeldung
+    string ReturnValueNoError;
+    string ErrorMessageText;        // Fehlermeldung bei Consistency Check
+    int AnzahlAnalog;
+    int AnzahlDigital;
+    int DecimalShift;
+    int Nachkomma;
+//    ClassFlowAnalog* ANALOG;
+//    ClassFlowDigit* DIGIT;
+
+    digit *digit_roi;
+    analog *analog_roi;
+
+
+
+    string name;
+};
+
+
+
+
+class ClassFlowPostProcessing :
+    public ClassFlow
+{
+protected:
+    std::vector<NumberPost*> NUMBERS;
+    bool UpdatePreValueINI;
+
+    bool PreValueUse;
+    int PreValueAgeStartup; 
+    bool ErrorMessage;
+
+
+    ClassFlowAnalog* flowAnalog;
+    ClassFlowDigit* flowDigit;    
+
+
+    string FilePreValue;
+
+    ClassFlowMakeImage *flowMakeImage;
+
+    bool LoadPreValue(void);
+    string ShiftDecimal(string in, int _decShift);
+
+    string ErsetzteN(string, float _prevalue);
+    float checkDigitConsistency(float input, int _decilamshift, bool _isanalog, float _preValue);
+    string RundeOutput(float _in, int _anzNachkomma);
+
+    void InitNUMBERS();
+    void handleDecimalSeparator(string _decsep, string _value);
+    void handleMaxRateValue(string _decsep, string _value);
+
+
+public:
+    ClassFlowPostProcessing(std::vector<ClassFlow*>* lfc);
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string getReadout(int _number);
+    string getReadoutParam(bool _rawValue, bool _noerror, int _number = 0);
+    string getReadoutError(int _number = 0);
+    string getReadoutRate(int _number = 0);
+    string getReadoutTimeStamp(int _number = 0);
+    void SavePreValue();
+    string GetPreValue(std::string _number = "");
+    void SetPreValue(float zw, string _numbers);
+    std::vector<NumberPost*> GetNumbers(){return NUMBERS;};
+
+    string name(){return "ClassFlowPostProcessing";};
+};
+