changed log message

log the uncatched MQTT connection error
Merge branch 'main' of https://github.com/jomjol/AI-on-the-edge-device
2025-12-07 12:06:58 +03:00 · 2024-10-06 16:49:48 +02:00 · 2024-10-06 16:44:43 +02:00 · 2024-10-06 16:43:51 +02:00 · 2024-10-05 23:15:38 +02:00 · 2024-10-05 22:42:51 +02:00
693 changed files with 56238 additions and 87032 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yaml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yaml
@@ -0,0 +1,67 @@
+name: 🐞 Bug Report
+description: Use this form if you think you found a bug / Verwende dieses Formular, wenn Du denkst, dass Du einen Fehler gefunden hast.
+labels: bug
+body:
+
+
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking your time to report a bug.
+
+        Before you proceed, please check:
+        - [ ] Do you use the [latest version](https://github.com/jomjol/AI-on-the-edge-device/releases)?
+        - [ ] Is there already another similar issue? Check for open and closed [Issue](https://github.com/jomjol/AI-on-the-edge-device/issues) and [Discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions).
+        - [ ] Are instructions in the [README](https://github.com/jomjol/AI-on-the-edge-device/tree/master#readme) solving your issue?
+        - [ ] Are instructions in the [Wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki) solving your issue?
+        
+        Du darfst gerne auch in Deutsch schreiben!
+
+
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: The Problem
+      description: A clear and concise description of what the bug is.
+
+
+
+  - type: input
+    validations:
+      required: true
+    attributes:
+      label: Version
+      description: Which version are you using? (See menu `System > Info`).    
+        
+        
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Logfile
+      description: Add the logfile (See menu `System > Log Viewer`) to help explain your problem. This will be automatically formatted into code, so no need to format it on your side.
+      render: shell
+
+
+
+  - type: textarea
+    attributes:
+      label: Expected Behavior
+      description: A clear and concise description of what you expected to happen.
+        
+
+
+  - type: textarea
+    attributes:
+      label: Screenshots
+      description: If applicable, add screenshots to help explain your problem.
+        
+
+
+  - type: textarea
+    attributes:
+      label: Additional Context
+      description: Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/config.yaml
+++ b/.github/ISSUE_TEMPLATE/config.yaml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 💬 Open a new Discussion
+    url: https://github.com/jomjol/AI-on-the-edge-device/discussions/categories/q-a
+    about: Use this form if you have a question or need help setting your AI-on-the-edge-device it up
--- a/.github/ISSUE_TEMPLATE/feature.yaml
+++ b/.github/ISSUE_TEMPLATE/feature.yaml
@@ -0,0 +1,23 @@
+name: 💡 Feature Request
+description: Use this form if you have an idea or wish for a new feature
+labels: enhancement
+body:
+
+
+  - type: markdown
+    attributes:
+      value: |
+        Thank you for taking your time to document your idea.
+
+        Before you proceed, please check:
+        - [ ] Is there already another similar issue open or closed? Check for open and closed [Issue](https://github.com/jomjol/AI-on-the-edge-device/issues) and [Discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions).
+        - [ ] Is there already another similar [discussion](https://github.com/jomjol/AI-on-the-edge-device/discussions) ongoing?
+
+        Please be aware that we might decline your request if we have a reason for it!
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: The Feature
+      description: A clear and concise description of what the new feature should do. If possible, refer to other projects or add a mockup.
--- a/.github/ISSUE_TEMPLATE/training.yaml
+++ b/.github/ISSUE_TEMPLATE/training.yaml
@@ -0,0 +1,19 @@
+name: 📖 New Training Data
+description: Use this form if you collected images and want to provide them for training the model
+title: New Training Data
+labels: new training data
+assignees: jomjol
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Before you proceed, please check:
+        - [ ] Did you make sure we don't have similar data yet in the training data? (see [Digital Counters](https://jomjol.github.io/neural-network-digital-counter-readout/) resp. [Analog Needles](https://jomjol.github.io/neural-network-analog-needle-readout))
+        - [ ] Did you follow the guideline as documented in the [Wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/ROI-Configuration)? We will only be able to accept the files if they fulfill the rules!
+
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Files
+      description: You can drag & drop your **zipped** images here
--- a/.github/ISSUE_TEMPLATE/x_plain.yaml
+++ b/.github/ISSUE_TEMPLATE/x_plain.yaml
@@ -0,0 +1,8 @@
+name: 🗒️ Blank Form
+description: Use this form if none of the others fit. Please only use none of the others fit!
+
+body:
+  - type: textarea
+    attributes:
+      label: Issue
+  
--- a/.github/label-commenter-config.yaml
+++ b/.github/label-commenter-config.yaml
@@ -0,0 +1,123 @@
+# Reply Bot Configuration
+# See https://github.com/peaceiris/actions-label-commenter
+# Make sure to also add the response to .github/workflows/reply-bot.yml!
+# Due to the way it works, you have to add each response twice, once for the issue, once for the discussions!
+  
+ labels:
+  #######################################################################
+  # Bot Response: Documentation
+  #######################################################################
+  - name: bot-reply Documentation
+    labeled:
+      issue:
+          body: |
+            Please have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs
+      discussion:
+          body: |
+            Please have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs
+
+  #######################################################################
+  # Bot Response: ROI setup
+  #######################################################################
+  - name: bot-reply ROI Setup
+    labeled:
+      issue:
+          body: |
+            Make sure to setup your ROIs properly. Have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs/ROI-Configuration/#how-to-setup-the-digit-rois-perfectly
+      discussion:
+          body: |
+            Make sure to setup your ROIs properly. Have a look on our documentation: https://jomjol.github.io/AI-on-the-edge-device-docs/ROI-Configuration/#how-to-setup-the-digit-rois-perfectly
+
+
+  #######################################################################
+  # Bot Response: Logfile
+  #######################################################################
+  - name: bot-reply Logfile
+    labeled:
+      issue:
+          body: |
+            Please provide a logfile!
+            Make sure to first enable the `DEBUG` level in `Settings->Configuration->Debug->Logfile Log Level`!
+            Then wait until the issue arises again.
+            When you copy the log into here, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+      discussion:
+          body: |
+            Please provide a logfile!
+            Make sure to first enable the `DEBUG` level in `Settings->Configuration->Debug->Logfile Log Level`!
+            Then wait until the issue arises again.
+            When you copy the log into here, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+
+
+  #######################################################################
+  # Bot Response: Web Console
+  #######################################################################
+  - name: bot-reply Web Console
+    labeled:
+      issue:
+          body: |
+            You can use the [Web Console](https://jomjol.github.io/AI-on-the-edge-device/index.html) to get USB log from the device.
+            The USB log contains more information about the startup and operation of the device than the normal Web UI log
+            When you copy the log into herm, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+      discussion:
+          body: |
+            You can use the [Web Console](https://jomjol.github.io/AI-on-the-edge-device/index.html) to get USB log from the device.
+            The USB log contains more information about the startup and operation of the device than the normal Web UI log
+            When you copy the log into herm, please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+
+
+  #######################################################################
+  # Bot Response: Properly Format Code
+  #######################################################################
+  - name: bot-reply Properly Format Code
+    labeled:
+      issue:
+          body: |
+            Please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+            This makes your code or log much easier to read!
+      discussion:
+          body: |
+            Please make sure to use **Fenced code blocks** by wrapping it into separate lines with ` ``` `, see https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/creating-and-highlighting-code-blocks#fenced-code-blocks
+            This makes your code or log much easier to read!
+
+
+  #######################################################################
+  # Bot Response: Web Installer
+  #######################################################################
+  - name: bot-reply Web Installer
+    labeled:
+      issue:
+          body: |
+            You can use the [Web Installer](https://jomjol.github.io/AI-on-the-edge-device/index.html) install the firmware onto the ESP32.
+      discussion:
+          body: |
+            You can use the [Web Installer](https://jomjol.github.io/AI-on-the-edge-device/index.html) install the firmware onto the ESP32.
+
+
+  #######################################################################
+  # Bot Response: Rolling Build
+  #######################################################################
+  - name: bot-reply Rolling Build
+    labeled:
+      issue:
+          body: |
+            You can try the latest [Automatic Build](https://github.com/jomjol/AI-on-the-edge-device/actions/workflows/build.yaml?query=branch%3Arolling+event%3Apush) of the the `rolling` or any other branch. It might already contain a fix for your issue.
+            See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/rolling-installation) for additional information.
+      discussion:
+          body: |
+            You can try the latest [Automatic Build](https://github.com/jomjol/AI-on-the-edge-device/actions/workflows/build.yaml?query=branch%3Arolling+event%3Apush) of the the `rolling` or any other branch. It might already contain a fix for your issue.
+            See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/rolling-installation) for additional information.
+            
+            
+  #######################################################################
+  # Bot Response: Show Trained Digits/Pointers
+  #######################################################################
+  - name: bot-reply Show Trained Digits/Pointers
+    labeled:
+      issue:
+          body: |
+            See [Digits](https://jomjol.github.io/neural-network-digital-counter-readout) resp. [Analogue Pointers](https://jomjol.github.io/neural-network-analog-needle-readout) for an overview of all trained data.
+            If your type is not contained it can be added to our training material, see [here](https://jomjol.github.io/AI-on-the-edge-device-docs/collect-new-images/).
+      discussion:
+          body: |
+            See [Digits](https://jomjol.github.io/neural-network-digital-counter-readout) resp. [Analogue Pointers](https://jomjol.github.io/neural-network-analog-needle-readout) for an overview of all trained data.
+            If your type is not contained it can be added to our training material, see [here](https://jomjol.github.io/AI-on-the-edge-device-docs/collect-new-images/).
--- a/.github/workflows/build.yaml
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,425 @@
+name: Build and Pack
+
+on: [push, pull_request]
+
+jobs:
+#########################################################################################
+## Build Firmware
+#########################################################################################
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - id: skip_check
+      uses: fkirc/skip-duplicate-actions@v5
+      with:
+        concurrent_skipping: same_content_newer
+
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+    - name: Update PIP cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: pip-${{ github.run_id }}
+        restore-keys: pip # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update PlatformIO cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ~/.platformio
+        key: platformio-${{ github.run_id }}
+        restore-keys: platformio # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update Build cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ./code/.pio/
+        key: build-${{ github.run_id }}
+        restore-keys: build # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache          
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.10'
+
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio
+
+    - name: Build Firmware
+      #run: echo "Testing... ${{ github.ref_name }}, ${{ steps.vars.outputs.sha_short }}" > ./sd-card/html/version.txt; mkdir -p ./code/.pio/build/esp32cam/; cd ./code/.pio/build/esp32cam/; echo "${{ steps.vars.outputs.sha_short }}" > firmware.bin; cp firmware.bin partitions.bin; cp firmware.bin bootloader.bin # Testing
+      run: cd code; platformio run --environment esp32cam
+
+    - name: Prepare Web UI (generate tooltip pages and update hashes in all files)
+      run: |
+        rm -rf ./html
+        mkdir html
+        cp -r ./sd-card/html/* ./html/
+
+        python -m pip install markdown
+        mkdir html/param-tooltips
+        cd tools/parameter-tooltip-generator
+        python generate-param-doc-tooltips.py
+        cd ../..
+
+        cp -r ./sd-card/html/* ./html/
+
+        echo "Replacing variables..."
+        cd html; find . -type f -exec sed -i 's/$COMMIT_HASH/${{ steps.vars.outputs.sha_short }}/g' {} \;
+
+
+#########################################################################################
+## Pack for Update
+#########################################################################################
+  pack-for-update:
+    # New OTA concept
+    # update__version.zip file with following content:
+    #  - /firmware.bin
+    #  - (optional) /html/* (inkl. subfolders)
+    #  - (optional) /config/*.tfl
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update update cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: update
+        key: update-${{ github.run_id }}
+        restore-keys: update # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare update__*.zip artifact
+      run: |
+        rm -rf ./update
+        mkdir -p ./update
+        cp "./code/.pio/build/esp32cam/firmware.bin" "update/firmware.bin"
+
+    - name: Add Web UI to update
+      run: cp -r ./html ./update/
+
+    - name: Add CNN to update
+      run: |
+        rm -rf ./update/config/
+        mkdir -p ./update/config/
+        cp ./sd-card/config/*.tfl ./update/config/ 2>/dev/null || true
+        cp ./sd-card/config/*.tflite ./update/config/ 2>/dev/null || true
+
+    - name: Upload update as update.zip artifact (Firmware + Web UI + CNN)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./update/*
+
+
+#########################################################################################
+## Pack for Remote Setup 
+#########################################################################################
+  pack-for-remote_setup:
+    # New Remote Setup concept
+    # remote_setup__version.zip file with following content:
+    #  - /firmware.bin
+    #  - /html/* (inkl. subfolders)
+    #  - /config/*
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update remote_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: remote_setup
+        key: remote_setup-${{ github.run_id }}
+        restore-keys: remote_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare remote_setup__*.zip artifact
+      run: |
+        rm -rf ./remote_setup
+        mkdir -p ./remote_setup
+
+    - name: Add Web UI to remote_setup
+      run: cp -r ./html ./remote_setup/
+
+    - name: Add whole config folder to remote_setup
+      run: |
+        rm -rf ./remote_setup/config/
+        mkdir -p ./remote_setup/config/
+        cp ./sd-card/config/* ./remote_setup/config/ 2>/dev/null || true
+
+    - name: Upload remote_setup as remote_setup.zip artifact (Firmware + Web UI + Config)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__remote-setup__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./remote_setup/*
+
+
+#########################################################################################
+## Pack for a fresh install (USB flashing) (manual_setup)
+#########################################################################################
+  pack-for-manual_setup:
+    # creates old style binaries for fresh installation (backward compatible to wiki)
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update manual_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: manual_setup
+        key: manual_setup-${{ github.run_id }}
+        restore-keys: manual_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare manual_setup__*.zip artifact
+      run: |
+        rm -rf manual_setup
+        mkdir -p manual_setup
+        rm -rf manual_setup/*.zip
+        rm -rf release
+        mkdir -p release
+        # copy builds to manual_setup folder
+        cp -f "./code/.pio/build/esp32cam/firmware.bin" "manual_setup/firmware.bin"
+        cp -f "./code/.pio/build/esp32cam/bootloader.bin" "manual_setup/bootloader.bin"
+        cp -f "./code/.pio/build/esp32cam/partitions.bin" "manual_setup/partitions.bin"
+        rm -rf ./sd-card/html
+        cp -r ./html ./sd-card/ # Overwrite the Web UI with the preprocessed files
+        cd sd-card; zip -r ../manual_setup/sd-card.zip *; cd ..
+        cd ./manual_setup
+
+    - name: Upload manual_setup.zip artifact (Firmware + Bootloader + Partitions + Web UI)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__manual-setup__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./manual_setup
+
+
+#########################################################################################
+## Prepare and create release
+#########################################################################################
+  release: 
+    runs-on: ubuntu-latest
+    needs: [pack-for-update, pack-for-manual_setup, pack-for-remote_setup]
+    if: startsWith(github.ref, 'refs/tags/') 
+
+    # Sets permissions of the GITHUB_TOKEN to allow updating the branches
+    permissions:
+      contents: write
+      pages: write
+      id-token: write
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update update cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: update
+        key: update-${{ github.run_id }}
+        restore-keys: update # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update remote_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: remote_setup
+        key: remote_setup-${{ github.run_id }}
+        restore-keys: remote_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update manual_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: manual_setup
+        key: manual_setup-${{ github.run_id }}
+        restore-keys: manual_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare artifacts for release
+      run: |
+        rm -rf release
+        mkdir -p release
+
+        # create AI-on-the-edge-device__update__*.zip like "AI-on-the-edge-device__update__v13.0.5.zip"
+        cd ./update
+        zip -r ../release/AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}.zip .
+
+        # create AI-on-the-edge-device__manual-setup__*.zip like "AI-on-the-edge-device__manual-setup__v13.0.5.zip"
+        cd ../manual_setup
+        zip -r ../release/AI-on-the-edge-device__manual-setup__${{ steps.vars.outputs.branch }}.zip .
+
+        # create AI-on-the-edge-device__remote-setup__*.zip like "AI-on-the-edge-device__remote-setup__v13.0.5.zip"
+        cd ../remote_setup
+        zip -r ../release/AI-on-the-edge-device__remote-setup__${{ steps.vars.outputs.branch }}.zip .
+
+    # extract the version used in next step
+    - id: get_version
+      uses: drewg13/get-version-action@98dda2a47a257e202c2e6c2ed2e6072ec23f448e
+
+#    # the changelog [unreleased] will now be changed to the release version
+#    - name: Update changelog
+#      uses: thomaseizinger/keep-a-changelog-new-release@v1
+#      with:
+#        changelogPath: Changelog.md
+#        version: ${{ steps.get_version.outputs.version-without-v }}
+
+#    # the release notes will be extracted from changelog 
+#    - name: Extract release notes
+#      id: extract-release-notes
+#      uses: ffurrer2/extract-release-notes@v1
+#      with:
+#          changelog_file: Changelog.md
+
+    # Releases should only be created on master by tagging the last commit.
+    # all artifacts in firmware folder pushed to the release
+    - name: Release
+      uses: softprops/action-gh-release@v2.0.8
+      # Note:
+      # If you get the error "Resource not accessible by integration",
+      # The access rights are not sufficient, see
+      # https://github.com/softprops/action-gh-release/issues/232#issuecomment-1131379440
+      with:
+        name:  ${{ steps.get_version.outputs.version-without-v }}
+        body: ${{ steps.extract-release-notes.outputs.release_notes }}
+        files: |
+          release/*
+
+#    # Commit&Push Changelog to master branch. Must be manually merged back to rolling
+#    - name: Commit changes and push changes
+#      run: |
+#        git config user.name github-actions
+#        git config user.email github-actions@github.com
+#        git add Changelog.md
+#        git commit Changelog.md -m "Update Changelog.md for ${{github.event.inputs.versionIncrement}} release"
+#        git push origin HEAD:master
+
+
+#########################################################################################
+## Update the Web Installer on a release
+#########################################################################################
+# Make sure to also update update-webinstaller.yml!
+  update-web-installer:
+    if: github.event_name == 'release' && github.event.action == 'published' # Only run on release but not on prerelease
+    needs: [release]
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+
+    # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+    permissions:
+      contents: read
+      pages: write
+      id-token: write
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+
+    - name: Get version of last release
+      id: last_release
+      uses: mindojo/get-latest-release@0b8ef1434d7468d6bffcc8263baff5c777f72321
+      with:
+        myToken: ${{ github.token }}
+        exclude_types: "draft|prerelease"
+        view_top: 1     
+
+    - name: Add binary to Web Installer and update manifest
+      run: |
+        echo "Updating Web installer to use firmware from ${{ steps.last_release.outputs.tag_name }}..."
+        rm -f docs/binary/firmware.bin
+        wget ${{ github.server_url }}/${{ github.repository }}/releases/download/${{ steps.last_release.outputs.tag_name }}/AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        unzip AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        cp -f firmware.bin docs/binary/firmware.bin
+        echo "Updating index and manifest file..."
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/index.html
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/manifest.json
+
+    - name: Setup Pages
+      uses: actions/configure-pages@v4
+
+    - name: Upload artifact
+      uses: actions/upload-pages-artifact@v2
+      with:
+        path: 'docs'
+
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v3  # Note: v4 does not work!
--- a/.github/workflows/clear_cache.yaml
+++ b/.github/workflows/clear_cache.yaml
@@ -0,0 +1,30 @@
+name: Clear cache
+
+on:
+  workflow_dispatch:
+
+permissions:
+  actions: write
+
+jobs:
+  clear-cache:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clear cache
+        uses: actions/github-script@v6
+        with:
+          script: |
+            console.log("About to clear")
+            const caches = await github.rest.actions.getActionsCacheList({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+            })
+            for (const cache of caches.data.actions_caches) {
+              console.log(cache)
+              github.rest.actions.deleteActionsCacheById({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                cache_id: cache.id,
+              })
+            }
+            console.log("Clear completed")
--- a/.github/workflows/manual-update-webinstaller.yaml
+++ b/.github/workflows/manual-update-webinstaller.yaml
@@ -0,0 +1,62 @@
+# This updates the Web Installer with the files from the docs folder and the binary of the latest release
+# it only gets run on:
+#  - Manually triggered
+# Make sure to also update the lower part of build.yml!
+
+name: Manual Web Installer Update
+
+on:
+  workflow_dispatch: # Run on manual trigger
+#  push:
+#    branches:
+#    - rolling
+#    paths:
+#    - docs # The path filter somehow does not work, so lets run it on every change to rolling
+
+jobs:
+  manually-update-web-installer:    
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+
+    # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+    permissions:
+      contents: read
+      pages: write
+      id-token: write
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+
+    - name: Get version of last release
+      id: last_release
+      uses: mindojo/get-latest-release@0b8ef1434d7468d6bffcc8263baff5c777f72321
+      with:
+        myToken: ${{ github.token }}
+        exclude_types: "draft|prerelease"
+        view_top: 1     
+
+    - name: Add binary to Web Installer and update manifest
+      run: |
+        echo "Updating Web installer to use firmware from ${{ steps.last_release.outputs.tag_name }}..."
+        rm -f docs/binary/firmware.bin
+        wget https://github.com/jomjol/AI-on-the-edge-device/releases/download/${{ steps.last_release.outputs.tag_name }}/AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        unzip AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        cp -f firmware.bin docs/binary/firmware.bin
+        echo "Updating index and manifest file..."
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/index.html
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/manifest.json
+
+    - name: Setup Pages
+      uses: actions/configure-pages@v2
+
+    - name: Upload artifact
+      uses: actions/upload-pages-artifact@v1
+      with:
+        path: 'docs'
+
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v1   
--- a/.github/workflows/reply-bot.yaml
+++ b/.github/workflows/reply-bot.yaml
@@ -0,0 +1,79 @@
+# Reply Bot
+# It uses the configuration in .github/label-commenter-config.yaml
+# See https://github.com/peaceiris/actions-label-commenter
+
+name: Reply-Bot
+
+on:
+  issues:
+    types: [labeled]
+  discussion:
+    types: [labeled]
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: write
+  discussions: write
+
+jobs:
+  comment:
+    runs-on: ubuntu-20.04
+    steps:
+      - uses: actions/checkout@v4
+
+      ####################################################################
+      ## Remove labels again (issues only)
+      ## Make sure to also add the reply message to .github/label-commenter-config.yaml!
+      ## This currently seems no longer to work due to changes on the actions-cool/issues-helper!
+      ####################################################################
+#      - name: Remove 'Logfile' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Logfile'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Logfile'
+#          
+#      - name: Remove 'Web Console' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Web Console'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Web Console'
+#
+#      - name: Remove 'Properly Format Code' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Properly Format Code'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Properly Format Code'
+#          
+#      - name: Remove 'Web Installer' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Web Installer'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Web Installer'
+#
+#      - name: Remove 'Rolling Build' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Rolling Build'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Rolling Build'
+#          
+#      - name: Remove 'Show Trained Digits/Pointers' label again (issues only)
+#        if: github.event.label.name == 'bot-reply Show Trained Digits/Pointers'
+#        uses: actions-cool/issues-helper@v3
+#        with:
+#          actions: 'remove-labels'
+#          labels: 'bot-reply Show Trained Digits/Pointers'
+
+      ####################################################################
+      ## Write the response
+      ####################################################################
+      - name: Write Response
+        uses: peaceiris/actions-label-commenter@c2d00660c86f2b9ed0fb35b372c451558eba85b3
+        with:
+          github_token: "${{ secrets.GITHUB_TOKEN }}"
+          config_file: .github/label-commenter-config.yaml
--- a/.gitignore
+++ b/.gitignore
@@ -2,17 +2,26 @@
 .pio/
 .vscode/
 .code-workspace
-.helper/
 /sd-card/htm./.vscode/
-
+/code/build
+/code/.helper
+/sd-card/html/debug/
+/firmware/
+version.txt
+/dist/
+/dist_release/
+/dist_old_ota
 CMakeLists.txt.user
 CMakeCache.txt
 CMakeFiles
 CMakeScripts
-Testing
 Makefile
 cmake_install.cmake
 install_manifest.txt
 compile_commands.json
 CTestTestfile.cmake
 _deps
+code/edgeAI.code-workspace
+.DS_Store
+tools/parameter-tooltip-generator/html
+tools/parameter-tooltip-generator/AI-on-the-edge-device-docs
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,12 @@
+[submodule "code/components/esp32-camera"]
+	path = code/components/esp32-camera
+	url = https://github.com/espressif/esp32-camera.git
+[submodule "code/components/esp-nn"]
+	path = code/components/esp-nn
+	url = https://github.com/espressif/esp-nn.git
+[submodule "code/components/esp-tflite-micro"]
+	path = code/components/esp-tflite-micro
+	url = https://github.com/espressif/esp-tflite-micro.git
+[submodule "code/components/stb"]
+	path = code/components/stb
+	url = https://github.com/nothings/stb.git
--- a/Changelog.md
+++ b/Changelog.md
--- a/FeatureRequest.md
+++ b/FeatureRequest.md
@@ -0,0 +1,314 @@
+## 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. Whoever has a new idea can put it here, so that it is not forgotten. 
+
+2. Whoever has the time, capacity and passion to support the project can take any of the ideas and implement them. I will provide support and help wherever I can!
+   
+   
+
+____
+
+
+#### #40 Trigger with cron like exact time slot
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2470
+
+
+
+#### #39 upnp implementation to auto detect the device
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2481
+
+  
+
+#### #38 Energy Saving
+
+* Deep sleep between recognition
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2486
+
+
+
+#### #37 Auto init SD card
+
+* Fully implement the SD card handling (including formatting) into the firmware
+* https://github.com/jomjol/AI-on-the-edge-device/issues/2488Demo 
+
+#### #36 Run demo without camera
+
+Demo mode requires a working camera (if not, one receives a 'Cam bad' error). Would be nice to demo or play around on other ESP32 boards (or on ESP32-CAM boards when you broke the camera cable...).
+
+#### #35 Use the same model, but provide the image from a Smartphone Camera
+as reading the Electricity or Water meter every few minutues only delivers apparent accuracy (DE: "Scheingenauigkeit") you could just as well take a picture with your Smartphone evey so often (e.g. once a week when you are in the Basement anyway), then with some "semi clever" tricks pass this image to the model developed here, and the values then on to who ever needs them e.g. via MQTT.
+IMO: It is not needed to have that many readings (datapoints) as our behaviour (Use of electricity or water) doesn't vary that much, say, over a weeks time. The interpolation between weekly readings will give sufficient information on the power and/or water usage. 
+
+
+#### #34 implement state and Roi for water leak detection
+for example see Roi on the next picture..
+![grafik](https://user-images.githubusercontent.com/38385805/207858812-2a6ba41d-1a8c-4fa1-9b6a-53cdd113c106.png)
+in case of position change between the measurments set this state to true, if there is no change set it back to false.
+In a defined time window this movement can lead into an alarm state / water leak..
+haveing this state in the mqtt broker can trigger functions like closing the ater pipe walve and so on...
+
+
+
+#### #33 Implement MATTER protocoll
+
+* see [#1404](https://github.com/jomjol/AI-on-the-edge-device/issues/1404)
+
+#### #32 Add feature to correct misinterpreted value
+
+* If a value is misinterpreted, the user can manually correct the value.
+* The misinterpreted ROIs would be saved in a "training data" -folder on the SD-card
+* Stretch goal: make sending of saved training data as easy as pushing a button =)
+
+#### #31 Implement InfluxDB v2.x interface
+
+* Currently only InfluxDB v1.x is supportet, extend to v2.x
+* Remark: interface has changed
+* see [#1160](https://github.com/jomjol/AI-on-the-edge-device/issues/1160)
+
+#### #30 Support meter clock over
+
+* In case of meter clocking over, that is, reaching its max. value and starting over from 0,
+  accept the new value and calculate correctly the difference.
+  (see line 739 onwards in ClassFlowPostProcessing.cpp)
+
+#### ~~#29 Add favicon and use the hostname for the website~~- implemented v11.3.1
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/927~~
+
+#### #28 Improved error handling for ROIs
+
+* In case a ROI is out of the image, there is no error message, but a non sense image is used
+* Implement a error message for wrong configuratioin of ROI
+
+#### #27 Use Homie Spec for Mqtt binding
+
+* Use the standardized Home Protocol for the Mqtt binding 
+* https://homieiot.github.io/
+
+#### #26 Changes behaviour for "N" replacement
+
+* in case the higher digits has already increased by minium 1 - don't set the "N" to the last value, but to "0"
+* https://github.com/jomjol/AI-on-the-edge-device/issues/792
+
+
+#### #25 Trigger Measurement via MQTT
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/727
+
+
+#### #24 Show Mqtt state directly in Webserver
+
+* Show MQTT log in Web page. E.g. connection established or failed to connect...
+
+  
+
+
+#### #23 CPU Temp and Mqtt values
+
+* Show the CPU Temp directly in Webpage. Also add the value to MQTT sending
+
+  
+
+#### ~~#22 Direct hint to the different neural network files in the other repositories~~- implemented >v11.3.1
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/644~~
+
+  
+
+#### #21 Extended "CheckDigitalConsistency" Logik
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/590
+
+  
+
+#### #20 Deep sleep and push mode
+
+* Let the device be normally in deep sleep state, and wake it up periodically to collect data and push it via MQTT or HTTP post.
+* Support ESP-NOW to reduce the overhead of connecting to wifi and mqtt 
+* the above should enable battery powered applications
+
+* An other way to set deep sleep would be to enable it in a specific period (at night).
+  
+
+#### #19 Extended log informations
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/580
+
+  
+
+#### ~~#18 Document WLAN-strength in web page~~
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/563~~
+
+
+
+#### ~~#17 Direct InfluxDB connection~~
+
+* ~~Done in v10.6.0~~
+
+
+#### #16 Serial Communication
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/512
+* Send the readout value via RX/TX interface with a dedicated TAG
+* Make dedicated communication FlowModule
+* Modification of RX/TX communication
+* Configuration interfache
+
+
+#### #15 Calibration for FishEye image
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/507
+
+1.  The development of such a correction algorithm with the libraries, that are available for the ESP32 environment.
+2. New module for integration of the flow into the image processing flow.
+3. Extension of the configuration (config.ini) and html-pages
+4. Parameter adjustment and testing for every different fish-eye module
+5. Maintenance for further updates / modules, ...
+
+
+
+#### ~~#14 Backup and restore option for configuration~~- implemented v11.3.1
+
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/459~~
+
+* ~~Implement a zip file compression for store and restore~~
+
+* ~~Update the html to handle it~~
+
+  
+
+#### #13 Manage non linear gauge without CNN re-training
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/443
+
+* Implement a look up table for non linear analog meters
+
+  
+
+#### ~~#12 Less reboots due to memory leakage~~
+
+* ~~Issue: #414 & #425  #430~~
+
+  
+
+#### #11 MQTT - configurable payload
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/344
+
+  
+
+#### #10 Improve and bug fix logging of images
+
+* https://github.com/jomjol/AI-on-the-edge-device/issues/307
+
+  
+
+#### #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~~
--- a/README.md
+++ b/README.md
@@ -1,108 +1,108 @@
-# AI-on-the-edge-device
+# Welcome to the AI-on-the-edge-device
+<img src="images/icon/watermeter.svg" width="100px">

-This is an example of Artificial Intelligence (AI) calculations on a very cheap hardware.
+Artificial intelligence based systems have become established in our everyday lives. Just think of speech or image recognition. Most of the systems rely on either powerful processors or a direct connection to the cloud for doing the calculations there. With the increasing power of modern processors, the AI systems are coming closer to the end user – which is usually called **edge computing**.
+Here, this edge computing is put into a practically oriented example, where an AI network is implemented on an ESP32 device so: **AI on the edge**.

-### Details on **function**, **installation** and **configuration** can be found on the **[Wiki Page](https://github.com/jomjol/AI-on-the-edge-device/wiki)**
+This project allows you to digitize your **analog** water, gas, power and other meters using cheap and easily available hardware.

-A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4571627
+All you need is an [ESP32 board with a supported camera](https://jomjol.github.io/AI-on-the-edge-device-docs/Hardware-Compatibility/) and something of a practical hand.

+<img src="images/esp32-cam.png" width="200px">
+
+## Key features
+- Tensorflow Lite (TFlite) integration – including easy-to-use wrapper
+- Inline image processing (feature detection, alignment, ROI extraction)
+- **Small** and **cheap** device (3 x 4.5 x 2 cm³, < 10 EUR)
+- Integrated camera and illumination
+- Web interface for administration and control
+- OTA interface for updating directly via the web interface
+- Full integration into Homeassistant
+- Support for Influx DB 1 and 2
+- MQTT
+- REST API
+
+## Workflow
+The device takes a photo of your meter at a defined interval. It then extracts the Regions of Interest (ROIs) from the image and runs them through artificial intelligence. As a result, you get the digitized value of your meter.
+
+There are several options for what to do with that value. Either send it to an MQTT broker, write it to an InfluxDb or simply provide access to it via a REST API.
+
+<img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/idea.jpg" width="600"> 
+
+## Impressions
+### AI-on-the-edge-device on a Water Meter
 <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"> 

+### Web Interface (Water Meter)
 <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"> 
+
+### AI-on-the-edge-device on a Electrical Power Meter
+<img src="https://raw.githubusercontent.com/jomjol/AI-on-the-edge-device/master/images/powermeter.jpg" width="600"> 


+## Setup
+There is growing [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/) which provides you with a lot of information. Head there to get a start, set it up and configure it.

-## Change log
+There are also articles in the German Heise magazine "make:" about the setup and technical background (behind a paywall): [DIY - Setup](https://www.heise.de/select/make/2021/2/2103513300897420296)

------
+A lot of people created useful Youtube videos which might help you getting started.
+Here a small selection:

-### Known Issues
+- [youtube.com/watch?v=HKBofb1cnNc](https://www.youtube.com/watch?v=HKBofb1cnNc)
+- [youtube.com/watch?v=yyf0ORNLCk4](https://www.youtube.com/watch?v=yyf0ORNLCk4)
+- [youtube.com/watch?v=XxmTubGek6M](https://www.youtube.com/watch?v=XxmTubGek6M)
+- [youtube.com/watch?v=mDIJEyElkAU](https://www.youtube.com/watch?v=mDIJEyElkAU)
+- [youtube.com/watch?v=SssiPkyKVVs](https://www.youtube.com/watch?v=SssiPkyKVVs)
+- [youtube.com/watch?v=MAHE_QyHZFQ](https://www.youtube.com/watch?v=MAHE_QyHZFQ)
+- [youtube.com/watch?v=Uap_6bwtILQ](https://www.youtube.com/watch?v=Uap_6bwtILQ)

-* spontaneous reboot, especially in case of intensive web server access (improved since v2.1.0)
+For further background information, head to [Neural Networks](https://www.heise.de/select/make/2021/6/2126410443385102621), [Training Neural Networks](https://www.heise.de/select/make/2022/1/2134114065999161585) and [Programming on the ESP32](https://www.heise.de/select/make/2022/2/2204010051597422030).

------
+### Download
+The latest available version can be found on the [Releases page](https://github.com/jomjol/AI-on-the-edge-device/releases).

-**General remark:** Beside the `firmware.bin`, typically also the content of `/html` needs to be updated!
+### Flashing the ESP32
+Initially you will have to flash the ESP32 via a USB connection. Later updates are possible directly over the air (OTA using WIFI).

+There are different ways to flash your ESP32:
+- The preferred way is the [Web Installer and Console](https://jomjol.github.io/AI-on-the-edge-device/index.html) which is a browser-based tool to flash the ESP32 and extract the log over USB:
+![](images/web-installer.png)
+- Flash Tool from Espressif
+- ESPtool (command-line tool)

+See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/) for more information.

-##### Rolling - (2020-09-25)
+### Flashing the SD Card
+The SD card can be setup automatically after the firmware got installed. See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#remote-setup-using-the-built-in-access-point) for details. For this to work, the SD card must be FAT formated (which is the default on a new SD card).
+Alternatively the SD card still can be setup manually, see the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#3-sd-card) for details!

-* based on v2.1.0 (2020-09-25)
+## Casing
+Various 3D-printable housing can be found here:
+  - https://www.thingiverse.com/thing:4573481 (Water Meter)
+  - https://www.thingiverse.com/thing:5028229 (Power Meter)
+  - https://www.thingiverse.com/thing:5224101 (Gas Meter)
+  - https://www.thingiverse.com/thing:4571627 (ESP32-cam housing only)

-  
+## 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).

-##### 2.1.0 Layout update  (2020-09-25)
+<a href="https://www.paypal.com/donate?hosted_button_id=8TRSVYNYKDSWL"><img border="0" src="images/paypal.png" width="200px" target="_blank"></a>

-* Implementation of Decimal Shift
+## Support
+If you have any technical problems please search the [discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions). In case you found a ug or have a feature request, please open an [issue](https://github.com/jomjol/AI-on-the-edge-device/issues).

-* Update default CNN for digits to v6.4.0
+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">

-* Improvement HTML
+## Changes and History 
+See [Changelog](Changelog.md).

-* Support for Chrome and Firefox
+## Build It Yourself
+See [Build Instructions](code/README.md).

-* Reduce logging to minimum - extended logging on demand
+## Tools
+* Logfile downloader and combiner (Thx to [reserve85](https://github.com/reserve85))
+  * Files see ['/tools/logfile-tool'](tbd), how-to see [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/outdated--Gasmeter-Log-Downloader/)

-* 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
-
-
-#### [Full Changelog](Changelog.md)
-
-
-
-## Solved topics
-
-* n.a.
+## Additional Ideas
+There are some ideas and feature requests which are not currently being pursued – mainly due to capacity reasons on the part of the developers.
+They features are collected in the [issues](https://github.com/jomjol/AI-on-the-edge-device/issues) and in [FeatureRequest.md](FeatureRequest.md).
--- a/code/.gitignore
+++ b/code/.gitignore
@@ -1,6 +1,16 @@
 .pio
+.idea
 .vscode/.browse.c_cpp.db*
 .vscode/c_cpp_properties.json
 .vscode/launch.json
 .vscode/ipch
-.helper
+version.cpp
+sdkconfig.esp32cam
+sdkconfig.esp32cam-dev
+sdkconfig.esp32cam-debug
+sdkconfig.esp32cam-board-rev3
+sdkconfig.esp32cam-cpu-freq-240
+sdkconfig.esp32cam-board-rev3-cpu-freq-240
+sdkconfig.esp32cam-dev-himem
+sdkconfig.esp32cam-dev-task-analysis
+sdkconfig.esp32cam-no-softap
--- a/code/.helper/copy.bat
+++ b/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"
--- a/code/.helper/makezip.bat
+++ b/code/.helper/makezip.bat
@@ -0,0 +1 @@
+powershell Compress-Archive -Path "..\..\sd-card\html\*.*" -DestinationPath "..\..\firmware\html.zip"
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -1,8 +1,22 @@
 cmake_minimum_required(VERSION 3.16.0)

-list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common)
+list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/protocol_examples_common components/esp-tflite-micro)

-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)
+
+if(EXISTS "${SDKCONFIG}.defaults")
+    if(EXISTS "sdkconfig.defaults")
+        set(SDKCONFIG_DEFAULTS "${SDKCONFIG}.defaults;sdkconfig.defaults")
+        message(STATUS "-- Using defaults: ${SDKCONFIG_DEFAULTS} + sdkconfig.defaults")
+    else()
+        set(SDKCONFIG_DEFAULTS "${SDKCONFIG}.defaults")
+    endif()
+    message(STATUS "-- Using defaults: ${SDKCONFIG_DEFAULTS}")
+endif()

 include($ENV{IDF_PATH}/tools/cmake/project.cmake)
-project(esp32cam-server-only)
+project(AI-on-the-edge)
--- a/code/README.md
+++ b/code/README.md
@@ -0,0 +1,74 @@
+# Build
+
+## Preparations
+```
+git clone https://github.com/jomjol/AI-on-the-edge-device.git
+cd AI-on-the-edge-device
+git checkout rolling
+git submodule update --init
+```
+
+## Update Submodules
+```
+cd /components/submodule-name (e.g. tflite-micro-example)
+git checkout VERSION (e.g. HASH of latest tflite-micro-example build)
+cd ../../ (auf Ebene von code)
+git submodule update --init
+```
+Evt. muss man vorher noch einige Verzeichnisse in compenents von Hand löschen, da sie beim checkout nicht gelöscht wurden (vor update -- init)
+
+## Build and Flash within terminal
+See further down to build it within an IDE.
+### Compile
+```
+cd code
+platformio run --environment esp32cam
+```
+
+### Upload
+```
+pio run --target upload --upload-port /dev/ttyUSB0
+```
+
+Alternatively you also can set the UART device in `platformio.ini`, eg. `upload_port = /dev/ttyUSB0`
+
+### Monitor UART Log
+```
+pio device monitor -p /dev/ttyUSB0
+```
+
+## Build and Flash with Visual Code IDE
+
+- Download and install VS Code
+  - https://code.visualstudio.com/Download
+- Install the VS Code platform io plugin
+  - <img src="https://raw.githubusercontent.com/jomjol/ai-on-the-edge-device/master/images/platformio_plugin.jpg" width="200" align="middle">
+  - Check for error messages, maybe you need to manually add some python libraries
+    - e.g. in my Ubuntu a python3-env was missing: `sudo apt-get install python3-venv`
+- git clone this project
+  - in Linux: 
+
+    ```
+    git clone https://github.com/jomjol/AI-on-the-edge-device.git
+    cd AI-on-the-edge-device
+    git checkout rolling
+    git submodule update --init
+    ```
+
+- in VS code, open the `AI-on-the-edge-device/code` 
+	- from terminal: `cd AI-on-the-edge-device/code && code .`
+- open a pio terminal (click on the terminal sign in the bottom menu bar)
+- make sure you are in the `code` directory
+- To build, type  `platformio run --environment esp32cam`
+  - or use the graphical interface:
+    <img src="https://raw.githubusercontent.com/jomjol/ai-on-the-edge-device/master/images/platformio_build.jpg" width="200" align="middle">
+  - the build artifacts are stored in  `code/.pio/build/esp32cam/`
+- Connect the device and type `pio device monitor`. There you will see your device and can copy the name to the next instruction
+- Add `upload_port = you_device_port` to the `platformio.ini` file
+- make sure an sd card with the contents of the `sd_card` folder is inserted and you have changed the wifi details
+- `pio run --target erase` to erase the flash
+- `pio run --target upload` this will upload the `bootloader.bin, partitions.bin,firmware.bin` from the `code/.pio/build/esp32cam/` folder. 
+- `pio device monitor` to observe the logs via uart
+
+# Update Parameters
+If you create or rename a parameter, make sure to update its documentation in `../param-docs/parameter-pages`! Check the `../param-docs/README.md` for more information.
--- a/code/components/esp-nn
+++ b/code/components/esp-nn
--- a/code/components/esp-tflite-micro
+++ b/code/components/esp-tflite-micro
--- a/code/components/esp32-camera
+++ b/code/components/esp32-camera
--- a/code/components/jomjol_configfile/CMakeLists.txt
+++ b/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)
+
+
--- a/code/components/jomjol_configfile/configFile.cpp
+++ b/code/components/jomjol_configfile/configFile.cpp
@@ -0,0 +1,86 @@
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+#include "Helper.h"
+#include "configFile.h"
+#include <esp_log.h>
+
+#include "../../include/defines.h"
+
+static const char *TAG = "CONFIG";
+
+ConfigFile::ConfigFile(std::string filePath)
+{
+    std::string config = FormatFileName(filePath);
+    pFile = fopen(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;
+	}
+
+	if (fgets(zw, 1024, pFile))
+	{
+		ESP_LOGD(TAG, "%s", zw);
+		if ((strlen(zw) == 0) && feof(pFile))
+		{
+			*rt = "";
+			eof = true;
+			return false;
+		}
+	}
+	else
+	{
+		*rt = "";
+		eof = true;
+		return false;
+	}
+	*rt = zw;
+	*rt = trim(*rt);
+	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))
+	{
+		fgets(zw, 1024, pFile);
+		ESP_LOGD(TAG, "%s", zw);
+		if (feof(pFile))
+		{
+			*rt = "";
+            eof = true;
+			return false;
+		}
+		*rt = zw;
+		*rt = trim(*rt);
+	}
+
+    disabled = ((*rt)[0] == ';');
+	return true;
+}
--- a/code/components/jomjol_configfile/configFile.h
+++ b/code/components/jomjol_configfile/configFile.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef CONFIGFILE_H
+#define CONFIGFILE_H
+
+#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);
+    bool ConfigFileExists(){return pFile;};
+    
+private:
+    FILE* pFile;
+};
+
+#endif //CONFIGFILE_H
--- a/code/components/jomjol_controlGPIO/CMakeLists.txt
+++ b/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)
+
+
--- a/code/components/jomjol_controlGPIO/Color.cpp
+++ b/code/components/jomjol_controlGPIO/Color.cpp
@@ -0,0 +1,132 @@
+#include "Color.h"
+#include <algorithm>
+#include <cmath>
+#include <cassert>
+
+namespace {
+
+// Int -> fixed point
+int up( int x ) { return x * 255; }
+
+} // namespace
+
+int iRgbSqrt( int num ) {
+    // https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Binary_numeral_system_.28base_2.29
+    assert( "sqrt input should be non-negative" && num >= 0 );
+    assert( "sqrt input should no exceed 16 bits" && num <= 0xFFFF );
+    int res = 0;
+    int bit = 1 << 16;
+    while ( bit > num )
+        bit >>= 2;
+    while ( bit != 0 ) {
+        if ( num >= res + bit ) {
+            num -= res + bit;
+            res = ( res >> 1 ) + bit;
+        } else
+            res >>= 1;
+        bit >>= 2;
+    }
+    return res;
+}
+
+Rgb::Rgb( Hsv y ) {
+    // https://stackoverflow.com/questions/24152553/hsv-to-rgb-and-back-without-floating-point-math-in-python
+    // greyscale
+    if( y.s == 0 ) {
+        r = g = b = y.v;
+        return;
+    }
+
+    const int region = y.h / 43;
+    const int remainder = ( y.h - ( region * 43 ) ) * 6;
+
+    const int p = ( y.v * ( 255 - y.s ) ) >> 8;
+    const int q = ( y.v * ( 255 - ( ( y.s * remainder ) >> 8 ) ) ) >> 8;
+    const int t = ( y.v * ( 255 - ( ( y.s * (255 -remainder ) ) >> 8 ) ) ) >> 8;
+
+    switch( region ) {
+        case 0: r = y.v; g = t; b = p; break;
+        case 1: r = q; g = y.v; b = p; break;
+        case 2: r = p; g = y.v; b = t; break;
+        case 3: r = p; g = q; b = y.v; break;
+        case 4: r = t; g = p; b = y.v; break;
+        case 5: r = y.v; g = p; b = q; break;
+        default: __builtin_trap();
+    }
+
+    a = y.a;
+}
+
+Rgb& Rgb::operator=( Hsv hsv ) {
+    Rgb r{ hsv };
+    swap( r );
+    return *this;
+}
+
+Rgb Rgb::operator+( Rgb in ) const {
+    auto copy = *this;
+    copy += in;
+    return copy;
+}
+
+Rgb& Rgb::operator+=( Rgb in ) {
+    unsigned int red = r + in.r;
+    r = ( red < 255 ) ? red : 255;
+    unsigned int green = g + in.g;
+    g = ( green < 255 ) ? green : 255;
+    unsigned int blue = b + in.b;
+    b = ( blue < 255 ) ? blue : 255;
+    return *this;
+}
+
+Rgb& Rgb::blend( Rgb in ) {
+    unsigned int inAlpha = in.a * ( 255 - a );
+    unsigned int alpha = a + inAlpha;
+    r = iRgbSqrt( ( ( r * r * a ) + ( in.r * in.r * inAlpha ) ) / alpha );
+    g = iRgbSqrt( ( ( g * g * a ) + ( in.g * in.g * inAlpha ) ) / alpha );
+    b = iRgbSqrt( ( ( b * b * a ) + ( in.b * in.b * inAlpha ) ) / alpha );
+    a = alpha;
+    return *this;
+}
+
+uint8_t IRAM_ATTR Rgb::getGrb( int idx ) {
+    switch ( idx ) {
+        case 0: return g;
+        case 1: return r;
+        case 2: return b;
+    }
+    __builtin_unreachable();
+}
+
+Hsv::Hsv( Rgb r ) {
+    int min = std::min( r.r, std::min( r.g, r.b ) );
+    int max = std::max( r.r, std::max( r.g, r.b ) );
+    int chroma = max - min;
+
+    v = max;
+    if ( chroma == 0 ) {
+        h = s = 0;
+        return;
+    }
+
+    s = up( chroma ) / max;
+    int hh;
+    if ( max == r.r )
+        hh = ( up( int( r.g ) - int( r.b ) ) ) / chroma / 6;
+    else if ( max == r.g )
+        hh = 255 / 3 + ( up( int( r.b ) - int( r.r ) ) ) / chroma / 6;
+    else
+        hh = 2 * 255 / 3 + ( up( int( r.r ) - int( r.g ) ) ) / chroma / 6;
+
+    if ( hh < 0 )
+        hh += 255;
+    h = hh;
+
+    a = r.a;
+}
+
+Hsv& Hsv::operator=( Rgb rgb ) {
+    Hsv h{ rgb };
+    swap( h );
+    return *this;
+}
--- a/code/components/jomjol_controlGPIO/Color.h
+++ b/code/components/jomjol_controlGPIO/Color.h
@@ -0,0 +1,74 @@
+#pragma once
+
+#ifndef COLOR_H
+#define COLOR_H
+
+#include <cstdint>
+#include "esp_attr.h"
+union Hsv;
+
+union Rgb {
+    struct __attribute__ ((packed)) {
+        uint8_t r, g, b, a;
+    };
+    uint32_t value;
+
+    Rgb( uint8_t r = 0, uint8_t g = 0, uint8_t b = 0, uint8_t a = 255 ) : r( r ), g( g ), b( b ), a( a ) {}
+    Rgb( Hsv c );
+    Rgb& operator=( Rgb rgb ) { swap( rgb ); return *this; }
+    Rgb& operator=( Hsv hsv );
+    Rgb operator+( Rgb in ) const;
+    Rgb& operator+=( Rgb in );
+    bool operator==( Rgb in ) const { return in.value == value; }
+    Rgb& blend( Rgb in );
+    void swap( Rgb& o ) {  value = o.value; }
+    void linearize() {
+        r = channelGamma(r);
+        g = channelGamma(g);
+        b = channelGamma(b);
+    }
+
+    uint8_t IRAM_ATTR getGrb( int idx );
+
+    void stretchChannels( uint8_t maxR, uint8_t maxG, uint8_t maxB ) {
+        r = stretch( r, maxR );
+        g = stretch( g, maxG );
+        b = stretch( b, maxB );
+    }
+
+    void stretchChannelsEvenly( uint8_t max ) {
+        stretchChannels( max, max, max );
+    }
+
+private:
+    uint8_t stretch( int value, uint8_t max ) {
+        return ( value * max ) >> 8;
+    }
+
+    uint8_t channelGamma( int channel ) {
+        /* The optimal gamma correction is x^2.8. However, this is expensive to
+         * compute. Therefore, we use x^3 for gamma correction. Also, we add a
+         * bias as the WS2812 LEDs do not turn on for values less than 4. */
+        if (channel == 0)
+            return channel;
+        channel = channel * channel * channel * 251;
+        channel >>= 24;
+        return static_cast< uint8_t >( 4 + channel );
+    }
+};
+
+union Hsv {
+    struct __attribute__ ((packed)) {
+        uint8_t h, s, v, a;
+    };
+    uint32_t value;
+
+    Hsv( uint8_t h, uint8_t s = 0, uint8_t v = 0, uint8_t a = 255 ) : h( h ), s( s ), v( v ), a( a ) {}
+    Hsv( Rgb r );
+    Hsv& operator=( Hsv h ) { swap( h ); return *this; }
+    Hsv& operator=( Rgb rgb );
+    bool operator==( Hsv in ) const { return in.value == value; }
+    void swap( Hsv& o ) { value = o.value; }
+};
+
+#endif //COLOR_H
--- a/code/components/jomjol_controlGPIO/SmartLeds.cpp
+++ b/code/components/jomjol_controlGPIO/SmartLeds.cpp
@@ -0,0 +1,90 @@
+#include "SmartLeds.h"
+
+
+/* PlatformIO 6 (ESP IDF 5) does no longer allow access to RMTMEM,
+   see https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/peripherals.html?highlight=rmtmem#id5 
+   As a dirty workaround, we copy the needed structures from rmt_struct.h
+   In the long run, this should be replaced! */
+typedef struct rmt_item32_s {
+    union {
+        struct {
+            uint32_t duration0 :15;
+            uint32_t level0 :1;
+            uint32_t duration1 :15;
+            uint32_t level1 :1;
+        };
+        uint32_t val;
+    };
+} rmt_item32_t;
+
+//Allow access to RMT memory using RMTMEM.chan[0].data32[8]
+typedef volatile struct rmt_mem_s {
+    struct {
+        rmt_item32_t data32[64];
+    } chan[8];
+} rmt_mem_t;
+extern rmt_mem_t RMTMEM;
+
+
+
+IsrCore SmartLed::_interruptCore = CoreCurrent;
+intr_handle_t SmartLed::_interruptHandle = NULL;
+
+SmartLed*& IRAM_ATTR SmartLed::ledForChannel( int channel ) {
+    static SmartLed* table[8] = { nullptr };
+    assert( channel < 8 );
+    return table[ channel ];
+}
+
+void IRAM_ATTR SmartLed::interruptHandler(void*) {
+    for (int channel = 0; channel != 8; channel++) {
+        auto self = ledForChannel( channel );
+
+        if ( RMT.int_st.val & (1 << (24 + channel ) ) ) { // tx_thr_event
+            if ( self )
+                self->copyRmtHalfBlock();
+            RMT.int_clr.val |= 1 << ( 24 + channel );
+        } else if ( RMT.int_st.val & ( 1 << (3 * channel ) ) ) { // tx_end
+            if ( self )
+                xSemaphoreGiveFromISR( self->_finishedFlag, nullptr );
+            RMT.int_clr.val |= 1 << ( 3 * channel );
+        }
+    }
+}
+
+void IRAM_ATTR SmartLed::copyRmtHalfBlock() {
+    int offset = detail::MAX_PULSES * _halfIdx;
+    _halfIdx = !_halfIdx;
+    int len = 3 - _componentPosition + 3 * ( _count - 1 );
+    len = std::min( len, detail::MAX_PULSES / 8 );
+
+    if ( !len ) {
+        for ( int i = 0; i < detail::MAX_PULSES; i++) {
+            RMTMEM.chan[ _channel].data32[i + offset ].val = 0;
+        }
+    }
+
+    int i;
+    for ( i = 0; i != len && _pixelPosition != _count; i++ ) {
+        uint8_t val = _buffer[ _pixelPosition ].getGrb( _componentPosition );
+        for ( int j = 0; j != 8; j++, val <<= 1 ) {
+            int bit = val >> 7;
+            int idx = i * 8 + offset + j;
+            RMTMEM.chan[ _channel ].data32[ idx ].val = _bitToRmt[ bit & 0x01 ].value;
+        }
+        if ( _pixelPosition == _count - 1 && _componentPosition == 2 ) {
+            RMTMEM.chan[ _channel ].data32[ i * 8 + offset + 7 ].duration1 =
+                _timing.TRS / ( detail::RMT_DURATION_NS * detail::DIVIDER );
+        }
+
+        _componentPosition++;
+        if ( _componentPosition == 3 ) {
+            _componentPosition = 0;
+            _pixelPosition++;
+        }
+    }
+
+    for ( i *= 8; i != detail::MAX_PULSES; i++ ) {
+        RMTMEM.chan[ _channel ].data32[ i + offset ].val = 0;
+    }
+}
--- a/code/components/jomjol_controlGPIO/SmartLeds.h
+++ b/code/components/jomjol_controlGPIO/SmartLeds.h
@@ -0,0 +1,570 @@
+#pragma once
+
+#ifndef SMARTLEDS_H
+#define SMARTLEDS_H
+
+/*
+ * A C++ driver for the WS2812 LEDs using the RMT peripheral on the ESP32.
+ *
+ * Jan "yaqwsx" Mrázek <email@honzamrazek.cz>
+ *
+ * Based on the work by Martin F. Falatic - https://github.com/FozzTexx/ws2812-demo
+ */
+
+/*
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <memory>
+#include <cassert>
+#include <cstring>
+
+#include "esp_idf_version.h"
+#if (ESP_IDF_VERSION_MAJOR >= 5)
+#include "soc/periph_defs.h"
+#include "esp_private/periph_ctrl.h"
+#include "soc/gpio_sig_map.h"
+#include "soc/gpio_periph.h"
+#include "soc/io_mux_reg.h"
+#include "esp_rom_gpio.h"
+#define gpio_pad_select_gpio esp_rom_gpio_pad_select_gpio
+#define gpio_matrix_in(a,b,c) esp_rom_gpio_connect_in_signal(a,b,c)
+#define gpio_matrix_out(a,b,c,d) esp_rom_gpio_connect_out_signal(a,b,c,d)
+#define ets_delay_us(a) esp_rom_delay_us(a)
+#endif
+
+#if defined ( ARDUINO )
+    extern "C" { // ...someone forgot to put in the includes...
+        #include "esp32-hal.h"
+        #include "esp_intr_alloc.h"
+        #include "esp_ipc.h"
+        #include "driver/gpio.h"
+        #include "driver/periph_ctrl.h"
+        #include "freertos/semphr.h"
+        #include "soc/rmt_struct.h"
+        #include <driver/spi_master.h>
+        #include "esp_idf_version.h"
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL( 4, 0, 0 )
+        #include "soc/dport_reg.h"
+#endif
+    }
+#elif defined ( ESP_PLATFORM )
+    extern "C" { // ...someone forgot to put in the includes...
+        #include <esp_intr_alloc.h>
+        #include <esp_ipc.h>
+        #include <driver/gpio.h>
+        #include <freertos/FreeRTOS.h>
+        #include <freertos/semphr.h>
+        #include <soc/dport_reg.h>
+        #include <soc/gpio_sig_map.h>
+        #include <soc/rmt_struct.h>
+        #include <driver/spi_master.h>
+    }
+    #include <stdio.h>
+#endif
+
+#if (ESP_IDF_VERSION_MAJOR >= 4) && (ESP_IDF_VERSION_MINOR > 1)
+#include "hal/gpio_ll.h"
+#else
+#include "soc/gpio_periph.h"
+#define esp_rom_delay_us ets_delay_us
+static inline int gpio_ll_get_level(gpio_dev_t *hw, int gpio_num)
+{
+    if (gpio_num < 32) {
+        return (hw->in >> gpio_num) & 0x1;
+    } else {
+        return (hw->in1.data >> (gpio_num - 32)) & 0x1;
+    }
+}
+#endif
+
+#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0))
+#if !(configENABLE_BACKWARD_COMPATIBILITY == 1)
+#define xSemaphoreHandle SemaphoreHandle_t
+#endif
+#endif
+
+#include "Color.h"
+
+namespace detail {
+
+struct TimingParams {
+    uint32_t T0H;
+    uint32_t T1H;
+    uint32_t T0L;
+    uint32_t T1L;
+    uint32_t TRS;
+};
+
+union RmtPulsePair {
+    struct {
+        int duration0:15;
+        int level0:1;
+        int duration1:15;
+        int level1:1;
+    };
+    uint32_t value;
+};
+
+static const int DIVIDER = 4; // 8 still seems to work, but timings become marginal
+static const int MAX_PULSES = 32; // A channel has a 64 "pulse" buffer - we use half per pass
+static const double RMT_DURATION_NS = 12.5; // minimum time of a single RMT duration based on clock ns
+
+} // namespace detail
+
+using LedType = detail::TimingParams;
+
+static const LedType LED_WS2812  = { 350, 700, 800, 600, 50000 };
+static const LedType LED_WS2812B = { 400, 850, 850, 400, 50100 };
+static const LedType LED_SK6812  = { 300, 600, 900, 600, 80000 };
+static const LedType LED_WS2813  = { 350, 800, 350, 350, 300000 };
+
+enum BufferType { SingleBuffer = 0, DoubleBuffer };
+
+enum IsrCore { CoreFirst = 0, CoreSecond = 1, CoreCurrent = 2};
+
+class SmartLed {
+public:
+    // The RMT interrupt must not run on the same core as WiFi interrupts, otherwise SmartLeds
+    // can't fill the RMT buffer fast enough, resulting in rendering artifacts.
+    // Usually, that means you have to set isrCore == CoreSecond.
+    //
+    // If you use anything other than CoreCurrent, the FreeRTOS scheduler MUST be already running,
+    // so you can't use it if you define SmartLed as global variable.
+    SmartLed( const LedType& type, int count, int pin, int channel = 0, BufferType doubleBuffer = SingleBuffer, IsrCore isrCore = CoreCurrent)
+        : _timing( type ),
+          _channel( channel ),
+          _count( count ),
+          _firstBuffer( new Rgb[ count ] ),
+          _secondBuffer( doubleBuffer ? new Rgb[ count ] : nullptr ),
+          _finishedFlag( xSemaphoreCreateBinary() )
+    {
+        assert( channel >= 0 && channel < 8 );
+        assert( ledForChannel( channel ) == nullptr );
+
+        xSemaphoreGive( _finishedFlag );
+
+        DPORT_SET_PERI_REG_MASK( DPORT_PERIP_CLK_EN_REG, DPORT_RMT_CLK_EN );
+        DPORT_CLEAR_PERI_REG_MASK( DPORT_PERIP_RST_EN_REG, DPORT_RMT_RST );
+
+        PIN_FUNC_SELECT( GPIO_PIN_MUX_REG[ pin ], 2 );
+        gpio_set_direction( static_cast< gpio_num_t >( pin ), GPIO_MODE_OUTPUT );
+        gpio_matrix_out( static_cast< gpio_num_t >( pin ), RMT_SIG_OUT0_IDX + _channel, 0, 0 );
+        initChannel( _channel );
+
+        RMT.tx_lim_ch[ _channel ].limit = detail::MAX_PULSES;
+        RMT.int_ena.val |= 1 << ( 24 + _channel );
+        RMT.int_ena.val |= 1 << ( 3 * _channel );
+
+        _bitToRmt[ 0 ].level0 = 1;
+        _bitToRmt[ 0 ].level1 = 0;
+        _bitToRmt[ 0 ].duration0 = _timing.T0H / ( detail::RMT_DURATION_NS * detail::DIVIDER );
+        _bitToRmt[ 0 ].duration1 = _timing.T0L / ( detail::RMT_DURATION_NS * detail::DIVIDER );
+
+        _bitToRmt[ 1 ].level0 = 1;
+        _bitToRmt[ 1 ].level1 = 0;
+        _bitToRmt[ 1 ].duration0 = _timing.T1H / ( detail::RMT_DURATION_NS * detail::DIVIDER );
+        _bitToRmt[ 1 ].duration1 = _timing.T1L / ( detail::RMT_DURATION_NS * detail::DIVIDER );
+
+        if ( !anyAlive() ) {
+            _interruptCore = isrCore;
+            if(isrCore != CoreCurrent) {
+                ESP_ERROR_CHECK(esp_ipc_call_blocking(isrCore, registerInterrupt, NULL));
+            } else {
+                registerInterrupt(NULL);
+            }
+        }
+
+        ledForChannel( channel ) = this;
+    }
+
+    ~SmartLed() {
+        ledForChannel( _channel ) = nullptr;
+        if ( !anyAlive() ) {
+            if(_interruptCore != CoreCurrent) {
+                ESP_ERROR_CHECK(esp_ipc_call_blocking(_interruptCore, unregisterInterrupt, NULL));
+            } else {
+                unregisterInterrupt(NULL);
+            }
+        }
+        vSemaphoreDelete( _finishedFlag );
+    }
+
+    Rgb& operator[]( int idx ) {
+        return _firstBuffer[ idx ];
+    }
+
+    const Rgb& operator[]( int idx ) const {
+        return _firstBuffer[ idx ];
+    }
+
+    void show() {
+        _buffer = _firstBuffer.get();
+        startTransmission();
+        swapBuffers();
+    }
+
+    bool wait( TickType_t timeout = portMAX_DELAY ) {
+        if( xSemaphoreTake( _finishedFlag, timeout ) == pdTRUE ) {
+            xSemaphoreGive( _finishedFlag );
+            return true;
+        }
+        return false;
+    }
+
+    int size() const {
+        return _count;
+    }
+
+    Rgb *begin() { return _firstBuffer.get(); }
+    const Rgb *begin() const { return _firstBuffer.get(); }
+    const Rgb *cbegin() const { return _firstBuffer.get(); }
+
+    Rgb *end() { return _firstBuffer.get() + _count; }
+    const Rgb *end() const { return _firstBuffer.get() + _count; }
+    const Rgb *cend() const { return _firstBuffer.get() + _count; }
+
+private:
+    static intr_handle_t _interruptHandle;
+    static IsrCore _interruptCore;
+
+    static void initChannel( int channel ) {
+        RMT.apb_conf.fifo_mask = 1;  //enable memory access, instead of FIFO mode.
+        RMT.apb_conf.mem_tx_wrap_en = 1; //wrap around when hitting end of buffer
+        RMT.conf_ch[ channel ].conf0.div_cnt = detail::DIVIDER;
+        RMT.conf_ch[ channel ].conf0.mem_size = 1;
+        RMT.conf_ch[ channel ].conf0.carrier_en = 0;
+        RMT.conf_ch[ channel ].conf0.carrier_out_lv = 1;
+        RMT.conf_ch[ channel ].conf0.mem_pd = 0;
+
+        RMT.conf_ch[ channel ].conf1.rx_en = 0;
+        RMT.conf_ch[ channel ].conf1.mem_owner = 0;
+        RMT.conf_ch[ channel ].conf1.tx_conti_mode = 0;    //loop back mode.
+        RMT.conf_ch[ channel ].conf1.ref_always_on = 1;    // use apb clock: 80M
+        RMT.conf_ch[ channel ].conf1.idle_out_en = 1;
+        RMT.conf_ch[ channel ].conf1.idle_out_lv = 0;
+    }
+
+    static void registerInterrupt(void *) {
+        ESP_ERROR_CHECK(esp_intr_alloc( ETS_RMT_INTR_SOURCE, 0, interruptHandler, nullptr, &_interruptHandle));
+    }
+
+    static void unregisterInterrupt(void*) {
+        esp_intr_free( _interruptHandle );
+    }
+
+    static SmartLed*& IRAM_ATTR ledForChannel( int channel );
+    static void IRAM_ATTR interruptHandler( void* );
+
+    void IRAM_ATTR copyRmtHalfBlock();
+
+    void swapBuffers() {
+        if ( _secondBuffer )
+            _firstBuffer.swap( _secondBuffer );
+    }
+
+    void startTransmission() {
+        // Invalid use of the library
+        if( xSemaphoreTake( _finishedFlag, 0 ) != pdTRUE )
+            abort();
+
+        _pixelPosition = _componentPosition = _halfIdx = 0;
+        copyRmtHalfBlock();
+        if ( _pixelPosition < _count )
+            copyRmtHalfBlock();
+
+        RMT.conf_ch[ _channel ].conf1.mem_rd_rst = 1;
+        RMT.conf_ch[ _channel ].conf1.tx_start = 1;
+    }
+
+    static bool anyAlive() {
+        for ( int i = 0; i != 8; i++ )
+            if ( ledForChannel( i ) != nullptr ) return true;
+        return false;
+    }
+
+    const LedType& _timing;
+    int _channel;
+    detail::RmtPulsePair _bitToRmt[ 2 ];
+    int _count;
+    std::unique_ptr< Rgb[] > _firstBuffer;
+    std::unique_ptr< Rgb[] > _secondBuffer;
+    Rgb *_buffer;
+
+    xSemaphoreHandle _finishedFlag;
+
+    int _pixelPosition;
+    int _componentPosition;
+    int _halfIdx;
+};
+
+class Apa102 {
+public:
+    struct ApaRgb {
+        ApaRgb( uint8_t r = 0, uint8_t g = 0, uint32_t b = 0, uint32_t v = 0xFF )
+            : v( 0xE0 | v ), b( b ), g( g ), r( r )
+        {}
+
+        ApaRgb& operator=( const Rgb& o ) {
+            r = o.r;
+            g = o.g;
+            b = o.b;
+            return *this;
+        }
+
+        ApaRgb& operator=( const Hsv& o ) {
+            *this = Rgb{ o };
+            return *this;
+        }
+
+        uint8_t v, b, g, r;
+    };
+
+    static const int FINAL_FRAME_SIZE = 4;
+    static const int TRANS_COUNT = 2 + 8;
+
+    Apa102( int count, int clkpin, int datapin, BufferType doubleBuffer = SingleBuffer )
+        : _count( count ),
+          _firstBuffer( new ApaRgb[ count ] ),
+          _secondBuffer( doubleBuffer ? new ApaRgb[ count ] : nullptr ),
+          _initFrame( 0 )
+    {
+        spi_bus_config_t buscfg;
+        memset( &buscfg, 0, sizeof( buscfg ) );
+        buscfg.mosi_io_num = datapin;
+        buscfg.miso_io_num = -1;
+        buscfg.sclk_io_num = clkpin;
+        buscfg.quadwp_io_num = -1;
+        buscfg.quadhd_io_num = -1;
+        buscfg.max_transfer_sz = 65535;
+
+        spi_device_interface_config_t devcfg;
+        memset( &devcfg, 0, sizeof( devcfg ) );
+        devcfg.clock_speed_hz = 1000000;
+        devcfg.mode = 0;
+        devcfg.spics_io_num = -1;
+        devcfg.queue_size = TRANS_COUNT;
+        devcfg.pre_cb = nullptr;
+
+        auto ret = spi_bus_initialize( HSPI_HOST, &buscfg, 1 );
+        assert( ret == ESP_OK );
+
+        ret = spi_bus_add_device( HSPI_HOST, &devcfg, &_spi );
+        assert( ret == ESP_OK );
+
+        std::fill_n( _finalFrame, FINAL_FRAME_SIZE, 0xFFFFFFFF );
+    }
+
+    ~Apa102() {
+        // ToDo
+    }
+
+    ApaRgb& operator[]( int idx ) {
+        return _firstBuffer[ idx ];
+    }
+
+    const ApaRgb& operator[]( int idx ) const {
+        return _firstBuffer[ idx ];
+    }
+
+    void show() {
+        _buffer = _firstBuffer.get();
+        startTransmission();
+        swapBuffers();
+    }
+
+    void wait() {
+        for ( int i = 0; i != _transCount; i++ ) {
+            spi_transaction_t *t;
+            spi_device_get_trans_result( _spi, &t, portMAX_DELAY );
+        }
+    }
+private:
+    void swapBuffers() {
+        if ( _secondBuffer )
+            _firstBuffer.swap( _secondBuffer );
+    }
+
+    void startTransmission() {
+        for ( int i = 0; i != TRANS_COUNT; i++ ) {
+            _transactions[ i ].cmd = 0;
+            _transactions[ i ].addr = 0;
+            _transactions[ i ].flags = 0;
+            _transactions[ i ].rxlength = 0;
+            _transactions[ i ].rx_buffer = nullptr;
+        }
+        // Init frame
+        _transactions[ 0 ].length = 32;
+        _transactions[ 0 ].tx_buffer = &_initFrame;
+        spi_device_queue_trans( _spi, _transactions + 0, portMAX_DELAY );
+        // Data
+        _transactions[ 1 ].length = 32 * _count;
+        _transactions[ 1 ].tx_buffer = _buffer;
+        spi_device_queue_trans( _spi, _transactions + 1, portMAX_DELAY );
+        _transCount = 2;
+        // End frame
+        for ( int i = 0; i != 1 + _count / 32 / FINAL_FRAME_SIZE; i++ ) {
+            _transactions[ 2 + i ].length = 32 * FINAL_FRAME_SIZE;
+            _transactions[ 2 + i ].tx_buffer = _finalFrame;
+            spi_device_queue_trans( _spi, _transactions + 2 + i, portMAX_DELAY );
+            _transCount++;
+        }
+    }
+
+    spi_device_handle_t _spi;
+    int _count;
+    std::unique_ptr< ApaRgb[] > _firstBuffer, _secondBuffer;
+    ApaRgb *_buffer;
+
+    spi_transaction_t _transactions[ TRANS_COUNT ];
+    int _transCount;
+
+    uint32_t _initFrame;
+    uint32_t _finalFrame[ FINAL_FRAME_SIZE ];
+};
+
+class LDP8806 {
+public:
+    struct LDP8806_GRB {
+
+        LDP8806_GRB( uint8_t g_7bit = 0, uint8_t r_7bit = 0, uint32_t b_7bit = 0 )
+            : g( g_7bit ), r( r_7bit ), b( b_7bit )
+        {
+        }
+
+        LDP8806_GRB& operator=( const Rgb& o ) {
+            //Convert 8->7bit colour
+            r = ( o.r * 127 / 256 ) | 0x80;
+            g = ( o.g * 127 / 256 ) | 0x80;
+            b = ( o.b * 127 / 256 ) | 0x80;
+            return *this;
+        }
+
+        LDP8806_GRB& operator=( const Hsv& o ) {
+            *this = Rgb{ o };
+            return *this;
+        }
+
+        uint8_t g, r, b;
+    };
+
+    static const int LED_FRAME_SIZE_BYTES = sizeof( LDP8806_GRB );
+    static const int LATCH_FRAME_SIZE_BYTES = 3;
+    static const int TRANS_COUNT_MAX = 20;//Arbitrary, supports up to 600 LED
+
+    LDP8806( int count, int clkpin, int datapin, BufferType doubleBuffer = SingleBuffer, uint32_t clock_speed_hz = 2000000 )
+        : _count( count ),
+          _firstBuffer( new LDP8806_GRB[ count ] ),
+          _secondBuffer( doubleBuffer ? new LDP8806_GRB[ count ] : nullptr ),
+          // one 'latch'/start-of-data mark frame for every 32 leds
+          _latchFrames( ( count + 31 ) / 32 )
+    {
+        spi_bus_config_t buscfg;
+        memset( &buscfg, 0, sizeof( buscfg ) );
+        buscfg.mosi_io_num = datapin;
+        buscfg.miso_io_num = -1;
+        buscfg.sclk_io_num = clkpin;
+        buscfg.quadwp_io_num = -1;
+        buscfg.quadhd_io_num = -1;
+        buscfg.max_transfer_sz = 65535;
+
+        spi_device_interface_config_t devcfg;
+        memset( &devcfg, 0, sizeof( devcfg ) );
+        devcfg.clock_speed_hz = clock_speed_hz;
+        devcfg.mode = 0;
+        devcfg.spics_io_num = -1;
+        devcfg.queue_size = TRANS_COUNT_MAX;
+        devcfg.pre_cb = nullptr;
+
+        auto ret = spi_bus_initialize( HSPI_HOST, &buscfg, 1 );
+        assert( ret == ESP_OK );
+
+        ret = spi_bus_add_device( HSPI_HOST, &devcfg, &_spi );
+        assert( ret == ESP_OK );
+
+        std::fill_n( _latchBuffer, LATCH_FRAME_SIZE_BYTES, 0x0 );
+    }
+
+    ~LDP8806() {
+        // noop
+    }
+
+    LDP8806_GRB& operator[]( int idx ) {
+        return _firstBuffer[ idx ];
+    }
+
+    const LDP8806_GRB& operator[]( int idx ) const {
+        return _firstBuffer[ idx ];
+    }
+
+    void show() {
+        _buffer = _firstBuffer.get();
+        startTransmission();
+        swapBuffers();
+    }
+
+    void wait() {
+        while ( _transCount-- ) {
+            spi_transaction_t *t;
+            spi_device_get_trans_result( _spi, &t, portMAX_DELAY );
+        }
+    }
+private:
+    void swapBuffers() {
+        if ( _secondBuffer )
+            _firstBuffer.swap( _secondBuffer );
+    }
+
+    void startTransmission() {
+        _transCount = 0;
+        for ( int i = 0; i != TRANS_COUNT_MAX; i++ ) {
+            _transactions[ i ].cmd = 0;
+            _transactions[ i ].addr = 0;
+            _transactions[ i ].flags = 0;
+            _transactions[ i ].rxlength = 0;
+            _transactions[ i ].rx_buffer = nullptr;
+        }
+        // LED Data
+        _transactions[ 0 ].length = ( LED_FRAME_SIZE_BYTES * 8 ) * _count;
+        _transactions[ 0 ].tx_buffer = _buffer;
+        spi_device_queue_trans( _spi, _transactions + _transCount, portMAX_DELAY );
+        _transCount++;
+
+        // 'latch'/start-of-data marker frames
+        for ( int i = 0; i < _latchFrames; i++ ) {
+            _transactions[ _transCount ].length = ( LATCH_FRAME_SIZE_BYTES * 8 );
+            _transactions[ _transCount ].tx_buffer = _latchBuffer;
+            spi_device_queue_trans( _spi, _transactions + _transCount, portMAX_DELAY );
+            _transCount++;
+        }
+    }
+
+    spi_device_handle_t _spi;
+    int _count;
+    std::unique_ptr< LDP8806_GRB[] > _firstBuffer, _secondBuffer;
+    LDP8806_GRB *_buffer;
+
+    spi_transaction_t _transactions[ TRANS_COUNT_MAX ];
+    int _transCount;
+
+    int _latchFrames;
+    uint8_t _latchBuffer[ LATCH_FRAME_SIZE_BYTES ];
+};
+
+#endif //SMARTLEDS_H
--- a/code/components/jomjol_controlGPIO/server_GPIO.cpp
+++ b/code/components/jomjol_controlGPIO/server_GPIO.cpp
@@ -0,0 +1,705 @@
+#include <string>
+#include <functional>
+#include "string.h"
+
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+
+#include "esp_log.h"
+
+#include <sys/stat.h>
+#include <vector>
+
+#include "../../include/defines.h"
+
+#include "server_GPIO.h"
+
+#include "ClassLogFile.h"
+#include "configFile.h"
+#include "Helper.h"
+
+#ifdef ENABLE_MQTT
+#include "interface_mqtt.h"
+#include "server_mqtt.h"
+#endif //ENABLE_MQTT
+
+
+static const char *TAG = "GPIO";
+QueueHandle_t gpio_queue_handle = NULL;
+
+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,"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,"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,"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) {
+#ifdef ENABLE_MQTT    
+    if (_mqttTopic.compare("") != 0) {
+        ESP_LOGD(TAG, "gpioInterrupt %s %d", _mqttTopic.c_str(), value);
+
+        MQTTPublish(_mqttTopic, value ? "true" : "false", 1);        
+    }
+#endif //ENABLE_MQTT
+    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) {                // ohne GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X, wenn das genutzt wird, dann soll auch der Handler hier nicht initialisiert werden, da das dann über SmartLED erfolgt.
+    if ((_interruptType != GPIO_INTR_DISABLE) && (_interruptType != GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X)) {
+        //hook isr handler for specific gpio pin
+        ESP_LOGD(TAG, "GpioPin::init add isr handler for GPIO %d", _gpio);
+        gpio_isr_handler_add(_gpio, gpio_isr_handler, (void*)&_gpio);
+    }
+
+#ifdef ENABLE_MQTT
+    if ((_mqttTopic.compare("") != 0) && ((_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);
+    }
+#endif //ENABLE_MQTT
+}
+
+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, "GpioPin::setValue %d", 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);
+
+#ifdef ENABLE_MQTT
+        if ((_mqttTopic.compare("") != 0) && (setSource != GPIO_SET_SOURCE_MQTT)) {
+            MQTTPublish(_mqttTopic, value ? "true" : "false", 1);
+        }
+#endif //ENABLE_MQTT
+    }
+}
+
+void GpioPin::publishState() {
+    int newState = gpio_get_level(_gpio);
+    if (newState != currentState) {
+        ESP_LOGD(TAG,"publish state of GPIO %d new state %d", _gpio, newState);
+#ifdef ENABLE_MQTT
+    if (_mqttTopic.compare("") != 0)
+        MQTTPublish(_mqttTopic, newState ? "true" : "false", 1);
+#endif //ENABLE_MQTT
+        currentState = newState;
+    }
+}
+
+#ifdef ENABLE_MQTT
+bool GpioPin::handleMQTT(std::string, char* data, int data_len) {
+    ESP_LOGD(TAG, "GpioPin::handleMQTT data %.*s", 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, "%s", errorText.c_str());
+    }
+
+    return (errorText == "");
+}
+#endif //ENABLE_MQTT
+
+esp_err_t callHandleHttpRequest(httpd_req_t *req)
+{
+    ESP_LOGD(TAG,"callHandleHttpRequest");
+
+    GpioHandler *gpioHandler = (GpioHandler*)req->user_ctx;
+    return gpioHandler->handleHttpRequest(req);
+}
+
+void taskGpioHandler(void *pvParameter)
+{
+    ESP_LOGD(TAG,"taskGpioHandler");
+    ((GpioHandler*)pvParameter)->init();
+}
+
+GpioHandler::GpioHandler(std::string configFile, httpd_handle_t httpServer) 
+{
+    ESP_LOGI(TAG,"start GpioHandler");
+    _configFile = configFile;
+    _httpServer = httpServer;
+
+    ESP_LOGI(TAG, "register GPIO Uri");
+    registerGpioUri();
+}
+
+GpioHandler::~GpioHandler()  {
+    if (gpioMap != NULL) {
+        clear();
+        delete gpioMap;
+    }
+}
+
+void GpioHandler::init()
+{
+    // TickType_t xDelay = 60000 / portTICK_PERIOD_MS;
+    // ESP_LOGD(TAG, "wait before start %ldms", (long) xDelay);
+    // vTaskDelay( xDelay );
+
+    ESP_LOGD(TAG, "*************** Start GPIOHandler_Init *****************");
+
+    if (gpioMap == NULL) {
+        gpioMap = new std::map<gpio_num_t, GpioPin*>();
+    } else {
+        clear();
+    }
+    
+    
+    ESP_LOGI(TAG, "read GPIO config and init GPIO");
+    if (!readConfig()) {
+        clear();
+        delete gpioMap;
+        gpioMap = NULL;
+        ESP_LOGI(TAG, "GPIO init completed, handler is disabled");
+        return;
+    }
+
+
+    for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) {
+        it->second->init();
+    }
+
+#ifdef ENABLE_MQTT
+    std::function<void()> f = std::bind(&GpioHandler::handleMQTTconnect, this);
+    MQTTregisterConnectFunction("gpio-handler", f);
+#endif //ENABLE_MQTT
+
+    if (xHandleTaskGpio == NULL) {
+        gpio_queue_handle = xQueueCreate(10,sizeof(GpioResult));
+        BaseType_t  xReturned = xTaskCreate(&gpioHandlerTask, "gpio_int", 3 * 1024, (void *)this, tskIDLE_PRIORITY + 4, &xHandleTaskGpio);
+        if(xReturned == pdPASS ) {
+            ESP_LOGD(TAG, "xHandletaskGpioHandler started");
+        } else {
+            ESP_LOGD(TAG, "xHandletaskGpioHandler not started %d ", (int)xHandleTaskGpio);
+        }
+    }
+
+    ESP_LOGI(TAG, "GPIO init completed, 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();
+        }
+    }
+}
+
+#ifdef ENABLE_MQTT
+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();
+        }
+    }
+}
+#endif //ENABLE_MQTT
+
+void GpioHandler::deinit() {
+#ifdef ENABLE_MQTT
+    MQTTunregisterConnectFunction("gpio-handler");
+#endif //ENABLE_MQTT
+    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> splitted;
+    std::string line = "";
+    bool disabledLine = false;
+    bool eof = false;
+    gpio_num_t gpioExtLED = (gpio_num_t) 0;
+    
+//    ESP_LOGD(TAG, "readConfig - Start 1");
+        
+    while ((!configFile.GetNextParagraph(line, disabledLine, eof) || (line.compare("[GPIO]") != 0)) && !eof) {}
+    if (eof)
+        return false;
+
+//    ESP_LOGD(TAG, "readConfig - Start 2 line: %s, disabbledLine: %d", line.c_str(), (int) disabledLine);
+
+
+    _isEnabled = !disabledLine;
+
+    if (!_isEnabled)
+        return false;
+
+//    ESP_LOGD(TAG, "readConfig - Start 3");
+
+#ifdef ENABLE_MQTT
+//    std::string mainTopicMQTT = "";
+    std::string mainTopicMQTT = mqttServer_getMainTopic();
+    if (mainTopicMQTT.length() > 0)
+    {
+        mainTopicMQTT = mainTopicMQTT + "/GPIO";
+        ESP_LOGD(TAG, "MAINTOPICMQTT found");
+    }
+#endif // ENABLE_MQTT
+    bool registerISR = false;
+    while (configFile.getNextLine(&line, disabledLine, eof) && !configFile.isNewParagraph(line))
+    {
+        splitted = ZerlegeZeile(line);
+        // const std::regex pieces_regex("IO([0-9]{1,2})");
+        // std::smatch pieces_match;
+        // if (std::regex_match(splitted[0], pieces_match, pieces_regex) && (pieces_match.size() == 2))
+        // {
+        //     std::string gpioStr = pieces_match[1];
+        ESP_LOGD(TAG, "conf param %s", toUpper(splitted[0]).c_str());
+        if (toUpper(splitted[0]) == "MAINTOPICMQTT") {
+//            ESP_LOGD(TAG, "MAINTOPICMQTT found");
+//            mainTopicMQTT = splitted[1];
+        } else if ((splitted[0].rfind("IO", 0) == 0) && (splitted.size() >= 6))
+        {
+            ESP_LOGI(TAG,"Enable GP%s in %s mode", splitted[0].c_str(), splitted[1].c_str());
+            std::string gpioStr = splitted[0].substr(2, 2);
+            gpio_num_t gpioNr = (gpio_num_t)atoi(gpioStr.c_str());
+            gpio_pin_mode_t pinMode = resolvePinMode(toLower(splitted[1]));
+            gpio_int_type_t intType = resolveIntType(toLower(splitted[2]));
+            uint16_t dutyResolution = (uint8_t)atoi(splitted[3].c_str());
+#ifdef ENABLE_MQTT 
+            bool mqttEnabled = (toLower(splitted[4]) == "true");
+#endif // ENABLE_MQTT
+            bool httpEnabled = (toLower(splitted[5]) == "true");
+            char gpioName[100];
+            if (splitted.size() >= 7) {
+                strcpy(gpioName, trim(splitted[6]).c_str());
+            } else {
+                sprintf(gpioName, "GPIO%d", gpioNr);
+            }
+#ifdef ENABLE_MQTT            
+            std::string mqttTopic = mqttEnabled ? (mainTopicMQTT + "/" + gpioName) : "";
+#else // ENABLE_MQTT
+            std::string mqttTopic = "";
+#endif // ENABLE_MQTT
+            GpioPin* gpioPin = new GpioPin(gpioNr, gpioName, pinMode, intType,dutyResolution, mqttTopic, httpEnabled);
+            (*gpioMap)[gpioNr] = gpioPin;
+
+            if (pinMode == GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X)
+            {
+                ESP_LOGD(TAG, "Set WS2812 to GPIO %d", gpioNr);
+                gpioExtLED = gpioNr;
+            }
+
+            if (intType != GPIO_INTR_DISABLE) {
+                registerISR = true;
+            }
+        }
+        if (toUpper(splitted[0]) == "LEDNUMBERS")
+        {
+            LEDNumbers = stoi(splitted[1]);
+        }
+        if (toUpper(splitted[0]) == "LEDCOLOR")
+        {
+            uint8_t _r, _g, _b;
+            _r = stoi(splitted[1]);
+            _g = stoi(splitted[2]);
+            _b = stoi(splitted[3]);
+
+            LEDColor = Rgb{_r, _g, _b};
+        }
+        if (toUpper(splitted[0]) == "LEDTYPE")
+        {
+            if (splitted[1] == "WS2812")
+                LEDType = LED_WS2812;
+            if (splitted[1] == "WS2812B")
+                LEDType = LED_WS2812B;
+            if (splitted[1] == "SK6812")
+                LEDType = LED_SK6812;
+            if (splitted[1] == "WS2813")
+                LEDType = LED_WS2813;
+        }
+    }
+
+    if (registerISR) {
+        //install gpio isr service
+        gpio_install_isr_service(ESP_INTR_FLAG_LOWMED | ESP_INTR_FLAG_IRAM);
+    }
+
+    if (gpioExtLED > 0)
+    {
+    //     LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Startsequence 06");      // Nremove
+//        vTaskDelay( xDelay );   
+//        xDelay = 5000 / portTICK_PERIOD_MS;
+//        ESP_LOGD(TAG, "main: sleep for: %ldms", (long) xDelay);
+
+//        SmartLed leds( LED_WS2812, 2, GPIO_NUM_12, 0, DoubleBuffer );
+
+
+//        leds[ 0 ] = Rgb{ 255, 0, 0 };
+//        leds[ 1 ] = Rgb{ 255, 255, 255 };
+//        leds.show();    
+//        SmartLed leds = new SmartLed(LEDType, LEDNumbers, gpioExtLED, 0, DoubleBuffer);
+//        _SmartLED = new SmartLed( LED_WS2812, 2, GPIO_NUM_12, 0, DoubleBuffer );
+    }
+
+    return true;
+}
+
+void GpioHandler::clear() 
+{
+    ESP_LOGD(TAG, "GpioHandler::clear");
+
+    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, "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, "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(ESP_LOG_DEBUG, TAG, "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, "Query: %s", _query);
+        
+        if (httpd_query_key_value(_query, "GPIO", _valueGPIO, 30) == ESP_OK)
+        {
+            ESP_LOGD(TAG, "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, "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) + " unsupported - 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, "GpioHandler::flashLightEnable %s", 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, "Flash light pin GPIO %d switched to %s", (int)it->first, (value ? "on" : "off"));
+                } else {
+                    ESP_LOGE(TAG, "Can't set flash light pin GPIO %d.  Error: %s", (int)it->first, resp_str.c_str());
+                }
+            } else 
+                {
+                    if (it->second->getMode() == GPIO_PIN_MODE_EXTERNAL_FLASH_WS281X)
+                    {
+#ifdef __LEDGLOBAL
+                        if (leds_global == NULL) {
+                            ESP_LOGI(TAG, "init SmartLed: LEDNumber=%d, GPIO=%d", LEDNumbers, (int)it->second->getGPIO());
+                            leds_global = new SmartLed( LEDType, LEDNumbers, it->second->getGPIO(), 0, DoubleBuffer );
+                        } else {
+                            // wait until we can update: https://github.com/RoboticsBrno/SmartLeds/issues/10#issuecomment-386921623
+                            leds_global->wait();
+                        }
+#else
+                        SmartLed leds( LEDType, LEDNumbers, it->second->getGPIO(), 0, DoubleBuffer );
+#endif
+  
+                        if (value)
+                        {
+                            for (int i = 0; i < LEDNumbers; ++i)
+#ifdef __LEDGLOBAL
+                                (*leds_global)[i] = LEDColor;
+#else
+                                leds[i] = LEDColor;
+#endif
+                        }
+                        else
+                        {
+                            for (int i = 0; i < LEDNumbers; ++i)
+#ifdef __LEDGLOBAL
+                                (*leds_global)[i] = Rgb{0, 0, 0};
+#else
+                                leds[i] = Rgb{0, 0, 0};
+#endif
+                        }
+#ifdef __LEDGLOBAL
+                        leds_global->show(); 
+#else
+                        leds.show(); 
+#endif 
+                    }
+                }
+        }
+    }
+}
+
+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) {
+        gpio_handler_deinit();
+        delete gpioHandler;
+        gpioHandler = NULL;
+    }
+}
+
+GpioHandler* gpio_handler_get()
+{
+    return gpioHandler;
+}
+
--- a/code/components/jomjol_controlGPIO/server_GPIO.h
+++ b/code/components/jomjol_controlGPIO/server_GPIO.h
@@ -0,0 +1,114 @@
+#pragma once
+
+#ifndef SERVER_GPIO_H
+#define SERVER_GPIO_H
+
+#include <esp_log.h>
+
+#include <esp_http_server.h>
+#include <map>
+#include "driver/gpio.h"
+
+#include "SmartLeds.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);
+#ifdef ENABLE_MQTT
+    bool handleMQTT(std::string, char* data, int data_len);
+#endif //ENABLE_MQTT
+    void publishState();
+    void gpioInterrupt(int value);
+    gpio_int_type_t getInterruptType() { return _interruptType; }
+    gpio_pin_mode_t getMode() { return _mode; }
+    gpio_num_t getGPIO(){return _gpio;};
+
+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; }
+#ifdef ENABLE_MQTT
+    void handleMQTTconnect();
+#endif //ENABLE_MQTT
+
+private:
+    std::string _configFile;
+    httpd_handle_t _httpServer;
+    std::map<gpio_num_t, GpioPin*> *gpioMap = NULL;
+    TaskHandle_t xHandleTaskGpio = NULL;
+    bool _isEnabled = false;
+
+    int LEDNumbers = 2;
+    Rgb LEDColor = Rgb{ 255, 255, 255 };
+    LedType LEDType = LED_WS2812;
+#ifdef __LEDGLOBAL
+    SmartLed *leds_global = NULL;
+#endif
+
+    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
+
--- a/code/components/jomjol_controlcamera/CMakeLists.txt
+++ b/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 esp_timer esp32-camera esp_http_server jomjol_logfile jomjol_image_proc nvs_flash jomjol_fileserver_ota jomjol_controlGPIO)
+
+
--- a/code/components/jomjol_controlcamera/ClassControllCamera.cpp
+++ b/code/components/jomjol_controlcamera/ClassControllCamera.cpp
--- a/code/components/jomjol_controlcamera/ClassControllCamera.h
+++ b/code/components/jomjol_controlcamera/ClassControllCamera.h
@@ -0,0 +1,113 @@
+#pragma once
+
+#ifndef CLASSCONTROLLCAMERA_H
+#define CLASSCONTROLLCAMERA_H
+
+#include <string>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/event_groups.h"
+
+#include "esp_camera.h"
+#include <string>
+#include <esp_http_server.h>
+#include "CImageBasis.h"
+#include "../../include/defines.h"
+
+typedef struct
+{
+    uint16_t CamSensor_id;
+
+    framesize_t ImageFrameSize = FRAMESIZE_VGA; // 0 - 10
+    gainceiling_t ImageGainceiling;             // Image gain (GAINCEILING_x2, x4, x8, x16, x32, x64 or x128)
+
+    int ImageQuality;    // 0 - 63
+    int ImageBrightness; // (-2 to 2) - set brightness
+    int ImageContrast;   //-2 - 2
+    int ImageSaturation; //-2 - 2
+    int ImageSharpness;  //-2 - 2
+    bool ImageAutoSharpness;
+    int ImageSpecialEffect; // 0 - 6
+    int ImageWbMode;        // 0 to 4 - if awb_gain enabled (0 - Auto, 1 - Sunny, 2 - Cloudy, 3 - Office, 4 - Home)
+    int ImageAwb;           // white balance enable (0 or 1)
+    int ImageAwbGain;       // Auto White Balance enable (0 or 1)
+    int ImageAec;           // auto exposure off (1 or 0)
+    int ImageAec2;          // automatic exposure sensor  (0 or 1)
+    int ImageAeLevel;       // auto exposure levels (-2 to 2)
+    int ImageAecValue;      // set exposure manually  (0-1200)
+    int ImageAgc;           // auto gain off (1 or 0)
+    int ImageAgcGain;       // set gain manually (0 - 30)
+    int ImageBpc;           // black pixel correction
+    int ImageWpc;           // white pixel correction
+    int ImageRawGma;        // (1 or 0)
+    int ImageLenc;          // lens correction (1 or 0)
+    int ImageHmirror;       // (0 or 1) flip horizontally
+    int ImageVflip;         // Invert image (0 or 1)
+    int ImageDcw;           // downsize enable (1 or 0)
+
+    int ImageDenoiseLevel; // The OV2640 does not support it, OV3660 and OV5640 (0 to 8)
+
+    int ImageWidth;
+    int ImageHeight;
+
+    int ImageLedIntensity;
+
+    bool ImageZoomEnabled;
+    int ImageZoomOffsetX;
+    int ImageZoomOffsetY;
+    int ImageZoomSize;
+
+    int WaitBeforePicture;
+    bool isImageSize;
+
+    bool CameraInitSuccessful;
+    bool changedCameraSettings;
+    bool DemoMode;
+    bool SaveAllFiles;
+} camera_controll_config_temp_t;
+
+extern camera_controll_config_temp_t CCstatus;
+
+class CCamera
+{
+protected:
+    void ledc_init(void);
+    bool loadNextDemoImage(camera_fb_t *fb);
+    long GetFileSize(std::string filename);
+    void SetCamWindow(sensor_t *s, int frameSizeX, int frameSizeY, int xOffset, int yOffset, int xTotal, int yTotal, int xOutput, int yOutput, int imageVflip);
+    void SetImageWidthHeightFromResolution(framesize_t resol);
+    void SanitizeZoomParams(int imageSize, int frameSizeX, int frameSizeY, int &imageWidth, int &imageHeight, int &zoomOffsetX, int &zoomOffsetY);
+
+public:
+    CCamera(void);
+    esp_err_t InitCam(void);
+
+    void LightOnOff(bool status);
+    void LEDOnOff(bool status);
+
+    esp_err_t setSensorDatenFromCCstatus(void);
+    esp_err_t getSensorDatenToCCstatus(void);
+
+    int ov5640_set_gainceiling(sensor_t *s, gainceiling_t level);
+
+    esp_err_t CaptureToHTTP(httpd_req_t *req, int delay = 0);
+    esp_err_t CaptureToStream(httpd_req_t *req, bool FlashlightOn);
+
+    void SetQualityZoomSize(int qual, framesize_t resol, bool zoomEnabled, int zoomOffsetX, int zoomOffsetY, int imageSize, int imageVflip);
+    void SetZoomSize(bool zoomEnabled, int zoomOffsetX, int zoomOffsetY, int imageSize, int imageVflip);
+    void SetCamSharpness(bool _autoSharpnessEnabled, int _sharpnessLevel);
+
+    void SetLEDIntensity(float _intrel);
+    bool testCamera(void);
+    bool getCameraInitSuccessful(void);
+    void useDemoMode(void);
+
+    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
--- a/code/components/jomjol_controlcamera/ov2640_sharpness.cpp
+++ b/code/components/jomjol_controlcamera/ov2640_sharpness.cpp
@@ -0,0 +1,152 @@
+#include <stdint.h>
+#include "esp_camera.h"
+#include "ov2640_sharpness.h"
+
+
+const static uint8_t OV2640_SHARPNESS_AUTO[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0x20, 0x20,
+    0x00, 0x00, 0x00
+};
+
+const static uint8_t OV2640_SHARPNESS_MANUAL[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0x00, 0x20,
+    0x00, 0x00, 0x00
+};
+
+const static uint8_t OV2640_SHARPNESS_LEVEL0[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC0, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL1[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC1, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL2[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC2, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL3[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC4, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL4[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xC8, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL5[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xD0, 0x1F,
+    0x00, 0x00, 0x00
+};
+const static uint8_t OV2640_SHARPNESS_LEVEL6[]=
+{
+	//reg, val, mask
+    0xFF, 0x00, 0xFF,
+    0x92, 0x01, 0xFF,
+    0x93, 0xDF, 0x1F,
+    0x00, 0x00, 0x00
+};
+
+const static uint8_t *OV2640_SETTING_SHARPNESS[]=
+{
+    OV2640_SHARPNESS_LEVEL0, // -3 sharpness
+    OV2640_SHARPNESS_LEVEL1,
+    OV2640_SHARPNESS_LEVEL2,
+    OV2640_SHARPNESS_LEVEL3,
+    OV2640_SHARPNESS_LEVEL4,
+    OV2640_SHARPNESS_LEVEL5,
+    OV2640_SHARPNESS_LEVEL6  // +3 sharpness
+};
+
+#define OV2640_MAXLEVEL_SHARPNESS 6
+
+
+static int table_mask_write(sensor_t *sensor, const uint8_t* ptab)
+{
+    uint8_t address;
+    uint8_t value;
+    uint8_t orgval;
+    uint8_t mask;
+    const uint8_t *pdata = ptab;
+
+    if (pdata == NULL)
+	{
+        return -1;
+	}
+
+    while (1)
+    {   
+        address = *pdata++;
+        value = *pdata++;
+        mask = *pdata++;
+		
+        if ((address == 0) && (value == 0) && (mask == 0))
+		{
+            break;
+		}
+		
+        sensor->set_reg(sensor, address, mask, value);
+    }   
+
+    return 0;
+}
+
+
+int ov2640_enable_auto_sharpness(sensor_t *sensor)
+{
+    table_mask_write(sensor, OV2640_SHARPNESS_AUTO);
+	
+    return 0;
+}
+
+
+int ov2640_set_sharpness(sensor_t *sensor, int sharpness)
+{
+	int sharpness_temp = 0;
+	
+    if (sharpness < -3)
+	{
+        sharpness_temp = -3;
+	}
+	
+    if (sharpness > OV2640_MAXLEVEL_SHARPNESS - 3)
+	{
+        sharpness_temp = OV2640_MAXLEVEL_SHARPNESS - 3;
+	}	
+
+    table_mask_write(sensor, OV2640_SHARPNESS_MANUAL);
+    table_mask_write(sensor, OV2640_SETTING_SHARPNESS[sharpness_temp + 3]);
+	
+    return 0;
+}
--- a/code/components/jomjol_controlcamera/ov2640_sharpness.h
+++ b/code/components/jomjol_controlcamera/ov2640_sharpness.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef OV2640_SHARPNESS_H
+#define OV2640_SHARPNESS_H
+
+#include "esp_camera.h"
+
+int ov2640_enable_auto_sharpness(sensor_t *sensor);
+int ov2640_set_sharpness(sensor_t *sensor, int sharpness); // -3 to +3, -4 for auto-sharpness
+
+#endif
--- a/code/components/jomjol_controlcamera/server_camera.cpp
+++ b/code/components/jomjol_controlcamera/server_camera.cpp
@@ -0,0 +1,303 @@
+#include "server_camera.h"
+
+#include <string>
+#include "string.h"
+
+#include "esp_camera.h"
+#include "ClassControllCamera.h"
+#include "MainFlowControl.h"
+
+#include "ClassLogFile.h"
+#include "esp_log.h"
+
+#include "../../include/defines.h"
+
+static const char *TAG = "server_cam";
+
+void PowerResetCamera()
+{
+#if CAM_PIN_PWDN == GPIO_NUM_NC // Use reset only if pin is available
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "No power down pin availbale to reset camera");
+#else
+    ESP_LOGD(TAG, "Resetting camera by power down line");
+    gpio_config_t conf;
+    conf.intr_type = GPIO_INTR_DISABLE;
+    conf.pin_bit_mask = 1LL << CAM_PIN_PWDN;
+    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
+    gpio_set_level(CAM_PIN_PWDN, 1);
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+    gpio_set_level(CAM_PIN_PWDN, 0);
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+#endif
+}
+
+esp_err_t handler_lightOn(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_lightOn - Start");
+    ESP_LOGD(TAG, "handler_lightOn uri: %s", req->uri);
+#endif
+
+    if (Camera.getCameraInitSuccessful())
+    {
+        Camera.LightOnOff(true);
+        const char *resp_str = (const char *)req->user_ctx;
+        httpd_resp_send(req, resp_str, strlen(resp_str));
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /lighton not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_lightOn - Done");
+#endif
+
+    return ESP_OK;
+}
+
+esp_err_t handler_lightOff(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_lightOff - Start");
+    ESP_LOGD(TAG, "handler_lightOff uri: %s", req->uri);
+#endif
+
+    if (Camera.getCameraInitSuccessful())
+    {
+        Camera.LightOnOff(false);
+        const char *resp_str = (const char *)req->user_ctx;
+        httpd_resp_send(req, resp_str, strlen(resp_str));
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /lightoff not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_lightOff - Done");
+#endif
+
+    return ESP_OK;
+}
+
+esp_err_t handler_capture(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_capture - Start");
+#endif
+
+    if (Camera.getCameraInitSuccessful())
+    {
+        // If the camera settings were changed by creating a new reference image, they must be reset
+        if (CFstatus.changedCameraSettings)
+        {
+            Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+            Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+            CFstatus.changedCameraSettings = false;
+        }
+
+#ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Size: %d, Quality: %d", CCstatus.ImageFrameSize, CCstatus.ImageQuality);
+#endif        
+
+        esp_err_t result;
+        result = Camera.CaptureToHTTP(req);
+
+#ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("handler_capture - Done");
+#endif
+
+        return result;
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /capture not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+}
+
+esp_err_t handler_capture_with_light(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_capture_with_light - Start");
+#endif
+
+    if (Camera.getCameraInitSuccessful())
+    {
+        char _query[100];
+        char _delay[10];
+        int delay = 2500;
+
+        if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+        {
+            ESP_LOGD(TAG, "Query: %s", _query);
+
+            if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
+            {
+#ifdef DEBUG_DETAIL_ON
+                ESP_LOGD(TAG, "Delay: %s", _delay);
+#endif
+                delay = atoi(_delay);
+
+                if (delay < 0)
+                {
+                    delay = 0;
+                }
+            }
+        }
+
+        // If the camera settings were changed by creating a new reference image, they must be reset
+        if (CFstatus.changedCameraSettings)
+        {
+            Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+            Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+            CFstatus.changedCameraSettings = false;
+        }
+
+#ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Size: %d, Quality: %d", CCstatus.ImageFrameSize, CCstatus.ImageQuality);
+#endif        
+
+        Camera.LightOnOff(true);
+        const TickType_t xDelay = delay / portTICK_PERIOD_MS;
+        vTaskDelay(xDelay);
+
+        esp_err_t result;
+        result = Camera.CaptureToHTTP(req);
+
+        Camera.LightOnOff(false);
+
+#ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("handler_capture_with_light - Done");
+#endif
+
+        return result;
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /capture_with_flashlight not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+}
+
+esp_err_t handler_capture_save_to_file(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_capture_save_to_file - Start");
+#endif
+
+    if (Camera.getCameraInitSuccessful())
+    {
+        char _query[100];
+        char _delay[10];
+        int delay = 0;
+        char filename[100];
+        std::string fn = "/sdcard/";
+
+        if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+        {
+            ESP_LOGD(TAG, "Query: %s", _query);
+
+            if (httpd_query_key_value(_query, "filename", filename, 100) == ESP_OK)
+            {
+                fn.append(filename);
+#ifdef DEBUG_DETAIL_ON
+                ESP_LOGD(TAG, "Filename: %s", fn.c_str());
+#endif
+            }
+            else
+            {
+                fn.append("noname.jpg");
+            }
+
+            if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
+            {
+#ifdef DEBUG_DETAIL_ON
+                ESP_LOGD(TAG, "Delay: %s", _delay);
+#endif
+                delay = atoi(_delay);
+
+                if (delay < 0)
+                {
+                    delay = 0;
+                }
+            }
+        }
+        else
+        {
+            fn.append("noname.jpg");
+        }
+
+        // If the camera settings were changed by creating a new reference image, they must be reset
+        if (CFstatus.changedCameraSettings)
+        {
+            Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+            Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+            CFstatus.changedCameraSettings = false;
+        }
+
+#ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Size: %d, Quality: %d", CCstatus.ImageFrameSize, CCstatus.ImageQuality);
+#endif        
+
+        esp_err_t result;
+        result = Camera.CaptureToFile(fn, delay);
+
+        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 result;
+    }
+    else
+    {
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /save not available!");
+        return ESP_ERR_NOT_FOUND;
+    }
+}
+
+void register_server_camera_uri(httpd_handle_t server)
+{
+#ifdef DEBUG_DETAIL_ON
+    ESP_LOGI(TAG, "server_part_camera - Registering URI handlers");
+#endif
+
+    httpd_uri_t camuri = {};
+    camuri.method = HTTP_GET;
+
+    camuri.uri = "/lighton";
+    camuri.handler = handler_lightOn;
+    camuri.user_ctx = (void *)"Light On";
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.uri = "/lightoff";
+    camuri.handler = handler_lightOff;
+    camuri.user_ctx = (void *)"Light Off";
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.uri = "/capture";
+    camuri.handler = handler_capture;
+    camuri.user_ctx = NULL;
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.uri = "/capture_with_flashlight";
+    camuri.handler = handler_capture_with_light;
+    camuri.user_ctx = NULL;
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.uri = "/save";
+    camuri.handler = handler_capture_save_to_file;
+    camuri.user_ctx = NULL;
+    httpd_register_uri_handler(server, &camuri);
+}
--- a/code/components/jomjol_controlcamera/server_camera.h
+++ b/code/components/jomjol_controlcamera/server_camera.h
@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef JOMJOL_CONTROLCAMERA_H
 #define JOMJOL_CONTROLCAMERA_H

@@ -7,10 +9,7 @@

 //#include "ClassControllCamera.h"

-static const char *TAGPARTCAMERA = "server_camera";
-
 void register_server_camera_uri(httpd_handle_t server);
-
 void PowerResetCamera();

 #endif
--- a/code/components/jomjol_fileserver_ota/CMakeLists.txt
+++ b/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" "miniz"
+                    REQUIRES vfs esp_http_server app_update esp_http_client nvs_flash jomjol_tfliteclass jomjol_flowcontroll spiffs jomjol_helper jomjol_controlGPIO)
+
+
--- a/code/components/jomjol_fileserver_ota/miniz/ChangeLog.md
+++ b/code/components/jomjol_fileserver_ota/miniz/ChangeLog.md
@@ -0,0 +1,235 @@
+## Changelog
+
+### 3.0.1
+
+ - Fix compilation error with MINIZ_USE_UNALIGNED_LOADS_AND_STORES=1
+
+### 3.0.0
+
+ - Reduce memory usage for inflate. This changes `struct tinfl_decompressor_tag` and therefore requires a major version bump (breaks ABI compatibility)
+ - Add padding to structures so it continues to work if features differ. This also changes some structures
+ - Use _ftelli64, _fseeki64 and stat with MinGW32 and OpenWatcom
+ - Fix varios warnings with OpenWatcom compiler
+ - Avoid using unaligned memory access in UBSan builds
+ - Set MINIZ_LITTLE_ENDIAN only if not set
+ - Add MINIZ_NO_DEFLATE_APIS and MINIZ_NO_INFLATE_APIS
+ - Fix use of uninitialized memory in tinfl_decompress_mem_to_callback()
+ - Use wfopen on windows
+ - Use _wstat64 instead _stat64 on windows
+ - Use level_and_flags after MZ_DEFAULT_COMPRESSION has been handled
+ - Improve endianess detection
+ - Don't use unaligned stores and loads per default
+ - Fix function declaration if MINIZ_NO_STDIO is used
+ - Fix MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 not being set
+ - Remove total files check (its 32-bit uint)
+ - tinfl_decompress: avoid NULL ptr arithmetic UB
+ - miniz_zip: fix mz_zip_reader_extract_to_heap to read correct sizes
+ - Eliminate 64-bit operations on 32-bit machines
+ - Disable treating warnings as error with MSVC
+ - Disable building shared lib via CMake by default
+ - Fixed alignment problems on MacOS
+ - Fixed get error string for MZ_ZIP_TOTAL_ERRORS
+ - Write correct FLEVEL 2-bit value in zlib header
+ - miniz.pc.in: fix include path not containing the "miniz" suffix
+ - Fix compatibility with FreeBSD
+ - pkg-config tweaks
+ - Fix integer overflow in header corruption check
+ - Fix some warnings
+ - tdefl_compress_normal: Avoid NULL ptr arithmetic UB
+ - replace use of stdint.h types with mz_ variants
+ 
+ 
+### 2.2.0
+
+ - Fix examples with amalgamation
+ - Modified cmake script to support shared library mode and find_package
+ - Fix for misleading doc comment on `mz_zip_reader_init_cfile` function
+ - Add include location tolerance and stop forcing `_GNU_SOURCE`
+ - Fix: mz_zip_reader_locate_file_v2 returns an mz_bool
+ - Fix large file system checks
+ - Add #elif to enable an external mz_crc32() to be linked in
+ - Write with dynamic size (size of file/data to be added not known before adding)
+ - Added uncompress2 for zlib compatibility
+ - Add support for building as a Meson subproject
+ - Added OSSFuzz support; Integrate with CIFuzz
+ - Add pkg-config file
+ - Fixed use-of-uninitialized value msan error when copying dist bytes with no output bytes written.
+ - mz_zip_validate_file(): fix memory leak on errors
+ - Fixed MSAN use-of-uninitialized in tinfl_decompress when invalid dist is decoded. In this instance dist was 31 which s_dist_base translates as 0
+ - Add flag to set (compressed) size in local file header
+ - avoid use of uninitialized value in tdefl_record_literal
+
+### 2.1.0
+
+ - More instances of memcpy instead of cast and use memcpy per default
+ - Remove inline for c90 support
+ - New function to read files via callback functions when adding them
+ - Fix out of bounds read while reading Zip64 extended information
+ - guard memcpy when n == 0 because buffer may be NULL
+ - Implement inflateReset() function
+ - Move comp/decomp alloc/free  prototypes under guarding #ifndef MZ_NO_MALLOC
+ - Fix large file support under Windows
+ - Don't warn if _LARGEFILE64_SOURCE is not defined to 1
+ - Fixes for MSVC warnings
+ - Remove check that path of file added to archive contains ':' or '\'
+ - Add !defined check on MINIZ_USE_ALIGNED_LOADS_AND_STORES
+
+### 2.0.8
+
+ - Remove unimplemented functions (mz_zip_locate_file and mz_zip_locate_file_v2)
+ - Add license, changelog, readme and example files to release zip
+ - Fix heap overflow to user buffer in tinfl_status tinfl_decompress
+ - Fix corrupt archive if uncompressed file smaller than 4 byte and the file is added by mz_zip_writer_add_mem*
+
+### 2.0.7
+
+ - Removed need in C++ compiler in cmake build
+ - Fixed a lot of uninitialized value errors found with Valgrind by memsetting m_dict to 0 in tdefl_init
+ - Fix resource leak in mz_zip_reader_init_file_v2
+ - Fix assert with mz_zip_writer_add_mem* w/MZ_DEFAULT_COMPRESSION
+ - cmake build: install library and headers
+ - Remove _LARGEFILE64_SOURCE requirement from apple defines for large files
+
+### 2.0.6
+
+ - Improve MZ_ZIP_FLAG_WRITE_ZIP64 documentation
+ - Remove check for cur_archive_file_ofs > UINT_MAX because cur_archive_file_ofs is not used after this point
+ - Add cmake debug configuration
+ - Fix PNG height when creating png files
+ - Add "iterative" file extraction method based on mz_zip_reader_extract_to_callback.
+ - Option to use memcpy for unaligned data access
+ - Define processor/arch macros as zero if not set to one
+
+### 2.0.4/2.0.5
+
+ - Fix compilation with the various omission compile definitions
+
+### 2.0.3
+
+- Fix GCC/clang compile warnings
+- Added callback for periodic flushes (for ZIP file streaming)
+- Use UTF-8 for file names in ZIP files per default
+
+### 2.0.2
+
+- Fix source backwards compatibility with 1.x
+- Fix a ZIP bit not being set correctly
+
+### 2.0.1
+
+- Added some tests
+- Added CI
+- Make source code ANSI C compatible
+
+### 2.0.0 beta
+
+- Matthew Sitton merged miniz 1.x to Rich Geldreich's vogl ZIP64 changes. Miniz is now licensed as MIT since the vogl code base is MIT licensed
+- Miniz is now split into several files
+- Miniz does now not seek backwards when creating ZIP files. That is the ZIP files can be streamed
+- Miniz automatically switches to the ZIP64 format when the created ZIP files goes over ZIP file limits
+- Similar to [SQLite](https://www.sqlite.org/amalgamation.html) the Miniz source code is amalgamated into one miniz.c/miniz.h pair in a build step (amalgamate.sh). Please use miniz.c/miniz.h in your projects
+- Miniz 2 is only source back-compatible with miniz 1.x. It breaks binary compatibility because structures changed
+
+### v1.16 BETA Oct 19, 2013
+
+Still testing, this release is downloadable from [here](http://www.tenacioussoftware.com/miniz_v116_beta_r1.7z). Two key inflator-only robustness and streaming related changes. Also merged in tdefl_compressor_alloc(), tdefl_compressor_free() helpers to make script bindings easier for rustyzip. I would greatly appreciate any help with testing or any feedback.
+
+The inflator in raw (non-zlib) mode is now usable on gzip or similar streams that have a bunch of bytes following the raw deflate data (problem discovered by rustyzip author williamw520). This version should never read beyond the last byte of the raw deflate data independent of how many bytes you pass into the input buffer.
+
+The inflator now has a new failure status TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS (-4). Previously, if the inflator was starved of bytes and could not make progress (because the input buffer was empty and the caller did not set the TINFL_FLAG_HAS_MORE_INPUT flag - say on truncated or corrupted compressed data stream) it would append all 0's to the input and try to soldier on. This is scary behavior if the caller didn't know when to stop accepting output (because it didn't know how much uncompressed data was expected, or didn't enforce a sane maximum). v1.16 will instead return TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS immediately if it needs 1 or more bytes to make progress, the input buf is empty, and the caller has indicated that no more input is available. This is a "soft" failure, so you can call the inflator again with more input and it will try to continue, or you can give up and fail. This could be very useful in network streaming scenarios.
+
+- The inflator coroutine func. is subtle and complex so I'm being cautious about this release. I would greatly appreciate any help with testing or any feedback.
+         I feel good about these changes, and they've been through several hours of automated testing, but they will probably not fix anything for the majority of prev. users so I'm
+         going to mark this release as beta for a few weeks and continue testing it at work/home on various things.
+- The inflator in raw (non-zlib) mode is now usable on gzip or similar data streams that have a bunch of bytes following the raw deflate data (problem discovered by rustyzip author williamw520).
+         This version should *never* read beyond the last byte of the raw deflate data independent of how many bytes you pass into the input buffer. This issue was caused by the various Huffman bitbuffer lookahead optimizations, and
+         would not be an issue if the caller knew and enforced the precise size of the raw compressed data *or* if the compressed data was in zlib format (i.e. always followed by the byte aligned zlib adler32).
+         So in other words, you can now call the inflator on deflate streams that are followed by arbitrary amounts of data and it's guaranteed that decompression will stop exactly on the last byte.
+- The inflator now has a new failure status: TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS (-4). Previously, if the inflator was starved of bytes and could not make progress (because the input buffer was empty and the
+         caller did not set the TINFL_FLAG_HAS_MORE_INPUT flag - say on truncated or corrupted compressed data stream) it would append all 0's to the input and try to soldier on.
+         This is scary, because in the worst case, I believe it was possible for the prev. inflator to start outputting large amounts of literal data. If the caller didn't know when to stop accepting output
+         (because it didn't know how much uncompressed data was expected, or didn't enforce a sane maximum) it could continue forever. v1.16 cannot fall into this failure mode, instead it'll return
+         TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS immediately if it needs 1 or more bytes to make progress, the input buf is empty, and the caller has indicated that no more input is available. This is a "soft"
+         failure, so you can call the inflator again with more input and it will try to continue, or you can give up and fail. This could be very useful in network streaming scenarios.
+- Added documentation to all the tinfl return status codes, fixed miniz_tester so it accepts double minus params for Linux, tweaked example1.c, added a simple "follower bytes" test to miniz_tester.cpp.
+### v1.15 r4 STABLE - Oct 13, 2013
+
+Merged over a few very minor bug fixes that I fixed in the zip64 branch. This is downloadable from [here](http://code.google.com/p/miniz/downloads/list) and also in SVN head (as of 10/19/13).
+
+
+### v1.15 - Oct. 13, 2013
+
+Interim bugfix release while I work on the next major release with zip64 and streaming compression/decompression support. Fixed the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY bug (thanks kahmyong.moon@hp.com), which could cause the locate files func to not find files when this flag was specified. Also fixed a bug in mz_zip_reader_extract_to_mem_no_alloc() with user provided read buffers (thanks kymoon). I also merged lots of compiler fixes from various github repo branches and Google Code issue reports. I finally added cmake support (only tested under for Linux so far), compiled and tested with clang v3.3 and gcc 4.6 (under Linux), added defl_write_image_to_png_file_in_memory_ex() (supports Y flipping for OpenGL use, real-time compression), added a new PNG example (example6.c - Mandelbrot), and I added 64-bit file I/O support (stat64(), etc.) for glibc.
+
+- Critical fix for the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY bug (thanks kahmyong.moon@hp.com) which could cause locate files to not find files. This bug
+        would only have occurred in earlier versions if you explicitly used this flag, OR if you used mz_zip_extract_archive_file_to_heap() or mz_zip_add_mem_to_archive_file_in_place()
+        (which used this flag). If you can't switch to v1.15 but want to fix this bug, just remove the uses of this flag from both helper funcs (and of course don't use the flag).
+- Bugfix in mz_zip_reader_extract_to_mem_no_alloc() from kymoon when pUser_read_buf is not NULL and compressed size is > uncompressed size
+- Fixing mz_zip_reader_extract_*() funcs so they don't try to extract compressed data from directory entries, to account for weird zipfiles which contain zero-size compressed data on dir entries.
+         Hopefully this fix won't cause any issues on weird zip archives, because it assumes the low 16-bits of zip external attributes are DOS attributes (which I believe they always are in practice).
+- Fixing mz_zip_reader_is_file_a_directory() so it doesn't check the internal attributes, just the filename and external attributes
+- mz_zip_reader_init_file() - missing MZ_FCLOSE() call if the seek failed
+- Added cmake support for Linux builds which builds all the examples, tested with clang v3.3 and gcc v4.6.
+- Clang fix for tdefl_write_image_to_png_file_in_memory() from toffaletti
+- Merged MZ_FORCEINLINE fix from hdeanclark
+- Fix <time.h> include before config #ifdef, thanks emil.brink
+- Added tdefl_write_image_to_png_file_in_memory_ex(): supports Y flipping (super useful for OpenGL apps), and explicit control over the compression level (so you can
+        set it to 1 for real-time compression).
+- Merged in some compiler fixes from paulharris's github repro.
+- Retested this build under Windows (VS 2010, including static analysis), tcc  0.9.26, gcc v4.6 and clang v3.3.
+- Added example6.c, which dumps an image of the mandelbrot set to a PNG file.
+- Modified example2 to help test the MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY flag more.
+- In r3: Bugfix to mz_zip_writer_add_file() found during merge: Fix possible src file fclose() leak if alignment bytes+local header file write faiiled
+- In r4: Minor bugfix to mz_zip_writer_add_from_zip_reader(): Was pushing the wrong central dir header offset, appears harmless in this release, but it became a problem in the zip64 branch
+
+### v1.14 - May 20, 2012
+
+(SVN Only) Minor tweaks to get miniz.c compiling with the Tiny C Compiler, added #ifndef MINIZ_NO_TIME guards around utime.h includes. Adding mz_free() function, so the caller can free heap blocks returned by miniz using whatever heap functions it has been configured to use, MSVC specific fixes to use "safe" variants of several functions (localtime_s, fopen_s, freopen_s).
+
+MinGW32/64 GCC 4.6.1 compiler fixes: added MZ_FORCEINLINE, #include <time.h> (thanks fermtect).
+
+Compiler specific fixes, some from fermtect. I upgraded to TDM GCC 4.6.1 and now static __forceinline is giving it fits, so I'm changing all usage of __forceinline to MZ_FORCEINLINE and forcing gcc to use __attribute__((__always_inline__)) (and MSVC to use __forceinline). Also various fixes from fermtect for MinGW32: added #include , 64-bit ftell/fseek fixes.
+
+### v1.13 - May 19, 2012
+
+From jason@cornsyrup.org and kelwert@mtu.edu - Most importantly, fixed mz_crc32() so it doesn't compute the wrong CRC-32's when mz_ulong is 64-bits. Temporarily/locally slammed in "typedef unsigned long mz_ulong" and re-ran a randomized regression test on ~500k files. Other stuff:
+
+Eliminated a bunch of warnings when compiling with GCC 32-bit/64. Ran all examples, miniz.c, and tinfl.c through MSVC 2008's /analyze (static analysis) option and fixed all warnings (except for the silly "Use of the comma-operator in a tested expression.." analysis warning, which I purposely use to work around a MSVC compiler warning).
+
+Created 32-bit and 64-bit Codeblocks projects/workspace. Built and tested Linux executables. The codeblocks workspace is compatible with Linux+Win32/x64. Added miniz_tester solution/project, which is a useful little app derived from LZHAM's tester app that I use as part of the regression test. Ran miniz.c and tinfl.c through another series of regression testing on ~500,000 files and archives. Modified example5.c so it purposely disables a bunch of high-level functionality (MINIZ_NO_STDIO, etc.). (Thanks to corysama for the MINIZ_NO_STDIO bug report.)
+
+Fix ftell() usage in a few of the examples so they exit with an error on files which are too large (a limitation of the examples, not miniz itself). Fix fail logic handling in mz_zip_add_mem_to_archive_file_in_place() so it always calls mz_zip_writer_finalize_archive() and mz_zip_writer_end(), even if the file add fails.
+
+- From jason@cornsyrup.org and kelwert@mtu.edu - Fix mz_crc32() so it doesn't compute the wrong CRC-32's when mz_ulong is 64-bit.
+- Temporarily/locally slammed in "typedef unsigned long mz_ulong" and re-ran a randomized regression test on ~500k files.
+- Eliminated a bunch of warnings when compiling with GCC 32-bit/64.
+- Ran all examples, miniz.c, and tinfl.c through MSVC 2008's /analyze (static analysis) option and fixed all warnings (except for the silly
+"Use of the comma-operator in a tested expression.." analysis warning, which I purposely use to work around a MSVC compiler warning).
+- Created 32-bit and 64-bit Codeblocks projects/workspace. Built and tested Linux executables. The codeblocks workspace is compatible with Linux+Win32/x64.
+- Added miniz_tester solution/project, which is a useful little app derived from LZHAM's tester app that I use as part of the regression test.
+- Ran miniz.c and tinfl.c through another series of regression testing on ~500,000 files and archives.
+- Modified example5.c so it purposely disables a bunch of high-level functionality (MINIZ_NO_STDIO, etc.). (Thanks to corysama for the MINIZ_NO_STDIO bug report.)
+- Fix ftell() usage in examples so they exit with an error on files which are too large (a limitation of the examples, not miniz itself).
+
+### v1.12 - 4/12/12
+
+More comments, added low-level example5.c, fixed a couple minor level_and_flags issues in the archive API's.
+level_and_flags can now be set to MZ_DEFAULT_COMPRESSION. Thanks to Bruce Dawson <bruced@valvesoftware.com> for the feedback/bug report.
+
+### v1.11 - 5/28/11
+
+Added statement from unlicense.org
+
+### v1.10 - 5/27/11
+
+- Substantial compressor optimizations:
+- Level 1 is now ~4x faster than before. The L1 compressor's throughput now varies between 70-110MB/sec. on a Core i7 (actual throughput varies depending on the type of data, and x64 vs. x86).
+- Improved baseline L2-L9 compression perf. Also, greatly improved compression perf. issues on some file types.
+- Refactored the compression code for better readability and maintainability.
+- Added level 10 compression level (L10 has slightly better ratio than level 9, but could have a potentially large drop in throughput on some files).
+
+### v1.09 - 5/15/11
+
+Initial stable release.
+
+
--- a/code/components/jomjol_fileserver_ota/miniz/LICENSE
+++ b/code/components/jomjol_fileserver_ota/miniz/LICENSE
@@ -1,21 +1,22 @@
-MIT License
-
-Copyright (c) 2020 jomjol
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Copyright 2013-2014 RAD Game Tools and Valve Software
+Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example1.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example1.c
@@ -0,0 +1,105 @@
+// example1.c - Demonstrates miniz.c's compress() and uncompress() functions (same as zlib's).
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+#include <stdio.h>
+#include "miniz.h"
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+// The string to compress.
+static const char *s_pStr = "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson." \
+  "Good morning Dr. Chandra. This is Hal. I am ready for my first lesson.";
+
+int main(int argc, char *argv[])
+{
+  uint step = 0;
+  int cmp_status;
+  uLong src_len = (uLong)strlen(s_pStr);
+  uLong cmp_len = compressBound(src_len);
+  uLong uncomp_len = src_len;
+  uint8 *pCmp, *pUncomp;
+  uint total_succeeded = 0;
+  (void)argc, (void)argv;
+
+  printf("miniz.c version: %s\n", MZ_VERSION);
+
+  do
+  {
+    // Allocate buffers to hold compressed and uncompressed data.
+    pCmp = (mz_uint8 *)malloc((size_t)cmp_len);
+    pUncomp = (mz_uint8 *)malloc((size_t)src_len);
+    if ((!pCmp) || (!pUncomp))
+    {
+      printf("Out of memory!\n");
+      return EXIT_FAILURE;
+    }
+
+    // Compress the string.
+    cmp_status = compress(pCmp, &cmp_len, (const unsigned char *)s_pStr, src_len);
+    if (cmp_status != Z_OK)
+    {
+      printf("compress() failed!\n");
+      free(pCmp);
+      free(pUncomp);
+      return EXIT_FAILURE;
+    }
+
+    printf("Compressed from %u to %u bytes\n", (mz_uint32)src_len, (mz_uint32)cmp_len);
+
+    if (step)
+    {
+      // Purposely corrupt the compressed data if fuzzy testing (this is a very crude fuzzy test).
+      uint n = 1 + (rand() % 3);
+      while (n--)
+      {
+        uint i = rand() % cmp_len;
+        pCmp[i] ^= (rand() & 0xFF);
+      }
+    }
+
+    // Decompress.
+    cmp_status = uncompress(pUncomp, &uncomp_len, pCmp, cmp_len);
+    total_succeeded += (cmp_status == Z_OK);
+
+    if (step)
+    {
+      printf("Simple fuzzy test: step %u total_succeeded: %u\n", step, total_succeeded);
+    }
+    else
+    {
+      if (cmp_status != Z_OK)
+      {
+        printf("uncompress failed!\n");
+        free(pCmp);
+        free(pUncomp);
+        return EXIT_FAILURE;
+      }
+
+      printf("Decompressed from %u to %u bytes\n", (mz_uint32)cmp_len, (mz_uint32)uncomp_len);
+
+      // Ensure uncompress() returned the expected data.
+      if ((uncomp_len != src_len) || (memcmp(pUncomp, s_pStr, (size_t)src_len)))
+      {
+        printf("Decompression failed!\n");
+        free(pCmp);
+        free(pUncomp);
+        return EXIT_FAILURE;
+      }
+    }
+
+    free(pCmp);
+    free(pUncomp);
+
+    step++;
+
+    // Keep on fuzzy testing if there's a non-empty command line.
+  } while (argc >= 2);
+
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example2.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example2.c
@@ -0,0 +1,164 @@
+// example2.c - Simple demonstration of miniz.c's ZIP archive API's.
+// Note this test deletes the test archive file "__mz_example2_test__.zip" in the current directory, then creates a new one with test data.
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+
+#if defined(__GNUC__)
+  // Ensure we get the 64-bit variants of the CRT's file I/O calls
+  #ifndef _FILE_OFFSET_BITS
+    #define _FILE_OFFSET_BITS 64
+  #endif
+  #ifndef _LARGEFILE64_SOURCE
+    #define _LARGEFILE64_SOURCE 1
+  #endif
+#endif
+
+#include <stdio.h>
+#include "miniz.h"
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+// The string to compress.
+static const char *s_pTest_str =
+  "MISSION CONTROL I wouldn't worry too much about the computer. First of all, there is still a chance that he is right, despite your tests, and" \
+  "if it should happen again, we suggest eliminating this possibility by allowing the unit to remain in place and seeing whether or not it" \
+  "actually fails. If the computer should turn out to be wrong, the situation is still not alarming. The type of obsessional error he may be" \
+  "guilty of is not unknown among the latest generation of HAL 9000 computers. It has almost always revolved around a single detail, such as" \
+  "the one you have described, and it has never interfered with the integrity or reliability of the computer's performance in other areas." \
+  "No one is certain of the cause of this kind of malfunctioning. It may be over-programming, but it could also be any number of reasons. In any" \
+  "event, it is somewhat analogous to human neurotic behavior. Does this answer your query?  Zero-five-three-Zero, MC, transmission concluded.";
+
+static const char *s_pComment = "This is a comment";
+
+int main(int argc, char *argv[])
+{
+  int i, sort_iter;
+  mz_bool status;
+  size_t uncomp_size;
+  mz_zip_archive zip_archive;
+  void *p;
+  const int N = 50;
+  char data[2048];
+  char archive_filename[64];
+  static const char *s_Test_archive_filename = "__mz_example2_test__.zip";
+
+  assert((strlen(s_pTest_str) + 64) < sizeof(data));
+
+  printf("miniz.c version: %s\n", MZ_VERSION);
+
+  (void)argc, (void)argv;
+
+  // Delete the test archive, so it doesn't keep growing as we run this test
+  remove(s_Test_archive_filename);
+
+  // Append a bunch of text files to the test archive
+  for (i = (N - 1); i >= 0; --i)
+  {
+    sprintf(archive_filename, "%u.txt", i);
+    sprintf(data, "%u %s %u", (N - 1) - i, s_pTest_str, i);
+
+    // Add a new file to the archive. Note this is an IN-PLACE operation, so if it fails your archive is probably hosed (its central directory may not be complete) but it should be recoverable using zip -F or -FF. So use caution with this guy.
+    // A more robust way to add a file to an archive would be to read it into memory, perform the operation, then write a new archive out to a temp file and then delete/rename the files.
+    // Or, write a new archive to disk to a temp file, then delete/rename the files. For this test this API is fine.
+    status = mz_zip_add_mem_to_archive_file_in_place(s_Test_archive_filename, archive_filename, data, strlen(data) + 1, s_pComment, (uint16)strlen(s_pComment), MZ_BEST_COMPRESSION);
+    if (!status)
+    {
+      printf("mz_zip_add_mem_to_archive_file_in_place failed!\n");
+      return EXIT_FAILURE;
+    }
+  }
+
+  // Add a directory entry for testing
+  status = mz_zip_add_mem_to_archive_file_in_place(s_Test_archive_filename, "directory/", NULL, 0, "no comment", (uint16)strlen("no comment"), MZ_BEST_COMPRESSION);
+  if (!status)
+  {
+    printf("mz_zip_add_mem_to_archive_file_in_place failed!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Now try to open the archive.
+  memset(&zip_archive, 0, sizeof(zip_archive));
+
+  status = mz_zip_reader_init_file(&zip_archive, s_Test_archive_filename, 0);
+  if (!status)
+  {
+    printf("mz_zip_reader_init_file() failed!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Get and print information about each file in the archive.
+  for (i = 0; i < (int)mz_zip_reader_get_num_files(&zip_archive); i++)
+  {
+    mz_zip_archive_file_stat file_stat;
+    if (!mz_zip_reader_file_stat(&zip_archive, i, &file_stat))
+    {
+       printf("mz_zip_reader_file_stat() failed!\n");
+       mz_zip_reader_end(&zip_archive);
+       return EXIT_FAILURE;
+    }
+
+    printf("Filename: \"%s\", Comment: \"%s\", Uncompressed size: %u, Compressed size: %u, Is Dir: %u\n", file_stat.m_filename, file_stat.m_comment, (uint)file_stat.m_uncomp_size, (uint)file_stat.m_comp_size, mz_zip_reader_is_file_a_directory(&zip_archive, i));
+
+    if (!strcmp(file_stat.m_filename, "directory/"))
+    {
+      if (!mz_zip_reader_is_file_a_directory(&zip_archive, i))
+      {
+        printf("mz_zip_reader_is_file_a_directory() didn't return the expected results!\n");
+        mz_zip_reader_end(&zip_archive);
+        return EXIT_FAILURE;
+      }
+    }
+  }
+
+  // Close the archive, freeing any resources it was using
+  mz_zip_reader_end(&zip_archive);
+
+  // Now verify the compressed data
+  for (sort_iter = 0; sort_iter < 2; sort_iter++)
+  {
+    memset(&zip_archive, 0, sizeof(zip_archive));
+    status = mz_zip_reader_init_file(&zip_archive, s_Test_archive_filename, sort_iter ? MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY : 0);
+    if (!status)
+    {
+      printf("mz_zip_reader_init_file() failed!\n");
+      return EXIT_FAILURE;
+    }
+
+    for (i = 0; i < N; i++)
+    {
+      sprintf(archive_filename, "%u.txt", i);
+      sprintf(data, "%u %s %u", (N - 1) - i, s_pTest_str, i);
+
+      // Try to extract all the files to the heap.
+      p = mz_zip_reader_extract_file_to_heap(&zip_archive, archive_filename, &uncomp_size, 0);
+      if (!p)
+      {
+        printf("mz_zip_reader_extract_file_to_heap() failed!\n");
+        mz_zip_reader_end(&zip_archive);
+        return EXIT_FAILURE;
+      }
+
+      // Make sure the extraction really succeeded.
+      if ((uncomp_size != (strlen(data) + 1)) || (memcmp(p, data, strlen(data))))
+      {
+        printf("mz_zip_reader_extract_file_to_heap() failed to extract the proper data\n");
+        mz_free(p);
+        mz_zip_reader_end(&zip_archive);
+        return EXIT_FAILURE;
+      }
+
+      printf("Successfully extracted file \"%s\", size %u\n", archive_filename, (uint)uncomp_size);
+      printf("File data: \"%s\"\n", (const char *)p);
+
+      // We're done.
+      mz_free(p);
+    }
+
+    // Close the archive, freeing any resources it was using
+    mz_zip_reader_end(&zip_archive);
+  }
+
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example3.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example3.c
@@ -0,0 +1,269 @@
+// example3.c - Demonstrates how to use miniz.c's deflate() and inflate() functions for simple file compression.
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+// For simplicity, this example is limited to files smaller than 4GB, but this is not a limitation of miniz.c.
+#include <stdio.h>
+#include <limits.h>
+#include "miniz.h"
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+#define my_max(a,b) (((a) > (b)) ? (a) : (b))
+#define my_min(a,b) (((a) < (b)) ? (a) : (b))
+
+#define BUF_SIZE (1024 * 1024)
+static uint8 s_inbuf[BUF_SIZE];
+static uint8 s_outbuf[BUF_SIZE];
+
+int main(int argc, char *argv[])
+{
+  const char *pMode;
+  FILE *pInfile, *pOutfile;
+  uint infile_size;
+  int level = Z_BEST_COMPRESSION;
+  z_stream stream;
+  int p = 1;
+  const char *pSrc_filename;
+  const char *pDst_filename;
+  long file_loc;
+
+  printf("miniz.c version: %s\n", MZ_VERSION);
+
+  if (argc < 4)
+  {
+    printf("Usage: example3 [options] [mode:c or d] infile outfile\n");
+    printf("\nModes:\n");
+    printf("c - Compresses file infile to a zlib stream in file outfile\n");
+    printf("d - Decompress zlib stream in file infile to file outfile\n");
+    printf("\nOptions:\n");
+    printf("-l[0-10] - Compression level, higher values are slower.\n");
+    return EXIT_FAILURE;
+  }
+
+  while ((p < argc) && (argv[p][0] == '-'))
+  {
+    switch (argv[p][1])
+    {
+      case 'l':
+      {
+        level = atoi(&argv[1][2]);
+        if ((level < 0) || (level > 10))
+        {
+          printf("Invalid level!\n");
+          return EXIT_FAILURE;
+        }
+        break;
+      }
+      default:
+      {
+        printf("Invalid option: %s\n", argv[p]);
+        return EXIT_FAILURE;
+      }
+    }
+    p++;
+  }
+
+  if ((argc - p) < 3)
+  {
+    printf("Must specify mode, input filename, and output filename after options!\n");
+    return EXIT_FAILURE;
+  }
+  else if ((argc - p) > 3)
+  {
+    printf("Too many filenames!\n");
+    return EXIT_FAILURE;
+  }
+
+  pMode = argv[p++];
+  if (!strchr("cCdD", pMode[0]))
+  {
+    printf("Invalid mode!\n");
+    return EXIT_FAILURE;
+  }
+
+  pSrc_filename = argv[p++];
+  pDst_filename = argv[p++];
+
+  printf("Mode: %c, Level: %u\nInput File: \"%s\"\nOutput File: \"%s\"\n", pMode[0], level, pSrc_filename, pDst_filename);
+
+  // Open input file.
+  pInfile = fopen(pSrc_filename, "rb");
+  if (!pInfile)
+  {
+    printf("Failed opening input file!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Determine input file's size.
+  fseek(pInfile, 0, SEEK_END);
+  file_loc = ftell(pInfile);
+  fseek(pInfile, 0, SEEK_SET);
+
+  if ((file_loc < 0) || ((mz_uint64)file_loc > INT_MAX))
+  {
+     // This is not a limitation of miniz or tinfl, but this example.
+     printf("File is too large to be processed by this example.\n");
+     return EXIT_FAILURE;
+  }
+
+  infile_size = (uint)file_loc;
+
+  // Open output file.
+  pOutfile = fopen(pDst_filename, "wb");
+  if (!pOutfile)
+  {
+    printf("Failed opening output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Input file size: %u\n", infile_size);
+
+  // Init the z_stream
+  memset(&stream, 0, sizeof(stream));
+  stream.next_in = s_inbuf;
+  stream.avail_in = 0;
+  stream.next_out = s_outbuf;
+  stream.avail_out = BUF_SIZE;
+
+  if ((pMode[0] == 'c') || (pMode[0] == 'C'))
+  {
+    // Compression.
+    uint infile_remaining = infile_size;
+
+    if (deflateInit(&stream, level) != Z_OK)
+    {
+      printf("deflateInit() failed!\n");
+      return EXIT_FAILURE;
+    }
+
+    for ( ; ; )
+    {
+      int status;
+      if (!stream.avail_in)
+      {
+        // Input buffer is empty, so read more bytes from input file.
+        uint n = my_min(BUF_SIZE, infile_remaining);
+
+        if (fread(s_inbuf, 1, n, pInfile) != n)
+        {
+          printf("Failed reading from input file!\n");
+          return EXIT_FAILURE;
+        }
+
+        stream.next_in = s_inbuf;
+        stream.avail_in = n;
+
+        infile_remaining -= n;
+        //printf("Input bytes remaining: %u\n", infile_remaining);
+      }
+
+      status = deflate(&stream, infile_remaining ? Z_NO_FLUSH : Z_FINISH);
+
+      if ((status == Z_STREAM_END) || (!stream.avail_out))
+      {
+        // Output buffer is full, or compression is done, so write buffer to output file.
+        uint n = BUF_SIZE - stream.avail_out;
+        if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+        {
+          printf("Failed writing to output file!\n");
+          return EXIT_FAILURE;
+        }
+        stream.next_out = s_outbuf;
+        stream.avail_out = BUF_SIZE;
+      }
+
+      if (status == Z_STREAM_END)
+        break;
+      else if (status != Z_OK)
+      {
+        printf("deflate() failed with status %i!\n", status);
+        return EXIT_FAILURE;
+      }
+    }
+
+    if (deflateEnd(&stream) != Z_OK)
+    {
+      printf("deflateEnd() failed!\n");
+      return EXIT_FAILURE;
+    }
+  }
+  else if ((pMode[0] == 'd') || (pMode[0] == 'D'))
+  {
+    // Decompression.
+    uint infile_remaining = infile_size;
+
+    if (inflateInit(&stream))
+    {
+      printf("inflateInit() failed!\n");
+      return EXIT_FAILURE;
+    }
+
+    for ( ; ; )
+    {
+      int status;
+      if (!stream.avail_in)
+      {
+        // Input buffer is empty, so read more bytes from input file.
+        uint n = my_min(BUF_SIZE, infile_remaining);
+
+        if (fread(s_inbuf, 1, n, pInfile) != n)
+        {
+          printf("Failed reading from input file!\n");
+          return EXIT_FAILURE;
+        }
+
+        stream.next_in = s_inbuf;
+        stream.avail_in = n;
+
+        infile_remaining -= n;
+      }
+
+      status = inflate(&stream, Z_SYNC_FLUSH);
+
+      if ((status == Z_STREAM_END) || (!stream.avail_out))
+      {
+        // Output buffer is full, or decompression is done, so write buffer to output file.
+        uint n = BUF_SIZE - stream.avail_out;
+        if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+        {
+          printf("Failed writing to output file!\n");
+          return EXIT_FAILURE;
+        }
+        stream.next_out = s_outbuf;
+        stream.avail_out = BUF_SIZE;
+      }
+
+      if (status == Z_STREAM_END)
+        break;
+      else if (status != Z_OK)
+      {
+        printf("inflate() failed with status %i!\n", status);
+        return EXIT_FAILURE;
+      }
+    }
+
+    if (inflateEnd(&stream) != Z_OK)
+    {
+      printf("inflateEnd() failed!\n");
+      return EXIT_FAILURE;
+    }
+  }
+  else
+  {
+    printf("Invalid mode!\n");
+    return EXIT_FAILURE;
+  }
+
+  fclose(pInfile);
+  if (EOF == fclose(pOutfile))
+  {
+    printf("Failed writing to output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Total input bytes: %u\n", (mz_uint32)stream.total_in);
+  printf("Total output bytes: %u\n", (mz_uint32)stream.total_out);
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example4.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example4.c
@@ -0,0 +1,102 @@
+// example4.c - Uses tinfl.c to decompress a zlib stream in memory to an output file
+// Public domain, May 15 2011, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+#include "miniz.h"
+#include <stdio.h>
+#include <limits.h>
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+#define my_max(a,b) (((a) > (b)) ? (a) : (b))
+#define my_min(a,b) (((a) < (b)) ? (a) : (b))
+
+static int tinfl_put_buf_func(const void* pBuf, int len, void *pUser)
+{
+  return len == (int)fwrite(pBuf, 1, len, (FILE*)pUser);
+}
+
+int main(int argc, char *argv[])
+{
+  int status;
+  FILE *pInfile, *pOutfile;
+  uint infile_size, outfile_size;
+  size_t in_buf_size;
+  uint8 *pCmp_data;
+  long file_loc;
+
+  if (argc != 3)
+  {
+    printf("Usage: example4 infile outfile\n");
+    printf("Decompresses zlib stream in file infile to file outfile.\n");
+    printf("Input file must be able to fit entirely in memory.\n");
+    printf("example3 can be used to create compressed zlib streams.\n");
+    return EXIT_FAILURE;
+  }
+
+  // Open input file.
+  pInfile = fopen(argv[1], "rb");
+  if (!pInfile)
+  {
+    printf("Failed opening input file!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Determine input file's size.
+  fseek(pInfile, 0, SEEK_END);
+  file_loc = ftell(pInfile);
+  fseek(pInfile, 0, SEEK_SET);
+
+  if ((file_loc < 0) || ((mz_uint64)file_loc > INT_MAX))
+  {
+     // This is not a limitation of miniz or tinfl, but this example.
+     printf("File is too large to be processed by this example.\n");
+     return EXIT_FAILURE;
+  }
+
+  infile_size = (uint)file_loc;
+
+  pCmp_data = (uint8 *)malloc(infile_size);
+  if (!pCmp_data)
+  {
+    printf("Out of memory!\n");
+    return EXIT_FAILURE;
+  }
+  if (fread(pCmp_data, 1, infile_size, pInfile) != infile_size)
+  {
+    printf("Failed reading input file!\n");
+    return EXIT_FAILURE;
+  }
+
+  // Open output file.
+  pOutfile = fopen(argv[2], "wb");
+  if (!pOutfile)
+  {
+    printf("Failed opening output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Input file size: %u\n", infile_size);
+
+  in_buf_size = infile_size;
+  status = tinfl_decompress_mem_to_callback(pCmp_data, &in_buf_size, tinfl_put_buf_func, pOutfile, TINFL_FLAG_PARSE_ZLIB_HEADER);
+  if (!status)
+  {
+    printf("tinfl_decompress_mem_to_callback() failed with status %i!\n", status);
+    return EXIT_FAILURE;
+  }
+
+  outfile_size = ftell(pOutfile);
+
+  fclose(pInfile);
+  if (EOF == fclose(pOutfile))
+  {
+    printf("Failed writing to output file!\n");
+    return EXIT_FAILURE;
+  }
+
+  printf("Total input bytes: %u\n", (uint)in_buf_size);
+  printf("Total output bytes: %u\n", outfile_size);
+  printf("Success.\n");
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example5.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example5.c
@@ -0,0 +1,327 @@
+// example5.c - Demonstrates how to use miniz.c's low-level tdefl_compress() and tinfl_inflate() API's for simple file to file compression/decompression.
+// The low-level API's are the fastest, make no use of dynamic memory allocation, and are the most flexible functions exposed by miniz.c.
+// Public domain, April 11 2012, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+// For simplicity, this example is limited to files smaller than 4GB, but this is not a limitation of miniz.c.
+
+// Purposely disable a whole bunch of stuff this low-level example doesn't use.
+#define MINIZ_NO_STDIO
+#define MINIZ_NO_ARCHIVE_APIS
+#define MINIZ_NO_TIME
+#define MINIZ_NO_ZLIB_APIS
+#define MINIZ_NO_MALLOC
+#include "miniz.h"
+
+// Now include stdio.h because this test uses fopen(), etc. (but we still don't want miniz.c's stdio stuff, for testing).
+#include <stdio.h>
+#include <limits.h>
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+#define my_max(a,b) (((a) > (b)) ? (a) : (b))
+#define my_min(a,b) (((a) < (b)) ? (a) : (b))
+
+// IN_BUF_SIZE is the size of the file read buffer.
+// IN_BUF_SIZE must be >= 1
+#define IN_BUF_SIZE (1024*512)
+static uint8 s_inbuf[IN_BUF_SIZE];
+
+// COMP_OUT_BUF_SIZE is the size of the output buffer used during compression.
+// COMP_OUT_BUF_SIZE must be >= 1 and <= OUT_BUF_SIZE
+#define COMP_OUT_BUF_SIZE (1024*512)
+
+// OUT_BUF_SIZE is the size of the output buffer used during decompression.
+// OUT_BUF_SIZE must be a power of 2 >= TINFL_LZ_DICT_SIZE (because the low-level decompressor not only writes, but reads from the output buffer as it decompresses)
+//#define OUT_BUF_SIZE (TINFL_LZ_DICT_SIZE)
+#define OUT_BUF_SIZE (1024*512)
+static uint8 s_outbuf[OUT_BUF_SIZE];
+
+// tdefl_compressor contains all the state needed by the low-level compressor so it's a pretty big struct (~300k).
+// This example makes it a global vs. putting it on the stack, of course in real-world usage you'll probably malloc() or new it.
+tdefl_compressor g_deflator;
+
+int main(int argc, char *argv[])
+{
+   const char *pMode;
+   FILE *pInfile, *pOutfile;
+   uint infile_size;
+   int level = 9;
+   int p = 1;
+   const char *pSrc_filename;
+   const char *pDst_filename;
+   const void *next_in = s_inbuf;
+   size_t avail_in = 0;
+   void *next_out = s_outbuf;
+   size_t avail_out = OUT_BUF_SIZE;
+   size_t total_in = 0, total_out = 0;
+   long file_loc;
+
+   assert(COMP_OUT_BUF_SIZE <= OUT_BUF_SIZE);
+
+   printf("miniz.c example5 (demonstrates tinfl/tdefl)\n");
+
+   if (argc < 4)
+   {
+      printf("File to file compression/decompression using the low-level tinfl/tdefl API's.\n");
+      printf("Usage: example5 [options] [mode:c or d] infile outfile\n");
+      printf("\nModes:\n");
+      printf("c - Compresses file infile to a zlib stream in file outfile\n");
+      printf("d - Decompress zlib stream in file infile to file outfile\n");
+      printf("\nOptions:\n");
+      printf("-l[0-10] - Compression level, higher values are slower, 0 is none.\n");
+      return EXIT_FAILURE;
+   }
+
+   while ((p < argc) && (argv[p][0] == '-'))
+   {
+      switch (argv[p][1])
+      {
+         case 'l':
+         {
+            level = atoi(&argv[1][2]);
+            if ((level < 0) || (level > 10))
+            {
+               printf("Invalid level!\n");
+               return EXIT_FAILURE;
+            }
+            break;
+         }
+         default:
+         {
+            printf("Invalid option: %s\n", argv[p]);
+            return EXIT_FAILURE;
+         }
+      }
+      p++;
+   }
+
+   if ((argc - p) < 3)
+   {
+      printf("Must specify mode, input filename, and output filename after options!\n");
+      return EXIT_FAILURE;
+   }
+   else if ((argc - p) > 3)
+   {
+      printf("Too many filenames!\n");
+      return EXIT_FAILURE;
+   }
+
+   pMode = argv[p++];
+   if (!strchr("cCdD", pMode[0]))
+   {
+      printf("Invalid mode!\n");
+      return EXIT_FAILURE;
+   }
+
+   pSrc_filename = argv[p++];
+   pDst_filename = argv[p++];
+
+   printf("Mode: %c, Level: %u\nInput File: \"%s\"\nOutput File: \"%s\"\n", pMode[0], level, pSrc_filename, pDst_filename);
+
+   // Open input file.
+   pInfile = fopen(pSrc_filename, "rb");
+   if (!pInfile)
+   {
+      printf("Failed opening input file!\n");
+      return EXIT_FAILURE;
+   }
+
+   // Determine input file's size.
+   fseek(pInfile, 0, SEEK_END);
+   file_loc = ftell(pInfile);
+   fseek(pInfile, 0, SEEK_SET);
+
+   if ((file_loc < 0) || ((mz_uint64)file_loc > INT_MAX))
+   {
+      // This is not a limitation of miniz or tinfl, but this example.
+      printf("File is too large to be processed by this example.\n");
+      return EXIT_FAILURE;
+   }
+
+   infile_size = (uint)file_loc;
+
+   // Open output file.
+   pOutfile = fopen(pDst_filename, "wb");
+   if (!pOutfile)
+   {
+      printf("Failed opening output file!\n");
+      return EXIT_FAILURE;
+   }
+
+   printf("Input file size: %u\n", infile_size);
+
+   if ((pMode[0] == 'c') || (pMode[0] == 'C'))
+   {
+      // The number of dictionary probes to use at each compression level (0-10). 0=implies fastest/minimal possible probing.
+      static const mz_uint s_tdefl_num_probes[11] = { 0, 1, 6, 32,  16, 32, 128, 256,  512, 768, 1500 };
+
+      tdefl_status status;
+      uint infile_remaining = infile_size;
+
+      // create tdefl() compatible flags (we have to compose the low-level flags ourselves, or use tdefl_create_comp_flags_from_zip_params() but that means MINIZ_NO_ZLIB_APIS can't be defined).
+      mz_uint comp_flags = TDEFL_WRITE_ZLIB_HEADER | s_tdefl_num_probes[MZ_MIN(10, level)] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
+      if (!level)
+         comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
+
+      // Initialize the low-level compressor.
+      status = tdefl_init(&g_deflator, NULL, NULL, comp_flags);
+      if (status != TDEFL_STATUS_OKAY)
+      {
+         printf("tdefl_init() failed!\n");
+         return EXIT_FAILURE;
+      }
+
+      avail_out = COMP_OUT_BUF_SIZE;
+
+      // Compression.
+      for ( ; ; )
+      {
+         size_t in_bytes, out_bytes;
+
+         if (!avail_in)
+         {
+            // Input buffer is empty, so read more bytes from input file.
+            uint n = my_min(IN_BUF_SIZE, infile_remaining);
+
+            if (fread(s_inbuf, 1, n, pInfile) != n)
+            {
+               printf("Failed reading from input file!\n");
+               return EXIT_FAILURE;
+            }
+
+            next_in = s_inbuf;
+            avail_in = n;
+
+            infile_remaining -= n;
+            //printf("Input bytes remaining: %u\n", infile_remaining);
+         }
+
+         in_bytes = avail_in;
+         out_bytes = avail_out;
+         // Compress as much of the input as possible (or all of it) to the output buffer.
+         status = tdefl_compress(&g_deflator, next_in, &in_bytes, next_out, &out_bytes, infile_remaining ? TDEFL_NO_FLUSH : TDEFL_FINISH);
+
+         next_in = (const char *)next_in + in_bytes;
+         avail_in -= in_bytes;
+         total_in += in_bytes;
+
+         next_out = (char *)next_out + out_bytes;
+         avail_out -= out_bytes;
+         total_out += out_bytes;
+
+         if ((status != TDEFL_STATUS_OKAY) || (!avail_out))
+         {
+            // Output buffer is full, or compression is done or failed, so write buffer to output file.
+            uint n = COMP_OUT_BUF_SIZE - (uint)avail_out;
+            if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+            {
+               printf("Failed writing to output file!\n");
+               return EXIT_FAILURE;
+            }
+            next_out = s_outbuf;
+            avail_out = COMP_OUT_BUF_SIZE;
+         }
+
+         if (status == TDEFL_STATUS_DONE)
+         {
+            // Compression completed successfully.
+            break;
+         }
+         else if (status != TDEFL_STATUS_OKAY)
+         {
+            // Compression somehow failed.
+            printf("tdefl_compress() failed with status %i!\n", status);
+            return EXIT_FAILURE;
+         }
+      }
+   }
+   else if ((pMode[0] == 'd') || (pMode[0] == 'D'))
+   {
+      // Decompression.
+      uint infile_remaining = infile_size;
+
+      tinfl_decompressor inflator;
+      tinfl_init(&inflator);
+
+      for ( ; ; )
+      {
+         size_t in_bytes, out_bytes;
+         tinfl_status status;
+         if (!avail_in)
+         {
+            // Input buffer is empty, so read more bytes from input file.
+            uint n = my_min(IN_BUF_SIZE, infile_remaining);
+
+            if (fread(s_inbuf, 1, n, pInfile) != n)
+            {
+               printf("Failed reading from input file!\n");
+               return EXIT_FAILURE;
+            }
+
+            next_in = s_inbuf;
+            avail_in = n;
+
+            infile_remaining -= n;
+         }
+
+         in_bytes = avail_in;
+         out_bytes = avail_out;
+         status = tinfl_decompress(&inflator, (const mz_uint8 *)next_in, &in_bytes, s_outbuf, (mz_uint8 *)next_out, &out_bytes, (infile_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0) | TINFL_FLAG_PARSE_ZLIB_HEADER);
+
+         avail_in -= in_bytes;
+         next_in = (const mz_uint8 *)next_in + in_bytes;
+         total_in += in_bytes;
+
+         avail_out -= out_bytes;
+         next_out = (mz_uint8 *)next_out + out_bytes;
+         total_out += out_bytes;
+
+         if ((status <= TINFL_STATUS_DONE) || (!avail_out))
+         {
+            // Output buffer is full, or decompression is done, so write buffer to output file.
+            uint n = OUT_BUF_SIZE - (uint)avail_out;
+            if (fwrite(s_outbuf, 1, n, pOutfile) != n)
+            {
+               printf("Failed writing to output file!\n");
+               return EXIT_FAILURE;
+            }
+            next_out = s_outbuf;
+            avail_out = OUT_BUF_SIZE;
+         }
+
+         // If status is <= TINFL_STATUS_DONE then either decompression is done or something went wrong.
+         if (status <= TINFL_STATUS_DONE)
+         {
+            if (status == TINFL_STATUS_DONE)
+            {
+               // Decompression completed successfully.
+               break;
+            }
+            else
+            {
+               // Decompression failed.
+               printf("tinfl_decompress() failed with status %i!\n", status);
+               return EXIT_FAILURE;
+            }
+         }
+      }
+   }
+   else
+   {
+      printf("Invalid mode!\n");
+      return EXIT_FAILURE;
+   }
+
+   fclose(pInfile);
+   if (EOF == fclose(pOutfile))
+   {
+      printf("Failed writing to output file!\n");
+      return EXIT_FAILURE;
+   }
+
+   printf("Total input bytes: %u\n", (mz_uint32)total_in);
+   printf("Total output bytes: %u\n", (mz_uint32)total_out);
+   printf("Success.\n");
+   return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/examples/example6.c
+++ b/code/components/jomjol_fileserver_ota/miniz/examples/example6.c
@@ -0,0 +1,166 @@
+// example6.c - Demonstrates how to miniz's PNG writer func
+// Public domain, April 11 2012, Rich Geldreich, richgel99@gmail.com. See "unlicense" statement at the end of tinfl.c.
+// Mandlebrot set code from http://rosettacode.org/wiki/Mandelbrot_set#C
+// Must link this example against libm on Linux.
+
+// Purposely disable a whole bunch of stuff this low-level example doesn't use.
+#define MINIZ_NO_STDIO
+#define MINIZ_NO_TIME
+#define MINIZ_NO_ZLIB_APIS
+#include "miniz.h"
+
+// Now include stdio.h because this test uses fopen(), etc. (but we still don't want miniz.c's stdio stuff, for testing).
+#include <stdio.h>
+#include <limits.h>
+#include <math.h>
+
+typedef unsigned char uint8;
+typedef unsigned short uint16;
+typedef unsigned int uint;
+
+typedef struct
+{
+  uint8 r, g, b;
+} rgb_t;
+
+static void hsv_to_rgb(int hue, int min, int max, rgb_t *p)
+{
+  const int invert = 0;
+  const int saturation = 1;
+  const int color_rotate = 0;
+
+  if (min == max) max = min + 1;
+  if (invert) hue = max - (hue - min);
+  if (!saturation) {
+    p->r = p->g = p->b = 255 * (max - hue) / (max - min);
+    return;
+  } else {
+    const double h_dbl = fmod(color_rotate + 1e-4 + 4.0 * (hue - min) / (max - min), 6);
+    const double c_dbl = 255 * saturation;
+    const double X_dbl = c_dbl * (1 - fabs(fmod(h_dbl, 2) - 1));
+    const int h = (int)h_dbl;
+    const int c = (int)c_dbl;
+    const int X = (int)X_dbl;
+
+    p->r = p->g = p->b = 0;
+
+    switch(h) {
+    case 0: p->r = c; p->g = X; return;
+    case 1:	p->r = X; p->g = c; return;
+    case 2: p->g = c; p->b = X; return;
+    case 3: p->g = X; p->b = c; return;
+    case 4: p->r = X; p->b = c; return;
+    default:p->r = c; p->b = X;
+    }
+  }
+}
+
+int main(int argc, char *argv[])
+{
+  // Image resolution
+  const int iXmax = 4096;
+  const int iYmax = 4096;
+
+  // Output filename
+  static const char *pFilename = "mandelbrot.png";
+
+  int iX, iY;
+  const double CxMin = -2.5;
+  const double CxMax = 1.5;
+  const double CyMin = -2.0;
+  const double CyMax = 2.0;
+
+  double PixelWidth = (CxMax - CxMin) / iXmax;
+  double PixelHeight = (CyMax - CyMin) / iYmax;
+
+  // Z=Zx+Zy*i  ;   Z0 = 0
+  double Zx, Zy;
+  double Zx2, Zy2; // Zx2=Zx*Zx;  Zy2=Zy*Zy
+
+  int Iteration;
+  const int IterationMax = 200;
+
+  // bail-out value , radius of circle
+  const double EscapeRadius = 2;
+  double ER2=EscapeRadius * EscapeRadius;
+
+  uint8 *pImage = (uint8 *)malloc(iXmax * 3 * iYmax);
+
+  // world ( double) coordinate = parameter plane
+  double Cx,Cy;
+
+  int MinIter = 9999, MaxIter = 0;
+
+  (void)argc, (void)argv;
+
+  for(iY = 0; iY < iYmax; iY++)
+  {
+    Cy = CyMin + iY * PixelHeight;
+    if (fabs(Cy) < PixelHeight/2)
+      Cy = 0.0; // Main antenna
+
+    for(iX = 0; iX < iXmax; iX++)
+    {
+      uint8 *color = pImage + (iX * 3) + (iY * iXmax * 3);
+
+      Cx = CxMin + iX * PixelWidth;
+
+      // initial value of orbit = critical point Z= 0
+      Zx = 0.0;
+      Zy = 0.0;
+      Zx2 = Zx * Zx;
+      Zy2 = Zy * Zy;
+
+      for (Iteration=0;Iteration<IterationMax && ((Zx2+Zy2)<ER2);Iteration++)
+      {
+        Zy = 2 * Zx * Zy + Cy;
+        Zx =Zx2 - Zy2 + Cx;
+        Zx2 = Zx * Zx;
+        Zy2 = Zy * Zy;
+      };
+
+      color[0] = (uint8)Iteration;
+      color[1] = (uint8)Iteration >> 8;
+      color[2] = 0;
+
+      if (Iteration < MinIter)
+        MinIter = Iteration;
+      if (Iteration > MaxIter)
+        MaxIter = Iteration;
+    }
+  }
+
+  for(iY = 0; iY < iYmax; iY++)
+  {
+    for(iX = 0; iX < iXmax; iX++)
+    {
+      uint8 *color = (uint8 *)(pImage + (iX * 3) + (iY * iXmax * 3));
+
+      uint Iterations = color[0] | (color[1] << 8U);
+
+      hsv_to_rgb((int)Iterations, MinIter, MaxIter, (rgb_t *)color);
+    }
+  }
+
+  // Now write the PNG image.
+  {
+    size_t png_data_size = 0;
+    void *pPNG_data = tdefl_write_image_to_png_file_in_memory_ex(pImage, iXmax, iYmax, 3, &png_data_size, 6, MZ_FALSE);
+    if (!pPNG_data)
+      fprintf(stderr, "tdefl_write_image_to_png_file_in_memory_ex() failed!\n");
+    else
+    {
+      FILE *pFile = fopen(pFilename, "wb");
+      fwrite(pPNG_data, 1, png_data_size, pFile);
+      fclose(pFile);
+      printf("Wrote %s\n", pFilename);
+    }
+
+    // mz_free() is by default just an alias to free() internally, but if you've overridden miniz's allocation funcs you'll probably need to call mz_free().
+    mz_free(pPNG_data);
+  }
+
+  free(pImage);
+
+  return EXIT_SUCCESS;
+}
--- a/code/components/jomjol_fileserver_ota/miniz/miniz.c
+++ b/code/components/jomjol_fileserver_ota/miniz/miniz.c
--- a/code/components/jomjol_fileserver_ota/miniz/miniz.h
+++ b/code/components/jomjol_fileserver_ota/miniz/miniz.h
@@ -1,4 +1,7 @@
-/* miniz.c 2.1.0 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
+#ifndef MINIZ_EXPORT
+#define MINIZ_EXPORT
+#endif
+/* miniz.c 3.0.0 - public domain deflate/inflate, zlib-subset, ZIP reading/writing/appending, PNG writing
   See "unlicense" statement at the end of this file.
   Rich Geldreich <richgel99@gmail.com>, last updated Oct. 13, 2013
   Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: http://www.ietf.org/rfc/rfc1951.txt
@@ -95,7 +98,7 @@
     possibility that the archive's central directory could be lost with this method if anything goes wrong, though.

     - ZIP archive support limitations:
-     No zip64 or spanning support. Extraction functions can only handle unencrypted, stored or deflated files.
+     No spanning support. Extraction functions can only handle unencrypted, stored or deflated files.
     Requires streams capable of seeking.

   * This is a header file library, like stb_image.c. To get only a header file, either cut and paste the
@@ -114,10 +117,8 @@



-
-
 /* Defines to completely disable specific portions of miniz.c: 
-   If all macros here are defined the only functionality remaining will be CRC-32, adler-32, tinfl, and tdefl. */
+   If all macros here are defined the only functionality remaining will be CRC-32 and adler-32. */

 /* Define MINIZ_NO_STDIO to disable all usage and any functions which rely on stdio for file I/O. */
 /*#define MINIZ_NO_STDIO */
@@ -127,6 +128,12 @@
 /* The current downside is the times written to your archives will be from 1979. */
 /*#define MINIZ_NO_TIME */

+/* Define MINIZ_NO_DEFLATE_APIS to disable all compression API's. */
+/*#define MINIZ_NO_DEFLATE_APIS */
+
+/* Define MINIZ_NO_INFLATE_APIS to disable all decompression API's. */
+/*#define MINIZ_NO_INFLATE_APIS */
+
 /* Define MINIZ_NO_ARCHIVE_APIS to disable all ZIP archive API's. */
 /*#define MINIZ_NO_ARCHIVE_APIS */

@@ -145,6 +152,14 @@
   functions (such as tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work. */
 /*#define MINIZ_NO_MALLOC */

+#ifdef MINIZ_NO_INFLATE_APIS
+//#define MINIZ_NO_ARCHIVE_APIS
+#endif
+
+#ifdef MINIZ_NO_DEFLATE_APIS
+#define MINIZ_NO_ARCHIVE_WRITING_APIS
+#endif
+
 #if defined(__TINYC__) && (defined(__linux) || defined(__linux__))
 /* TODO: Work around "error: include file 'sys\utime.h' when compiling with tcc on Linux */
 #define MINIZ_NO_TIME
@@ -163,18 +178,40 @@
 #define MINIZ_X86_OR_X64_CPU 0
 #endif

-#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU
+/* Set MINIZ_LITTLE_ENDIAN only if not set */
+#if !defined(MINIZ_LITTLE_ENDIAN)
+#if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
+
+#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
 /* Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian. */
 #define MINIZ_LITTLE_ENDIAN 1
 #else
 #define MINIZ_LITTLE_ENDIAN 0
 #endif

+#else
+
+#if MINIZ_X86_OR_X64_CPU
+#define MINIZ_LITTLE_ENDIAN 1
+#else
+#define MINIZ_LITTLE_ENDIAN 0
+#endif
+
+#endif
+#endif
+
+/* Using unaligned loads and stores causes errors when using UBSan */
+#if defined(__has_feature)
+#if __has_feature(undefined_behavior_sanitizer)
+#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
+#endif
+#endif
+
 /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES only if not set */
 #if !defined(MINIZ_USE_UNALIGNED_LOADS_AND_STORES)
 #if MINIZ_X86_OR_X64_CPU
 /* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient integer loads and stores from unaligned addresses. */
-#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1
+#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
 #define MINIZ_UNALIGNED_USE_MEMCPY
 #else
 #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0
@@ -198,15 +235,15 @@ extern "C" {
 typedef unsigned long mz_ulong;

 /* mz_free() internally uses the MZ_FREE() macro (which by default calls free() unless you've modified the MZ_MALLOC macro) to release a block allocated from the heap. */
-void mz_free(void *p);
+MINIZ_EXPORT void mz_free(void *p);

 #define MZ_ADLER32_INIT (1)
 /* mz_adler32() returns the initial adler-32 value to use when called with ptr==NULL. */
-mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);
+MINIZ_EXPORT mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len);

 #define MZ_CRC32_INIT (0)
 /* mz_crc32() returns the initial CRC-32 value to use when called with ptr==NULL. */
-mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);
+MINIZ_EXPORT mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, size_t buf_len);

 /* Compression strategies. */
 enum
@@ -222,7 +259,7 @@ enum
 #define MZ_DEFLATED 8

 /* Heap allocation callbacks.
-Note that mz_alloc_func parameter types purpsosely differ from zlib's: items/size is size_t, not unsigned long. */
+Note that mz_alloc_func parameter types purposely differ from zlib's: items/size is size_t, not unsigned long. */
 typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size);
 typedef void (*mz_free_func)(void *opaque, void *address);
 typedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items, size_t size);
@@ -238,9 +275,9 @@ enum
    MZ_DEFAULT_COMPRESSION = -1
 };

-#define MZ_VERSION "10.1.0"
-#define MZ_VERNUM 0xA100
-#define MZ_VER_MAJOR 10
+#define MZ_VERSION "11.0.1"
+#define MZ_VERNUM 0xB001
+#define MZ_VER_MAJOR 11
 #define MZ_VER_MINOR 1
 #define MZ_VER_REVISION 0
 #define MZ_VER_SUBREVISION 0
@@ -304,7 +341,9 @@ typedef struct mz_stream_s
 typedef mz_stream *mz_streamp;

 /* Returns the version string of miniz.c. */
-const char *mz_version(void);
+MINIZ_EXPORT const char *mz_version(void);
+
+#ifndef MINIZ_NO_DEFLATE_APIS

 /* mz_deflateInit() initializes a compressor with default options: */
 /* Parameters: */
@@ -317,17 +356,17 @@ const char *mz_version(void);
 /*  MZ_STREAM_ERROR if the stream is bogus. */
 /*  MZ_PARAM_ERROR if the input parameters are bogus. */
 /*  MZ_MEM_ERROR on out of memory. */
-int mz_deflateInit(mz_streamp pStream, int level);
+MINIZ_EXPORT int mz_deflateInit(mz_streamp pStream, int level);

 /* mz_deflateInit2() is like mz_deflate(), except with more control: */
 /* Additional parameters: */
 /*   method must be MZ_DEFLATED */
 /*   window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no header or footer) */
 /*   mem_level must be between [1, 9] (it's checked but ignored by miniz.c) */
-int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);
+MINIZ_EXPORT int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy);

 /* Quickly resets a compressor without having to reallocate anything. Same as calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2(). */
-int mz_deflateReset(mz_streamp pStream);
+MINIZ_EXPORT int mz_deflateReset(mz_streamp pStream);

 /* mz_deflate() compresses the input to output, consuming as much of the input and producing as much output as possible. */
 /* Parameters: */
@@ -339,34 +378,38 @@ int mz_deflateReset(mz_streamp pStream);
 /*   MZ_STREAM_ERROR if the stream is bogus. */
 /*   MZ_PARAM_ERROR if one of the parameters is invalid. */
 /*   MZ_BUF_ERROR if no forward progress is possible because the input and/or output buffers are empty. (Fill up the input buffer or free up some output space and try again.) */
-int mz_deflate(mz_streamp pStream, int flush);
+MINIZ_EXPORT int mz_deflate(mz_streamp pStream, int flush);

 /* mz_deflateEnd() deinitializes a compressor: */
 /* Return values: */
 /*  MZ_OK on success. */
 /*  MZ_STREAM_ERROR if the stream is bogus. */
-int mz_deflateEnd(mz_streamp pStream);
+MINIZ_EXPORT int mz_deflateEnd(mz_streamp pStream);

 /* mz_deflateBound() returns a (very) conservative upper bound on the amount of data that could be generated by deflate(), assuming flush is set to only MZ_NO_FLUSH or MZ_FINISH. */
-mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);
+MINIZ_EXPORT mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len);

 /* Single-call compression functions mz_compress() and mz_compress2(): */
 /* Returns MZ_OK on success, or one of the error codes from mz_deflate() on failure. */
-int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
-int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);
+MINIZ_EXPORT int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
+MINIZ_EXPORT int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level);

 /* mz_compressBound() returns a (very) conservative upper bound on the amount of data that could be generated by calling mz_compress(). */
-mz_ulong mz_compressBound(mz_ulong source_len);
+MINIZ_EXPORT mz_ulong mz_compressBound(mz_ulong source_len);
+
+#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
+
+#ifndef MINIZ_NO_INFLATE_APIS

 /* Initializes a decompressor. */
-int mz_inflateInit(mz_streamp pStream);
+MINIZ_EXPORT int mz_inflateInit(mz_streamp pStream);

 /* mz_inflateInit2() is like mz_inflateInit() with an additional option that controls the window size and whether or not the stream has been wrapped with a zlib header/footer: */
 /* window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate). */
-int mz_inflateInit2(mz_streamp pStream, int window_bits);
+MINIZ_EXPORT int mz_inflateInit2(mz_streamp pStream, int window_bits);

 /* Quickly resets a compressor without having to reallocate anything. Same as calling mz_inflateEnd() followed by mz_inflateInit()/mz_inflateInit2(). */
-int mz_inflateReset(mz_streamp pStream);
+MINIZ_EXPORT int mz_inflateReset(mz_streamp pStream);

 /* Decompresses the input stream to the output, consuming only as much of the input as needed, and writing as much to the output as possible. */
 /* Parameters: */
@@ -382,17 +425,19 @@ int mz_inflateReset(mz_streamp pStream);
 /*   MZ_PARAM_ERROR if one of the parameters is invalid. */
 /*   MZ_BUF_ERROR if no forward progress is possible because the input buffer is empty but the inflater needs more input to continue, or if the output buffer is not large enough. Call mz_inflate() again */
 /*   with more input data, or with more room in the output buffer (except when using single call decompression, described above). */
-int mz_inflate(mz_streamp pStream, int flush);
+MINIZ_EXPORT int mz_inflate(mz_streamp pStream, int flush);

 /* Deinitializes a decompressor. */
-int mz_inflateEnd(mz_streamp pStream);
+MINIZ_EXPORT int mz_inflateEnd(mz_streamp pStream);

 /* Single-call decompression. */
 /* Returns MZ_OK on success, or one of the error codes from mz_inflate() on failure. */
-int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
+MINIZ_EXPORT int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len);
+MINIZ_EXPORT int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong *pSource_len);
+#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/

 /* Returns a string description of the specified error code, or NULL if the error code is invalid. */
-const char *mz_error(int err);
+MINIZ_EXPORT const char *mz_error(int err);

 /* Redefine zlib-compatible names to miniz equivalents, so miniz.c can be used as a drop-in replacement for the subset of zlib that miniz.c supports. */
 /* Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility if you use zlib in the same project. */
@@ -440,6 +485,8 @@ typedef void *const voidpc;
 #define free_func mz_free_func
 #define internal_state mz_internal_state
 #define z_stream mz_stream
+
+#ifndef MINIZ_NO_DEFLATE_APIS
 #define deflateInit mz_deflateInit
 #define deflateInit2 mz_deflateInit2
 #define deflateReset mz_deflateReset
@@ -449,12 +496,18 @@ typedef void *const voidpc;
 #define compress mz_compress
 #define compress2 mz_compress2
 #define compressBound mz_compressBound
+#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
+
+#ifndef MINIZ_NO_INFLATE_APIS
 #define inflateInit mz_inflateInit
 #define inflateInit2 mz_inflateInit2
 #define inflateReset mz_inflateReset
 #define inflate mz_inflate
 #define inflateEnd mz_inflateEnd
 #define uncompress mz_uncompress
+#define uncompress2 mz_uncompress2
+#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
+
 #define crc32 mz_crc32
 #define adler32 mz_adler32
 #define MAX_WBITS 15
@@ -475,12 +528,19 @@ typedef void *const voidpc;
 #ifdef __cplusplus
 }
 #endif
+
+
+
+
+
 #pragma once
 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>

+
+
 /* ------------------- Types and macros */
 typedef unsigned char mz_uint8;
 typedef signed short mz_int16;
@@ -511,7 +571,8 @@ typedef int mz_bool;
 #ifdef MINIZ_NO_TIME
 typedef struct mz_dummy_time_t_tag
 {
-    int m_dummy;
+    mz_uint32 m_dummy1;
+    mz_uint32 m_dummy2;
 } mz_dummy_time_t;
 #define MZ_TIME_T mz_dummy_time_t
 #else
@@ -533,6 +594,8 @@ typedef struct mz_dummy_time_t_tag
 #define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b))
 #define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b))
 #define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj))
+#define MZ_CLEAR_ARR(obj) memset((obj), 0, sizeof(obj))
+#define MZ_CLEAR_PTR(obj) memset((obj), 0, sizeof(*obj))

 #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
 #define MZ_READ_LE16(p) *((const mz_uint16 *)(p))
@@ -556,9 +619,9 @@ typedef struct mz_dummy_time_t_tag
 extern "C" {
 #endif

-extern void *miniz_def_alloc_func(void *opaque, size_t items, size_t size);
-extern void miniz_def_free_func(void *opaque, void *address);
-extern void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size);
+extern MINIZ_EXPORT void *miniz_def_alloc_func(void *opaque, size_t items, size_t size);
+extern MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address);
+extern MINIZ_EXPORT void *miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size);

 #define MZ_UINT16_MAX (0xFFFFU)
 #define MZ_UINT32_MAX (0xFFFFFFFFU)
@@ -566,9 +629,11 @@ extern void *miniz_def_realloc_func(void *opaque, void *address, size_t items, s
 #ifdef __cplusplus
 }
 #endif
-#pragma once
+ #pragma once


+#ifndef MINIZ_NO_DEFLATE_APIS
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -616,11 +681,11 @@ enum
 /*  Function returns a pointer to the compressed data, or NULL on failure. */
 /*  *pOut_len will be set to the compressed data's size, which could be larger than src_buf_len on uncompressible data. */
 /*  The caller must free() the returned block when it's no longer needed. */
-void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
+MINIZ_EXPORT void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);

 /* tdefl_compress_mem_to_mem() compresses a block in memory to another block in memory. */
 /* Returns 0 on failure. */
-size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
+MINIZ_EXPORT size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);

 /* Compresses an image to a compressed PNG file in memory. */
 /* On entry: */
@@ -632,14 +697,14 @@ size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void
 /*  Function returns a pointer to the compressed data, or NULL on failure. */
 /*  *pLen_out will be set to the size of the PNG image file. */
 /*  The caller must mz_free() the returned heap block (which will typically be larger than *pLen_out) when it's no longer needed. */
-void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);
-void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);
+MINIZ_EXPORT void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, int num_chans, size_t *pLen_out, mz_uint level, mz_bool flip);
+MINIZ_EXPORT void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, int num_chans, size_t *pLen_out);

 /* Output stream interface. The compressor uses this interface to write compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time. */
 typedef mz_bool (*tdefl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);

 /* tdefl_compress_mem_to_output() compresses a block to an output stream. The above helpers use this function internally. */
-mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
+MINIZ_EXPORT mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);

 enum
 {
@@ -727,39 +792,43 @@ typedef struct
 /* pBut_buf_func: If NULL, output data will be supplied to the specified callback. In this case, the user should call the tdefl_compress_buffer() API for compression. */
 /* If pBut_buf_func is NULL the user should always call the tdefl_compress() API. */
 /* flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, etc.) */
-tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
+MINIZ_EXPORT tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);

 /* Compresses a block of data, consuming as much of the specified input buffer as possible, and writing as much compressed data to the specified output buffer as possible. */
-tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);
+MINIZ_EXPORT tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, size_t *pIn_buf_size, void *pOut_buf, size_t *pOut_buf_size, tdefl_flush flush);

 /* tdefl_compress_buffer() is only usable when the tdefl_init() is called with a non-NULL tdefl_put_buf_func_ptr. */
 /* tdefl_compress_buffer() always consumes the entire input buffer. */
-tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);
+MINIZ_EXPORT tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush);

-tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
-mz_uint32 tdefl_get_adler32(tdefl_compressor *d);
+MINIZ_EXPORT tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d);
+MINIZ_EXPORT mz_uint32 tdefl_get_adler32(tdefl_compressor *d);

 /* Create tdefl_compress() flags given zlib-style compression parameters. */
 /* level may range from [0,10] (where 10 is absolute max compression, but may be much slower on some files) */
 /* window_bits may be -15 (raw deflate) or 15 (zlib) */
 /* strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, MZ_RLE, or MZ_FIXED */
-mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);
+MINIZ_EXPORT mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy);

 #ifndef MINIZ_NO_MALLOC
 /* Allocate the tdefl_compressor structure in C so that */
 /* non-C language bindings to tdefl_ API don't need to worry about */
 /* structure size and allocation mechanism. */
-tdefl_compressor *tdefl_compressor_alloc(void);
-void tdefl_compressor_free(tdefl_compressor *pComp);
+MINIZ_EXPORT tdefl_compressor *tdefl_compressor_alloc(void);
+MINIZ_EXPORT void tdefl_compressor_free(tdefl_compressor *pComp);
 #endif

 #ifdef __cplusplus
 }
 #endif
-#pragma once
+
+#endif /*#ifndef MINIZ_NO_DEFLATE_APIS*/
+ #pragma once

 /* ------------------- Low-level Decompression API Definitions */

+#ifndef MINIZ_NO_INFLATE_APIS
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -784,17 +853,17 @@ enum
 /*  Function returns a pointer to the decompressed data, or NULL on failure. */
 /*  *pOut_len will be set to the decompressed data's size, which could be larger than src_buf_len on uncompressible data. */
 /*  The caller must call mz_free() on the returned block when it's no longer needed. */
-void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);
+MINIZ_EXPORT void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags);

 /* tinfl_decompress_mem_to_mem() decompresses a block in memory to another block in memory. */
 /* Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes written on success. */
 #define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1))
-size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);
+MINIZ_EXPORT size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags);

 /* tinfl_decompress_mem_to_callback() decompresses a block in memory to an internal 32KB buffer, and a user provided callback function will be called to flush the buffer. */
 /* Returns 1 on success or 0 on failure. */
 typedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser);
-int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);
+MINIZ_EXPORT int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, tinfl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags);

 struct tinfl_decompressor_tag;
 typedef struct tinfl_decompressor_tag tinfl_decompressor;
@@ -803,8 +872,8 @@ typedef struct tinfl_decompressor_tag tinfl_decompressor;
 /* Allocate the tinfl_decompressor structure in C so that */
 /* non-C language bindings to tinfl_ API don't need to worry about */
 /* structure size and allocation mechanism. */
-tinfl_decompressor *tinfl_decompressor_alloc(void);
-void tinfl_decompressor_free(tinfl_decompressor *pDecomp);
+MINIZ_EXPORT tinfl_decompressor *tinfl_decompressor_alloc(void);
+MINIZ_EXPORT void tinfl_decompressor_free(tinfl_decompressor *pDecomp);
 #endif

 /* Max size of LZ dictionary. */
@@ -855,7 +924,7 @@ typedef enum {

 /* Main low-level decompressor coroutine function. This is the only function actually needed for decompression. All the other functions are just high-level helpers for improved usability. */
 /* This is a universal API, i.e. it can be used as a building block to build any desired higher level decompression API. In the limit case, it can be called once per every byte input or output. */
-tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);
+MINIZ_EXPORT tinfl_status tinfl_decompress(tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, const mz_uint32 decomp_flags);

 /* Internal/private bits follow. */
 enum
@@ -868,12 +937,6 @@ enum
    TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS
 };

-typedef struct
-{
-    mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0];
-    mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
-} tinfl_huff_table;
-
 #if MINIZ_HAS_64BIT_REGISTERS
 #define TINFL_USE_64BIT_BITBUF 1
 #else
@@ -893,7 +956,13 @@ struct tinfl_decompressor_tag
    mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, m_check_adler32, m_dist, m_counter, m_num_extra, m_table_sizes[TINFL_MAX_HUFF_TABLES];
    tinfl_bit_buf_t m_bit_buf;
    size_t m_dist_from_out_buf_start;
-    tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES];
+    mz_int16 m_look_up[TINFL_MAX_HUFF_TABLES][TINFL_FAST_LOOKUP_SIZE];
+    mz_int16 m_tree_0[TINFL_MAX_HUFF_SYMBOLS_0 * 2];
+    mz_int16 m_tree_1[TINFL_MAX_HUFF_SYMBOLS_1 * 2];
+    mz_int16 m_tree_2[TINFL_MAX_HUFF_SYMBOLS_2 * 2];
+    mz_uint8 m_code_size_0[TINFL_MAX_HUFF_SYMBOLS_0];
+    mz_uint8 m_code_size_1[TINFL_MAX_HUFF_SYMBOLS_1];
+    mz_uint8 m_code_size_2[TINFL_MAX_HUFF_SYMBOLS_2];
    mz_uint8 m_raw_header[4], m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137];
 };

@@ -901,6 +970,8 @@ struct tinfl_decompressor_tag
 }
 #endif

+#endif /*#ifndef MINIZ_NO_INFLATE_APIS*/
+ 
 #pragma once


@@ -934,10 +1005,6 @@ typedef struct
    mz_uint16 m_bit_flag;
    mz_uint16 m_method;

-#ifndef MINIZ_NO_TIME
-    MZ_TIME_T m_time;
-#endif
-
    /* CRC-32 of uncompressed data. */
    mz_uint32 m_crc32;

@@ -974,6 +1041,11 @@ typedef struct
    /* Guaranteed to be zero terminated, may be truncated to fit. */
    char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE];

+#ifdef MINIZ_NO_TIME
+    MZ_TIME_T m_padding;
+#else
+    MZ_TIME_T m_time;
+#endif
 } mz_zip_archive_file_stat;

 typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n);
@@ -999,7 +1071,10 @@ typedef enum {
    MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000,     /* validate the local headers, but don't decompress the entire file and check the crc32 */
    MZ_ZIP_FLAG_WRITE_ZIP64 = 0x4000,               /* always use the zip64 file format, instead of the original zip file format with automatic switch to zip64. Use as flags parameter with mz_zip_writer_init*_v2 */
    MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000,
-    MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000
+    MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000,
+    /*After adding a compressed file, seek back
+    to local file header and set the correct sizes*/
+    MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE = 0x20000
 } mz_zip_flags;

 typedef enum {
@@ -1082,9 +1157,7 @@ typedef struct
    mz_uint flags;

    int status;
-#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
-    mz_uint file_crc32;
-#endif
+
    mz_uint64 read_buf_size, read_buf_ofs, read_buf_avail, comp_remaining, out_buf_ofs, cur_file_ofs;
    mz_zip_archive_file_stat file_stat;
    void *pRead_buf;
@@ -1094,149 +1167,157 @@ typedef struct

    tinfl_decompressor inflator;

+#ifdef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
+    mz_uint padding;
+#else
+    mz_uint file_crc32;
+#endif
+
 } mz_zip_reader_extract_iter_state;

 /* -------- ZIP reading */

 /* Inits a ZIP archive reader. */
 /* These functions read and validate the archive's central directory. */
-mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, mz_uint flags);

-mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags);

 #ifndef MINIZ_NO_STDIO
 /* Read a archive from a disk file. */
 /* file_start_ofs is the file offset where the archive actually begins, or 0. */
 /* actual_archive_size is the true total size of the archive, which may be smaller than the file's actual size on disk. If zero the entire file is treated as the archive. */
-mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);
-mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint32 flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size);

 /* Read an archive from an already opened FILE, beginning at the current file position. */
-/* The archive is assumed to be archive_size bytes long. If archive_size is < 0, then the entire rest of the file is assumed to contain the archive. */
+/* The archive is assumed to be archive_size bytes long. If archive_size is 0, then the entire rest of the file is assumed to contain the archive. */
 /* The FILE will NOT be closed when mz_zip_reader_end() is called. */
-mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags);
 #endif

 /* Ends archive reading, freeing all allocations, and closing the input archive file if mz_zip_reader_init_file() was used. */
-mz_bool mz_zip_reader_end(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_reader_end(mz_zip_archive *pZip);

 /* -------- ZIP reading or writing */

 /* Clears a mz_zip_archive struct to all zeros. */
 /* Important: This must be done before passing the struct to any mz_zip functions. */
-void mz_zip_zero_struct(mz_zip_archive *pZip);
+MINIZ_EXPORT void mz_zip_zero_struct(mz_zip_archive *pZip);

-mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip);
-mz_zip_type mz_zip_get_type(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_type mz_zip_get_type(mz_zip_archive *pZip);

 /* Returns the total number of files in the archive. */
-mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip);

-mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip);
-mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip);
-MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip);
+MINIZ_EXPORT MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip);

 /* Reads n bytes of raw archive data, starting at file offset file_ofs, to pBuf. */
-size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n);
+MINIZ_EXPORT size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n);

 /* All mz_zip funcs set the m_last_error field in the mz_zip_archive struct. These functions retrieve/manipulate this field. */
 /* Note that the m_last_error functionality is not thread safe. */
-mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num);
-mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip);
-mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip);
-const char *mz_zip_get_error_string(mz_zip_error mz_err);
+MINIZ_EXPORT mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num);
+MINIZ_EXPORT mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip);
+MINIZ_EXPORT const char *mz_zip_get_error_string(mz_zip_error mz_err);

 /* MZ_TRUE if the archive file entry is a directory entry. */
-mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);
+MINIZ_EXPORT mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, mz_uint file_index);

 /* MZ_TRUE if the file is encrypted/strong encrypted. */
-mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);
+MINIZ_EXPORT mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, mz_uint file_index);

 /* MZ_TRUE if the compression method is supported, and the file is not encrypted, and the file is not a compressed patch file. */
-mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index);
+MINIZ_EXPORT mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, mz_uint file_index);

 /* Retrieves the filename of an archive file entry. */
 /* Returns the number of bytes written to pFilename, or if filename_buf_size is 0 this function returns the number of bytes needed to fully store the filename. */
-mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);
+MINIZ_EXPORT mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size);

 /* Attempts to locates a file in the archive's central directory. */
 /* Valid flags: MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_IGNORE_PATH */
 /* Returns -1 if the file cannot be found. */
-int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
-int mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *file_index);
+MINIZ_EXPORT int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *file_index);

 /* Returns detailed information about an archive file entry. */
-mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);
+MINIZ_EXPORT mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat);

 /* MZ_TRUE if the file is in zip64 format. */
 /* A file is considered zip64 if it contained a zip64 end of central directory marker, or if it contained any zip64 extended file information fields in the central directory. */
-mz_bool mz_zip_is_zip64(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_is_zip64(mz_zip_archive *pZip);

 /* Returns the total central directory size in bytes. */
 /* The current max supported size is <= MZ_UINT32_MAX. */
-size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip);
+MINIZ_EXPORT size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip);

 /* Extracts a archive file to a memory buffer using no memory allocation. */
 /* There must be at least enough room on the stack to store the inflator's state (~34KB or so). */
-mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
-mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_mem_no_alloc(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size);

 /* Extracts a archive file to a memory buffer. */
-mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, mz_uint flags);

 /* Extracts a archive file to a dynamically allocated heap buffer. */
 /* The memory will be allocated via the mz_zip_archive's alloc/realloc functions. */
 /* Returns NULL and sets the last error on failure. */
-void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);
-void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);
+MINIZ_EXPORT void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags);
+MINIZ_EXPORT void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, const char *pFilename, size_t *pSize, mz_uint flags);

 /* Extracts a archive file using a callback function to output the file's data. */
-mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, void *pOpaque, mz_uint flags);

 /* Extract a file iteratively */
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
-size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size);
-mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState);
+MINIZ_EXPORT mz_zip_reader_extract_iter_state* mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
+MINIZ_EXPORT mz_zip_reader_extract_iter_state* mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
+MINIZ_EXPORT size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state* pState, void* pvBuf, size_t buf_size);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state* pState);

 #ifndef MINIZ_NO_STDIO
 /* Extracts a archive file to a disk file and sets its last accessed and modified times. */
 /* This function only extracts files, not archive directory records. */
-mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, const char *pArchive_filename, const char *pDst_filename, mz_uint flags);

 /* Extracts a archive file starting at the current position in the destination FILE stream. */
-mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *File, mz_uint flags);
-mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *File, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, mz_uint flags);
 #endif

 #if 0
 /* TODO */
 	typedef void *mz_zip_streaming_extract_state_ptr;
 	mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
-	uint64_t mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	uint64_t mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
-	mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, uint64_t new_ofs);
+	mz_uint64 mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
+	mz_uint64 mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
+	mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, mz_uint64 new_ofs);
 	size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size);
 	mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState);
 #endif

 /* This function compares the archive's local headers, the optional local zip64 extended information block, and the optional descriptor following the compressed data vs. the data in the central directory. */
 /* It also validates that each file can be successfully uncompressed unless the MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY is specified. */
-mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags);

 /* Validates an entire archive by calling mz_zip_validate_file() on each file. */
-mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags);

 /* Misc utils/helpers, valid for ZIP reading or writing */
-mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr);
-mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr);
+MINIZ_EXPORT mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, mz_uint flags, mz_zip_error *pErr);
+#ifndef MINIZ_NO_STDIO
+MINIZ_EXPORT mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, mz_zip_error *pErr);
+#endif

 /* Universal end function - calls either mz_zip_reader_end() or mz_zip_writer_end(). */
-mz_bool mz_zip_end(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_end(mz_zip_archive *pZip);

 /* -------- ZIP writing */

@@ -1245,16 +1326,16 @@ mz_bool mz_zip_end(mz_zip_archive *pZip);
 /* Inits a ZIP archive writer. */
 /*Set pZip->m_pWrite (and pZip->m_pIO_opaque) before calling mz_zip_writer_init or mz_zip_writer_init_v2*/
 /*The output is streamable, i.e. file_ofs in mz_file_write_func always increases only by n*/
-mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);
-mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags);

-mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size);
-mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, size_t initial_allocation_size, mz_uint flags);

 #ifndef MINIZ_NO_STDIO
-mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning);
-mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags);
-mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint64 size_to_reserve_at_beginning, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint flags);
 #endif

 /* Converts a ZIP archive reader object into a writer object, to allow efficient in-place file appends to occur on an existing archive. */
@@ -1263,56 +1344,57 @@ mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint f
 /* Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's user provided m_pWrite function cannot be NULL. */
 /* Note: In-place archive modification is not recommended unless you know what you're doing, because if execution stops or something goes wrong before */
 /* the archive is finalized the file's central directory will be hosed. */
-mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);
-mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, const char *pFilename);
+MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags);

 /* Adds the contents of a memory buffer to an archive. These functions record the current local time into the archive. */
 /* To add a directory entry, call this method with an archive name ending in a forwardslash with an empty buffer. */
 /* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, mz_uint level_and_flags);

 /* Like mz_zip_writer_add_mem(), except you can specify a file comment field, and optionally supply the function with already compressed data. */
 /* uncomp_size/uncomp_crc32 are only used if the MZ_ZIP_FLAG_COMPRESSED_DATA flag is specified. */
-mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
+                                              mz_uint64 uncomp_size, mz_uint32 uncomp_crc32);

-mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
-                                    mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
-                                    const char *user_extra_data_central, mz_uint user_extra_data_central_len);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex_v2(mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags,
+                                                 mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, MZ_TIME_T *last_modified, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
+                                                 const char *user_extra_data_central, mz_uint user_extra_data_central_len);

 /* Adds the contents of a file to an archive. This function also records the disk file's modified time into the archive. */
 /* File data is supplied via a read callback function. User mz_zip_writer_add_(c)file to add a file directly.*/
-mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void* callback_opaque, mz_uint64 size_to_add,
+MINIZ_EXPORT mz_bool mz_zip_writer_add_read_buf_callback(mz_zip_archive *pZip, const char *pArchive_name, mz_file_read_func read_callback, void* callback_opaque, mz_uint64 max_size,
 	const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
 	const char *user_extra_data_central, mz_uint user_extra_data_central_len);

+
 #ifndef MINIZ_NO_STDIO
 /* Adds the contents of a disk file to an archive. This function also records the disk file's modified time into the archive. */
 /* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
-mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);

 /* Like mz_zip_writer_add_file(), except the file data is read from the specified FILE stream. */
-mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 size_to_add,
+MINIZ_EXPORT mz_bool mz_zip_writer_add_cfile(mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, mz_uint64 max_size,
                                const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, const char *user_extra_data_local, mz_uint user_extra_data_local_len,
                                const char *user_extra_data_central, mz_uint user_extra_data_central_len);
 #endif

 /* Adds a file to an archive by fully cloning the data from another archive. */
 /* This function fully clones the source file's compressed data (no recompression), along with its full filename, extra data (it may add or modify the zip64 local header extra data field), and the optional descriptor following the compressed data. */
-mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index);
+MINIZ_EXPORT mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index);

 /* Finalizes the archive by writing the central directory records followed by the end of central directory record. */
 /* After an archive is finalized, the only valid call on the mz_zip_archive struct is mz_zip_writer_end(). */
 /* An archive must be manually finalized by calling this function for it to be valid. */
-mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip);

-/* Finalizes a heap archive, returning a poiner to the heap block and its size. */
+/* Finalizes a heap archive, returning a pointer to the heap block and its size. */
 /* The heap block will be allocated using the mz_zip_archive's alloc/realloc callbacks. */
-mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize);
+MINIZ_EXPORT mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, size_t *pSize);

 /* Ends archive writing, freeing all allocations, and closing the output file if mz_zip_writer_init_file() was used. */
 /* Note for the archive to be valid, it *must* have been finalized before ending (this function will not do it for you). */
-mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
+MINIZ_EXPORT mz_bool mz_zip_writer_end(mz_zip_archive *pZip);

 /* -------- Misc. high-level helper functions: */

@@ -1320,14 +1402,16 @@ mz_bool mz_zip_writer_end(mz_zip_archive *pZip);
 /* Note this is NOT a fully safe operation. If it crashes or dies in some way your archive can be left in a screwed up state (without a central directory). */
 /* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or just set to MZ_DEFAULT_COMPRESSION. */
 /* TODO: Perhaps add an option to leave the existing central dir in place in case the add dies? We could then truncate the file (so the old central dir would be at the end) if something goes wrong. */
-mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
-mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr);
+MINIZ_EXPORT mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags);
+MINIZ_EXPORT mz_bool mz_zip_add_mem_to_archive_file_in_place_v2(const char *pZip_filename, const char *pArchive_name, const void *pBuf, size_t buf_size, const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, mz_zip_error *pErr);

+#ifndef MINIZ_NO_STDIO
 /* Reads a single file from an archive into a heap block. */
 /* If pComment is not NULL, only the file with the specified comment will be extracted. */
 /* Returns NULL on failure. */
-void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags);
-void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr);
+MINIZ_EXPORT void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const char *pArchive_name, size_t *pSize, mz_uint flags);
+MINIZ_EXPORT void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, const char *pArchive_name, const char *pComment, size_t *pSize, mz_uint flags, mz_zip_error *pErr);
+#endif

 #endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */

--- a/code/components/jomjol_fileserver_ota/miniz/readme.md
+++ b/code/components/jomjol_fileserver_ota/miniz/readme.md
@@ -0,0 +1,46 @@
+## Miniz
+
+Miniz is a lossless, high performance data compression library in a single source file that implements the zlib (RFC 1950) and Deflate (RFC 1951) compressed data format specification standards. It supports the most commonly used functions exported by the zlib library, but is a completely independent implementation so zlib's licensing requirements do not apply. Miniz also contains simple to use functions for writing .PNG format image files and reading/writing/appending .ZIP format archives. Miniz's compression speed has been tuned to be comparable to zlib's, and it also has a specialized real-time compressor function designed to compare well against fastlz/minilzo.
+
+## Usage
+
+Releases are available at the [releases page](https://github.com/richgel999/miniz/releases) as a pair of `miniz.c`/`miniz.h` files which can be simply added to a project. To create this file pair the different source and header files are [amalgamated](https://www.sqlite.org/amalgamation.html) during build. Alternatively use as cmake or meson module (or build system of your choice).
+
+## Features
+
+* MIT licensed
+* A portable, single source and header file library written in plain C. Tested with GCC, clang and Visual Studio.
+* Easily tuned and trimmed down by defines
+* A drop-in replacement for zlib's most used API's (tested in several open source projects that use zlib, such as libpng and libzip).
+* Fills a single threaded performance vs. compression ratio gap between several popular real-time compressors and zlib. For example, at level 1, miniz.c compresses around 5-9% better than minilzo, but is approx. 35% slower. At levels 2-9, miniz.c is designed to compare favorably against zlib's ratio and speed. See the miniz performance comparison page for example timings.
+* Not a block based compressor: miniz.c fully supports stream based processing using a coroutine-style implementation. The zlib-style API functions can be called a single byte at a time if that's all you've got.
+* Easy to use. The low-level compressor (tdefl) and decompressor (tinfl) have simple state structs which can be saved/restored as needed with simple memcpy's. The low-level codec API's don't use the heap in any way.
+* Entire inflater (including optional zlib header parsing and Adler-32 checking) is implemented in a single function as a coroutine, which is separately available in a small (~550 line) source file: miniz_tinfl.c
+* A fairly complete (but totally optional) set of .ZIP archive manipulation and extraction API's. The archive functionality is intended to solve common problems encountered in embedded, mobile, or game development situations. (The archive API's are purposely just powerful enough to write an entire archiver given a bit of additional higher-level logic.)
+
+## Building miniz - Using vcpkg
+
+You can download and install miniz using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    ./vcpkg install miniz
+
+The miniz port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+## Known Problems
+
+* No support for encrypted archives. Not sure how useful this stuff is in practice.
+* Minimal documentation. The assumption is that the user is already familiar with the basic zlib API. I need to write an API wiki - for now I've tried to place key comments before each enum/API, and I've included 6 examples that demonstrate how to use the module's major features.
+
+## Special Thanks
+
+Thanks to Alex Evans for the PNG writer function. Also, thanks to Paul Holden and Thorsten Scheuermann for feedback and testing, Matt Pritchard for all his encouragement, and Sean Barrett's various public domain libraries for inspiration (and encouraging me to write miniz.c in C, which was much more enjoyable and less painful than I thought it would be considering I've been programming in C++ for so long).
+
+Thanks to Bruce Dawson for reporting a problem with the level_and_flags archive API parameter (which is fixed in v1.12) and general feedback, and Janez Zemva for indirectly encouraging me into writing more examples.
+
+## Patents
+
+I was recently asked if miniz avoids patent issues. miniz purposely uses the same core algorithms as the ones used by zlib. The compressor uses vanilla hash chaining as described [here](https://datatracker.ietf.org/doc/html/rfc1951#section-4). Also see the [gzip FAQ](https://web.archive.org/web/20160308045258/http://www.gzip.org/#faq11). In my opinion, if miniz falls prey to a patent attack then zlib/gzip are likely to be at serious risk too.
--- a/code/components/jomjol_fileserver_ota/miniz/readme2.md
+++ b/code/components/jomjol_fileserver_ota/miniz/readme2.md
@@ -0,0 +1,8 @@
+The files in this folder are a direct extraction of the miniz release from https://github.com/richgel999/miniz/releases
+
+It should be possible to include the repo directly as a submodule, how ever it causes various issues. See also
+ - https://github.com/richgel999/miniz/issues/145
+ - https://github.com/espressif/esptool/pull/500#issuecomment-574879468
+
+ For simplicity we therefore use the release files as suggested in the readme.
+ Additionally we added the CMakeLists.txt and this readme.
--- a/code/components/jomjol_fileserver_ota/server_file.cpp
+++ b/code/components/jomjol_fileserver_ota/server_file.cpp
--- a/code/components/jomjol_fileserver_ota/server_file.h
+++ b/code/components/jomjol_fileserver_ota/server_file.h
@@ -0,0 +1,21 @@
+#pragma once
+
+#ifndef SERVERFILE_H
+#define SERVERFILE_H
+
+#include <esp_http_server.h>
+#include <string>
+
+void register_server_file_uri(httpd_handle_t server, const char *base_path);
+
+void unzip(std::string _in_zip_file, std::string _target_directory);
+std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::string _target_bin, std::string _main = "/sdcard/", bool _initial_setup = false);
+
+
+void delete_all_in_directory(std::string _directory);
+
+esp_err_t get_tflite_file_handler(httpd_req_t *req);
+esp_err_t get_data_file_handler(httpd_req_t *req);
+esp_err_t get_numbers_file_handler(httpd_req_t *req);
+
+#endif //SERVERFILE_H
--- a/code/components/jomjol_fileserver_ota/server_help.cpp
+++ b/code/components/jomjol_fileserver_ota/server_help.cpp
@@ -5,35 +5,71 @@
 #include <sys/param.h>
 #include <sys/unistd.h>
 #include <sys/stat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
 #include <dirent.h>
+#ifdef __cplusplus
+}
+#endif

 #include "esp_err.h"
 #include "esp_log.h"

+#include "Helper.h"
+
 #include "esp_http_server.h"

-
-static const char *TAG = "serverhelp";
-
-#define SCRATCH_BUFSIZE  8192 
-char scratch[SCRATCH_BUFSIZE];
+#include "../../include/defines.h"


-#define IS_FILE_EXT(filename, ext) \
-    (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)
+static const char *TAG = "SERVER HELP";
+
+char scratch[SERVER_HELPER_SCRATCH_BUFSIZE];


-esp_err_t send_file(httpd_req_t *req, std::string filename,  struct stat * file_stat)
+bool endsWith(std::string const &str, std::string const &suffix) {
+    if (str.length() < suffix.length()) {
+        return false;
+    }
+    return str.compare(str.length() - suffix.length(), suffix.length(), suffix) == 0;
+}
+
+
+esp_err_t send_file(httpd_req_t *req, std::string filename)
 {
    FILE *fd = fopen(filename.c_str(), "r");
    if (!fd) {
-        ESP_LOGE(TAG, "Failed to read existing file : %s", filename.c_str());
-        /* Respond with 500 Internal Server Error */
-        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read existing file");
+        ESP_LOGE(TAG, "Failed to read file: %s", filename.c_str());
+        /* Respond with 404 Error */
+        httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
        return ESP_FAIL;
    }

-    ESP_LOGI(TAG, "Sending file : %s (%ld bytes)...", filename.c_str(), file_stat->st_size);
+    ESP_LOGD(TAG, "Sending file: %s ...", filename.c_str());
+//    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+
+    /* For all files with the following file extention tell
+       the webbrowser to cache them for 24h */
+    if (endsWith(filename, ".html") ||
+        endsWith(filename, ".htm") ||
+        endsWith(filename, ".css") ||
+        endsWith(filename, ".js") ||
+        endsWith(filename, ".map") ||
+        endsWith(filename, ".jpg") ||
+        endsWith(filename, ".jpeg") ||
+        endsWith(filename, ".ico") ||
+        endsWith(filename, ".png")) {
+
+    	if (filename == "/sdcard/html/setup.html") {    
+            httpd_resp_set_hdr(req, "Clear-Site-Data", "\"*\"");
+        }
+        else {
+            httpd_resp_set_hdr(req, "Cache-Control", "max-age=86400");
+        }
+    }
+
    set_content_type_from_file(req, filename.c_str());

    /* Retrieve the pointer to scratch buffer for temporary storage */
@@ -41,7 +77,7 @@ esp_err_t send_file(httpd_req_t *req, std::string filename,  struct stat * file_
    size_t chunksize;
    do {
        /* Read file in chunks into the scratch buffer */
-        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+        chunksize = fread(chunk, 1, SERVER_HELPER_SCRATCH_BUFSIZE, fd);

        /* Send the buffer contents as HTTP response chunk */
        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
@@ -59,12 +95,13 @@ esp_err_t send_file(httpd_req_t *req, std::string filename,  struct stat * file_

    /* Close file after sending complete */
    fclose(fd);
-    ESP_LOGI(TAG, "File sending complete");    
+    ESP_LOGD(TAG, "File sending complete");    
    return ESP_OK;    
 }



+
 /* 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,8 +141,14 @@ 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");
+    } else if (IS_FILE_EXT(filename, ".js")) {
+        return httpd_resp_set_type(req, "text/javascript");
+    } else if (IS_FILE_EXT(filename, ".css")) {
+        return httpd_resp_set_type(req, "text/css");
    }
    /* This is a limited set only */
    /* For any other type always set as plain text */
--- a/code/components/jomjol_fileserver_ota/server_help.h
+++ b/code/components/jomjol_fileserver_ota/server_help.h
@@ -1,3 +1,8 @@
+#pragma once
+
+#ifndef SERVERHELP_H
+#define SERVERHELP_H
+
 #include <string>
 //#include <sys/param.h>
 #include "esp_http_server.h"
@@ -5,6 +10,8 @@

 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);
+esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename);
+
+#endif //SERVERHELP_H
--- a/code/components/jomjol_fileserver_ota/server_ota.cpp
+++ b/code/components/jomjol_fileserver_ota/server_ota.cpp
@@ -0,0 +1,703 @@
+#include "server_ota.h"
+
+#include <string>
+#include "string.h"
+
+/* TODO Rethink the usage of the int watchdog. It is no longer to be used, see
+https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/system.html?highlight=esp_int_wdt */
+#include "esp_private/esp_int_wdt.h"
+
+#include <esp_task_wdt.h>
+
+
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_log.h"
+#include <esp_ota_ops.h>
+#include "esp_http_client.h"
+#include "esp_flash_partitions.h"
+#include "esp_partition.h"
+#include <nvs.h>
+#include "esp_app_format.h"
+#include "nvs_flash.h"
+#include "driver/gpio.h"
+// #include "protocol_examples_common.h"
+#include "errno.h"
+
+#include <sys/stat.h>
+
+#include "MainFlowControl.h"
+#include "server_file.h"
+#include "server_GPIO.h"
+#ifdef ENABLE_MQTT
+    #include "interface_mqtt.h"
+#endif //ENABLE_MQTT
+#include "ClassControllCamera.h"
+#include "connect_wlan.h"
+
+
+#include "ClassLogFile.h"
+
+#include "Helper.h"
+#include "statusled.h"
+#include "../../include/defines.h"
+
+/*an ota data write buffer ready to write to the flash*/
+static char ota_write_data[SERVER_OTA_SCRATCH_BUFSIZE + 1] = { 0 };
+
+static const char *TAG = "OTA";
+
+esp_err_t handler_reboot(httpd_req_t *req);
+static bool ota_update_task(std::string fn);
+
+std::string _file_name_update;
+bool initial_setup = false;
+
+
+static void infinite_loop(void)
+{
+    int i = 0;
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "When a new firmware is available on the server, press the reset button to download it");
+    while(1) {
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Waiting for a new firmware... (" + to_string(++i) + ")");
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
+}
+
+
+void task_do_Update_ZIP(void *pvParameter)
+{
+    StatusLED(AP_OR_OTA, 1, true);  // Signaling an OTA update
+    
+    std::string filetype = toUpper(getFileType(_file_name_update));
+
+  	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "File: " + _file_name_update + " Filetype: " + filetype);
+
+
+    if (filetype == "ZIP")
+    {
+        std::string in, out, outbin, zw, retfirmware;
+
+        out = "/sdcard/html";
+        outbin = "/sdcard/firmware";
+
+        retfirmware = unzip_new(_file_name_update, out+"/", outbin+"/", "/sdcard/", initial_setup);
+    	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Files unzipped.");
+
+        if (retfirmware.length() > 0)
+        {
+        	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Found firmware.bin");
+            ota_update_task(retfirmware);
+        }
+
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Trigger reboot due to firmware update");
+        doRebootOTA();
+    } else if (filetype == "BIN")
+    {
+       	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Do firmware update - file: " + _file_name_update);
+        ota_update_task(_file_name_update);
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Trigger reboot due to firmware update");
+        doRebootOTA();
+    }
+    else
+    {
+    	LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Only ZIP-Files support for update during startup!");
+    }
+}
+
+
+void CheckUpdate()
+{
+ 	FILE *pfile;
+    if ((pfile = fopen("/sdcard/update.txt", "r")) == NULL)
+    {
+		LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "No pending update");
+        return;
+	}
+
+	char zw[1024] = "";
+	fgets(zw, 1024, pfile);
+    _file_name_update = std::string(zw);
+    if (fgets(zw, 1024, pfile))
+	{
+		std::string _szw = std::string(zw);
+        if (_szw == "init")
+        {
+       		LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Inital Setup triggered");
+        }
+	}
+
+    fclose(pfile);
+    DeleteFile("/sdcard/update.txt");   // Prevent Boot Loop!!!
+	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Start update process (" + _file_name_update + ")");
+
+
+    xTaskCreate(&task_do_Update_ZIP, "task_do_Update_ZIP", configMINIMAL_STACK_SIZE * 35, NULL, tskIDLE_PRIORITY+1, NULL);
+    while(1) { // wait until reboot within task_do_Update_ZIP
+        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    }
+}
+
+
+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(TAG, "Starting OTA update");
+
+    const esp_partition_t *configured = esp_ota_get_boot_partition();
+    const esp_partition_t *running = esp_ota_get_running_partition();
+
+    if (configured != running) {        
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Configured OTA boot partition at offset " + to_string(configured->address) + 
+                ", but running from offset " + to_string(running->address));
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "(This can happen if either the OTA boot data or preferred boot image become somehow corrupted.)");
+    }
+    ESP_LOGI(TAG, "Running partition type %d subtype %d (offset 0x%08x)",
+             running->type, running->subtype, (unsigned int)running->address);
+
+
+    update_partition = esp_ota_get_next_update_partition(NULL);
+    ESP_LOGI(TAG, "Writing to partition subtype %d at offset 0x%x",
+             update_partition->subtype, (unsigned int)update_partition->address);
+//    assert(update_partition != NULL);
+
+    int binary_file_length = 0;
+
+    // deal with all receive packet 
+    bool image_header_was_checked = false;
+
+    int data_read;     
+
+    FILE* f = fopen(fn.c_str(), "rb");     // previously only "r
+
+    if (f == NULL) { // File does not exist
+        return false;
+    }
+
+    data_read = fread(ota_write_data, 1, SERVER_OTA_SCRATCH_BUFSIZE, f);
+
+    while (data_read > 0) {
+        if (data_read < 0) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Error: SSL data read error");
+            return false;
+        } else if (data_read > 0) {
+            if (image_header_was_checked == false) {
+                esp_app_desc_t new_app_info;
+                if (data_read > sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t)) {
+                    // check current version with downloading
+                    memcpy(&new_app_info, &ota_write_data[sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t)], sizeof(esp_app_desc_t));
+                    ESP_LOGI(TAG, "New firmware version: %s", new_app_info.version);
+
+                    esp_app_desc_t running_app_info;
+                    if (esp_ota_get_partition_description(running, &running_app_info) == ESP_OK) {
+                        ESP_LOGI(TAG, "Running firmware version: %s", running_app_info.version);
+                    }
+
+                    const esp_partition_t* last_invalid_app = esp_ota_get_last_invalid_partition();
+                    esp_app_desc_t invalid_app_info;
+                    if (esp_ota_get_partition_description(last_invalid_app, &invalid_app_info) == ESP_OK) {
+                        ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
+                    }
+
+                    // check current version with last invalid partition
+                    if (last_invalid_app != NULL) {
+                        if (memcmp(invalid_app_info.version, new_app_info.version, sizeof(new_app_info.version)) == 0) {
+                            LogFile.WriteToFile(ESP_LOG_WARN, TAG, "New version is the same as invalid version");
+                            LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Previously, there was an attempt to launch the firmware with " + 
+                                    string(invalid_app_info.version) + " version, but it failed");
+                            LogFile.WriteToFile(ESP_LOG_WARN, TAG, "The firmware has been rolled back to the previous version");
+                            infinite_loop();
+                        }
+                    }
+
+/*
+                    if (memcmp(new_app_info.version, running_app_info.version, sizeof(new_app_info.version)) == 0) {
+                        LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Current running version is the same as a new. We will not continue the update");
+                        infinite_loop();
+                    }
+*/
+                    image_header_was_checked = true;
+
+                    err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
+                    if (err != ESP_OK) {
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_begin failed (" + string(esp_err_to_name(err)) + ")");
+                        return false;
+                    }
+                    ESP_LOGI(TAG, "esp_ota_begin succeeded");
+                } else {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "received package is not fit len");
+                    return false;
+                }
+            }            
+            err = esp_ota_write( update_handle, (const void *)ota_write_data, data_read);
+            if (err != ESP_OK) {
+                return false;
+            }
+            binary_file_length += data_read;
+            ESP_LOGD(TAG, "Written image length %d", binary_file_length);
+        } else if (data_read == 0) {
+           //
+           // * As esp_http_client_read never returns negative error code, we rely on
+           // * `errno` to check for underlying transport connectivity closure if any
+           //
+            if (errno == ECONNRESET || errno == ENOTCONN) {
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Connection closed, errno = " + to_string(errno));
+                break;
+            }
+        }
+        data_read = fread(ota_write_data, 1, SERVER_OTA_SCRATCH_BUFSIZE, f);
+    }
+    fclose(f);  
+
+    ESP_LOGI(TAG, "Total Write binary data length: %d", binary_file_length);
+
+    err = esp_ota_end(update_handle);
+    if (err != ESP_OK) {
+        if (err == ESP_ERR_OTA_VALIDATE_FAILED) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Image validation failed, image is corrupted");
+        }
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_end failed (" + string(esp_err_to_name(err)) + ")!");
+        return false;
+    }
+
+    err = esp_ota_set_boot_partition(update_partition);
+    if (err != ESP_OK) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_set_boot_partition failed (" + string(esp_err_to_name(err)) + ")!");
+
+    }
+//    ESP_LOGI(TAG, "Prepare to restart system!");
+//    esp_restart();
+
+    return true ;
+}
+
+
+static void print_sha256 (const uint8_t *image_hash, const char *label)
+{
+    char hash_print[HASH_LEN * 2 + 1];
+    hash_print[HASH_LEN * 2] = 0;
+    for (int i = 0; i < HASH_LEN; ++i) {
+        sprintf(&hash_print[i * 2], "%02x", image_hash[i]);
+    }
+    ESP_LOGI(TAG, "%s: %s", label, hash_print);
+}
+
+
+static bool diagnostic(void)
+{
+    return true;
+}
+
+
+void CheckOTAUpdate(void)
+{
+    ESP_LOGI(TAG, "Start CheckOTAUpdateCheck...");
+
+    uint8_t sha_256[HASH_LEN] = { 0 };
+    esp_partition_t partition;
+
+    // get sha256 digest for the partition table
+    partition.address   = ESP_PARTITION_TABLE_OFFSET;
+    partition.size      = ESP_PARTITION_TABLE_MAX_LEN;
+    partition.type      = ESP_PARTITION_TYPE_DATA;
+    esp_partition_get_sha256(&partition, sha_256);
+    print_sha256(sha_256, "SHA-256 for the partition table: ");
+
+    // get sha256 digest for bootloader
+    partition.address   = ESP_BOOTLOADER_OFFSET;
+    partition.size      = ESP_PARTITION_TABLE_OFFSET;
+    partition.type      = ESP_PARTITION_TYPE_APP;
+    esp_partition_get_sha256(&partition, sha_256);
+    print_sha256(sha_256, "SHA-256 for bootloader: ");
+
+    // get sha256 digest for running partition
+    esp_partition_get_sha256(esp_ota_get_running_partition(), sha_256);
+    print_sha256(sha_256, "SHA-256 for current firmware: ");
+
+    const esp_partition_t *running = esp_ota_get_running_partition();
+    esp_ota_img_states_t ota_state;
+    esp_err_t res_stat_partition = esp_ota_get_state_partition(running, &ota_state);
+    switch (res_stat_partition)
+    {
+        case ESP_OK:
+            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_OK");
+            if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
+                if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
+                    // run diagnostic function ...
+                    bool diagnostic_is_ok = diagnostic();
+                    if (diagnostic_is_ok) {
+                        ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
+                        esp_ota_mark_app_valid_cancel_rollback();
+                    } else {
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Diagnostics failed! Start rollback to the previous version...");
+                        esp_ota_mark_app_invalid_rollback_and_reboot();
+                    }
+                }
+            }            
+            break;
+        case ESP_ERR_INVALID_ARG:
+            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_INVALID_ARG");
+            break;
+        case ESP_ERR_NOT_SUPPORTED:
+            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_SUPPORTED");
+            break;
+        case ESP_ERR_NOT_FOUND:
+            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_FOUND");
+            break;
+    }
+    if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
+        if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
+            // run diagnostic function ...
+            bool diagnostic_is_ok = diagnostic();
+            if (diagnostic_is_ok) {
+                ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
+                esp_ota_mark_app_valid_cancel_rollback();
+            } else {
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Diagnostics failed! Start rollback to the previous version...");
+                esp_ota_mark_app_invalid_rollback_and_reboot();
+            }
+        }
+    }
+}
+
+
+esp_err_t handler_ota_update(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON     
+    LogFile.WriteHeapInfo("handler_ota_update - Start");    
+#endif
+
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "handler_ota_update");
+    char _query[200];
+    char _filename[100];
+    char _valuechar[30];    
+    std::string fn = "/sdcard/firmware/";
+    bool _file_del = false;
+    std::string _task = "";
+
+    if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK)
+    {
+        ESP_LOGD(TAG, "Query: %s", _query);
+        
+        if (httpd_query_key_value(_query, "task", _valuechar, 30) == ESP_OK)
+        {
+            ESP_LOGD(TAG, "task is found: %s", _valuechar);
+            _task = std::string(_valuechar);
+        }
+
+        if (httpd_query_key_value(_query, "file", _filename, 100) == ESP_OK)
+        {
+            fn.append(_filename);
+            ESP_LOGD(TAG, "File: %s", fn.c_str());
+        }
+        if (httpd_query_key_value(_query, "delete", _filename, 100) == ESP_OK)
+        {
+            fn.append(_filename);
+            _file_del = true;
+            ESP_LOGD(TAG, "Delete Default File: %s", fn.c_str());
+        }
+
+    }
+
+    if (_task.compare("emptyfirmwaredir") == 0)
+    {
+        ESP_LOGD(TAG, "Start empty directory /firmware");
+        delete_all_in_directory("/sdcard/firmware");
+        std::string zw = "firmware directory deleted - v2\n";
+        ESP_LOGD(TAG, "%s", zw.c_str());
+        printf("Ausgabe: %s\n", zw.c_str());
+    
+        httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+        httpd_resp_send(req, zw.c_str(), strlen(zw.c_str())); 
+        /* Respond with an empty chunk to signal HTTP response completion */
+        httpd_resp_send_chunk(req, NULL, 0);  
+
+        ESP_LOGD(TAG, "Done empty directory /firmware");
+        return ESP_OK;
+    }
+
+    if (_task.compare("update") == 0)
+    {
+        std::string filetype = toUpper(getFileType(fn));
+        if (filetype.length() == 0)
+        {
+            std::string zw = "Update failed - no file specified (zip, bin, tfl, tlite)";
+            httpd_resp_sendstr_chunk(req, zw.c_str());
+            httpd_resp_sendstr_chunk(req, NULL);  
+            return ESP_OK;        
+        }
+
+
+        if ((filetype == "TFLITE") || (filetype == "TFL"))
+        {
+            std::string out = "/sdcard/config/" + getFileFullFileName(fn);
+            DeleteFile(out);
+            CopyFile(fn, out);
+            DeleteFile(fn);
+
+            const char*  resp_str = "Neural Network File copied.";
+            httpd_resp_sendstr_chunk(req, resp_str);
+            httpd_resp_sendstr_chunk(req, NULL);  
+            return ESP_OK;
+        }
+
+
+        if ((filetype == "ZIP") || (filetype == "BIN"))
+        {
+           	FILE *pfile;
+            LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Update for reboot");
+            pfile = fopen("/sdcard/update.txt", "w");
+            fwrite(fn.c_str(), fn.length(), 1, pfile);
+            fclose(pfile);
+
+            std::string zw = "reboot\n";
+            httpd_resp_sendstr_chunk(req, zw.c_str());
+            httpd_resp_sendstr_chunk(req, NULL);  
+            ESP_LOGD(TAG, "Send reboot");
+            return ESP_OK;                
+
+        }
+
+/*
+        if (filetype == "BIN")
+        {
+            const char* resp_str; 
+
+            DeleteMainFlowTask();
+            gpio_handler_deinit();
+            if (ota_update_task(fn))
+            {
+                std::string zw = "reboot\n";
+                httpd_resp_sendstr_chunk(req, zw.c_str());
+                httpd_resp_sendstr_chunk(req, NULL);  
+                ESP_LOGD(TAG, "Send reboot");
+                return ESP_OK;                
+            }
+
+            resp_str = "Error during Firmware Update!!!\nPlease check output of console.";
+            httpd_resp_send(req, resp_str, strlen(resp_str));  
+
+            #ifdef DEBUG_DETAIL_ON 
+                LogFile.WriteHeapInfo("handler_ota_update - Done");    
+            #endif
+
+            return ESP_OK;
+        }
+*/
+
+        std::string zw = "Update failed - no valid file specified (zip, bin, tfl, tlite)!";
+        httpd_resp_sendstr_chunk(req, zw.c_str());
+        httpd_resp_sendstr_chunk(req, NULL);  
+        return ESP_OK;        
+    }
+
+
+    if (_task.compare("unziphtml") == 0)
+    {
+        ESP_LOGD(TAG, "Task unziphtml");
+        std::string in, out, zw;
+
+        in = "/sdcard/firmware/html.zip";
+        out = "/sdcard/html";
+
+        delete_all_in_directory(out);
+
+        unzip(in, out+"/");
+        zw = "Web Interface Update Successfull!\nNo reboot necessary";
+        httpd_resp_send(req, zw.c_str(), strlen(zw.c_str()));
+        httpd_resp_sendstr_chunk(req, NULL);  
+        return ESP_OK;        
+    }
+
+    if (_file_del)
+    {
+        ESP_LOGD(TAG, "Delete !! _file_del: %s", fn.c_str());
+        struct stat file_stat;
+        int _result = stat(fn.c_str(), &file_stat);
+        ESP_LOGD(TAG, "Ergebnis %d\n", _result);
+        if (_result == 0) {
+            ESP_LOGD(TAG, "Deleting file: %s", fn.c_str());
+            /* Delete file */
+            unlink(fn.c_str());
+        }
+        else
+        {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File does not exist: " + fn);
+        }
+        /* Respond with an empty chunk to signal HTTP response completion */
+        std::string zw = "file deleted\n";
+        ESP_LOGD(TAG, "%s", zw.c_str());
+        httpd_resp_send(req, zw.c_str(), strlen(zw.c_str()));
+        httpd_resp_send_chunk(req, NULL, 0);
+        return ESP_OK;
+    }
+
+    string zw = "ota without parameter - should not be the case!";
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+    httpd_resp_send(req, zw.c_str(), strlen(zw.c_str())); 
+    httpd_resp_send_chunk(req, NULL, 0);  
+
+    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ota without parameter - should not be the case!");
+
+/*  
+    const char* resp_str;    
+
+    DeleteMainFlowTask();
+    gpio_handler_deinit();
+    if (ota_update_task(fn))
+    {
+        resp_str = "Firmware Update Successfull! You can restart now.";
+    }
+    else
+    {
+        resp_str = "Error during Firmware Update!!! Please check console output.";
+    }
+
+    httpd_resp_send(req, resp_str, strlen(resp_str));  
+*/
+
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("handler_ota_update - Done");    
+    #endif
+
+    return ESP_OK;
+}
+
+
+void hard_restart() 
+{
+  esp_task_wdt_config_t twdt_config = {
+    .timeout_ms = 1,
+    .idle_core_mask = (1 << portNUM_PROCESSORS) - 1,    // Bitmask of all cores
+    .trigger_panic = true,
+  };
+  ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
+
+  esp_task_wdt_add(NULL);
+  while(true);
+}
+
+
+void task_reboot(void *DeleteMainFlow)
+{
+    // write a reboot, to identify a reboot by purpouse
+    FILE* pfile = fopen("/sdcard/reboot.txt", "w");
+    std::string _s_zw= "reboot";
+    fwrite(_s_zw.c_str(), strlen(_s_zw.c_str()), 1, pfile);
+    fclose(pfile);
+
+    vTaskDelay(3000 / portTICK_PERIOD_MS);
+
+    if ((bool)DeleteMainFlow) {
+        DeleteMainFlowTask();  // Kill autoflow task if executed in extra task, if not don't kill parent task
+    }
+
+    Camera.LightOnOff(false);
+    StatusLEDOff();
+
+    /* Stop service tasks */
+    #ifdef ENABLE_MQTT
+        MQTTdestroy_client(true);
+    #endif //ENABLE_MQTT
+    gpio_handler_destroy();
+    esp_camera_deinit();
+    WIFIDestroy();
+
+    vTaskDelay(3000 / portTICK_PERIOD_MS);
+    esp_restart();      // Reset type: CPU reset (Reset both CPUs)
+
+    vTaskDelay(5000 / portTICK_PERIOD_MS);
+    hard_restart();     // Reset type: System reset (Triggered by watchdog), if esp_restart stalls (WDT needs to be activated)
+
+    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Reboot failed!");
+    vTaskDelete(NULL); //Delete this task if it comes to this point
+}
+
+
+void doReboot()
+{
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Reboot triggered by Software (5s)");
+    LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Reboot in 5sec");
+
+    BaseType_t xReturned = xTaskCreate(&task_reboot, "task_reboot", configMINIMAL_STACK_SIZE * 4, (void*) true, 10, NULL);
+    if( xReturned != pdPASS )
+    {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "task_reboot not created -> force reboot without killing flow");
+        task_reboot((void*) false);
+    }
+    vTaskDelay(10000 / portTICK_PERIOD_MS); // Prevent serving web client fetch response until system is shuting down
+}
+
+
+void doRebootOTA()
+{
+    LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Reboot in 5sec");
+
+    Camera.LightOnOff(false);
+    StatusLEDOff();
+    esp_camera_deinit();
+
+    vTaskDelay(5000 / portTICK_PERIOD_MS);
+    esp_restart();      // Reset type: CPU reset (Reset both CPUs)
+
+    vTaskDelay(5000 / portTICK_PERIOD_MS);
+    hard_restart();     // Reset type: System reset (Triggered by watchdog), if esp_restart stalls (WDT needs to be activated)
+}
+
+
+esp_err_t handler_reboot(httpd_req_t *req)
+{
+    #ifdef DEBUG_DETAIL_ON     
+        LogFile.WriteHeapInfo("handler_reboot - Start");
+    #endif    
+
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "handler_reboot");
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "!!! System will restart within 5 sec!!!");
+
+    std::string response = 
+        "<html><head><script>"
+            "function m(h) {"
+                "document.getElementById('t').innerHTML=h;"
+                "setInterval(function (){h +='.'; document.getElementById('t').innerHTML=h;"
+                "fetch('reboot_page.html',{mode: 'no-cors'}).then(r=>{parent.location.href=('index.html');})}, 1000);"
+            "}</script></head></html><body style='font-family: arial'><h3 id=t></h3>"
+            "<script>m('Rebooting!<br>The page will automatically reload in around 25..60s.<br><br>');</script>"
+            "</body></html>";
+
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+    httpd_resp_send(req, response.c_str(), strlen(response.c_str()));
+    
+    doReboot();
+
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("handler_reboot - Done");    
+    #endif
+
+    return ESP_OK;
+}
+
+
+void register_server_ota_sdcard_uri(httpd_handle_t server)
+{
+    ESP_LOGI(TAG, "Registering URI handlers");
+    
+    httpd_uri_t camuri = { };
+    camuri.method    = HTTP_GET;
+    camuri.uri       = "/ota";
+    camuri.handler   = handler_ota_update;
+    camuri.user_ctx  = (void*) "Do OTA";    
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.method    = HTTP_GET;
+    camuri.uri       = "/reboot";
+    camuri.handler   = handler_reboot;
+    camuri.user_ctx  = (void*) "Reboot";    
+    httpd_register_uri_handler(server, &camuri);
+
+}
--- a/code/components/jomjol_fileserver_ota/server_ota.h
+++ b/code/components/jomjol_fileserver_ota/server_ota.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#ifndef SERVEROTA_H
+#define SERVEROTA_H
+
+#include <esp_log.h>
+
+#include <esp_http_server.h>
+
+#include <string>
+
+
+void register_server_ota_sdcard_uri(httpd_handle_t server);
+void CheckOTAUpdate();
+void doReboot();
+void doRebootOTA();
+void hard_restart();
+void CheckUpdate();
+
+#endif //SERVEROTA_H
--- a/code/components/jomjol_flowcontroll/CMakeLists.txt
+++ b/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 esp_timer esp_wifi jomjol_tfliteclass jomjol_helper jomjol_controlcamera jomjol_mqtt jomjol_influxdb jomjol_webhook jomjol_fileserver_ota jomjol_image_proc jomjol_wlan openmetrics)
+
+
--- a/code/components/jomjol_flowcontroll/ClassFlow.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlow.cpp
@@ -0,0 +1,114 @@
+#include "ClassFlow.h"
+#include <fstream>
+#include <string>
+#include <iostream>
+#include <string.h>
+#include "esp_log.h"
+#include "../../include/defines.h"
+
+static const char *TAG = "CLASS";
+
+
+void ClassFlow::SetInitialParameter(void)
+{
+	ListFlowControll = NULL;
+	previousElement = NULL;	
+	disabled = false;
+}
+
+bool ClassFlow::isNewParagraph(string input)
+{
+	if ((input[0] == '[') || ((input[0] == ';') && (input[1] == '[')))
+	{
+		return true;
+	}
+	return false;
+}
+
+bool ClassFlow::GetNextParagraph(FILE* pfile, string& aktparamgraph)
+{
+	while (getNextLine(pfile, &aktparamgraph) && !isNewParagraph(aktparamgraph));
+
+	if (isNewParagraph(aktparamgraph))
+		return true;
+	return false;
+}
+
+
+ClassFlow::ClassFlow(void)
+{
+	SetInitialParameter();
+}
+
+ClassFlow::ClassFlow(std::vector<ClassFlow*> * lfc)
+{
+	SetInitialParameter();	
+	ListFlowControll = lfc;
+}
+
+ClassFlow::ClassFlow(std::vector<ClassFlow*> * lfc, ClassFlow *_prev)
+{
+	SetInitialParameter();	
+	ListFlowControll = lfc;
+	previousElement = _prev;
+}	
+
+bool ClassFlow::ReadParameter(FILE* pfile, string &aktparamgraph)
+{
+	return false;
+}
+
+bool ClassFlow::doFlow(string time)
+{
+	return false;
+}
+
+string ClassFlow::getHTMLSingleStep(string host){
+	return "";
+}
+
+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;
+    }
+//    ESP_LOGD(TAG, "Parameter: %s, Pospunkt: %d", _param.c_str(), _pospunkt);
+	return _param;
+}
+
+
+bool ClassFlow::getNextLine(FILE* pfile, string *rt)
+{
+	char zw[1024];
+	if (pfile == NULL)
+	{
+		*rt = "";
+		return false;
+	}
+	if (!fgets(zw, 1024, pfile))
+	{
+		*rt = "";
+		ESP_LOGD(TAG, "END OF FILE");
+		return false;
+	}
+	ESP_LOGD(TAG, "%s", zw);
+	*rt = zw;
+	*rt = trim(*rt);
+	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))
+	{
+		*rt = "";
+		if (!fgets(zw, 1024, pfile))
+			return false;
+		ESP_LOGD(TAG, "%s", zw);
+		*rt = zw;
+		*rt = trim(*rt);
+	}
+	return true;
+}
--- a/code/components/jomjol_flowcontroll/ClassFlow.h
+++ b/code/components/jomjol_flowcontroll/ClassFlow.h
@@ -1,41 +1,53 @@
 #pragma once

+#ifndef CLASSFLOW_H
+#define CLASSFLOW_H
+
 #include <fstream>
 #include <string>
 #include <vector>

 #include "Helper.h"
-#include "CFindTemplate.h"
+#include "CImageBasis.h"

 using namespace std;

 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);
 	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);
-	virtual string getReadout();
 	virtual string name(){return "ClassFlow";};

 };

+#endif //CLASSFLOW_H
--- a/code/components/jomjol_flowcontroll/ClassFlowAlignment.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowAlignment.cpp
@@ -0,0 +1,374 @@
+#include "ClassFlowAlignment.h"
+#include "ClassFlowTakeImage.h"
+#include "ClassFlow.h"
+#include "MainFlowControl.h"
+
+#include "CRotateImage.h"
+#include "esp_log.h"
+
+#include "ClassLogFile.h"
+#include "psram.h"
+#include "../../include/defines.h"
+
+static const char *TAG = "ALIGN";
+
+// #define DEBUG_DETAIL_ON
+
+void ClassFlowAlignment::SetInitialParameter(void)
+{
+    initialrotate = 0;
+    anz_ref = 0;
+    use_antialiasing = false;
+    initialflip = false;
+    SaveAllFiles = false;
+    namerawimage = "/sdcard/img_tmp/raw.jpg";
+    FileStoreRefAlignment = "/sdcard/config/align.txt";
+    ListFlowControll = NULL;
+    AlignAndCutImage = NULL;
+    ImageBasis = NULL;
+    ImageTMP = NULL;
+#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+    AlgROI = (ImageData *)malloc_psram_heap(std::string(TAG) + "->AlgROI", sizeof(ImageData), MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
+#endif
+    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("ClassFlowTakeImage") == 0) {
+            ImageBasis = ((ClassFlowTakeImage *)(*ListFlowControll)[i])->rawImage;
+        }
+    }
+
+    // the function take pictures does not exist --> must be created first ONLY FOR TEST PURPOSES
+    if (!ImageBasis)  {
+        ESP_LOGD(TAG, "CImageBasis had to be created");
+        ImageBasis = new CImageBasis("ImageBasis", namerawimage);
+    }
+}
+
+bool ClassFlowAlignment::ReadParameter(FILE *pfile, string &aktparamgraph)
+{
+    std::vector<string> splitted;
+    int suchex = 40;
+    int suchey = 40;
+    int alg_algo = 0; // default=0; 1 =HIGHACCURACY; 2= FAST; 3= OFF //add disable aligment algo |01.2023
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+    {
+        if (!this->GetNextParagraph(pfile, aktparamgraph)) {
+            return false;
+        }
+    }
+
+    if (aktparamgraph.compare("[Alignment]") != 0)
+    {
+        // Paragraph does not fit Alignment
+        return false;
+    }
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        splitted = ZerlegeZeile(aktparamgraph);
+
+        if ((toUpper(splitted[0]) == "FLIPIMAGESIZE") && (splitted.size() > 1)) {
+            initialflip = alphanumericToBoolean(splitted[1]);
+        }
+        else if (((toUpper(splitted[0]) == "initialrotate") || (toUpper(splitted[0]) == "INITIALROTATE")) && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1])) {
+                this->initialrotate = std::stod(splitted[1]);
+            }
+        }
+        else if ((toUpper(splitted[0]) == "SEARCHFIELDX") && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1])) {
+                suchex = std::stod(splitted[1]);
+            }
+        }
+        else if ((toUpper(splitted[0]) == "SEARCHFIELDY") && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1])) {
+                suchey = std::stod(splitted[1]);
+            }
+        }
+        else if ((toUpper(splitted[0]) == "ANTIALIASING") && (splitted.size() > 1)) {
+            use_antialiasing = alphanumericToBoolean(splitted[1]);
+        }
+        else if ((splitted.size() == 3) && (anz_ref < 2)) {
+            if ((isStringNumeric(splitted[1])) && (isStringNumeric(splitted[2])))
+            {
+                References[anz_ref].image_file = FormatFileName("/sdcard" + splitted[0]);
+                References[anz_ref].target_x = std::stod(splitted[1]);
+                References[anz_ref].target_y = std::stod(splitted[2]);
+                anz_ref++;
+            }
+            else
+            {
+                References[anz_ref].image_file = FormatFileName("/sdcard" + splitted[0]);
+                References[anz_ref].target_x = 10;
+                References[anz_ref].target_y = 10;
+                anz_ref++;
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "SAVEALLFILES") && (splitted.size() > 1)) {
+            SaveAllFiles = alphanumericToBoolean(splitted[1]);
+        }
+        else if ((toUpper(splitted[0]) == "ALIGNMENTALGO") && (splitted.size() > 1)) {
+#ifdef DEBUG_DETAIL_ON
+            std::string zw2 = "Alignment mode selected: " + splitted[1];
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, zw2);
+#endif
+            if (toUpper(splitted[1]) == "HIGHACCURACY") {
+                alg_algo = 1;
+            }
+            if (toUpper(splitted[1]) == "FAST") {
+                alg_algo = 2;
+            }
+            if (toUpper(splitted[1]) == "OFF") {
+                // no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
+                alg_algo = 3;
+            }
+        }
+    }
+
+    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 = "Alignment mode written: " + std::to_string(alg_algo);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, zw2);
+#endif
+    }
+
+    // no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
+    if (References[0].alignment_algo != 3) {
+        return 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)
+{
+#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+    // AlgROI needs to be allocated before ImageTMP to avoid heap fragmentation
+    if (!AlgROI)  {
+        AlgROI = (ImageData *)heap_caps_realloc(AlgROI, sizeof(ImageData), MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
+
+        if (!AlgROI) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate AlgROI");
+            LogFile.WriteHeapInfo("ClassFlowAlignment-doFlow");
+        }
+    }
+
+    if (AlgROI) {
+        ImageBasis->writeToMemoryAsJPG((ImageData *)AlgROI, 90);
+    }
+#endif
+
+    if (!ImageTMP) {
+        ImageTMP = new CImageBasis("tmpImage", ImageBasis); // Make sure the name does not get change, it is relevant for the PSRAM allocation!
+
+        if (!ImageTMP) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate tmpImage -> Exec this round aborted!");
+            LogFile.WriteHeapInfo("ClassFlowAlignment-doFlow");
+            return false;
+        }
+    }
+
+    delete AlignAndCutImage;
+    AlignAndCutImage = new CAlignAndCutImage("AlignAndCutImage", ImageBasis, ImageTMP);
+
+    if (!AlignAndCutImage) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate AlignAndCutImage -> Exec this round aborted!");
+        LogFile.WriteHeapInfo("ClassFlowAlignment-doFlow");
+        return false;
+    }
+
+    CRotateImage rt("rawImage", AlignAndCutImage, ImageTMP, initialflip);
+
+    if (initialflip) {
+        int _zw = ImageBasis->height;
+        ImageBasis->height = ImageBasis->width;
+        ImageBasis->width = _zw;
+
+        _zw = ImageTMP->width;
+        ImageTMP->width = ImageTMP->height;
+        ImageTMP->height = _zw;
+    }
+
+    if ((initialrotate != 0) || initialflip) {
+        if (use_antialiasing) {
+            rt.RotateAntiAliasing(initialrotate);
+        }
+        else {
+            rt.Rotate(initialrotate);
+        }
+
+        if (SaveAllFiles) {
+            AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/rot.jpg"));
+        }
+    }
+
+    // no align algo if set to 3 = off //add disable aligment algo |01.2023
+    if (References[0].alignment_algo != 3) {
+        if (!AlignAndCutImage->Align(&References[0], &References[1])) {
+            SaveReferenceAlignmentValues();
+        }
+    } // no align
+
+#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+    if (AlgROI) {
+        // no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
+        if (References[0].alignment_algo != 3) {
+            DrawRef(ImageTMP);
+        }
+
+        flowctrl.DigitDrawROI(ImageTMP);
+        flowctrl.AnalogDrawROI(ImageTMP);
+        ImageTMP->writeToMemoryAsJPG((ImageData *)AlgROI, 90);
+    }
+#endif
+
+    if (SaveAllFiles) {
+        AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/alg.jpg"));
+        ImageTMP->SaveToFile(FormatFileName("/sdcard/img_tmp/alg_roi.jpg"));
+    }
+
+    // must be deleted to have memory space for loading tflite
+    delete ImageTMP;
+    ImageTMP = NULL;
+
+    // no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
+    if (References[0].alignment_algo != 3) {
+        return 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> splitted;
+
+    pFile = fopen(FileStoreRefAlignment.c_str(), "r");
+
+    if (pFile == NULL) {
+        return false;
+    }
+
+    fgets(zw, 1024, pFile);
+    ESP_LOGD(TAG, "%s", zw);
+
+    fgets(zw, 1024, pFile);
+    splitted = ZerlegeZeile(std::string(zw), " \t");
+
+    if (splitted.size() < 6) {
+        fclose(pFile);
+        return false;
+    }
+
+    References[0].fastalg_x = stoi(splitted[0]);
+    References[0].fastalg_y = stoi(splitted[1]);
+    References[0].fastalg_SAD = stof(splitted[2]);
+    References[0].fastalg_min = stoi(splitted[3]);
+    References[0].fastalg_max = stoi(splitted[4]);
+    References[0].fastalg_avg = stof(splitted[5]);
+
+    fgets(zw, 1024, pFile);
+    splitted = ZerlegeZeile(std::string(zw));
+
+    if (splitted.size() < 6) {
+        fclose(pFile);
+        return false;
+    }
+
+    References[1].fastalg_x = stoi(splitted[0]);
+    References[1].fastalg_y = stoi(splitted[1]);
+    References[1].fastalg_SAD = stof(splitted[2]);
+    References[1].fastalg_min = stoi(splitted[3]);
+    References[1].fastalg_max = stoi(splitted[4]);
+    References[1].fastalg_avg = stof(splitted[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)
+{
+    if (_zw->ImageOkay()) {
+        _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);
+    }
+}
--- a/code/components/jomjol_flowcontroll/ClassFlowAlignment.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowAlignment.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#ifndef CLASSFLOWALIGNMENT_H
+#define CLASSFLOWALIGNMENT_H
+
+#include "ClassFlow.h"
+#include "Helper.h"
+#include "CAlignAndCutImage.h"
+#include "CFindTemplate.h"
+
+#include <string>
+
+using namespace std;
+
+class ClassFlowAlignment : public ClassFlow
+{
+protected:
+    float initialrotate;
+    bool initialflip;
+    bool use_antialiasing;
+    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;
+#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+    ImageData *AlgROI;
+#endif
+
+    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"; };
+};
+
+#endif // CLASSFLOWALIGNMENT_H
--- a/code/components/jomjol_flowcontroll/ClassFlowCNNGeneral.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowCNNGeneral.cpp
@@ -0,0 +1,944 @@
+#include "ClassFlowCNNGeneral.h"
+
+#include <math.h>
+#include <iomanip> 
+#include <sys/types.h>
+#include <sstream>      // std::stringstream
+
+#include "CTfLiteClass.h"
+#include "ClassLogFile.h"
+#include "esp_log.h"
+#include "../../include/defines.h"
+
+static const char* TAG = "CNN";
+
+//#ifdef CONFIG_HEAP_TRACING_STANDALONE
+#ifdef HEAP_TRACING_CLASS_FLOW_CNN_GENERAL_DO_ALING_AND_CUT
+    #include <esp_heap_trace.h>
+    #define NUM_RECORDS 300
+    static heap_trace_record_t trace_record[NUM_RECORDS]; // This buffer must be in internal RAM
+#endif
+
+ClassFlowCNNGeneral::ClassFlowCNNGeneral(ClassFlowAlignment *_flowalign, t_CNNType _cnntype) : ClassFlowImage(NULL, TAG) {
+    string cnnmodelfile = "";
+    modelxsize = 1;
+    modelysize = 1;
+    CNNGoodThreshold = 0.0;
+    ListFlowControll = NULL;
+    previousElement = NULL;   
+    SaveAllFiles = false; 
+    disabled = false;
+    isLogImageSelect = false;
+    CNNType = AutoDetect;
+    CNNType = _cnntype;
+    flowpostalignment = _flowalign;
+    imagesRetention = 5;
+}
+
+string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution, int prev, float _before_narrow_Analog, float AnalogToDigitTransitionStart) {
+    string result = "";    
+
+    if (GENERAL[_analog]->ROI.size() == 0) {
+        return result;
+    }
+    
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout _analog=" + std::to_string(_analog) + ", _extendedResolution=" + std::to_string(_extendedResolution) + ", prev=" + std::to_string(prev));
+ 
+    if (CNNType == Analogue || CNNType == Analogue100) {
+        float number = GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float;
+        int result_after_decimal_point = ((int) floor(number * 10) + 10) % 10;
+        
+        prev = PointerEvalAnalogNew(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, prev);
+//        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(analog) number=" + std::to_string(number) + ", result_after_decimal_point=" + std::to_string(result_after_decimal_point) + ", prev=" + std::to_string(prev));
+        result = std::to_string(prev);
+
+        if (_extendedResolution) {
+            result = result + std::to_string(result_after_decimal_point);
+        }
+
+        for (int i = GENERAL[_analog]->ROI.size() - 2; i >= 0; --i) {
+            prev = PointerEvalAnalogNew(GENERAL[_analog]->ROI[i]->result_float, prev);
+            result = std::to_string(prev) + result;
+        }
+        return result;
+    }
+
+    if (CNNType == Digit) {
+        for (int i = 0; i < GENERAL[_analog]->ROI.size(); ++i) {
+            if (GENERAL[_analog]->ROI[i]->result_klasse >= 10) {
+                result = result + "N";
+            }
+            else {
+                result = result + std::to_string(GENERAL[_analog]->ROI[i]->result_klasse);
+            }
+        }
+        return result;
+    }
+
+    if ((CNNType == DoubleHyprid10) || (CNNType == Digit100)) {
+        float number = GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float;
+        // NaN?
+        if (number >= 0) {
+            // is only set if it is the first digit (no analogue before!)
+            if (_extendedResolution) {
+                int result_after_decimal_point = ((int) floor(number * 10)) % 10;
+                int result_before_decimal_point = ((int) floor(number)) % 10;
+
+                result = std::to_string(result_before_decimal_point) + std::to_string(result_after_decimal_point);
+                prev = result_before_decimal_point;
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(dig100-ext) result_before_decimal_point=" + std::to_string(result_before_decimal_point) + ", result_after_decimal_point=" + std::to_string(result_after_decimal_point) + ", prev=" + std::to_string(prev));
+            }
+            else {
+                if (_before_narrow_Analog >= 0) {
+                    prev = PointerEvalHybridNew(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, _before_narrow_Analog, prev, true, AnalogToDigitTransitionStart);
+                }
+                else {
+                    prev = PointerEvalHybridNew(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, prev, prev);
+                }
+                result = std::to_string(prev);
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(dig100)  prev=" + std::to_string(prev));
+            }
+        }
+        else {
+            result = "N";
+            if (_extendedResolution && (CNNType != Digit)) {
+                result = "NN";
+            }
+        }
+
+        for (int i = GENERAL[_analog]->ROI.size() - 2; i >= 0; --i) {
+            if (GENERAL[_analog]->ROI[i]->result_float >= 0) {
+                prev = PointerEvalHybridNew(GENERAL[_analog]->ROI[i]->result_float, GENERAL[_analog]->ROI[i+1]->result_float, prev);
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout#PointerEvalHybridNew()= " + std::to_string(prev));
+                result = std::to_string(prev) + result;
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout#result= " + result);
+            }
+            else {
+                prev = -1;
+                result = "N" + result;
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(result_float<0 /'N')  result_float=" + std::to_string(GENERAL[_analog]->ROI[i]->result_float));
+        
+            }
+        }
+        return result;
+    }
+    return result;
+}
+
+/**
+ * @brief Determines the number of an ROI in connection with previous ROI results
+ * 
+ * @param number: is the current ROI as float value from recognition
+ * @param number_of_predecessors: is the last (lower) ROI as float from recognition
+ * @param eval_predecessors: is the evaluated number. Sometimes a much lower value can change higer values
+ *                          example: 9.8, 9.9, 0.1
+ *                          0.1 => 0 (eval_predecessors)
+ *                          The 0 makes a 9.9 to 0 (eval_predecessors)
+ *                          The 0 makes a 9.8 to 0 
+ * @param Analog_Predecessors false/true if the last ROI is an analog or digit ROI (default=false)
+ *                              runs in special handling because analog is much less precise
+ * @param digitAnalogTransitionStart start of the transitionlogic begins on number_of_predecessor (default=9.2)
+ *
+ * @return int the determined number of the current ROI
+ */
+int ClassFlowCNNGeneral::PointerEvalHybridNew(float number, float number_of_predecessors, int eval_predecessors, bool Analog_Predecessors, float digitAnalogTransitionStart) {
+    int result;
+    int result_after_decimal_point = ((int) floor(number * 10)) % 10;
+    int result_before_decimal_point = ((int) floor(number) + 10) % 10;
+
+    if (eval_predecessors < 0) {   
+        // on first digit is no spezial logic for transition needed
+        // we use the recognition as given. The result is the int value of the recognition
+        // add precisition of 2 digits and round before trunc
+        result = (int) ((int) trunc(round((number+10 % 10)*100)) )  / 100;
+
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - No predecessor - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digit_Uncertainty = " +  std::to_string(Digit_Uncertainty));
+        return result;
+    }
+
+    if (Analog_Predecessors) {
+        result = PointerEvalAnalogToDigitNew(number, number_of_predecessors, eval_predecessors, digitAnalogTransitionStart);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - Analog predecessor, evaluation over PointerEvalAnalogNew = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digit_Uncertainty = " +  std::to_string(Digit_Uncertainty));
+        return result;
+    }
+
+    if ((number_of_predecessors >= Digit_Transition_Area_Predecessor ) && (number_of_predecessors <= (10.0 - Digit_Transition_Area_Predecessor))) {
+        // no digit change, because predecessor is far enough away (0+/-DigitTransitionRangePredecessor) --> number is rounded
+        // Band around the digit --> Round off, as digit reaches inaccuracy in the frame
+        if ((result_after_decimal_point <= DigitBand) || (result_after_decimal_point >= (10-DigitBand))) {
+            result = ((int) round(number) + 10) % 10;
+        }
+        else {
+            result = ((int) trunc(number) + 10) % 10;
+        }
+
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - NO analogue predecessor, no change of digits, as pre-decimal point far enough away = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digit_Uncertainty = " +  std::to_string(Digit_Uncertainty));
+        return result;
+    }  
+
+    // Zero crossing at the predecessor has taken place (! evaluation via Prev_value and not number!) --> round up here (2.8 --> 3, but also 3.1 --> 3)
+    if (eval_predecessors <= 1) {
+        // We simply assume that the current digit after the zero crossing of the predecessor
+        // has passed through at least half (x.5)
+        if (result_after_decimal_point > 5) {
+            // The current digit does not yet have a zero crossing, but the predecessor does..
+            result =  (result_before_decimal_point + 1) % 10;
+        }
+        else {
+            // Act. digit and predecessor have zero crossing
+            result =  result_before_decimal_point % 10;
+        }
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - NO analogue predecessor, zero crossing has taken placen = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digit_Uncertainty = " +  std::to_string(Digit_Uncertainty));
+        return result;
+    }
+
+    // remains only >= 9.x --> no zero crossing yet --> 2.8 --> 2, 
+    // and from 9.7(DigitTransitionRangeLead) 3.1 --> 2
+    // everything >=x.4 can be considered as current number in transition. With 9.x predecessor the current
+    // number can still be x.6 - x.7. 
+    // Preceding (else - branch) does not already happen from 9.
+    if (Digit_Transition_Area_Forward>=number_of_predecessors || result_after_decimal_point >= 4) {
+        // The current digit, like the previous digit, does not yet have a zero crossing. 
+        result =  result_before_decimal_point % 10;
+    }
+    else {
+        // current digit precedes the smaller digit (9.x). So already >=x.0 while the previous digit has not yet
+        // has no zero crossing. Therefore, it is reduced by 1.
+        result =  (result_before_decimal_point - 1 + 10) % 10;
+    }
+
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - O analogue predecessor, >= 9.5 --> no zero crossing yet = " + std::to_string(result) +
+                                                " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digit_Uncertainty = " +  std::to_string(Digit_Uncertainty) + " result_after_decimal_point = " + std::to_string(result_after_decimal_point));
+    return result;
+}
+
+int ClassFlowCNNGeneral::PointerEvalAnalogToDigitNew(float number, float numeral_preceder,  int eval_predecessors, float AnalogToDigitTransitionStart) {
+    int result;
+    int result_after_decimal_point = ((int) floor(number * 10)) % 10;
+    int result_before_decimal_point = ((int) floor(number) + 10) % 10;
+    bool roundedUp = false;
+
+    // Within the digit inequalities 
+    if ((result_after_decimal_point >= (10-Digit_Uncertainty * 10))     // Band around the digit --> Round off, as digit reaches inaccuracy in the frame
+        || (eval_predecessors <= 4 && result_after_decimal_point>=6))  {   // or digit runs after (analogue =0..4, digit >=6)
+        result = (int) (round(number) + 10) % 10;
+        roundedUp = true;
+        // before/ after decimal point, because we adjust the number based on the uncertainty.
+        result_after_decimal_point = ((int) floor(result * 10)) % 10;
+        result_before_decimal_point = ((int) floor(result) + 10) % 10;
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogToDigitNew - Digit Uncertainty - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " numeral_preceder: " + std::to_string(numeral_preceder) +
+                                                    " erg before comma: " + std::to_string(result_before_decimal_point) + 
+                                                    " erg after comma: " + std::to_string(result_after_decimal_point));
+    } 
+    else {
+        result = (int) ((int) trunc(number) + 10) % 10;
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogToDigitNew - NO digit Uncertainty - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder));
+    }
+
+    // No zero crossing has taken place.
+    // Only eval_predecessors used because numeral_preceder could be wrong here.
+    // numeral_preceder<=0.1 & eval_predecessors=9 corresponds to analogue was reset because of previous analogue that are not yet at 0.
+    if ((eval_predecessors>=6 && (numeral_preceder>AnalogToDigitTransitionStart || numeral_preceder<=0.2) && roundedUp)) {
+        result =  ((result_before_decimal_point+10) - 1) % 10;
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogToDigitNew - Nulldurchgang noch nicht stattgefunden = " + std::to_string(result) +
+                                    " number: " + std::to_string(number) + 
+                                    " numeral_preceder = " + std::to_string(numeral_preceder) + 
+                                    " eerg after comma = " +  std::to_string(result_after_decimal_point));
+    }
+
+    return result;
+}
+
+int ClassFlowCNNGeneral::PointerEvalAnalogNew(float number, int numeral_preceder) {
+    float number_min, number_max;
+    int result;
+
+    if (numeral_preceder == -1) {
+        result = (int) floor(number);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - No predecessor - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
+        return result;
+    }
+
+    number_min = number - Analog_error / 10.0;
+    number_max = number + Analog_error / 10.0;
+
+    if ((int) floor(number_max) - (int) floor(number_min) != 0) {
+        if (numeral_preceder <= Analog_error) {
+            result = ((int) floor(number_max) + 10) % 10;
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - number ambiguous, correction upwards - result = " + std::to_string(result) +
+                                                        " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
+            return result;
+        }
+        if (numeral_preceder >= 10 - Analog_error) {
+            result = ((int) floor(number_min) + 10) % 10;
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - number ambiguous, downward correction - result = " + std::to_string(result) +
+                                                        " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
+            return result;
+        }
+    }
+    
+    result = ((int) floor(number) + 10) % 10;
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - number unambiguous, no correction necessary - result = " + std::to_string(result) +
+                                                " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
+
+    return result;
+}
+
+bool ClassFlowCNNGeneral::ReadParameter(FILE* pfile, string& aktparamgraph) {
+    std::vector<string> splitted;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0) {
+        if (!this->GetNextParagraph(pfile, aktparamgraph)) {
+            return false;
+        }
+    }
+
+    if ((toUpper(aktparamgraph) != "[ANALOG]") && (toUpper(aktparamgraph) != ";[ANALOG]") 
+        && (toUpper(aktparamgraph) != "[DIGIT]") && (toUpper(aktparamgraph) != ";[DIGIT]")
+        && (toUpper(aktparamgraph) != "[DIGITS]") && (toUpper(aktparamgraph) != ";[DIGITS]")) {      
+        // Paragraph passt nicht
+        return false;
+    }
+
+    if (aktparamgraph[0] == ';') {
+        disabled = true;
+        while (getNextLine(pfile, &aktparamgraph) && !isNewParagraph(aktparamgraph));
+        ESP_LOGD(TAG, "[Analog/Digit] is disabled!");
+        return true;
+    }
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph)) {
+        splitted = ZerlegeZeile(aktparamgraph);
+        if ((toUpper(splitted[0]) == "ROIIMAGESLOCATION") && (splitted.size() > 1)) {
+            this->imagesLocation = "/sdcard" + splitted[1];
+            this->isLogImage = true;
+        }
+        
+        if ((toUpper(splitted[0]) == "LOGIMAGESELECT") && (splitted.size() > 1)) {
+            LogImageSelect = splitted[1];
+            isLogImageSelect = true;            
+        }
+
+        if ((toUpper(splitted[0]) == "ROIIMAGESRETENTION") && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1])) {
+                this->imagesRetention = std::stoi(splitted[1]);
+            }
+        }
+
+        if ((toUpper(splitted[0]) == "MODEL") && (splitted.size() > 1)) {
+            this->cnnmodelfile = splitted[1];
+        }
+        
+        if ((toUpper(splitted[0]) == "CNNGOODTHRESHOLD") && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1])) {
+                CNNGoodThreshold = std::stof(splitted[1]);
+            }
+        }
+        
+        if (splitted.size() >= 5) {
+            general* _analog = GetGENERAL(splitted[0], true);
+            roi* neuroi = _analog->ROI[_analog->ROI.size()-1];
+            neuroi->posx = std::stoi(splitted[1]);
+            neuroi->posy = std::stoi(splitted[2]);
+            neuroi->deltax = std::stoi(splitted[3]);
+            neuroi->deltay = std::stoi(splitted[4]);
+            neuroi->CCW = false;
+            
+            if (splitted.size() >= 6) {
+                neuroi->CCW = toUpper(splitted[5]) == "TRUE";
+            }
+            
+            neuroi->result_float = -1;
+            neuroi->image = NULL;
+            neuroi->image_org = NULL;
+        }
+
+        if ((toUpper(splitted[0]) == "SAVEALLFILES") && (splitted.size() > 1)) {
+            SaveAllFiles = alphanumericToBoolean(splitted[1]);
+        }
+    }
+
+    if (!getNetworkParameter()) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "An error occured on setting up the Network -> Disabling it!");
+        disabled = true; // An error occured, disable this CNN!
+        return false;
+    }
+
+    for (int _ana = 0; _ana < GENERAL.size(); ++_ana) {
+        for (int i = 0; i < GENERAL[_ana]->ROI.size(); ++i) {
+            GENERAL[_ana]->ROI[i]->image = new CImageBasis("ROI " + GENERAL[_ana]->ROI[i]->name, 
+                    modelxsize, modelysize, modelchannel);
+            GENERAL[_ana]->ROI[i]->image_org = new CImageBasis("ROI " + GENERAL[_ana]->ROI[i]->name + " original",
+                    GENERAL[_ana]->ROI[i]->deltax, GENERAL[_ana]->ROI[i]->deltay, 3);
+        }
+    }
+
+    return true;
+}
+
+general* ClassFlowCNNGeneral::FindGENERAL(string _name_number) {
+    for (int i = 0; i < GENERAL.size(); ++i) {
+        if (GENERAL[i]->name == _name_number) {
+            return GENERAL[i];
+        }
+    }
+    
+    return NULL;
+}
+
+general* ClassFlowCNNGeneral::GetGENERAL(string _name, bool _create = true) {
+    string _analog, _roi;
+    int _pospunkt = _name.find_first_of(".");
+
+    if (_pospunkt > -1) {
+        _analog = _name.substr(0, _pospunkt);
+        _roi = _name.substr(_pospunkt+1, _name.length() - _pospunkt - 1);
+    }
+    else {
+        _analog = "default";
+        _roi = _name;
+    }
+
+    general *_ret = NULL;
+
+    for (int i = 0; i < GENERAL.size(); ++i) {
+        if (GENERAL[i]->name == _analog) {
+            _ret = GENERAL[i];
+        }
+    }
+
+    // not found and should not be created
+    if (!_create) {        
+        return _ret;
+    }
+
+    if (_ret == NULL) {
+        _ret = new general;
+        _ret->name = _analog;
+        GENERAL.push_back(_ret);
+    }
+
+    roi* neuroi = new roi;
+    neuroi->name = _roi;
+
+    _ret->ROI.push_back(neuroi);
+
+    ESP_LOGD(TAG, "GetGENERAL - GENERAL %s - roi %s - CCW: %d", _analog.c_str(), _roi.c_str(), neuroi->CCW);
+
+    return _ret;
+}
+
+string ClassFlowCNNGeneral::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 ClassFlowCNNGeneral::doFlow(string time) {
+#ifdef HEAP_TRACING_CLASS_FLOW_CNN_GENERAL_DO_ALING_AND_CUT
+    //register a buffer to record the memory trace
+    ESP_ERROR_CHECK( heap_trace_init_standalone(trace_record, NUM_RECORDS) );
+    // start tracing
+    ESP_ERROR_CHECK( heap_trace_start(HEAP_TRACE_LEAKS) );
+#endif
+
+    if (disabled) {
+      return true;
+    }
+
+    if (!doAlignAndCut(time)){
+        return false;
+    }
+
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "doFlow after alignment");
+
+    doNeuralNetwork(time);
+
+    RemoveOldLogs();
+
+#ifdef HEAP_TRACING_CLASS_FLOW_CNN_GENERAL_DO_ALING_AND_CUT
+    ESP_ERROR_CHECK( heap_trace_stop() );
+    heap_trace_dump(); 
+#endif   
+
+    return true;
+}
+
+bool ClassFlowCNNGeneral::doAlignAndCut(string time) {
+    if (disabled) {
+        return true;
+    }
+
+    CAlignAndCutImage *caic = flowpostalignment->GetAlignAndCutImage();    
+
+    for (int _ana = 0; _ana < GENERAL.size(); ++_ana) {
+        for (int i = 0; i < GENERAL[_ana]->ROI.size(); ++i) {
+            ESP_LOGD(TAG, "General %d - Align&Cut", i);
+            
+            caic->CutAndSave(GENERAL[_ana]->ROI[i]->posx, GENERAL[_ana]->ROI[i]->posy, GENERAL[_ana]->ROI[i]->deltax, GENERAL[_ana]->ROI[i]->deltay, GENERAL[_ana]->ROI[i]->image_org);
+            if (SaveAllFiles) {
+                if (GENERAL[_ana]->name == "default") {
+                    GENERAL[_ana]->ROI[i]->image_org->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
+                }
+                else {
+                    GENERAL[_ana]->ROI[i]->image_org->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
+                }
+            } 
+
+            GENERAL[_ana]->ROI[i]->image_org->Resize(modelxsize, modelysize, GENERAL[_ana]->ROI[i]->image);
+            if (SaveAllFiles) {
+                if (GENERAL[_ana]->name == "default") {
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
+                }
+                else {
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
+                }
+            } 
+        }
+    }
+
+    return true;
+} 
+
+void ClassFlowCNNGeneral::DrawROI(CImageBasis *_zw) {
+    if (_zw->ImageOkay()) { 
+        if (CNNType == Analogue || CNNType == Analogue100) {
+            int r = 0;
+            int g = 255;
+            int b = 0;
+
+            for (int _ana = 0; _ana < GENERAL.size(); ++_ana) {
+                for (int i = 0; i < GENERAL[_ana]->ROI.size(); ++i) {
+                    _zw->drawRect(GENERAL[_ana]->ROI[i]->posx, GENERAL[_ana]->ROI[i]->posy, GENERAL[_ana]->ROI[i]->deltax, GENERAL[_ana]->ROI[i]->deltay, r, g, b, 1);
+                    _zw->drawEllipse( (int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int)  (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), (int) (GENERAL[_ana]->ROI[i]->deltax/2), (int) (GENERAL[_ana]->ROI[i]->deltay/2), r, g, b, 2);
+                    _zw->drawLine((int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int) GENERAL[_ana]->ROI[i]->posy, (int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay), r, g, b, 2);
+                    _zw->drawLine((int) GENERAL[_ana]->ROI[i]->posx, (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), (int) GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax, (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), r, g, b, 2);
+                }
+            }
+        }
+        else {
+            for (int _dig = 0; _dig < GENERAL.size(); ++_dig) {
+                for (int i = 0; i < GENERAL[_dig]->ROI.size(); ++i) {
+                    _zw->drawRect(GENERAL[_dig]->ROI[i]->posx, GENERAL[_dig]->ROI[i]->posy, GENERAL[_dig]->ROI[i]->deltax, GENERAL[_dig]->ROI[i]->deltay, 0, 0, (255 - _dig*100), 2);
+                }
+            }
+        }
+    }
+} 
+
+bool ClassFlowCNNGeneral::getNetworkParameter() {
+    if (disabled) {
+        return true;
+    }
+
+    CTfLiteClass *tflite = new CTfLiteClass;  
+    string zwcnn = "/sdcard" + cnnmodelfile;
+    zwcnn = FormatFileName(zwcnn);
+    ESP_LOGD(TAG, "%s", zwcnn.c_str());
+    
+    if (!tflite->LoadModel(zwcnn)) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't load tflite model " + cnnmodelfile + " -> Init aborted!");
+        LogFile.WriteHeapInfo("getNetworkParameter-LoadModel");
+        delete tflite;
+        return false;
+    } 
+
+    if (!tflite->MakeAllocate()) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate tflite model -> Init aborted!");
+        LogFile.WriteHeapInfo("getNetworkParameter-MakeAllocate");
+        delete tflite;
+        return false;
+    }
+
+    if (CNNType == AutoDetect) {
+        tflite->GetInputDimension(false);
+        modelxsize = tflite->ReadInputDimenstion(0);
+        modelysize = tflite->ReadInputDimenstion(1);
+        modelchannel = tflite->ReadInputDimenstion(2);
+
+        int _anzoutputdimensions = tflite->GetAnzOutPut();
+        switch (_anzoutputdimensions) {
+            case 2:
+                CNNType = Analogue;
+                ESP_LOGD(TAG, "TFlite-Type set to Analogue");
+                break;
+            case 10:
+                CNNType = DoubleHyprid10;
+                ESP_LOGD(TAG, "TFlite-Type set to DoubleHyprid10");
+                break;
+            case 11:
+                CNNType = Digit;
+                ESP_LOGD(TAG, "TFlite-Type set to Digit");
+                break;
+/*            case 20:
+                CNNType = DigitHyprid10;
+                ESP_LOGD(TAG, "TFlite-Type set to DigitHyprid10");
+                break;
+*/
+//            case 22:
+//                CNNType = DigitHyprid;
+//                ESP_LOGD(TAG, "TFlite-Type set to DigitHyprid");
+//                break;
+             case 100:
+                if (modelxsize==32 && modelysize == 32) {
+                    CNNType = Analogue100;
+                    ESP_LOGD(TAG, "TFlite-Type set to Analogue100");
+                } 
+                else {
+                    CNNType = Digit100;
+                    ESP_LOGD(TAG, "TFlite-Type set to Digit");
+                }
+                break;
+            default:
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "tflite does not fit the firmware (outout_dimension=" + std::to_string(_anzoutputdimensions) + ")");
+        }
+    }
+
+    delete tflite;
+    return true;
+}
+
+bool ClassFlowCNNGeneral::doNeuralNetwork(string time) {
+    if (disabled) {
+        return true;
+    }
+
+    string logPath = CreateLogFolder(time);
+
+    CTfLiteClass *tflite = new CTfLiteClass;  
+    string zwcnn = "/sdcard" + cnnmodelfile;
+    zwcnn = FormatFileName(zwcnn);
+    ESP_LOGD(TAG, "%s", zwcnn.c_str());
+
+    if (!tflite->LoadModel(zwcnn)) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't load tflite model " + cnnmodelfile + " -> Exec aborted this round!");
+        LogFile.WriteHeapInfo("doNeuralNetwork-LoadModel");
+        delete tflite;
+        return false;
+    }
+
+    if (!tflite->MakeAllocate()) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate tfilte model -> Exec aborted this round!");
+        LogFile.WriteHeapInfo("doNeuralNetwork-MakeAllocate");
+        delete tflite;
+        return false;
+    }
+
+    // For each NUMBER
+    for (int n = 0; n < GENERAL.size(); ++n) {
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Processing Number '" + GENERAL[n]->name + "'");
+        // For each ROI
+        for (int roi = 0; roi < GENERAL[n]->ROI.size(); ++roi) {
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ROI #" + std::to_string(roi) + " - TfLite");
+            //ESP_LOGD(TAG, "General %d - TfLite", i);
+
+            switch (CNNType) {
+                case Analogue:
+                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "CNN Type: Analogue");
+                    {
+                        float f1, f2;
+                        f1 = 0; f2 = 0;
+
+                        tflite->LoadInputImageBasis(GENERAL[n]->ROI[roi]->image);        
+                        tflite->Invoke();
+                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "After Invoke");
+
+                        f1 = tflite->GetOutputValue(0);
+                        f2 = tflite->GetOutputValue(1);
+                        float result = fmod(atan2(f1, f2) / (M_PI * 2) + 2, 1);
+                              
+                        if(GENERAL[n]->ROI[roi]->CCW) {
+                            GENERAL[n]->ROI[roi]->result_float = 10 - (result * 10);
+                        }
+                        else {
+                            GENERAL[n]->ROI[roi]->result_float = result * 10;
+                        }
+                              
+                        ESP_LOGD(TAG, "General result (Analog)%i - CCW: %d -  %f", roi, GENERAL[n]->ROI[roi]->CCW, GENERAL[n]->ROI[roi]->result_float);
+                        if (isLogImage) {
+                            LogImage(logPath, GENERAL[n]->ROI[roi]->name, &GENERAL[n]->ROI[roi]->result_float, NULL, time, GENERAL[n]->ROI[roi]->image_org);
+                        }
+                    } break;
+
+                case Digit:
+                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "CNN Type: Digit");
+                    {
+                        GENERAL[n]->ROI[roi]->result_klasse = 0;
+                        GENERAL[n]->ROI[roi]->result_klasse = tflite->GetClassFromImageBasis(GENERAL[n]->ROI[roi]->image);
+                        ESP_LOGD(TAG, "General result (Digit)%i: %d", roi, GENERAL[n]->ROI[roi]->result_klasse);
+
+                        if (isLogImage) {
+                            string _imagename = GENERAL[n]->name +  "_" + GENERAL[n]->ROI[roi]->name;
+                            if (isLogImageSelect) {
+                                if (LogImageSelect.find(GENERAL[n]->ROI[roi]->name) != std::string::npos) {
+                                    LogImage(logPath, _imagename, NULL, &GENERAL[n]->ROI[roi]->result_klasse, time, GENERAL[n]->ROI[roi]->image_org);
+                                }
+                            }
+                            else {
+                                LogImage(logPath, _imagename, NULL, &GENERAL[n]->ROI[roi]->result_klasse, time, GENERAL[n]->ROI[roi]->image_org);
+                            }
+                        }
+                    } break;
+
+                case DoubleHyprid10:
+                    {
+                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "CNN Type: DoubleHyprid10");
+                        int _num, _numplus, _numminus;
+                        float _val, _valplus, _valminus;
+                        float _fit;
+                        float _result_save_file;
+
+                        tflite->LoadInputImageBasis(GENERAL[n]->ROI[roi]->image);        
+                        tflite->Invoke();
+                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "After Invoke");
+
+                        _num = tflite->GetOutClassification(0, 9);
+                        _numplus = (_num + 1) % 10;
+                        _numminus = (_num - 1 + 10) % 10;
+
+                        _val = tflite->GetOutputValue(_num);
+                        _valplus = tflite->GetOutputValue(_numplus);
+                        _valminus = tflite->GetOutputValue(_numminus);
+
+                        float result = _num;
+
+                        if (_valplus > _valminus) {
+                            result = result + _valplus / (_valplus + _val);
+                            _fit = _val + _valplus;
+                        }
+                        else {
+                            result = result - _valminus / (_val + _valminus);
+                            _fit = _val + _valminus;
+                        }
+                        
+                        if (result >= 10) {
+                            result = result - 10;
+                        }
+                        
+                        if (result < 0) {
+                            result = result + 10;
+                        }
+
+                        string zw = "_num (p, m): " + to_string(_num) + " " + to_string(_numplus) + " " + to_string(_numminus);
+                        zw = zw + " _val (p, m): " + to_string(_val) + " " + to_string(_valplus) + " " + to_string(_valminus);
+                        zw = zw + " result: " + to_string(result) + " _fit: " + to_string(_fit);
+                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, zw);
+
+                        _result_save_file = result;
+
+                        if (_fit < CNNGoodThreshold) {
+                            GENERAL[n]->ROI[roi]->isReject = true;
+                            result = -1;
+                            _result_save_file+= 100;     // In case fit is not sufficient, the result should still be saved with "-10x.y".
+                            string zw = "Value Rejected due to Threshold (Fit: " + to_string(_fit) + ", Threshold: " + to_string(CNNGoodThreshold) + ")";
+                            LogFile.WriteToFile(ESP_LOG_WARN, TAG, zw);
+                        }
+                        else {
+                            GENERAL[n]->ROI[roi]->isReject = false;
+                        }
+
+                        GENERAL[n]->ROI[roi]->result_float = result;
+                        ESP_LOGD(TAG, "Result General(Analog)%i: %f", roi, GENERAL[n]->ROI[roi]->result_float);
+
+                        if (isLogImage) {
+                            string _imagename = GENERAL[n]->name +  "_" + GENERAL[n]->ROI[roi]->name;
+                            if (isLogImageSelect) {
+                                if (LogImageSelect.find(GENERAL[n]->ROI[roi]->name) != std::string::npos) {
+                                    LogImage(logPath, _imagename, &_result_save_file, NULL, time, GENERAL[n]->ROI[roi]->image_org);
+                                }
+                            }
+                            else {
+                                LogImage(logPath, _imagename, &_result_save_file, NULL, time, GENERAL[n]->ROI[roi]->image_org);
+                            }
+                        }
+                    } break;
+                case Digit100:
+                case Analogue100:
+                    {
+                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "CNN Type: Digit100 or Analogue100");
+                        int _num;
+                        float _result_save_file;
+                        
+                        tflite->LoadInputImageBasis(GENERAL[n]->ROI[roi]->image);        
+                        tflite->Invoke();
+    
+                        _num = tflite->GetOutClassification();
+                        
+                        if(GENERAL[n]->ROI[roi]->CCW) {
+                            GENERAL[n]->ROI[roi]->result_float = 10 - ((float)_num / 10.0);
+                        }
+                        else {
+                            GENERAL[n]->ROI[roi]->result_float = (float)_num / 10.0;
+                        }
+
+                        _result_save_file = GENERAL[n]->ROI[roi]->result_float;
+                        
+                        GENERAL[n]->ROI[roi]->isReject = false;
+                        
+                        ESP_LOGD(TAG, "Result General(Analog)%i - CCW: %d -  %f", roi, GENERAL[n]->ROI[roi]->CCW, GENERAL[n]->ROI[roi]->result_float);
+
+                        if (isLogImage) {
+                            string _imagename = GENERAL[n]->name +  "_" + GENERAL[n]->ROI[roi]->name;
+                            if (isLogImageSelect) {
+                                if (LogImageSelect.find(GENERAL[n]->ROI[roi]->name) != std::string::npos) {
+                                    LogImage(logPath, _imagename, &_result_save_file, NULL, time, GENERAL[n]->ROI[roi]->image_org);
+                                }
+                            }
+                            else {
+                                LogImage(logPath, _imagename, &_result_save_file, NULL, time, GENERAL[n]->ROI[roi]->image_org);
+                            }
+                        }
+
+                    } break;
+            
+                default:
+                    break;
+            }
+        }
+    }
+
+    delete tflite;
+
+    return true;
+}
+
+bool ClassFlowCNNGeneral::isExtendedResolution(int _number) {
+    if (CNNType == Digit) {
+        return false;
+    }
+    
+    return true;
+}
+
+std::vector<HTMLInfo*> ClassFlowCNNGeneral::GetHTMLInfo() {
+    std::vector<HTMLInfo*> result;
+
+    for (int _ana = 0; _ana < GENERAL.size(); ++_ana) {
+        for (int i = 0; i < GENERAL[_ana]->ROI.size(); ++i) {
+            ESP_LOGD(TAG, "Image: %d", (int) GENERAL[_ana]->ROI[i]->image);
+            if (GENERAL[_ana]->ROI[i]->image) {
+                if (GENERAL[_ana]->name == "default") {
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
+                }
+                else {
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
+                }
+            }
+
+            HTMLInfo *zw = new HTMLInfo;
+            if (GENERAL[_ana]->name == "default") {
+                zw->filename = GENERAL[_ana]->ROI[i]->name + ".jpg";
+                zw->filename_org = GENERAL[_ana]->ROI[i]->name + ".jpg";
+            }
+            else {
+                zw->filename = GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg";
+                zw->filename_org = GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg";
+            }
+
+            if (CNNType == Digit) {
+                zw->val = GENERAL[_ana]->ROI[i]->result_klasse;
+            }
+            else {
+                zw->val = GENERAL[_ana]->ROI[i]->result_float;
+            }
+            
+            zw->image = GENERAL[_ana]->ROI[i]->image;
+            zw->image_org = GENERAL[_ana]->ROI[i]->image_org;
+
+            result.push_back(zw);
+        }
+    }
+
+    return result;
+}
+
+int ClassFlowCNNGeneral::getNumberGENERAL() {
+    return GENERAL.size();
+}
+
+string ClassFlowCNNGeneral::getNameGENERAL(int _analog) {
+    if (_analog < GENERAL.size()) {
+        return GENERAL[_analog]->name;
+    }
+
+    return "GENERAL DOES NOT EXIST";
+}
+
+general* ClassFlowCNNGeneral::GetGENERAL(int _analog) {
+    if (_analog < GENERAL.size()) {
+        return GENERAL[_analog];
+    }
+
+    return NULL;
+}
+
+void ClassFlowCNNGeneral::UpdateNameNumbers(std::vector<std::string> *_name_numbers) {
+    for (int _dig = 0; _dig < GENERAL.size(); _dig++) {
+        std::string _name = GENERAL[_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);
+        }
+    }
+}
+
+string ClassFlowCNNGeneral::getReadoutRawString(int _analog) 
+{
+    string rt = "";
+
+    if (_analog >= GENERAL.size() || GENERAL[_analog]==NULL || GENERAL[_analog]->ROI.size() == 0) {
+        return rt;
+    }
+ 
+    for (int i = 0; i < GENERAL[_analog]->ROI.size(); ++i) {
+        if (CNNType == Analogue || CNNType == Analogue100) {
+            rt = rt + "," + RundeOutput(GENERAL[_analog]->ROI[i]->result_float, 1);
+        }
+
+        if (CNNType == Digit) {
+            if (GENERAL[_analog]->ROI[i]->result_klasse >= 10) {
+                rt = rt + ",N";
+            }
+            else {
+                rt = rt + "," + RundeOutput(GENERAL[_analog]->ROI[i]->result_klasse, 0);
+            }
+        }
+
+        if ((CNNType == DoubleHyprid10) || (CNNType == Digit100)) {
+            rt = rt + "," + RundeOutput(GENERAL[_analog]->ROI[i]->result_float, 1);
+        }
+    }
+    return rt;
+}
--- a/code/components/jomjol_flowcontroll/ClassFlowCNNGeneral.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowCNNGeneral.h
@@ -0,0 +1,79 @@
+#pragma once
+
+#ifndef CLASSFLOWCNNGENERAL_H
+#define CLASSFLOWCNNGENERAL_H
+
+#include"ClassFlowDefineTypes.h"
+#include "ClassFlowAlignment.h"
+
+
+enum t_CNNType {
+    AutoDetect,
+    Analogue,
+    Analogue100,
+    Digit,
+    DigitHyprid10,
+    DoubleHyprid10,
+    Digit100,
+    None
+ };
+
+class ClassFlowCNNGeneral :
+    public ClassFlowImage
+{
+protected:
+    t_CNNType CNNType;
+    std::vector<general*> GENERAL;
+    float CNNGoodThreshold;
+
+    string cnnmodelfile;
+    int modelxsize, modelysize, modelchannel;
+    bool isLogImageSelect;
+    string LogImageSelect;
+    ClassFlowAlignment* flowpostalignment;
+
+    bool SaveAllFiles;   
+
+    int PointerEvalAnalogNew(float zahl, int numeral_preceder);
+    int PointerEvalAnalogToDigitNew(float zahl, float numeral_preceder,  int eval_predecessors, float AnalogToDigitTransitionStart);
+    int PointerEvalHybridNew(float zahl, float number_of_predecessors, int eval_predecessors, bool Analog_Predecessors = false, float AnalogToDigitTransitionStart=9.2);
+
+
+
+    bool doNeuralNetwork(string time); 
+    bool doAlignAndCut(string time);
+
+    bool getNetworkParameter();
+
+public:
+    ClassFlowCNNGeneral(ClassFlowAlignment *_flowalign, t_CNNType _cnntype = AutoDetect);
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+
+    string getHTMLSingleStep(string host);
+    string getReadout(int _analog, bool _extendedResolution = false, int prev = -1, float _before_narrow_Analog = -1, float AnalogToDigitTransitionStart=9.2); 
+
+    string getReadoutRawString(int _analog);  
+
+    void DrawROI(CImageBasis *_zw); 
+
+   	std::vector<HTMLInfo*> GetHTMLInfo();   
+
+    int getNumberGENERAL();
+    general* GetGENERAL(int _analog);
+    general* GetGENERAL(string _name, bool _create);
+    general* FindGENERAL(string _name_number);    
+    string getNameGENERAL(int _analog);    
+
+    bool isExtendedResolution(int _number = 0);
+
+    void UpdateNameNumbers(std::vector<std::string> *_name_numbers);
+
+    t_CNNType getCNNType(){return CNNType;};
+
+    string name(){return "ClassFlowCNNGeneral";}; 
+};
+
+#endif
+
--- a/code/components/jomjol_flowcontroll/ClassFlowControll.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowControll.cpp
@@ -0,0 +1,930 @@
+#include "ClassFlowControll.h"
+
+#include "connect_wlan.h"
+#include "read_wlanini.h"
+
+#include "freertos/task.h"
+
+#include <sys/stat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <dirent.h>
+#ifdef __cplusplus
+}
+#endif
+
+#include "ClassLogFile.h"
+#include "time_sntp.h"
+#include "Helper.h"
+#include "server_ota.h"
+#ifdef ENABLE_MQTT
+    #include "interface_mqtt.h"
+    #include "server_mqtt.h"
+#endif //ENABLE_MQTT
+
+#include "server_help.h"
+#include "MainFlowControl.h"
+#include "../../include/defines.h"
+
+static const char* TAG = "FLOWCTRL";
+
+//#define DEBUG_DETAIL_ON
+
+std::string ClassFlowControll::doSingleStep(std::string _stepname, std::string _host){
+    std::string _classname = "";
+    std::string result = "";
+
+    ESP_LOGD(TAG, "Step %s start", _stepname.c_str());
+
+    if ((_stepname.compare("[TakeImage]") == 0) || (_stepname.compare(";[TakeImage]") == 0)){
+        _classname = "ClassFlowTakeImage";
+    }
+    if ((_stepname.compare("[Alignment]") == 0) || (_stepname.compare(";[Alignment]") == 0)){
+        _classname = "ClassFlowAlignment";
+    }
+    if ((_stepname.compare(0, 7, "[Digits") == 0) || (_stepname.compare(0, 8, ";[Digits") == 0)) {
+        _classname = "ClassFlowCNNGeneral";
+    }
+    if ((_stepname.compare("[Analog]") == 0) || (_stepname.compare(";[Analog]") == 0)){
+        _classname = "ClassFlowCNNGeneral";
+    }
+    #ifdef ENABLE_MQTT
+    if ((_stepname.compare("[MQTT]") == 0) || (_stepname.compare(";[MQTT]") == 0)){
+        _classname = "ClassFlowMQTT";
+    }
+    #endif //ENABLE_MQTT
+
+    #ifdef ENABLE_INFLUXDB
+    if ((_stepname.compare("[InfluxDB]") == 0) || (_stepname.compare(";[InfluxDB]") == 0)){
+        _classname = "ClassFlowInfluxDB";
+    }
+    if ((_stepname.compare("[InfluxDBv2]") == 0) || (_stepname.compare(";[InfluxDBv2]") == 0)){
+        _classname = "ClassFlowInfluxDBv2";
+    }
+    #endif //ENABLE_INFLUXDB
+    #ifdef ENABLE_WEBHOOK
+    if ((_stepname.compare("[Webhook]") == 0) || (_stepname.compare(";[Webhook]") == 0)){
+        _classname = "ClassFlowWebhook";
+    }
+    #endif //ENABLE_WEBHOOK
+
+    for (int i = 0; i < FlowControll.size(); ++i)
+        if (FlowControll[i]->name().compare(_classname) == 0){
+            if (!(FlowControll[i]->name().compare("ClassFlowTakeImage") == 0)) {
+                // if it is a TakeImage, the image does not need to be included, this happens automatically with the html query.
+                FlowControll[i]->doFlow("");
+            }
+		
+            result = FlowControll[i]->getHTMLSingleStep(_host);
+        }
+
+    ESP_LOGD(TAG, "Step %s end", _stepname.c_str());
+
+    return result;
+}
+
+std::string ClassFlowControll::TranslateAktstatus(std::string _input)
+{
+    if (_input.compare("ClassFlowTakeImage") == 0) {
+        return ("Take Image");
+    }
+
+    if (_input.compare("ClassFlowAlignment") == 0) {
+        return ("Aligning");
+    }
+
+    if (_input.compare("ClassFlowCNNGeneral") == 0) {
+        return ("Digitization of ROIs");
+    }
+
+    #ifdef ENABLE_MQTT
+        if (_input.compare("ClassFlowMQTT") == 0) {
+            return ("Sending MQTT");
+        }
+    #endif //ENABLE_MQTT
+		
+    #ifdef ENABLE_INFLUXDB
+        if (_input.compare("ClassFlowInfluxDB") == 0) {
+            return ("Sending InfluxDB");
+        }
+		
+        if (_input.compare("ClassFlowInfluxDBv2") == 0) {
+            return ("Sending InfluxDBv2");
+        }
+    #endif //ENABLE_INFLUXDB
+    #ifdef ENABLE_WEBHOOK
+    if (_input.compare("ClassFlowWebhook") == 0) {
+        return ("Sending Webhook");
+    }
+    #endif //ENABLE_WEBHOOK
+    if (_input.compare("ClassFlowPostProcessing") == 0) {
+        return ("Post-Processing");
+    }
+
+    return "Unkown Status";
+}
+
+std::vector<HTMLInfo*> ClassFlowControll::GetAllDigit() 
+{
+    if (flowdigit) {
+        ESP_LOGD(TAG, "ClassFlowControll::GetAllDigit - flowdigit != NULL");
+        return flowdigit->GetHTMLInfo();
+    }
+
+    std::vector<HTMLInfo*> empty;
+    return empty;
+}
+
+std::vector<HTMLInfo*> ClassFlowControll::GetAllAnalog()
+{
+    if (flowanalog) {
+        return flowanalog->GetHTMLInfo();
+    }
+
+    std::vector<HTMLInfo*> empty;
+    return empty;
+}
+
+t_CNNType ClassFlowControll::GetTypeDigit()
+{
+    if (flowdigit) {
+        return flowdigit->getCNNType();
+    }
+
+    return t_CNNType::None;
+}
+
+t_CNNType ClassFlowControll::GetTypeAnalog()
+{
+    if (flowanalog) {
+        return flowanalog->getCNNType();
+    }
+
+    return t_CNNType::None;
+}
+
+#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+void ClassFlowControll::DigitDrawROI(CImageBasis *_zw)
+{
+    if (flowdigit) {
+        flowdigit->DrawROI(_zw);
+    }
+}
+
+void ClassFlowControll::AnalogDrawROI(CImageBasis *_zw)
+{
+    if (flowanalog) {
+        flowanalog->DrawROI(_zw);
+    }
+}
+#endif
+
+#ifdef ENABLE_MQTT
+bool ClassFlowControll::StartMQTTService() 
+{
+    /* Start the MQTT service */
+    for (int i = 0; i < FlowControll.size(); ++i) {
+        if (FlowControll[i]->name().compare("ClassFlowMQTT") == 0) {
+            return ((ClassFlowMQTT*) (FlowControll[i]))->Start(AutoInterval);
+        }  
+    } 
+    return false;
+}
+#endif //ENABLE_MQTT
+
+void ClassFlowControll::SetInitialParameter(void)
+{
+    AutoStart = false;
+    SetupModeActive = false;
+    AutoInterval = 10; // Minutes
+    flowdigit = NULL;
+    flowanalog = NULL;
+    flowpostprocessing = NULL;
+    disabled = false;
+    aktRunNr = 0;
+    aktstatus = "Flow task not yet created";
+    aktstatusWithTime = aktstatus;
+}
+
+bool ClassFlowControll::getIsAutoStart(void)
+{
+    return AutoStart;
+}
+
+
+void ClassFlowControll::setAutoStartInterval(long &_interval)
+{
+    _interval = AutoInterval * 60 * 1000; // AutoInterval: minutes -> ms
+}
+
+ClassFlow* ClassFlowControll::CreateClassFlow(std::string _type)
+{
+    ClassFlow* cfc = NULL;
+
+    _type = trim(_type);
+
+    if (toUpper(_type).compare("[TAKEIMAGE]") == 0) {
+        cfc = new ClassFlowTakeImage(&FlowControll);
+        flowtakeimage = (ClassFlowTakeImage*) cfc;
+    }
+	
+    if (toUpper(_type).compare("[ALIGNMENT]") == 0) {
+        cfc = new ClassFlowAlignment(&FlowControll);
+        flowalignment = (ClassFlowAlignment*) cfc;
+    }
+	
+    if (toUpper(_type).compare("[ANALOG]") == 0) {
+        cfc = new ClassFlowCNNGeneral(flowalignment);
+        flowanalog = (ClassFlowCNNGeneral*) cfc;
+    }
+	
+    if (toUpper(_type).compare(0, 7, "[DIGITS") == 0) {
+        cfc = new ClassFlowCNNGeneral(flowalignment);
+        flowdigit = (ClassFlowCNNGeneral*) cfc;
+    }
+	
+    #ifdef ENABLE_MQTT
+    if (toUpper(_type).compare("[MQTT]") == 0) {
+        cfc = new ClassFlowMQTT(&FlowControll);
+    }
+    #endif //ENABLE_MQTT
+	
+    #ifdef ENABLE_INFLUXDB
+    if (toUpper(_type).compare("[INFLUXDB]") == 0) {
+        cfc = new ClassFlowInfluxDB(&FlowControll);
+    }
+
+    if (toUpper(_type).compare("[INFLUXDBV2]") == 0) {
+        cfc = new ClassFlowInfluxDBv2(&FlowControll);
+    }
+    #endif //ENABLE_INFLUXDB  
+    #ifdef ENABLE_WEBHOOK
+    if (toUpper(_type).compare("[WEBHOOK]") == 0)
+        cfc = new ClassFlowWebhook(&FlowControll);
+    #endif //ENABLE_WEBHOOK
+
+    if (toUpper(_type).compare("[POSTPROCESSING]") == 0) {
+        cfc = new ClassFlowPostProcessing(&FlowControll, flowanalog, flowdigit); 
+        flowpostprocessing = (ClassFlowPostProcessing*) cfc;
+    }
+
+    if (cfc) {                           
+        // Attached only if it is not [AutoTimer], because this is for FlowControll
+        FlowControll.push_back(cfc);
+    }
+
+    if (toUpper(_type).compare("[AUTOTIMER]") == 0) {
+        cfc = this;
+    }
+
+    if (toUpper(_type).compare("[DATALOGGING]") == 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)
+{
+    aktstatus = "Initialization";
+    aktstatusWithTime = aktstatus;
+
+    //#ifdef ENABLE_MQTT
+        //MQTTPublish(mqttServer_getMainTopic() + "/" + "status", "Initialization", 1, false); // Right now, not possible -> MQTT Service is going to be started later
+    //#endif //ENABLE_MQTT
+    
+    string line;
+    flowpostprocessing = NULL;
+
+    ClassFlow* cfc;
+    FILE* pFile;
+    config = FormatFileName(config);
+    pFile = fopen(config.c_str(), "r");
+
+    line = "";
+
+    char zw[1024];
+	
+    if (pFile != NULL) {
+        fgets(zw, 1024, pFile);
+        ESP_LOGD(TAG, "%s", zw);
+        line = std::string(zw);
+    }
+
+    while ((line.size() > 0) && !(feof(pFile))) {
+        cfc = CreateClassFlow(line);
+        // printf("Name: %s\n", cfc->name().c_str());
+	    
+        if (cfc) {
+            ESP_LOGE(TAG, "Start ReadParameter (%s)", line.c_str());
+            cfc->ReadParameter(pFile, line);
+        }
+        else {
+            line = "";
+		
+            if (fgets(zw, 1024, pFile) && !feof(pFile)) {
+                ESP_LOGD(TAG, "Read: %s", zw);
+                line = std::string(zw);
+            }
+        }
+    }
+
+    fclose(pFile);
+}
+
+std::string* ClassFlowControll::getActStatusWithTime()
+{
+    return &aktstatusWithTime;
+}
+
+std::string* ClassFlowControll::getActStatus()
+{
+    return &aktstatus;
+}
+
+void ClassFlowControll::setActStatus(std::string _aktstatus)
+{
+    aktstatus = _aktstatus;
+    aktstatusWithTime = aktstatus;
+}
+
+void ClassFlowControll::doFlowTakeImageOnly(string time)
+{
+    std::string zw_time;
+
+    for (int i = 0; i < FlowControll.size(); ++i) {
+        if (FlowControll[i]->name() == "ClassFlowTakeImage") {
+            zw_time = getCurrentTimeString("%H:%M:%S");
+            aktstatus = TranslateAktstatus(FlowControll[i]->name());
+            aktstatusWithTime = aktstatus + " (" + zw_time + ")";
+            #ifdef ENABLE_MQTT
+                MQTTPublish(mqttServer_getMainTopic() + "/" + "status", aktstatus, 1, false);
+            #endif //ENABLE_MQTT
+
+            FlowControll[i]->doFlow(time);
+        }
+    }
+}
+
+bool ClassFlowControll::doFlow(string time)
+{
+    bool result = true;
+    std::string zw_time;
+    int repeat = 0;
+    int qos = 1;
+
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::doFlow - Start");
+    #endif
+
+    /* Check if we have a valid date/time and if not restart the NTP client */
+   /* if (! getTimeIsSet()) {
+        LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Time not set, restarting NTP Client!");
+        restartNtpClient();
+    }*/
+
+    //checkNtpStatus(0);
+
+    for (int i = 0; i < FlowControll.size(); ++i) {
+        zw_time = getCurrentTimeString("%H:%M:%S");
+        aktstatus = TranslateAktstatus(FlowControll[i]->name());
+        aktstatusWithTime = aktstatus + " (" + zw_time + ")";
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Status: " + aktstatusWithTime);
+        #ifdef ENABLE_MQTT
+            MQTTPublish(mqttServer_getMainTopic() + "/" + "status", aktstatus, qos, false);
+        #endif //ENABLE_MQTT
+
+        #ifdef DEBUG_DETAIL_ON
+            string zw = "FlowControll.doFlow - " + FlowControll[i]->name();
+            LogFile.WriteHeapInfo(zw);
+        #endif
+
+        if (!FlowControll[i]->doFlow(time)){
+            repeat++;
+            LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Fehler im vorheriger Schritt - wird zum " + to_string(repeat) + ". Mal wiederholt");
+            if (i) { i -= 1; }   // vPrevious step must be repeated (probably take pictures)
+            result = false;
+            if (repeat > 5) {
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Wiederholung 5x nicht erfolgreich --> reboot");
+                doReboot();
+                //Step was repeated 5x --> reboot
+            }
+        }
+        else {
+            result = true;
+        }
+        
+        #ifdef DEBUG_DETAIL_ON  
+            LogFile.WriteHeapInfo("ClassFlowControll::doFlow");
+        #endif
+    }
+
+    zw_time = getCurrentTimeString("%H:%M:%S");
+    aktstatus = "Flow finished";
+    aktstatusWithTime = aktstatus + " (" + zw_time + ")";
+    //LogFile.WriteToFile(ESP_LOG_INFO, TAG, aktstatusWithTime);
+    #ifdef ENABLE_MQTT
+        MQTTPublish(mqttServer_getMainTopic() + "/" + "status", aktstatus, qos, false);
+    #endif //ENABLE_MQTT
+
+    return result;
+}
+
+
+string ClassFlowControll::getReadoutAll(int _type)
+{
+    std::string out = "";
+	
+    if (flowpostprocessing) {
+        std::vector<NumberPost*> *numbers = flowpostprocessing->GetNumbers();
+
+        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:
+                    if (flowpostprocessing->PreValueUse) {
+                        if ((*numbers)[i]->PreValueOkay) {
+                            out = out + (*numbers)[i]->ReturnPreValue;
+			}
+                        else {
+                            out = out + "PreValue too old"; 
+			}
+                    }
+                    else {
+                        out = out + "PreValue deactivated";
+		    }
+                    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";
+	    }
+        }
+    //    ESP_LOGD(TAG, "OUT: %s", out.c_str());
+    }
+
+    return out;
+}	
+
+string ClassFlowControll::getReadout(bool _rawvalue = false, bool _noerror = false, int _number = 0)
+{
+    if (flowpostprocessing) {
+        return flowpostprocessing->getReadoutParam(_rawvalue, _noerror, _number);
+    }
+
+    return std::string("");
+}
+
+string ClassFlowControll::GetPrevalue(std::string _number)	
+{
+    if (flowpostprocessing) {
+        return flowpostprocessing->GetPreValue(_number);   
+    }
+
+    return std::string("");    
+}
+
+bool ClassFlowControll::UpdatePrevalue(std::string _newvalue, std::string _numbers, bool _extern)
+{
+    double newvalueAsDouble;
+    char* p;
+
+    _newvalue = trim(_newvalue);
+    //ESP_LOGD(TAG, "Input UpdatePreValue: %s", _newvalue.c_str());
+
+    if (_newvalue.substr(0,8).compare("0.000000") == 0 || _newvalue.compare("0.0") == 0 || _newvalue.compare("0") == 0) {
+        newvalueAsDouble = 0;   // preset to value = 0
+    }
+    else {
+        newvalueAsDouble = strtod(_newvalue.c_str(), &p);
+        if (newvalueAsDouble == 0) {
+            LogFile.WriteToFile(ESP_LOG_WARN, TAG, "UpdatePrevalue: No valid value for processing: " + _newvalue);
+            return false;
+        }
+    }
+    
+    if (flowpostprocessing) {
+        if (flowpostprocessing->SetPreValue(newvalueAsDouble, _numbers, _extern)) {
+            return true;
+	}
+        else {
+            return false;
+	}
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "UpdatePrevalue: ERROR - Class Post-Processing not initialized");
+        return false;
+    }
+}
+
+bool ClassFlowControll::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> splitted;
+
+    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 && (toUpper(aktparamgraph).compare("[DATALOGGING]") != 0))) {     
+        // Paragraph passt nicht zu Debug oder DataLogging
+        return false;
+    }
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph)) {
+        splitted = ZerlegeZeile(aktparamgraph, " =");
+	    
+        if ((toUpper(splitted[0]) == "AUTOSTART") && (splitted.size() > 1)) {
+            AutoStart = alphanumericToBoolean(splitted[1]);
+        }
+
+        if ((toUpper(splitted[0]) == "INTERVAL") && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1]))
+            {
+                AutoInterval = std::stof(splitted[1]);
+            }
+        }
+
+        if ((toUpper(splitted[0]) == "DATALOGACTIVE") && (splitted.size() > 1)) {
+            LogFile.SetDataLogToSD(alphanumericToBoolean(splitted[1]));
+        }
+
+        if ((toUpper(splitted[0]) == "DATAFILESRETENTION") && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1]))
+            {
+                LogFile.SetDataLogRetention(std::stoi(splitted[1]));
+            }
+        }
+
+        if ((toUpper(splitted[0]) == "LOGLEVEL") && (splitted.size() > 1)) {
+            /* matches esp_log_level_t */
+            if ((toUpper(splitted[1]) == "TRUE") || (toUpper(splitted[1]) == "2")) {
+                LogFile.setLogLevel(ESP_LOG_WARN);
+            }
+            else if ((toUpper(splitted[1]) == "FALSE") || (toUpper(splitted[1]) == "0") || (toUpper(splitted[1]) == "1")) {
+                LogFile.setLogLevel(ESP_LOG_ERROR);
+            }
+            else if (toUpper(splitted[1]) == "3") {
+                LogFile.setLogLevel(ESP_LOG_INFO);
+            }
+            else if (toUpper(splitted[1]) == "4") {
+                LogFile.setLogLevel(ESP_LOG_DEBUG);
+            }
+
+            /* If system reboot was not triggered by user and reboot was caused by execption -> keep log level to DEBUG */
+            if (!getIsPlannedReboot() && (esp_reset_reason() == ESP_RST_PANIC)) {
+                LogFile.setLogLevel(ESP_LOG_DEBUG);
+	    }
+        }
+	    
+        if ((toUpper(splitted[0]) == "LOGFILESRETENTION") && (splitted.size() > 1)) {
+            if (isStringNumeric(splitted[1]))
+            {
+                LogFile.SetLogFileRetention(std::stoi(splitted[1]));
+            }
+        }
+
+        /* TimeServer and TimeZone got already read from the config, see setupTime () */
+        
+        #if (defined WLAN_USE_ROAMING_BY_SCANNING || (defined WLAN_USE_MESH_ROAMING && defined WLAN_USE_MESH_ROAMING_ACTIVATE_CLIENT_TRIGGERED_QUERIES))
+        if ((toUpper(splitted[0]) == "RSSITHRESHOLD") && (splitted.size() > 1)) {
+            int RSSIThresholdTMP = atoi(splitted[1].c_str());
+            RSSIThresholdTMP = min(0, max(-100, RSSIThresholdTMP)); // Verify input limits (-100 - 0)
+            
+            if (ChangeRSSIThreshold(WLAN_CONFIG_FILE, RSSIThresholdTMP)) {
+                // reboot necessary so that the new wlan.ini is also used !!!
+                fclose(pfile);
+                LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Rebooting to activate new RSSITHRESHOLD ...");
+                doReboot();
+            }
+        }
+        #endif
+
+        if ((toUpper(splitted[0]) == "HOSTNAME") && (splitted.size() > 1)) {
+            if (ChangeHostName(WLAN_CONFIG_FILE, splitted[1])) {
+                // reboot necessary so that the new wlan.ini is also used !!!
+                fclose(pfile);
+                LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Rebooting to activate new HOSTNAME...");             
+                doReboot();
+            }
+        }
+
+        if ((toUpper(splitted[0]) == "SETUPMODE") && (splitted.size() > 1)) {
+            SetupModeActive = alphanumericToBoolean(splitted[1]);        
+        }
+    }
+    return true;
+}
+
+int ClassFlowControll::CleanTempFolder() {
+    const char* folderPath = "/sdcard/img_tmp";
+    
+    ESP_LOGD(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_LOGD(TAG, "%d files deleted", deleted);
+    
+    return 0;
+}
+
+esp_err_t ClassFlowControll::SendRawJPG(httpd_req_t *req)
+{
+    return flowtakeimage != NULL ? flowtakeimage->SendRawJPG(req) : ESP_FAIL;
+}
+
+esp_err_t ClassFlowControll::GetJPGStream(std::string _fn, httpd_req_t *req)
+{
+    ESP_LOGD(TAG, "ClassFlowControll::GetJPGStream %s", _fn.c_str());
+
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::GetJPGStream - Start");
+    #endif
+
+    CImageBasis *_send = NULL;
+    esp_err_t result = ESP_FAIL;
+    bool _sendDelete = false;
+
+    if (_fn == "alg.jpg") {
+        if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+            _send = flowalignment->ImageBasis;
+        }
+        else {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: alg.jpg cannot be served");
+            return ESP_FAIL;
+        }
+    }
+    else if (_fn == "alg_roi.jpg") {
+        #ifdef ALGROI_LOAD_FROM_MEM_AS_JPG      // no CImageBasis needed to create alg_roi.jpg (ca. 790kB less RAM)
+            if (aktstatus.find("Initialization (delayed)") != -1) {
+                FILE* file = fopen("/sdcard/html/Flowstate_initialization_delayed.jpg", "rb"); 
+
+                if (!file) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_initialization_delayed.jpg not found");
+                    return ESP_FAIL;
+                }
+
+                fseek(file, 0, SEEK_END);
+                long fileSize = ftell(file); /* how long is the file ? */
+                fseek(file, 0, SEEK_SET); /* reset */
+
+                unsigned char* fileBuffer = (unsigned char*) malloc(fileSize);
+
+                if (!fileBuffer) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: Not enough memory to create fileBuffer: " + std::to_string(fileSize));
+                    fclose(file);  
+                    return ESP_FAIL;
+                }
+
+                fread(fileBuffer, fileSize, 1, file);
+                fclose(file);
+
+                httpd_resp_set_type(req, "image/jpeg");
+                result = httpd_resp_send(req, (const char *)fileBuffer, fileSize); 
+                free(fileBuffer);
+            }
+            else if (aktstatus.find("Initialization") != -1) {
+                FILE* file = fopen("/sdcard/html/Flowstate_initialization.jpg", "rb"); 
+
+                if (!file) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_initialization.jpg not found");
+                    return ESP_FAIL;
+                }
+
+                fseek(file, 0, SEEK_END);
+                long fileSize = ftell(file); /* how long is the file ? */
+                fseek(file, 0, SEEK_SET); /* reset */
+
+                unsigned char* fileBuffer = (unsigned char*) malloc(fileSize);
+
+                if (!fileBuffer) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: Not enough memory to create fileBuffer: " + std::to_string(fileSize));
+                    fclose(file);  
+                    return ESP_FAIL;
+                }
+
+                fread(fileBuffer, fileSize, 1, file);
+                fclose(file);
+
+                httpd_resp_set_type(req, "image/jpeg");
+                result = httpd_resp_send(req, (const char *)fileBuffer, fileSize); 
+                free(fileBuffer);
+            }
+            else if (aktstatus.find("Take Image") != -1) {
+                if (flowalignment && flowalignment->AlgROI) {
+                    FILE* file = fopen("/sdcard/html/Flowstate_take_image.jpg", "rb");    
+
+                    if (!file) {
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_take_image.jpg not found");
+                        return ESP_FAIL;
+                    }
+
+                    fseek(file, 0, SEEK_END);
+                    flowalignment->AlgROI->size = ftell(file); /* how long is the file ? */
+                    fseek(file, 0, SEEK_SET); /* reset */
+                    
+                    if (flowalignment->AlgROI->size > MAX_JPG_SIZE) {
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_take_image.jpg (" + std::to_string(flowalignment->AlgROI->size) +
+                                                                ") > allocated buffer (" + std::to_string(MAX_JPG_SIZE) + ")");
+                        fclose(file);
+                        return ESP_FAIL;
+                    }
+
+                    fread(flowalignment->AlgROI->data, flowalignment->AlgROI->size, 1, file);
+                    fclose(file);
+
+                    httpd_resp_set_type(req, "image/jpeg");
+                    result = httpd_resp_send(req, (const char *)flowalignment->AlgROI->data, flowalignment->AlgROI->size);
+                }
+                else {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: alg_roi.jpg cannot be served -> alg.jpg is going to be served!");
+                    if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+                        _send = flowalignment->ImageBasis;
+                    }
+                    else {
+                        httpd_resp_send(req, NULL, 0);
+                        return ESP_OK;
+                    }
+                }
+            }
+            else {
+                if (flowalignment && flowalignment->AlgROI) {
+                    httpd_resp_set_type(req, "image/jpeg");
+                    result = httpd_resp_send(req, (const char *)flowalignment->AlgROI->data, flowalignment->AlgROI->size);
+                }
+                else {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: alg_roi.jpg cannot be served -> alg.jpg is going to be served!");
+                    if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+                        _send = flowalignment->ImageBasis;
+                    }
+                    else {
+                        httpd_resp_send(req, NULL, 0);
+                        return ESP_OK;
+                    }
+                }
+            }
+        #else
+            if (!flowalignment) {
+                ESP_LOGD(TAG, "ClassFloDControll::GetJPGStream: FlowAlignment is not (yet) initialized. Interrupt serving!");
+                httpd_resp_send(req, NULL, 0);
+                return ESP_FAIL;
+            }
+
+            _send = new CImageBasis("alg_roi", flowalignment->ImageBasis);
+			
+            if (_send->ImageOkay()) {
+                if (flowalignment) flowalignment->DrawRef(_send);
+                if (flowdigit) flowdigit->DrawROI(_send);
+                if (flowanalog) flowanalog->DrawROI(_send);
+                _sendDelete = true; // delete temporary _send element after sending
+            }
+            else {
+                LogFile.WriteToFile(ESP_LOG_WARN, TAG, "ClassFlowControll::GetJPGStream: Not enough memory to create alg_roi.jpg -> alg.jpg is going to be served!");
+                
+                if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+                    _send = flowalignment->ImageBasis;
+                }
+                else {
+                    httpd_resp_send(req, NULL, 0);
+                    return ESP_OK;
+                }
+            }
+        #endif
+    }
+    else {
+        std::vector<HTMLInfo*> htmlinfo;
+    
+        htmlinfo = GetAllDigit();
+        ESP_LOGD(TAG, "After getClassFlowControll::GetAllDigit");
+
+        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)
+        {
+	        htmlinfo = GetAllAnalog();
+	        ESP_LOGD(TAG, "After getClassFlowControll::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();
+    	}
+    }
+
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::GetJPGStream - before send");
+    #endif
+
+    if (_send)
+    {
+        ESP_LOGD(TAG, "Sending file: %s ...", _fn.c_str());
+        set_content_type_from_file(req, _fn.c_str());
+        result = _send->SendJPGtoHTTP(req);
+        /* Respond with an empty chunk to signal HTTP response completion */
+        httpd_resp_send_chunk(req, NULL, 0);
+        ESP_LOGD(TAG, "File sending complete");
+
+        if (_sendDelete)
+            delete _send;
+            
+        _send = NULL;  
+    }
+
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::GetJPGStream - done");
+    #endif
+
+    return result;
+}
+
+string ClassFlowControll::getNumbersName()
+{
+    return flowpostprocessing->getNumbersName();
+}
+
+string ClassFlowControll::getJSON()
+{
+    return flowpostprocessing->GetJSON();
+}
+
+/** 
+ * @returns a vector of all current sequences
+ **/
+const std::vector<NumberPost*> &ClassFlowControll::getNumbers()
+{
+    return *flowpostprocessing->GetNumbers();
+}
--- a/code/components/jomjol_flowcontroll/ClassFlowControll.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowControll.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#ifndef CLASSFLOWCONTROLL_H
+#define CLASSFLOWCONTROLL_H
+
+#include <string>
+
+#include "ClassFlow.h"
+#include "ClassFlowTakeImage.h"
+#include "ClassFlowAlignment.h"
+#include "ClassFlowCNNGeneral.h"
+#include "ClassFlowPostProcessing.h"
+#ifdef ENABLE_MQTT
+	#include "ClassFlowMQTT.h"
+#endif //ENABLE_MQTT
+#ifdef ENABLE_INFLUXDB
+	#include "ClassFlowInfluxDB.h"
+	#include "ClassFlowInfluxDBv2.h"
+#endif //ENABLE_INFLUXDB
+#ifdef ENABLE_WEBHOOK
+	#include "ClassFlowWebhook.h"
+#endif //ENABLE_WEBHOOK
+#include "ClassFlowCNNGeneral.h"
+
+class ClassFlowControll :
+    public ClassFlow
+{
+protected:
+	std::vector<ClassFlow*> FlowControll;
+	ClassFlowPostProcessing* flowpostprocessing;
+	ClassFlowAlignment* flowalignment;	
+	ClassFlowCNNGeneral* flowanalog;
+	ClassFlowCNNGeneral* flowdigit;
+//	ClassFlowDigit* flowdigit;
+	ClassFlowTakeImage* flowtakeimage;
+	ClassFlow* CreateClassFlow(std::string _type);
+
+	bool AutoStart;
+	float AutoInterval;
+	void SetInitialParameter(void);	
+	std::string aktstatusWithTime;
+	std::string aktstatus;
+	int aktRunNr;
+
+public:
+	bool SetupModeActive;
+
+	void InitFlow(std::string config);
+	bool doFlow(string time);
+	void doFlowTakeImageOnly(string time);
+	bool getStatusSetupModus(){return SetupModeActive;};
+	string getReadout(bool _rawvalue, bool _noerror, int _number);
+	string getReadoutAll(int _type);	
+	bool UpdatePrevalue(std::string _newvalue, std::string _numbers, bool _extern);
+	string GetPrevalue(std::string _number = "");	
+	bool ReadParameter(FILE* pfile, string& aktparamgraph);	
+	string getJSON();
+	const std::vector<NumberPost*> &getNumbers();
+	string getNumbersName();
+
+	string TranslateAktstatus(std::string _input);
+
+	#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+	void DigitDrawROI(CImageBasis *_zw);
+	void AnalogDrawROI(CImageBasis *_zw);
+	#endif
+
+	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 getIsAutoStart();
+	void setAutoStartInterval(long &_interval);
+
+	std::string* getActStatusWithTime();
+	std::string* getActStatus();
+	void setActStatus(std::string _aktstatus);
+
+	std::vector<HTMLInfo*> GetAllDigit();
+	std::vector<HTMLInfo*> GetAllAnalog();	
+
+	t_CNNType GetTypeDigit();
+	t_CNNType GetTypeAnalog();
+	
+	#ifdef ENABLE_MQTT
+	bool StartMQTTService();
+	#endif //ENABLE_MQTT
+
+	int CleanTempFolder();
+
+	string name(){return "ClassFlowControll";};
+};
+
+#endif
+
+
+
--- a/code/components/jomjol_flowcontroll/ClassFlowDefineTypes.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowDefineTypes.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#ifndef CLASSFLOWDEFINETYPES_H
+#define CLASSFLOWDEFINETYPES_H
+
+#include "ClassFlowImage.h"
+
+/**
+ * Properties of one ROI
+ * FIXME: naming of members could use some refactoring to comply with common C++ coding style guidelines
+ */
+struct roi {
+    int posx, posy, deltax, deltay;
+    float result_float;
+    int result_klasse;
+    bool isReject, CCW;
+    string name;
+    CImageBasis *image, *image_org;
+};
+
+/**
+ * FIXME: Why is this additional layer needed?
+ */
+struct general {
+    string name;
+    std::vector<roi*> ROI;
+};
+
+enum t_RateType {
+    AbsoluteChange, // ignores the time difference; only the value difference is used comparison with NumberPost.maxRate
+    RateChange      // time difference is considered and a normalized rate is used for comparison with NumberPost.maxRate
+ };
+
+
+/**
+ * Holds all properties and settings of a sequence. A sequence is a set of digit and/or analog ROIs that are combined to 
+ * provide one meter reading (value).
+ * FIXME: can be renamed to `Sequence`
+ */
+struct NumberPost {
+    float MaxRateValue;         // maxRate; upper bound for the difference between two consecutive readings; affected by maxRateType;
+    bool useMaxRateValue;       // consistencyChecksEnabled; enables consistency checks; uses maxRate and maxRateType
+    t_RateType MaxRateType;        // maxRateType; affects how the value of maxRate is used for comparing the current and previous value
+    bool ErrorMessage;          // FIXME: not used; can be removed
+    int ChangeRateThreshold;  // threshold parameter for negative rate detection
+    bool PreValueOkay;          // previousValueValid; indicates that the reading of the previous round has no errors
+    bool AllowNegativeRates;    // allowNegativeRate; defines if the consistency checks allow negative rates between consecutive meter readings.
+    bool checkDigitIncreaseConsistency; // extendedConsistencyCheck; performs an additional consistency check to avoid wrong readings
+    time_t timeStampLastValue;     // Timestamp for the last read value; is used for the log
+    time_t timeStampLastPreValue;  // Timestamp for the last PreValue set; is used for useMaxRateValue
+    time_t timeStampTimeUTC;    // FIXME: not used; can be removed.
+    string timeStamp;           // localTimeStr; timestamp of last valid reading formatted as local time
+    double FlowRateAct;         // currentRate; ΔValue/min; since usage is not limited to water meters, the physical unit is not known.
+    double PreValue;            // lastValidValue; most recent value that could be read w/o any errors
+    double Value;               // value; most recent readout; may include corrections
+    string ReturnRateValue;     // currentRateStr; current normalized rate; ΔValue/min
+    string ReturnChangeAbsolute; // currentChangeStr; absolute difference between current and previous measurement
+    string ReturnRawValue;      // rawValueStr; Raw value (with N & leading 0)    
+    string ReturnValue;         // valueStr; corrected return value, if necessary with error message
+    string ReturnPreValue;      // lastValidValueStr; corrected return value without error message
+    string ErrorMessageText;    // errorMessage; Error message for consistency checks
+    int AnzahlAnalog;           // numAnalogRoi; number of analog ROIs used in this sequence
+    int AnzahlDigit;          // numDigitRoi; number of digit ROIs used in this sequence
+    int DecimalShift;           // decimalShift; each increment shifts the decimal separator by one digit; value=value*10^decimalShift; pos. value shifts to the right
+    int DecimalShiftInitial;    // decimalShiftInitial; same as decimalShift but is a const to reset decimalShift after calculations
+    float AnalogToDigitTransitionStart; // AnalogToDigitTransitionStartValue; FIXME: need a better description; When is the digit > x.1, i.e. when does it start to tilt?
+    int Nachkomma;              // decimalPlaces; usually defined by the number of analog ROIs; affected by DecimalShift
+
+    string FieldV1;             // influxdbFieldName_v1; Name of the Field in InfluxDBv1
+    string MeasurementV1;       // influxdbMeasurementName_v1; Name of the Measurement in InfluxDBv1
+
+    string FieldV2;             // influxdbFieldName_v2; Name of the Field in InfluxDBv2
+    string MeasurementV2;       // influxdbMeasurementName_v2; Name of the Measurement in InfluxDBv2
+
+    bool isExtendedResolution;  // extendResolution; Adds the decimal place of the least significant analog ROI to the value
+
+    general *digit_roi;         // digitRoi; set of digit ROIs for the sequence
+    general *analog_roi;        // analogRoi; set of analog ROIs for the sequence
+
+    string name;                // name; Designation for the sequence 
+};
+
+#endif
+
--- a/code/components/jomjol_flowcontroll/ClassFlowImage.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowImage.cpp
@@ -0,0 +1,140 @@
+#include "ClassFlowImage.h"
+#include <string>
+#include <string.h>
+#include <sys/stat.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <dirent.h>
+#ifdef __cplusplus
+}
+#endif
+
+#include "time_sntp.h"
+#include "ClassLogFile.h"
+#include "CImageBasis.h"
+#include "esp_log.h"
+#include "../../include/defines.h"
+
+static const char* TAG = "FLOWIMAGE";
+
+
+ClassFlowImage::ClassFlowImage(const char* logTag)
+{
+	this->logTag = logTag;
+	isLogImage = false;
+    disabled = false;
+    this->imagesRetention = 5;
+}
+
+ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, const char* logTag) : ClassFlow(lfc)
+{
+	this->logTag = logTag;
+	isLogImage = false;
+    disabled = false;
+    this->imagesRetention = 5;
+}
+
+ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, ClassFlow *_prev, const char* logTag) :  ClassFlow(lfc, _prev)
+{
+	this->logTag = logTag;
+	isLogImage = false;
+    disabled = false;
+    this->imagesRetention = 5;
+}
+
+
+string ClassFlowImage::CreateLogFolder(string time) {
+	if (!isLogImage)
+		return "";
+
+	string logPath = imagesLocation + "/" + time.LOGFILE_TIME_FORMAT_DATE_EXTR + "/" + time.LOGFILE_TIME_FORMAT_HOUR_EXTR;
+    isLogImage = mkdir_r(logPath.c_str(), S_IRWXU) == 0;
+    if (!isLogImage) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't create log folder 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) {
+        if (*resultFloat < 0)
+            sprintf(buf, "N.N_");
+        else
+        {
+            sprintf(buf, "%.1f_", *resultFloat);
+            if (strcmp(buf, "10.0_") == 0)
+                sprintf(buf, "0.0_");
+        }
+            
+	} 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);
+	ESP_LOGD(logTag, "save to file: %s", nm.c_str());
+	_img->SaveToFile(nm);
+//	CopyFile(output, nm);
+}
+
+void ClassFlowImage::RemoveOldLogs()
+{
+	if (!isLogImage)
+		return;
+	
+	ESP_LOGD(TAG, "remove old images");
+    if (imagesRetention == 0) {
+        return;
+    }
+
+    time_t rawtime;
+    struct tm* timeinfo;
+    char cmpfilename[30];
+
+    time(&rawtime);
+    rawtime = addDays(rawtime, -1 * imagesRetention + 1);
+    timeinfo = localtime(&rawtime);
+    //ESP_LOGD(TAG, "ImagefileRetentionInDays: %d", imagesRetention);
+    
+    strftime(cmpfilename, 30, LOGFILE_TIME_FORMAT, timeinfo);
+    //ESP_LOGD(TAG, "file name to compare: %s", cmpfilename);
+	string folderName = string(cmpfilename).LOGFILE_TIME_FORMAT_DATE_EXTR;
+
+    DIR *dir = opendir(imagesLocation.c_str());
+    if (!dir) {
+        ESP_LOGE(TAG, "Failed to stat dir: %s", imagesLocation.c_str());
+        return;
+    }
+
+    struct dirent *entry;
+    int deleted = 0;
+    int notDeleted = 0;
+    while ((entry = readdir(dir)) != NULL) {
+        string folderPath = imagesLocation + "/" + entry->d_name;
+		if (entry->d_type == DT_DIR) {
+			//ESP_LOGD(TAG, "Compare %s to %s", entry->d_name, folderName.c_str());	
+			if ((strlen(entry->d_name) == folderName.length()) && (strcmp(entry->d_name, folderName.c_str()) < 0)) {
+                removeFolder(folderPath.c_str(), logTag);
+                deleted++;
+			} else {
+                notDeleted ++;
+            }
+		}
+    }
+    ESP_LOGD(TAG, "Image folder deleted: %d | Image folder not deleted: %d", deleted, notDeleted);	
+    closedir(dir);
+}
+
--- a/code/components/jomjol_flowcontroll/ClassFlowImage.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowImage.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#ifndef CLASSFLOWIMAGE_H
+#define CLASSFLOWIMAGE_H
+
+#include "ClassFlow.h"
+
+using namespace std;
+
+class ClassFlowImage : public ClassFlow
+{
+protected:
+	string imagesLocation;
+    bool isLogImage;
+    unsigned short imagesRetention;
+	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();
+};
+
+#endif //CLASSFLOWIMAGE_H
--- a/code/components/jomjol_flowcontroll/ClassFlowInfluxDB.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowInfluxDB.cpp
@@ -0,0 +1,227 @@
+#ifdef ENABLE_INFLUXDB
+#include <sstream>
+#include "ClassFlowInfluxDB.h"
+#include "Helper.h"
+#include "connect_wlan.h"
+
+#include "time_sntp.h"
+#include "interface_influxdb.h"
+
+#include "ClassFlowPostProcessing.h"
+#include "esp_log.h"
+#include "../../include/defines.h"
+
+#include "ClassLogFile.h"
+
+#include <time.h>
+
+static const char* TAG = "INFLUXDB";
+
+void ClassFlowInfluxDB::SetInitialParameter(void)
+{
+    uri = "";
+    database = "";
+
+    OldValue = "";
+    flowpostprocessing = NULL;  
+    user = "";
+    password = "";   
+    previousElement = NULL;
+    ListFlowControll = NULL; 
+    disabled = false;
+    InfluxDBenable = false;
+}       
+
+ClassFlowInfluxDB::ClassFlowInfluxDB()
+{
+    SetInitialParameter();
+}
+
+ClassFlowInfluxDB::ClassFlowInfluxDB(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];
+        }
+    }
+}
+
+ClassFlowInfluxDB::ClassFlowInfluxDB(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 ClassFlowInfluxDB::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> splitted;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+    if (toUpper(aktparamgraph).compare("[INFLUXDB]") != 0) 
+        return false;
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        ESP_LOGD(TAG, "while loop reading line: %s", aktparamgraph.c_str());
+        splitted = ZerlegeZeile(aktparamgraph);
+        std::string _param = GetParameterName(splitted[0]);
+
+        if ((toUpper(_param) == "USER") && (splitted.size() > 1))
+        {
+            this->user = splitted[1];
+        }  
+        if ((toUpper(_param) == "PASSWORD") && (splitted.size() > 1))
+        {
+            this->password = splitted[1];
+        }               
+        if ((toUpper(_param) == "URI") && (splitted.size() > 1))
+        {
+            this->uri = splitted[1];
+        }
+        if (((toUpper(_param) == "DATABASE")) && (splitted.size() > 1))
+        {
+            this->database = splitted[1];
+        }
+        if (((toUpper(_param) == "MEASUREMENT")) && (splitted.size() > 1))
+        {
+            handleMeasurement(splitted[0], splitted[1]);
+        }
+        if (((toUpper(_param) == "FIELD")) && (splitted.size() > 1))
+        {
+            handleFieldname(splitted[0], splitted[1]);
+        }
+    }
+
+    if ((uri.length() > 0) && (database.length() > 0)) 
+    { 
+//        ESP_LOGD(TAG, "Init InfluxDB with uri: %s, measurement: %s, user: %s, password: %s", uri.c_str(), measurement.c_str(), user.c_str(), password.c_str());
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Init InfluxDB with uri: " + uri + ", user: " + user + ", password: " + password);
+        InfluxDBInit(uri, database, user, password); 
+        InfluxDBenable = true;
+    } else {
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "InfluxDB init skipped as we are missing some parameters");
+    }
+   
+    return true;
+}
+
+bool ClassFlowInfluxDB::doFlow(string zwtime)
+{
+    if (!InfluxDBenable)
+        return true;
+
+    std::string result;
+    std::string measurement;
+    std::string resulterror = "";
+    std::string resultraw = "";
+    std::string resultrate = "";
+    std::string resulttimestamp = "";
+    long int timeutc;
+    string zw = "";
+    string namenumber = "";
+
+    if (flowpostprocessing)
+    {
+        std::vector<NumberPost*>* NUMBERS = flowpostprocessing->GetNumbers();
+
+        for (int i = 0; i < (*NUMBERS).size(); ++i)
+        {
+            measurement = (*NUMBERS)[i]->MeasurementV1;
+            result =  (*NUMBERS)[i]->ReturnValue;
+            resultraw =  (*NUMBERS)[i]->ReturnRawValue;
+            resulterror = (*NUMBERS)[i]->ErrorMessageText;
+            resultrate = (*NUMBERS)[i]->ReturnRateValue;
+            resulttimestamp = (*NUMBERS)[i]->timeStamp;
+            timeutc = (*NUMBERS)[i]->timeStampTimeUTC;
+
+            if ((*NUMBERS)[i]->FieldV1.length() > 0)
+            {
+                namenumber = (*NUMBERS)[i]->FieldV1;
+            }
+            else
+            {
+                namenumber = (*NUMBERS)[i]->name;
+                if (namenumber == "default")
+                    namenumber = "value";
+                else
+                    namenumber = namenumber + "/value";
+            }
+
+            if (result.length() > 0)   
+                InfluxDBPublish(measurement, namenumber, result, timeutc);
+        }
+    }
+   
+    OldValue = result;
+    
+    return true;
+}
+
+void ClassFlowInfluxDB::handleMeasurement(string _decsep, string _value)
+{
+    string _digit, _decpos;
+    int _pospunkt = _decsep.find_first_of(".");
+//    ESP_LOGD(TAG, "Name: %s, Pospunkt: %d", _decsep.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+        _digit = _decsep.substr(0, _pospunkt);
+    else
+        _digit = "default";
+    for (int j = 0; j < flowpostprocessing->NUMBERS.size(); ++j)
+    {
+        if (_digit == "default")                        //  Set to default first (if nothing else is set)
+        {
+            flowpostprocessing->NUMBERS[j]->MeasurementV1 = _value;
+        }
+        if (flowpostprocessing->NUMBERS[j]->name == _digit)
+        {
+            flowpostprocessing->NUMBERS[j]->MeasurementV1 = _value;
+        }
+    }
+}
+
+
+void ClassFlowInfluxDB::handleFieldname(string _decsep, string _value)
+{
+    string _digit, _decpos;
+    int _pospunkt = _decsep.find_first_of(".");
+//    ESP_LOGD(TAG, "Name: %s, Pospunkt: %d", _decsep.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+        _digit = _decsep.substr(0, _pospunkt);
+    else
+        _digit = "default";
+    for (int j = 0; j < flowpostprocessing->NUMBERS.size(); ++j)
+    {
+        if (_digit == "default")                        //  Set to default first (if nothing else is set)
+        {
+            flowpostprocessing->NUMBERS[j]->FieldV1 = _value;
+        }
+        if (flowpostprocessing->NUMBERS[j]->name == _digit)
+        {
+            flowpostprocessing->NUMBERS[j]->FieldV1 = _value;
+        }
+    }
+}
+
+
+#endif //ENABLE_INFLUXDB
--- a/code/components/jomjol_flowcontroll/ClassFlowInfluxDB.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowInfluxDB.h
@@ -0,0 +1,44 @@
+#ifdef ENABLE_INFLUXDB
+
+#pragma once
+
+#ifndef CLASSFINFLUXDB_H
+#define CLASSFINFLUXDB_H
+
+#include "ClassFlow.h"
+
+#include "ClassFlowPostProcessing.h"
+
+#include <string>
+
+class ClassFlowInfluxDB :
+    public ClassFlow
+{
+protected:
+    std::string uri, database, measurement;
+    std::string OldValue;
+	ClassFlowPostProcessing* flowpostprocessing;  
+    std::string user, password; 
+    bool InfluxDBenable;
+
+    void SetInitialParameter(void);    
+    
+    void handleFieldname(string _decsep, string _value);   
+    void handleMeasurement(string _decsep, string _value);
+
+    
+
+public:
+    ClassFlowInfluxDB();
+    ClassFlowInfluxDB(std::vector<ClassFlow*>* lfc);
+    ClassFlowInfluxDB(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
+
+//    string GetInfluxDBMeasurement();
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string name(){return "ClassFlowInfluxDB";};
+};
+
+#endif //CLASSFINFLUXDB_H
+#endif //ENABLE_INFLUXDB
--- a/code/components/jomjol_flowcontroll/ClassFlowInfluxDBv2.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowInfluxDBv2.cpp
@@ -0,0 +1,244 @@
+#ifdef ENABLE_INFLUXDB
+#include <sstream>
+#include "ClassFlowInfluxDBv2.h"
+#include "Helper.h"
+#include "connect_wlan.h"
+
+#include "time_sntp.h"
+#include "interface_influxdb.h"
+
+#include "ClassFlowPostProcessing.h"
+#include "esp_log.h"
+#include "../../include/defines.h"
+
+#include "ClassLogFile.h"
+
+#include <time.h>
+
+static const char* TAG = "INFLUXDBV2";
+
+void ClassFlowInfluxDBv2::SetInitialParameter(void)
+{
+    uri = "";
+    bucket = "";
+    dborg = "";  
+    dbtoken = "";  
+//    dbfield = "";
+
+    OldValue = "";
+    flowpostprocessing = NULL;  
+    previousElement = NULL;
+    ListFlowControll = NULL; 
+    disabled = false;
+    InfluxDBenable = false;
+}       
+
+ClassFlowInfluxDBv2::ClassFlowInfluxDBv2()
+{
+    SetInitialParameter();
+}
+
+ClassFlowInfluxDBv2::ClassFlowInfluxDBv2(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];
+        }
+    }
+}
+
+ClassFlowInfluxDBv2::ClassFlowInfluxDBv2(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 ClassFlowInfluxDBv2::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> splitted;
+
+    aktparamgraph = trim(aktparamgraph);
+    printf("akt param: %s\n", aktparamgraph.c_str());
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+    if (toUpper(aktparamgraph).compare("[INFLUXDBV2]") != 0) 
+        return false;
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+//        ESP_LOGD(TAG, "while loop reading line: %s", aktparamgraph.c_str());
+        splitted = ZerlegeZeile(aktparamgraph);
+        std::string _param = GetParameterName(splitted[0]);
+
+        if ((toUpper(_param) == "ORG") && (splitted.size() > 1))
+        {
+            this->dborg = splitted[1];
+        }  
+        if ((toUpper(_param) == "TOKEN") && (splitted.size() > 1))
+        {
+            this->dbtoken = splitted[1];
+        }               
+        if ((toUpper(_param) == "URI") && (splitted.size() > 1))
+        {
+            this->uri = splitted[1];
+        }
+        if (((toUpper(_param) == "FIELD")) && (splitted.size() > 1))
+        {
+            handleFieldname(splitted[0], splitted[1]);
+        }
+        if (((toUpper(_param) == "MEASUREMENT")) && (splitted.size() > 1))
+        {
+            handleMeasurement(splitted[0], splitted[1]);
+        }
+        if (((toUpper(splitted[0]) == "BUCKET")) && (splitted.size() > 1))
+        {
+            this->bucket = splitted[1];
+        }
+    }
+
+    printf("uri:         %s\n", uri.c_str());
+    printf("org:         %s\n", dborg.c_str());
+    printf("token:       %s\n", dbtoken.c_str());
+
+    if ((uri.length() > 0) && (bucket.length() > 0) && (dbtoken.length() > 0) && (dborg.length() > 0)) 
+    { 
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Init InfluxDB with uri: " + uri + ", org: " + dborg + ", token: *****");
+//        printf("vor V2 Init\n");
+        InfluxDB_V2_Init(uri, bucket, dborg, dbtoken); 
+//        printf("nach V2 Init\n");
+        InfluxDBenable = true;
+    } else {
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "InfluxDBv2 (Verion2 !!!) init skipped as we are missing some parameters");
+    }
+   
+    return true;
+}
+
+/*
+string ClassFlowInfluxDBv2::GetInfluxDBMeasurement()
+{
+    return measurement;
+}
+*/
+
+void ClassFlowInfluxDBv2::handleFieldname(string _decsep, string _value)
+{
+    string _digit, _decpos;
+    int _pospunkt = _decsep.find_first_of(".");
+//    ESP_LOGD(TAG, "Name: %s, Pospunkt: %d", _decsep.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+        _digit = _decsep.substr(0, _pospunkt);
+    else
+        _digit = "default";
+    for (int j = 0; j < flowpostprocessing->NUMBERS.size(); ++j)
+    {
+        if (_digit == "default")                        //  Set to default first (if nothing else is set)
+        {
+            flowpostprocessing->NUMBERS[j]->FieldV2 = _value;
+        }
+        if (flowpostprocessing->NUMBERS[j]->name == _digit)
+        {
+            flowpostprocessing->NUMBERS[j]->FieldV2 = _value;
+        }
+    }
+}
+
+void ClassFlowInfluxDBv2::handleMeasurement(string _decsep, string _value)
+{
+    string _digit, _decpos;
+    int _pospunkt = _decsep.find_first_of(".");
+//    ESP_LOGD(TAG, "Name: %s, Pospunkt: %d", _decsep.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+        _digit = _decsep.substr(0, _pospunkt);
+    else
+        _digit = "default";
+    for (int j = 0; j < flowpostprocessing->NUMBERS.size(); ++j)
+    {
+        if (_digit == "default")                        //  Set to default first (if nothing else is set)
+        {
+            flowpostprocessing->NUMBERS[j]->MeasurementV2 = _value;
+        }
+        if (flowpostprocessing->NUMBERS[j]->name == _digit)
+        {
+            flowpostprocessing->NUMBERS[j]->MeasurementV2 = _value;
+        }
+    }
+}
+
+
+bool ClassFlowInfluxDBv2::doFlow(string zwtime)
+{
+    if (!InfluxDBenable)
+        return true;
+
+    std::string measurement;
+    std::string result;
+    std::string resulterror = "";
+    std::string resultraw = "";
+    std::string resultrate = "";
+    std::string resulttimestamp = "";
+    long int resulttimeutc = 0;
+    string zw = "";
+    string namenumber = "";
+
+
+    if (flowpostprocessing)
+    {
+        std::vector<NumberPost*>* NUMBERS = flowpostprocessing->GetNumbers();
+
+        for (int i = 0; i < (*NUMBERS).size(); ++i)
+        {
+            measurement = (*NUMBERS)[i]->MeasurementV2;
+            result =  (*NUMBERS)[i]->ReturnValue;
+            resultraw =  (*NUMBERS)[i]->ReturnRawValue;
+            resulterror = (*NUMBERS)[i]->ErrorMessageText;
+            resultrate = (*NUMBERS)[i]->ReturnRateValue;
+            resulttimestamp = (*NUMBERS)[i]->timeStamp;
+            resulttimeutc = (*NUMBERS)[i]->timeStampTimeUTC;
+
+
+            if ((*NUMBERS)[i]->FieldV2.length() > 0)
+            {
+                namenumber = (*NUMBERS)[i]->FieldV2;
+            }
+            else
+            {
+                namenumber = (*NUMBERS)[i]->name;
+                if (namenumber == "default")
+                    namenumber = "value";
+                else
+                    namenumber = namenumber + "/value";
+            }
+            
+            printf("vor sende Influx_DB_V2 - namenumber. %s, result: %s, timestampt: %s", namenumber.c_str(), result.c_str(), resulttimestamp.c_str());
+
+            if (result.length() > 0)   
+                InfluxDB_V2_Publish(measurement, namenumber, result, resulttimeutc);
+        }
+    }
+   
+    OldValue = result;
+    
+    return true;
+}
+
+#endif //ENABLE_INFLUXDB
--- a/code/components/jomjol_flowcontroll/ClassFlowInfluxDBv2.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowInfluxDBv2.h
@@ -0,0 +1,43 @@
+#ifdef ENABLE_INFLUXDB
+
+#pragma once
+
+#ifndef CLASSFINFLUXDBv2_H
+#define CLASSFINFLUXDBv2_H
+
+#include "ClassFlow.h"
+
+#include "ClassFlowPostProcessing.h"
+
+#include <string>
+
+class ClassFlowInfluxDBv2 :
+    public ClassFlow
+{
+protected:
+    std::string uri, bucket;
+    std::string dborg, dbtoken, dbfield;
+    std::string OldValue;
+	ClassFlowPostProcessing* flowpostprocessing;  
+    bool InfluxDBenable;
+
+    void SetInitialParameter(void);     
+
+    void handleFieldname(string _decsep, string _value);   
+    void handleMeasurement(string _decsep, string _value);
+
+
+public:
+    ClassFlowInfluxDBv2();
+    ClassFlowInfluxDBv2(std::vector<ClassFlow*>* lfc);
+    ClassFlowInfluxDBv2(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
+
+//    string GetInfluxDBMeasurement();
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string name(){return "ClassFlowInfluxDBv2";};
+};
+
+#endif //CLASSFINFLUXDBv2_H
+#endif //ENABLE_INFLUXDB
--- a/code/components/jomjol_flowcontroll/ClassFlowMQTT.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowMQTT.cpp
@@ -0,0 +1,330 @@
+#ifdef ENABLE_MQTT
+
+#include <sstream>
+#include <iomanip>
+#include "ClassFlowMQTT.h"
+#include "Helper.h"
+#include "connect_wlan.h"
+#include "read_wlanini.h"
+#include "ClassLogFile.h"
+
+#include "time_sntp.h"
+#include "interface_mqtt.h"
+#include "ClassFlowPostProcessing.h"
+#include "ClassFlowControll.h"
+
+#include "server_mqtt.h"
+
+#include <time.h>
+#include "../../include/defines.h"
+
+static const char *TAG = "MQTT";
+
+extern const char* libfive_git_version(void);
+extern const char* libfive_git_revision(void);
+extern const char* libfive_git_branch(void);
+
+
+void ClassFlowMQTT::SetInitialParameter(void)
+{
+    uri = "";
+    topic = "";
+    topicError = "";
+    topicRate = "";
+    topicTimeStamp = "";
+    maintopic = wlan_config.hostname;
+
+    topicUptime = "";
+    topicFreeMem = "";
+
+    caCertFilename = "";
+    clientCertFilename = "";
+    clientKeyFilename = "";
+    clientname = wlan_config.hostname;
+
+    OldValue = "";
+    flowpostprocessing = NULL;  
+    user = "";
+    password = ""; 
+    SetRetainFlag = false;
+    previousElement = NULL;
+    ListFlowControll = NULL; 
+    disabled = false;
+    keepAlive = 25*60;
+}       
+
+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> splitted;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+    if (toUpper(aktparamgraph).compare("[MQTT]") != 0)       // Paragraph does not fit MQTT
+        return false;
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        splitted = ZerlegeZeile(aktparamgraph);
+        if ((toUpper(splitted[0]) == "CACERT") && (splitted.size() > 1))
+        {
+            this->caCertFilename = splitted[1];
+        }  
+        if ((toUpper(splitted[0]) == "CLIENTCERT") && (splitted.size() > 1))
+        {
+            this->clientCertFilename = splitted[1];
+        }  
+        if ((toUpper(splitted[0]) == "CLIENTKEY") && (splitted.size() > 1))
+        {
+            this->clientKeyFilename = splitted[1];
+        }  
+        if ((toUpper(splitted[0]) == "USER") && (splitted.size() > 1))
+        {
+            this->user = splitted[1];
+        }  
+        if ((toUpper(splitted[0]) == "PASSWORD") && (splitted.size() > 1))
+        {
+            this->password = splitted[1];
+        }               
+        if ((toUpper(splitted[0]) == "URI") && (splitted.size() > 1))
+        {
+            this->uri = splitted[1];
+        }
+        if ((toUpper(splitted[0]) == "RETAINMESSAGES") && (splitted.size() > 1))
+        {
+            if (toUpper(splitted[1]) == "TRUE") {
+                SetRetainFlag = true;  
+                setMqtt_Server_Retain(SetRetainFlag);
+            }
+        }
+        if ((toUpper(splitted[0]) == "HOMEASSISTANTDISCOVERY") && (splitted.size() > 1))
+        {
+            if (toUpper(splitted[1]) == "TRUE")
+                SetHomeassistantDiscoveryEnabled(true);  
+        }
+        if ((toUpper(splitted[0]) == "METERTYPE") && (splitted.size() > 1)) {
+        /* Use meter type for the device class 
+           Make sure it is a listed one on https://developers.home-assistant.io/docs/core/entity/sensor/#available-device-classes */
+            if (toUpper(splitted[1]) == "WATER_M3") {
+                mqttServer_setMeterType("water", "m³", "h", "m³/h");
+            }
+            else if (toUpper(splitted[1]) == "WATER_L") {
+                mqttServer_setMeterType("water", "L", "h", "L/h");
+            }
+            else if (toUpper(splitted[1]) == "WATER_FT3") {
+                mqttServer_setMeterType("water", "ft³", "m", "ft³/m"); // Minutes
+            }
+            else if (toUpper(splitted[1]) == "WATER_GAL") {
+                mqttServer_setMeterType("water", "gal", "h", "gal/h");
+            }
+            else if (toUpper(splitted[1]) == "GAS_M3") {
+                mqttServer_setMeterType("gas", "m³", "h", "m³/h");
+            }
+            else if (toUpper(splitted[1]) == "GAS_FT3") {
+                mqttServer_setMeterType("gas", "ft³", "m", "ft³/m"); // Minutes
+            }
+            else if (toUpper(splitted[1]) == "ENERGY_WH") {
+                mqttServer_setMeterType("energy", "Wh", "h", "W");
+            }
+            else if (toUpper(splitted[1]) == "ENERGY_KWH") {
+                mqttServer_setMeterType("energy", "kWh", "h", "kW");
+            }
+            else if (toUpper(splitted[1]) == "ENERGY_MWH") {
+                mqttServer_setMeterType("energy", "MWh", "h", "MW");
+            }
+            else if (toUpper(splitted[1]) == "ENERGY_GJ") {
+                mqttServer_setMeterType("energy", "GJ", "h", "GJ/h");
+            }
+        }
+
+        if ((toUpper(splitted[0]) == "CLIENTID") && (splitted.size() > 1))
+        {
+            this->clientname = splitted[1];
+        }
+
+        if (((toUpper(splitted[0]) == "TOPIC") || (toUpper(splitted[0]) == "MAINTOPIC")) && (splitted.size() > 1))
+        {
+            maintopic = splitted[1];
+        }
+    }
+
+    /* Note:
+     * Originally, we started the MQTT client here.
+     * How ever we need the interval parameter from the ClassFlowControll, but that only gets started later.
+     * To work around this, we delay the start and trigger it from ClassFlowControll::ReadParameter() */
+
+    mqttServer_setMainTopic(maintopic);
+
+    return true;
+}
+
+
+bool ClassFlowMQTT::Start(float AutoInterval) 
+{
+    roundInterval = AutoInterval; // Minutes
+    keepAlive = roundInterval * 60 * 2.5; // Seconds, make sure it is greater thatn 2 rounds!
+
+    std::stringstream stream;
+    stream << std::fixed << std::setprecision(1) << "Digitizer interval is " << roundInterval <<
+            " minutes => setting MQTT LWT timeout to " << ((float)keepAlive/60) << " minutes.";
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, stream.str());
+
+    mqttServer_setParameter(flowpostprocessing->GetNumbers(), keepAlive, roundInterval);
+
+    bool MQTTConfigCheck = MQTT_Configure(uri, clientname, user, password, maintopic, LWT_TOPIC, LWT_CONNECTED,
+                                     LWT_DISCONNECTED, caCertFilename, clientCertFilename, clientKeyFilename,
+                                     keepAlive, SetRetainFlag, (void *)&GotConnected);
+
+    if (!MQTTConfigCheck) {
+        return false;
+    }
+
+    return (MQTT_Init() == 1);
+}
+
+
+bool ClassFlowMQTT::doFlow(string zwtime)
+{
+    bool success;
+    std::string result;
+    std::string resulterror = "";
+    std::string resultraw = "";
+    std::string resultpre = "";
+    std::string resultrate = ""; // Always Unit / Minute
+    std::string resultRatePerTimeUnit = ""; // According to selection
+    std::string resulttimestamp = "";
+    std::string resultchangabs = "";
+    string zw = "";
+    string namenumber = "";
+    int qos = 1;
+
+    /* Send the the Homeassistant Discovery and the Static Topics in case they where scheduled */
+    sendDiscovery_and_static_Topics();
+
+    success = publishSystemData(qos);
+
+    if (flowpostprocessing && getMQTTisConnected())
+    {
+        std::vector<NumberPost*>* NUMBERS = flowpostprocessing->GetNumbers();
+
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Publishing MQTT topics...");
+
+        for (int i = 0; i < (*NUMBERS).size(); ++i)
+        {
+            result =  (*NUMBERS)[i]->ReturnValue;
+            resultraw =  (*NUMBERS)[i]->ReturnRawValue;
+            resultpre =  (*NUMBERS)[i]->ReturnPreValue;
+            resulterror = (*NUMBERS)[i]->ErrorMessageText;
+            resultrate = (*NUMBERS)[i]->ReturnRateValue; // Unit per minutes
+            resultchangabs = (*NUMBERS)[i]->ReturnChangeAbsolute; // Units per round
+            resulttimestamp = (*NUMBERS)[i]->timeStamp;
+
+            namenumber = (*NUMBERS)[i]->name;
+            if (namenumber == "default")
+                namenumber = maintopic + "/";
+            else
+                namenumber = maintopic + "/" + namenumber + "/";
+
+
+            if (result.length() > 0)   
+                success |= MQTTPublish(namenumber + "value", result, qos, SetRetainFlag);
+
+            if (resulterror.length() > 0)  
+                success |= MQTTPublish(namenumber + "error", resulterror, qos, SetRetainFlag);
+
+            if (resultrate.length() > 0) {
+                success |= MQTTPublish(namenumber + "rate", resultrate, qos, SetRetainFlag);
+                
+                std::string resultRatePerTimeUnit;
+                if (getTimeUnit() == "h") { // Need conversion to be per hour
+                    resultRatePerTimeUnit = resultRatePerTimeUnit = to_string((*NUMBERS)[i]->FlowRateAct * 60); // per minutes => per hour
+                }
+                else { // Keep per minute
+                    resultRatePerTimeUnit = resultrate;
+                }
+                success |= MQTTPublish(namenumber + "rate_per_time_unit", resultRatePerTimeUnit, qos, SetRetainFlag);
+            }
+
+            if (resultchangabs.length() > 0) {
+                success |= MQTTPublish(namenumber + "changeabsolut", resultchangabs, qos, SetRetainFlag); // Legacy API
+                success |= MQTTPublish(namenumber + "rate_per_digitization_round", resultchangabs, qos, SetRetainFlag);
+            }
+
+            if (resultraw.length() > 0)   
+                success |= MQTTPublish(namenumber + "raw", resultraw, qos, SetRetainFlag);
+
+            if (resulttimestamp.length() > 0)
+                success |= MQTTPublish(namenumber + "timestamp", resulttimestamp, qos, SetRetainFlag);
+
+            std::string json = flowpostprocessing->getJsonFromNumber(i, "\n");
+            success |= MQTTPublish(namenumber + "json", json, qos, SetRetainFlag);
+        }
+    }
+    
+    /* Disabled because this is no longer a use case */
+    // 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;
+    //         }
+    //     }
+    //     success |= MQTTPublish(topic, result, qos, SetRetainFlag);
+    // }
+    
+    OldValue = result;
+
+    if (!success) {
+        LogFile.WriteToFile(ESP_LOG_WARN, TAG, "One or more MQTT topics failed to be published!");
+    }
+    
+    return true;
+}
+
+
+#endif //ENABLE_MQTT
--- a/code/components/jomjol_flowcontroll/ClassFlowMQTT.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowMQTT.h
@@ -0,0 +1,42 @@
+#ifdef ENABLE_MQTT
+
+#pragma once
+
+#ifndef CLASSFFLOWMQTT_H
+#define CLASSFFLOWMQTT_H
+
+#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; 
+    std::string caCertFilename, clientCertFilename, clientKeyFilename; 
+    bool SetRetainFlag;
+    int keepAlive; // Seconds
+    float roundInterval; // Minutes
+
+    std::string maintopic; 
+	void SetInitialParameter(void);        
+
+public:
+    ClassFlowMQTT();
+    ClassFlowMQTT(std::vector<ClassFlow*>* lfc);
+    ClassFlowMQTT(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
+
+    bool Start(float AutoInterval);
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string name(){return "ClassFlowMQTT";};
+};
+#endif //CLASSFFLOWMQTT_H
+#endif //ENABLE_MQTT
--- a/code/components/jomjol_flowcontroll/ClassFlowPostProcessing.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowPostProcessing.cpp
--- a/code/components/jomjol_flowcontroll/ClassFlowPostProcessing.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowPostProcessing.h
@@ -0,0 +1,79 @@
+#pragma once
+
+#ifndef CLASSFFLOWPOSTPROCESSING_H
+#define CLASSFFLOWPOSTPROCESSING_H
+
+#include "ClassFlow.h"
+#include "ClassFlowTakeImage.h"
+#include "ClassFlowCNNGeneral.h"
+#include "ClassFlowDefineTypes.h"
+
+#include <string>
+
+
+class ClassFlowPostProcessing :
+    public ClassFlow
+{
+protected:
+    bool UpdatePreValueINI;
+
+    int PreValueAgeStartup; 
+    bool ErrorMessage;
+    bool IgnoreLeadingNaN;          // SPECIAL CASE for User Gustl ???
+
+    ClassFlowCNNGeneral* flowAnalog;
+    ClassFlowCNNGeneral* flowDigit;    
+
+    string FilePreValue;
+
+    ClassFlowTakeImage *flowTakeImage;
+
+    bool LoadPreValue(void);
+    string ShiftDecimal(string in, int _decShift);
+
+    string ErsetzteN(string, double _prevalue);
+    float checkDigitConsistency(double input, int _decilamshift, bool _isanalog, double _preValue);
+
+    void InitNUMBERS();
+    void handleDecimalSeparator(string _decsep, string _value);
+    void handleMaxRateValue(string _decsep, string _value);
+    void handleDecimalExtendedResolution(string _decsep, string _value); 
+    void handleMaxRateType(string _decsep, string _value);
+    void handleAnalogToDigitTransitionStart(string _decsep, string _value);
+    void handleAllowNegativeRate(string _decsep, string _value);
+    void handleChangeRateThreshold(string _decsep, string _value);
+    
+    std::string GetStringReadouts(general);
+
+    void WriteDataLog(int _index);
+
+public:
+    bool PreValueUse;
+    std::vector<NumberPost*> NUMBERS;
+
+    ClassFlowPostProcessing(std::vector<ClassFlow*>* lfc, ClassFlowCNNGeneral *_analog, ClassFlowCNNGeneral *_digit);
+    virtual ~ClassFlowPostProcessing(){};
+    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 getJsonFromNumber(int i, std::string _lineend);
+    string GetPreValue(std::string _number = "");
+    bool SetPreValue(double zw, string _numbers, bool _extern = false);
+
+    std::string GetJSON(std::string _lineend = "\n");
+    std::string getNumbersName();
+
+    void UpdateNachkommaDecimalShift();
+
+    std::vector<NumberPost*>* GetNumbers(){return &NUMBERS;};
+
+    string name(){return "ClassFlowPostProcessing";};
+};
+
+
+#endif //CLASSFFLOWPOSTPROCESSING_H
--- a/code/components/jomjol_flowcontroll/ClassFlowTakeImage.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowTakeImage.cpp
@@ -0,0 +1,619 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <regex>
+
+#include "ClassFlowTakeImage.h"
+#include "Helper.h"
+#include "ClassLogFile.h"
+
+#include "CImageBasis.h"
+#include "ClassControllCamera.h"
+#include "MainFlowControl.h"
+
+#include "esp_wifi.h"
+#include "esp_log.h"
+#include "../../include/defines.h"
+#include "psram.h"
+
+#include <time.h>
+
+// #define DEBUG_DETAIL_ON
+// #define WIFITURNOFF
+
+static const char *TAG = "TAKEIMAGE";
+
+esp_err_t ClassFlowTakeImage::camera_capture(void)
+{
+    string nm = namerawimage;
+    Camera.CaptureToFile(nm);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    return ESP_OK;
+}
+
+void ClassFlowTakeImage::takePictureWithFlash(int flash_duration)
+{
+    // in case the image is flipped, it must be reset here //
+    rawImage->width = CCstatus.ImageWidth;
+    rawImage->height = CCstatus.ImageHeight;
+
+    ESP_LOGD(TAG, "flash_duration: %d", flash_duration);
+
+    Camera.CaptureToBasisImage(rawImage, flash_duration);
+
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    if (CCstatus.SaveAllFiles)
+    {
+        rawImage->SaveToFile(namerawimage);
+    }
+}
+
+void ClassFlowTakeImage::SetInitialParameter(void)
+{
+    TimeImageTaken = 0;
+    rawImage = NULL;
+    disabled = false;
+    namerawimage = "/sdcard/img_tmp/raw.jpg";
+}
+
+// auslesen der Kameraeinstellungen aus der config.ini
+// wird beim Start aufgerufen
+bool ClassFlowTakeImage::ReadParameter(FILE *pfile, string &aktparamgraph)
+{
+    Camera.getSensorDatenToCCstatus(); // Kamera >>> CCstatus
+
+    std::vector<string> splitted;
+
+    aktparamgraph = trim(aktparamgraph);
+
+    if (aktparamgraph.size() == 0)
+    {
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+        {
+            return false;
+        }
+    }
+
+    if (aktparamgraph.compare("[TakeImage]") != 0)
+    {
+        // Paragraph does not fit TakeImage
+        return false;
+    }
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        splitted = ZerlegeZeile(aktparamgraph);
+
+        if ((toUpper(splitted[0]) == "RAWIMAGESLOCATION") && (splitted.size() > 1))
+        {
+            imagesLocation = "/sdcard" + splitted[1];
+            isLogImage = true;
+        }
+
+        else if ((toUpper(splitted[0]) == "RAWIMAGESRETENTION") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                this->imagesRetention = std::stod(splitted[1]);
+            }          
+        }
+
+        else if ((toUpper(splitted[0]) == "SAVEALLFILES") && (splitted.size() > 1))
+        {
+            CCstatus.SaveAllFiles = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "WAITBEFORETAKINGPICTURE") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _WaitBeforePicture = std::stoi(splitted[1]);
+                if (_WaitBeforePicture != 0)
+                {
+                    CCstatus.WaitBeforePicture = _WaitBeforePicture;
+                }
+                else
+                {
+                    CCstatus.WaitBeforePicture = 2;
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMGAINCEILING") && (splitted.size() > 1))
+        {
+            std::string _ImageGainceiling = toUpper(splitted[1]);
+
+            if (isStringNumeric(_ImageGainceiling))
+            {
+                int _ImageGainceiling_ = std::stoi(_ImageGainceiling);
+                switch (_ImageGainceiling_)
+                {
+                case 1:
+                    CFstatus.ImageGainceiling = GAINCEILING_4X;
+                    break;
+                case 2:
+                    CFstatus.ImageGainceiling = GAINCEILING_8X;
+                    break;
+                case 3:
+                    CFstatus.ImageGainceiling = GAINCEILING_16X;
+                    break;
+                case 4:
+                    CFstatus.ImageGainceiling = GAINCEILING_32X;
+                    break;
+                case 5:
+                    CFstatus.ImageGainceiling = GAINCEILING_64X;
+                    break;
+                case 6:
+                    CFstatus.ImageGainceiling = GAINCEILING_128X;
+                    break;
+                default:
+                    CFstatus.ImageGainceiling = GAINCEILING_2X;
+                }
+            }
+            else
+            {
+                if (_ImageGainceiling == "X4")
+                {
+                    CCstatus.ImageGainceiling = GAINCEILING_4X;
+                }
+                else if (_ImageGainceiling == "X8")
+                {
+                    CCstatus.ImageGainceiling = GAINCEILING_8X;
+                }
+                else if (_ImageGainceiling == "X16")
+                {
+                    CCstatus.ImageGainceiling = GAINCEILING_16X;
+                }
+                else if (_ImageGainceiling == "X32")
+                {
+                    CCstatus.ImageGainceiling = GAINCEILING_32X;
+                }
+                else if (_ImageGainceiling == "X64")
+                {
+                    CCstatus.ImageGainceiling = GAINCEILING_64X;
+                }
+                else if (_ImageGainceiling == "X128")
+                {
+                    CCstatus.ImageGainceiling = GAINCEILING_128X;
+                }
+                else
+                {
+                    CCstatus.ImageGainceiling = GAINCEILING_2X;
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMQUALITY") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageQuality = std::stoi(splitted[1]);
+                CCstatus.ImageQuality = clipInt(_ImageQuality, 63, 6);
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMBRIGHTNESS") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageBrightness = std::stoi(splitted[1]);
+                CCstatus.ImageBrightness = clipInt(_ImageBrightness, 2, -2);
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMCONTRAST") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageContrast = std::stoi(splitted[1]);
+                CCstatus.ImageContrast = clipInt(_ImageContrast, 2, -2);
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMSATURATION") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageSaturation = std::stoi(splitted[1]);
+                CCstatus.ImageSaturation = clipInt(_ImageSaturation, 2, -2);
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMSHARPNESS") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageSharpness = std::stoi(splitted[1]);
+                if (CCstatus.CamSensor_id == OV2640_PID)
+                {
+                    CCstatus.ImageSharpness = clipInt(_ImageSharpness, 2, -2);
+                }
+                else
+                {
+                    CCstatus.ImageSharpness = clipInt(_ImageSharpness, 3, -3);
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAUTOSHARPNESS") && (splitted.size() > 1))
+        {
+            CCstatus.ImageAutoSharpness = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMSPECIALEFFECT") && (splitted.size() > 1))
+        {
+            std::string _ImageSpecialEffect = toUpper(splitted[1]);
+
+            if (isStringNumeric(_ImageSpecialEffect))
+            {
+                int _ImageSpecialEffect_ = std::stoi(_ImageSpecialEffect);
+                CFstatus.ImageSpecialEffect = clipInt(_ImageSpecialEffect_, 6, 0);
+            }
+            else
+            {
+                if (_ImageSpecialEffect == "NEGATIVE")
+                {
+                    CCstatus.ImageSpecialEffect = 1;
+                }
+                else if (_ImageSpecialEffect == "GRAYSCALE")
+                {
+                    CCstatus.ImageSpecialEffect = 2;
+                }
+                else if (_ImageSpecialEffect == "RED")
+                {
+                    CCstatus.ImageSpecialEffect = 3;
+                }
+                else if (_ImageSpecialEffect == "GREEN")
+                {
+                    CCstatus.ImageSpecialEffect = 4;
+                }
+                else if (_ImageSpecialEffect == "BLUE")
+                {
+                    CCstatus.ImageSpecialEffect = 5;
+                }
+                else if (_ImageSpecialEffect == "RETRO")
+                {
+                    CCstatus.ImageSpecialEffect = 6;
+                }
+                else
+                {
+                    CCstatus.ImageSpecialEffect = 0;
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMWBMODE") && (splitted.size() > 1))
+        {
+            std::string _ImageWbMode = toUpper(splitted[1]);
+
+            if (isStringNumeric(_ImageWbMode))
+            {
+                int _ImageWbMode_ = std::stoi(_ImageWbMode);
+                CFstatus.ImageWbMode = clipInt(_ImageWbMode_, 4, 0);
+            }
+            else
+            {
+                if (_ImageWbMode == "SUNNY")
+                {
+                    CCstatus.ImageWbMode = 1;
+                }
+                else if (_ImageWbMode == "CLOUDY")
+                {
+                    CCstatus.ImageWbMode = 2;
+                }
+                else if (_ImageWbMode == "OFFICE")
+                {
+                    CCstatus.ImageWbMode = 3;
+                }
+                else if (_ImageWbMode == "HOME")
+                {
+                    CCstatus.ImageWbMode = 4;
+                }
+                else
+                {
+                    CCstatus.ImageWbMode = 0;
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAWB") && (splitted.size() > 1))
+        {
+            CCstatus.ImageAwb = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAWBGAIN") && (splitted.size() > 1))
+        {
+            CCstatus.ImageAwbGain = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAEC") && (splitted.size() > 1))
+        {
+            CCstatus.ImageAec = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAEC2") && (splitted.size() > 1))
+        {
+            CCstatus.ImageAec2 = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAELEVEL") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageAeLevel = std::stoi(splitted[1]);
+                if (CCstatus.CamSensor_id == OV2640_PID)
+                {
+                    CCstatus.ImageAeLevel = clipInt(_ImageAeLevel, 2, -2);
+                }
+                else
+                {
+                    CCstatus.ImageAeLevel = clipInt(_ImageAeLevel, 5, -5);
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAECVALUE") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageAecValue = std::stoi(splitted[1]);
+                CCstatus.ImageAecValue = clipInt(_ImageAecValue, 1200, 0);
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAGC") && (splitted.size() > 1))
+        {
+            CCstatus.ImageAgc = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMAGCGAIN") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageAgcGain = std::stoi(splitted[1]);
+                CCstatus.ImageAgcGain = clipInt(_ImageAgcGain, 30, 0);
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMBPC") && (splitted.size() > 1))
+        {
+            CCstatus.ImageBpc = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMWPC") && (splitted.size() > 1))
+        {
+            CCstatus.ImageWpc = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMRAWGMA") && (splitted.size() > 1))
+        {
+            CCstatus.ImageRawGma = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMLENC") && (splitted.size() > 1))
+        {
+            CCstatus.ImageLenc = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMHMIRROR") && (splitted.size() > 1))
+        {
+            CCstatus.ImageHmirror = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMVFLIP") && (splitted.size() > 1))
+        {
+            CCstatus.ImageVflip = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMDCW") && (splitted.size() > 1))
+        {
+            CCstatus.ImageDcw = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMDENOISE") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageDenoiseLevel = std::stoi(splitted[1]);
+                if (CCstatus.CamSensor_id == OV2640_PID)
+                {
+                    CCstatus.ImageDenoiseLevel = 0;
+                }
+                else
+                {
+                    CCstatus.ImageDenoiseLevel = clipInt(_ImageDenoiseLevel, 8, 0);
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMZOOM") && (splitted.size() > 1))
+        {
+            CCstatus.ImageZoomEnabled = alphanumericToBoolean(splitted[1]);
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMZOOMOFFSETX") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageZoomOffsetX = std::stoi(splitted[1]);
+                if (CCstatus.CamSensor_id == OV2640_PID)
+                {
+                    CCstatus.ImageZoomOffsetX = clipInt(_ImageZoomOffsetX, 480, -480);
+                }
+                else if (CCstatus.CamSensor_id == OV3660_PID)
+                {
+                    CCstatus.ImageZoomOffsetX = clipInt(_ImageZoomOffsetX, 704, -704);
+                }
+                else if (CCstatus.CamSensor_id == OV5640_PID)
+                {
+                    CCstatus.ImageZoomOffsetX = clipInt(_ImageZoomOffsetX, 960, -960);
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMZOOMOFFSETY") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageZoomOffsetY = std::stoi(splitted[1]);
+                if (CCstatus.CamSensor_id == OV2640_PID)
+                {
+                    CCstatus.ImageZoomOffsetY = clipInt(_ImageZoomOffsetY, 360, -360);
+                }
+                else if (CCstatus.CamSensor_id == OV3660_PID)
+                {
+                    CCstatus.ImageZoomOffsetY = clipInt(_ImageZoomOffsetY, 528, -528);
+                }
+                else if (CCstatus.CamSensor_id == OV5640_PID)
+                {
+                    CCstatus.ImageZoomOffsetY = clipInt(_ImageZoomOffsetY, 720, -720);
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "CAMZOOMSIZE") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                int _ImageZoomSize = std::stoi(splitted[1]);
+                if (CCstatus.CamSensor_id == OV2640_PID)
+                {
+                    CCstatus.ImageZoomSize = clipInt(_ImageZoomSize, 29, 0);
+                }
+                else if (CCstatus.CamSensor_id == OV3660_PID)
+                {
+                    CCstatus.ImageZoomSize = clipInt(_ImageZoomSize, 43, 0);
+                }
+                else if (CCstatus.CamSensor_id == OV5640_PID)
+                {
+                    CCstatus.ImageZoomSize = clipInt(_ImageZoomSize, 59, 0);
+                }
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "LEDINTENSITY") && (splitted.size() > 1))
+        {
+            if (isStringNumeric(splitted[1]))
+            {
+                float ledintensity = std::stof(splitted[1]);
+                Camera.SetLEDIntensity(ledintensity);
+            }
+        }
+
+        else if ((toUpper(splitted[0]) == "DEMO") && (splitted.size() > 1))
+        {
+            CCstatus.DemoMode = alphanumericToBoolean(splitted[1]);
+            if (CCstatus.DemoMode == true)
+            {
+                Camera.useDemoMode();
+            }
+        }
+    }
+
+    Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+    Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+
+    rawImage = new CImageBasis("rawImage");
+    rawImage->CreateEmptyImage(CCstatus.ImageWidth, CCstatus.ImageHeight, 3);
+
+    return true;
+}
+
+ClassFlowTakeImage::ClassFlowTakeImage(std::vector<ClassFlow *> *lfc) : ClassFlowImage(lfc, TAG)
+{
+    imagesLocation = "/log/source";
+    imagesRetention = 5;
+    SetInitialParameter();
+}
+
+string ClassFlowTakeImage::getHTMLSingleStep(string host)
+{
+    string result;
+    result = "Raw Image: <br>\n<img src=\"" + host + "/img_tmp/raw.jpg\">\n";
+    return result;
+}
+
+// wird bei jeder Auswertrunde aufgerufen
+bool ClassFlowTakeImage::doFlow(string zwtime)
+{
+    psram_init_shared_memory_for_take_image_step();
+
+    string logPath = CreateLogFolder(zwtime);
+
+    int flash_duration = (int)(CCstatus.WaitBeforePicture * 1000);
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("ClassFlowTakeImage::doFlow - Before takePictureWithFlash");
+#endif
+
+#ifdef WIFITURNOFF
+    esp_wifi_stop(); // to save power usage and
+#endif
+
+    // wenn die Kameraeinstellungen durch Erstellen eines neuen Referenzbildes verändert wurden, müssen sie neu gesetzt werden
+    if (CFstatus.changedCameraSettings)
+    {
+        Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+        Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+        CFstatus.changedCameraSettings = false;
+    }
+
+    takePictureWithFlash(flash_duration);
+
+#ifdef WIFITURNOFF
+    esp_wifi_start();
+#endif
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("ClassFlowTakeImage::doFlow - After takePictureWithFlash");
+#endif
+
+    LogImage(logPath, "raw", NULL, NULL, zwtime, rawImage);
+
+    RemoveOldLogs();
+
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("ClassFlowTakeImage::doFlow - After RemoveOldLogs");
+#endif
+
+    psram_deinit_shared_memory_for_take_image_step();
+
+    return true;
+}
+
+esp_err_t ClassFlowTakeImage::SendRawJPG(httpd_req_t *req)
+{
+    int flash_duration = (int)(CCstatus.WaitBeforePicture * 1000);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    return Camera.CaptureToHTTP(req, flash_duration);
+}
+
+ImageData *ClassFlowTakeImage::SendRawImage(void)
+{
+    CImageBasis *zw = new CImageBasis("SendRawImage", rawImage);
+    ImageData *id;
+    int flash_duration = (int)(CCstatus.WaitBeforePicture * 1000);
+    Camera.CaptureToBasisImage(zw, flash_duration);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    id = zw->writeToMemoryAsJPG();
+    delete zw;
+    return id;
+}
+
+time_t ClassFlowTakeImage::getTimeImageTaken(void)
+{
+    return TimeImageTaken;
+}
+
+ClassFlowTakeImage::~ClassFlowTakeImage(void)
+{
+    delete rawImage;
+}
--- a/code/components/jomjol_flowcontroll/ClassFlowTakeImage.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowTakeImage.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#ifndef CLASSFFLOWTAKEIMAGE_H
+#define CLASSFFLOWTAKEIMAGE_H
+
+#include "ClassFlowImage.h"
+#include "ClassControllCamera.h"
+#include "../../include/defines.h"
+
+#include <string>
+
+class ClassFlowTakeImage : public ClassFlowImage
+{
+protected:
+    time_t TimeImageTaken;
+    string namerawimage;
+
+    esp_err_t camera_capture(void);
+    void takePictureWithFlash(int flash_duration);
+
+    void SetInitialParameter(void);
+
+public:
+    CImageBasis *rawImage;
+
+    ClassFlowTakeImage(std::vector<ClassFlow *> *lfc);
+
+    bool ReadParameter(FILE *pfile, string &aktparamgraph);
+    bool doFlow(string time);
+    string getHTMLSingleStep(string host);
+    time_t getTimeImageTaken(void);
+    string name() { return "ClassFlowTakeImage"; };
+
+    ImageData *SendRawImage(void);
+    esp_err_t SendRawJPG(httpd_req_t *req);
+
+    ~ClassFlowTakeImage(void);
+};
+
+#endif // CLASSFFLOWTAKEIMAGE_H
--- a/code/components/jomjol_flowcontroll/ClassFlowWebhook.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowWebhook.cpp
@@ -0,0 +1,171 @@
+#ifdef ENABLE_WEBHOOK
+#include <sstream>
+#include "ClassFlowWebhook.h"
+#include "Helper.h"
+#include "connect_wlan.h"
+
+#include "time_sntp.h"
+#include "interface_webhook.h"
+
+#include "ClassFlowPostProcessing.h"
+#include "ClassFlowAlignment.h"
+#include "esp_log.h"
+#include "../../include/defines.h"
+
+#include "ClassLogFile.h"
+
+#include <time.h>
+
+static const char* TAG = "WEBHOOK";
+
+void ClassFlowWebhook::SetInitialParameter(void)
+{
+    uri = "";
+    flowpostprocessing = NULL;
+    flowAlignment = NULL;
+    previousElement = NULL;
+    ListFlowControll = NULL; 
+    disabled = false;
+    WebhookEnable = false;
+    WebhookUploadImg = 0;
+}       
+
+ClassFlowWebhook::ClassFlowWebhook()
+{
+    SetInitialParameter();
+}
+
+ClassFlowWebhook::ClassFlowWebhook(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];
+        }
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowAlignment") == 0)
+        {
+            flowAlignment = (ClassFlowAlignment*) (*ListFlowControll)[i];
+        }
+
+    }
+}
+
+ClassFlowWebhook::ClassFlowWebhook(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];
+        }
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowAlignment") == 0)
+        {
+            flowAlignment = (ClassFlowAlignment*) (*ListFlowControll)[i];
+        }
+    }
+}
+
+
+bool ClassFlowWebhook::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> splitted;
+
+    aktparamgraph = trim(aktparamgraph);
+    printf("akt param: %s\n", aktparamgraph.c_str());
+
+    if (aktparamgraph.size() == 0)
+        if (!this->GetNextParagraph(pfile, aktparamgraph))
+            return false;
+
+    if (toUpper(aktparamgraph).compare("[WEBHOOK]") != 0) 
+        return false;
+
+    
+
+    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
+    {
+        ESP_LOGD(TAG, "while loop reading line: %s", aktparamgraph.c_str());
+        splitted = ZerlegeZeile(aktparamgraph);
+        std::string _param = GetParameterName(splitted[0]);
+            
+        if ((toUpper(_param) == "URI") && (splitted.size() > 1))
+        {
+            this->uri = splitted[1];
+        }
+        if (((toUpper(_param) == "APIKEY")) && (splitted.size() > 1))
+        {
+            this->apikey = splitted[1];
+        }
+        if (((toUpper(_param) == "UPLOADIMG")) && (splitted.size() > 1))
+        {
+            if (toUpper(splitted[1]) == "1")
+            {
+                this->WebhookUploadImg = 1;
+            } else if (toUpper(splitted[1]) == "2")
+            {
+                this->WebhookUploadImg = 2;
+            }
+        }
+    }
+    
+    WebhookInit(uri,apikey);
+    WebhookEnable = true;
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Webhook Enabled for Uri " + uri);
+
+    printf("uri:         %s\n", uri.c_str());   
+    return true;
+}
+
+
+void ClassFlowWebhook::handleMeasurement(string _decsep, string _value)
+{
+    string _digit, _decpos;
+    int _pospunkt = _decsep.find_first_of(".");
+//    ESP_LOGD(TAG, "Name: %s, Pospunkt: %d", _decsep.c_str(), _pospunkt);
+    if (_pospunkt > -1)
+        _digit = _decsep.substr(0, _pospunkt);
+    else
+        _digit = "default";
+    for (int j = 0; j < flowpostprocessing->NUMBERS.size(); ++j)
+    {
+        if (_digit == "default")                        //  Set to default first (if nothing else is set)
+        {
+            flowpostprocessing->NUMBERS[j]->MeasurementV2 = _value;
+        }
+        if (flowpostprocessing->NUMBERS[j]->name == _digit)
+        {
+            flowpostprocessing->NUMBERS[j]->MeasurementV2 = _value;
+        }
+    }
+}
+
+
+bool ClassFlowWebhook::doFlow(string zwtime)
+{
+    if (!WebhookEnable)
+        return true;
+
+    if (flowpostprocessing)
+    {
+        printf("vor sende WebHook");
+        bool numbersWithError = WebhookPublish(flowpostprocessing->GetNumbers());
+
+        #ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+            if ((WebhookUploadImg == 1 || (WebhookUploadImg != 0 && numbersWithError)) && flowAlignment && flowAlignment->AlgROI) {
+                WebhookUploadPic(flowAlignment->AlgROI);
+            }
+        #endif
+    }
+       
+    return true;
+}
+#endif //ENABLE_WEBHOOK
--- a/code/components/jomjol_flowcontroll/ClassFlowWebhook.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowWebhook.h
@@ -0,0 +1,43 @@
+#ifdef ENABLE_WEBHOOK
+
+#pragma once
+
+#ifndef CLASSFWEBHOOK_H
+#define CLASSFWEBHOOK_H
+
+#include "ClassFlow.h"
+
+#include "ClassFlowPostProcessing.h"
+#include "ClassFlowAlignment.h"
+
+#include <string>
+
+class ClassFlowWebhook :
+    public ClassFlow
+{
+protected:
+    std::string uri, apikey;
+	ClassFlowPostProcessing* flowpostprocessing;
+    ClassFlowAlignment* flowAlignment;
+
+    bool WebhookEnable;
+    int WebhookUploadImg;
+
+    void SetInitialParameter(void); 
+
+    void handleFieldname(string _decsep, string _value);   
+    void handleMeasurement(string _decsep, string _value);
+
+
+public:
+    ClassFlowWebhook();
+    ClassFlowWebhook(std::vector<ClassFlow*>* lfc);
+    ClassFlowWebhook(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
+
+    bool ReadParameter(FILE* pfile, string& aktparamgraph);
+    bool doFlow(string time);
+    string name(){return "ClassFlowWebhook";};
+};
+
+#endif //CLASSFWEBHOOK_H
+#endif //ENABLE_WEBHOOK
--- a/code/components/jomjol_flowcontroll/MainFlowControl.cpp
+++ b/code/components/jomjol_flowcontroll/MainFlowControl.cpp
--- a/code/components/jomjol_flowcontroll/MainFlowControl.h
+++ b/code/components/jomjol_flowcontroll/MainFlowControl.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#ifndef MAINFLOWCONTROL_H
+#define MAINFLOWCONTROL_H
+
+#include <esp_log.h>
+#include <string>
+
+#include <esp_http_server.h>
+#include "CImageBasis.h"
+#include "ClassFlowControll.h"
+#include "openmetrics.h"
+
+typedef struct
+{
+    uint16_t CamSensor_id;
+
+    framesize_t ImageFrameSize = FRAMESIZE_VGA; // 0 - 10
+    gainceiling_t ImageGainceiling;             // Image gain (GAINCEILING_x2, x4, x8, x16, x32, x64 or x128)
+
+    int ImageQuality;    // 0 - 63
+    int ImageBrightness; // (-2 to 2) - set brightness
+    int ImageContrast;   //-2 - 2
+    int ImageSaturation; //-2 - 2
+    int ImageSharpness;  //-2 - 2
+    bool ImageAutoSharpness;
+    int ImageSpecialEffect; // 0 - 6
+    int ImageWbMode;        // 0 to 4 - if awb_gain enabled (0 - Auto, 1 - Sunny, 2 - Cloudy, 3 - Office, 4 - Home)
+    int ImageAwb;           // white balance enable (0 or 1)
+    int ImageAwbGain;       // Auto White Balance enable (0 or 1)
+    int ImageAec;           // auto exposure off (1 or 0)
+    int ImageAec2;          // automatic exposure sensor  (0 or 1)
+    int ImageAeLevel;       // auto exposure levels (-2 to 2)
+    int ImageAecValue;      // set exposure manually  (0-1200)
+    int ImageAgc;           // auto gain off (1 or 0)
+    int ImageAgcGain;       // set gain manually (0 - 30)
+    int ImageBpc;           // black pixel correction
+    int ImageWpc;           // white pixel correction
+    int ImageRawGma;        // (1 or 0)
+    int ImageLenc;          // lens correction (1 or 0)
+    int ImageHmirror;       // (0 or 1) flip horizontally
+    int ImageVflip;         // Invert image (0 or 1)
+    int ImageDcw;           // downsize enable (1 or 0)
+
+    int ImageDenoiseLevel; // The OV2640 does not support it, OV3660 and OV5640 (0 to 8)
+
+    int ImageWidth;
+    int ImageHeight;
+
+    int ImageLedIntensity;
+
+    bool ImageZoomEnabled;
+    int ImageZoomOffsetX;
+    int ImageZoomOffsetY;
+    int ImageZoomSize;
+
+    int WaitBeforePicture;
+    bool isImageSize;
+
+    bool CameraInitSuccessful;
+    bool changedCameraSettings;
+    bool DemoMode;
+    bool SaveAllFiles;
+} camera_flow_config_temp_t;
+
+extern camera_flow_config_temp_t CFstatus;
+extern ClassFlowControll flowctrl;
+
+esp_err_t setCCstatusToCFstatus(void); // CCstatus >>> CFstatus
+esp_err_t setCFstatusToCCstatus(void); // CFstatus >>> CCstatus
+esp_err_t setCFstatusToCam(void);      // CFstatus >>> Kamera
+
+void register_server_main_flow_task_uri(httpd_handle_t server);
+
+void CheckIsPlannedReboot(void);
+bool getIsPlannedReboot(void);
+
+void InitializeFlowTask(void);
+void DeleteMainFlowTask(void);
+bool isSetupModusActive(void);
+
+int getCountFlowRounds(void);
+
+#ifdef ENABLE_MQTT
+esp_err_t MQTTCtrlFlowStart(std::string _topic);
+#endif // ENABLE_MQTT
+
+esp_err_t GetRawJPG(httpd_req_t *req);
+esp_err_t GetJPG(std::string _filename, httpd_req_t *req);
+
+#endif // MAINFLOWCONTROL_H
--- a/code/components/jomjol_helper/CMakeLists.txt
+++ b/code/components/jomjol_helper/CMakeLists.txt
@@ -0,0 +1,7 @@
+FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)
+
+idf_component_register(SRCS ${app_sources}
+                    INCLUDE_DIRS "."
+                    REQUIRES esp_timer esp-tflite-micro jomjol_logfile fatfs sdmmc vfs)
+
+
--- a/code/components/jomjol_helper/Helper.cpp
+++ b/code/components/jomjol_helper/Helper.cpp
--- a/code/components/jomjol_helper/Helper.h
+++ b/code/components/jomjol_helper/Helper.h
@@ -0,0 +1,112 @@
+#pragma once
+
+#ifndef HELPER_H
+#define HELPER_H
+
+#include <string>
+#include <fstream>
+#include <vector>
+
+#include "sdmmc_cmd.h"
+
+using namespace std;
+
+std::string FormatFileName(std::string input);
+std::size_t file_size(const std::string& file_name);
+void FindReplace(std::string& line, std::string& oldString, std::string& newString);
+
+bool CopyFile(string input, string output);
+bool DeleteFile(string fn);
+bool RenameFile(string from, string to);
+bool MakeDir(std::string _what);
+bool FileExists(string filename);
+
+string RundeOutput(double _in, int _anzNachkomma);
+
+size_t findDelimiterPos(string input, string delimiter);
+//string trim(string istring);
+string trim(string istring, string adddelimiter = "");
+bool ctype_space(const char c, string adddelimiter);
+
+string getFileType(string filename);
+string getFileFullFileName(string filename);
+string getDirectory(string filename);
+
+int mkdir_r(const char *dir, const mode_t mode);
+int removeFolder(const char* folderPath, const char* logTag);
+
+string toLower(string in);
+string toUpper(string in);
+
+float temperatureRead();
+
+time_t addDays(time_t startTime, int days);
+
+void memCopyGen(uint8_t* _source, uint8_t* _target, int _size);
+
+std::vector<string> HelperZerlegeZeile(std::string input, std::string _delimiter);
+std::vector<std::string> ZerlegeZeile(std::string input, std::string delimiter = " =, \t");
+
+///////////////////////////
+size_t getInternalESPHeapSize();
+size_t getESPHeapSize();
+string getESPHeapInfo();
+
+/////////////////////////////
+string getSDCardPartitionSize();
+string getSDCardFreePartitionSpace();
+string getSDCardPartitionAllocationSize();
+
+void SaveSDCardInfo(sdmmc_card_t* card);
+string SDCardParseManufacturerIDs(int);
+string getSDCardManufacturer();
+string getSDCardName();
+string getSDCardCapacity();
+string getSDCardSectorSize();
+
+string getMac(void);
+
+/* Error bit fields
+   One bit per error
+   Make sure it matches https://jomjol.github.io/AI-on-the-edge-device-docs/Error-Codes */
+enum SystemStatusFlag_t {          // One bit per error
+    // First Byte
+    SYSTEM_STATUS_PSRAM_BAD         = 1 << 0, //  1, Critical Error
+    SYSTEM_STATUS_HEAP_TOO_SMALL    = 1 << 1, //  2, Critical Error
+    SYSTEM_STATUS_CAM_BAD           = 1 << 2, //  4, Critical Error
+    SYSTEM_STATUS_SDCARD_CHECK_BAD  = 1 << 3, //  8, Critical Error
+    SYSTEM_STATUS_FOLDER_CHECK_BAD  = 1 << 4, //  16, Critical Error
+
+    // Second Byte
+    SYSTEM_STATUS_CAM_FB_BAD        = 1 << (0+8), //  8, Flow still might work
+    SYSTEM_STATUS_NTP_BAD           = 1 << (1+8), //  9, Flow will work but time will be wrong
+};
+
+void setSystemStatusFlag(SystemStatusFlag_t flag);
+void clearSystemStatusFlag(SystemStatusFlag_t flag);
+int getSystemStatus(void);
+bool isSetSystemStatusFlag(SystemStatusFlag_t flag);
+
+time_t getUpTime(void);
+string getResetReason(void);
+std::string getFormatedUptime(bool compact);
+
+const char* get404(void);
+
+std::string UrlDecode(const std::string& value);
+
+void replaceAll(std::string& s, const std::string& toReplace, const std::string& replaceWith);
+bool replaceString(std::string& s, std::string const& toReplace, std::string const& replaceWith);
+bool replaceString(std::string& s, std::string const& toReplace, std::string const& replaceWith, bool logIt);
+bool isInString(std::string& s, std::string const& toFind);
+
+bool isStringNumeric(std::string &input);
+bool isStringAlphabetic(std::string &input);
+bool isStringAlphanumeric(std::string &input);
+bool alphanumericToBoolean(std::string &input);
+
+int clipInt(int input, int high, int low);
+bool numericStrToBool(std::string input);
+bool stringToBoolean(std::string input);
+
+#endif //HELPER_H
--- a/code/components/jomjol_helper/esp_sys.cpp
+++ b/code/components/jomjol_helper/esp_sys.cpp
@@ -0,0 +1,179 @@
+#include "../../include/defines.h"
+
+#ifdef DEBUG_ENABLE_SYSINFO
+
+#include "esp_sys.h"
+#include "esp_chip_info.h"
+
+#include <string>
+
+
+#include "esp_chip_info.h"
+
+
+void Restart() {
+    esp_restart();
+}
+
+//source : https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/misc_system_api.html#_CPPv416esp_chip_model_t
+
+//https://github.com/espressif/esp-idf/blob/8464186e67e34b417621df6b6f1f289a6c60b859/components/esp_hw_support/include/esp_chip_info.h
+/*
+typedef enum {
+    CHIP_ESP32  = 1, //!< ESP32
+    CHIP_ESP32S2 = 2, //!< ESP32-S2
+    CHIP_ESP32S3 = 9, //!< ESP32-S3
+    CHIP_ESP32C3 = 5, //!< ESP32-C3
+    CHIP_ESP32H4 = 6, //!< ESP32-H4
+    CHIP_ESP32C2 = 12, //!< ESP32-C2
+    CHIP_ESP32C6 = 13, //!< ESP32-C6
+    CHIP_ESP32H2 = 16, //!< ESP32-H2
+    CHIP_POSIX_LINUX = 999, //!< The code is running on POSIX/Linux simulator
+} esp_chip_model_t;
+*/
+
+char* GetChipModel(){
+    esp_chip_info_t chipInfo;
+    esp_chip_info(&chipInfo);
+    switch((int)chipInfo.model) {
+        case 0 : return (char*)"ESP8266";
+        case (int)esp_chip_model_t::CHIP_ESP32 : return (char*)"ESP32";
+#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 0, 0)        
+        case (int)esp_chip_model_t::CHIP_ESP32S2 : return (char*)"ESP32-S2";
+        case (int)esp_chip_model_t::CHIP_ESP32S3 : return (char*)"ESP32-S3";
+        case (int)esp_chip_model_t::CHIP_ESP32C3 : return (char*)"ESP32-C3";
+        case 6 : return (char*)"ESP32-H4";
+        case 12 : return (char*)"ESP32-C2";
+        case 13 : return (char*)"ESP32-C6";
+        //case (int)esp_chip_model_t::CHIP_ESP32H4 : return (char*)"ESP32-H4";
+        //case (int)esp_chip_model_t::CHIP_ESP32C2 : return (char*)"ESP32-C2";
+        //case (int)esp_chip_model_t::CHIP_ESP32C6 : return (char*)"ESP32-C6";
+        //case (int)esp_chip_model_t::CHIP_ESP32H2 : return (char*)"ESP32-H2";
+        case 16 : return (char*)"ESP32-H2";
+        //case (int)esp_chip_model_t::CHIP_POSIX_LINUX : return (char*)"CHIP_POSIX_LINUX";
+
+#endif
+    }
+    return (char*)"Chip Unknown";
+}
+
+uint8_t GetChipCoreCount() {
+    esp_chip_info_t chipInfo;
+    esp_chip_info(&chipInfo);
+    return chipInfo.cores;
+}
+
+uint16_t GetChipRevision() {
+    esp_chip_info_t chipInfo;
+    esp_chip_info(&chipInfo);
+    return chipInfo.revision;
+}
+
+uint32_t  GetChipfeatures() {
+    esp_chip_info_t chipInfo;
+    esp_chip_info(&chipInfo);
+    return chipInfo.features;
+}
+
+
+uint32_t GetFreeHeap() {
+    return esp_get_free_heap_size();
+}
+
+uint32_t GetLeastHeapFreeSinceBoot() {
+    return esp_get_minimum_free_heap_size();
+}
+
+
+std::string get_device_info()
+{
+    esp_chip_info_t chip_info;
+    esp_chip_info(&chip_info);
+    
+    std::string espInfoResultStr = "";
+    char aMsgBuf[40];
+
+    espInfoResultStr += "Device Info:";
+    espInfoResultStr += "---------------\n";
+    espInfoResultStr += "Chip Model: " + std::string(GetChipModel()) +"\n";
+    sprintf(aMsgBuf,"Chip Revision: %d\n", chip_info.revision);
+    espInfoResultStr += std::string(aMsgBuf);
+    sprintf(aMsgBuf,"CPU Cores: %d\n", chip_info.cores);
+    espInfoResultStr += std::string(aMsgBuf);
+    sprintf(aMsgBuf,"Flash Memory: %dMB\n", spi_flash_get_chip_size()/(1024*1024));
+    espInfoResultStr += std::string(aMsgBuf);
+    if(chip_info.features & CHIP_FEATURE_WIFI_BGN)
+        //espInfoResultStr += "Base MAC: " + std::string(getMac()) +"\n";
+        espInfoResultStr += "ESP-IDF version: " + std::string(esp_get_idf_version()) +"\n";
+    if((chip_info.features & CHIP_FEATURE_WIFI_BGN) || (chip_info.features & CHIP_FEATURE_BT) ||
+       (chip_info.features & CHIP_FEATURE_BLE) || (chip_info.features & CHIP_FEATURE_EMB_FLASH))
+    {
+        espInfoResultStr += "Characteristics:\n";
+        if(chip_info.features & CHIP_FEATURE_WIFI_BGN)
+            espInfoResultStr += "    WiFi 2.4GHz\n";
+        if(chip_info.features & CHIP_FEATURE_BT)
+            espInfoResultStr += "    Bluetooth Classic\n";
+        if(chip_info.features & CHIP_FEATURE_BLE)
+            espInfoResultStr += "    Bluetooth Low Energy\n";
+        if(chip_info.features & CHIP_FEATURE_EMB_FLASH)
+            espInfoResultStr += "    Embedded Flash memory\n";
+        else
+           espInfoResultStr += "    External Flash memory\n";
+    }
+
+    #ifdef USE_HIMEM_IF_AVAILABLE
+        sprintf(aMsgBuf,"spiram size %u\n", esp_psram_get_size());
+        espInfoResultStr += std::string(aMsgBuf);
+        sprintf(aMsgBuf,"himem free %u\n", esp_himem_get_free_size());
+        espInfoResultStr += std::string(aMsgBuf);
+        sprintf(aMsgBuf,"himem phys %u\n", esp_himem_get_phys_size());
+        espInfoResultStr += std::string(aMsgBuf);
+        sprintf(aMsgBuf,"himem reserved %u\n", esp_himem_reserved_area_size());
+        espInfoResultStr += std::string(aMsgBuf);
+    #endif
+    
+    return espInfoResultStr; 
+}
+
+
+size_t getFreeMemoryInternal(){ //Current Free Memory
+    return heap_caps_get_free_size(MALLOC_CAP_8BIT) - heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
+}
+
+size_t getFreeMemorySPIRAM(){ //Current Free Memory
+    return heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
+}
+
+
+size_t getLargestFreeBlockInternal(){ //Largest Free Block
+    return heap_caps_get_largest_free_block(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
+}
+
+size_t getLargestFreeBlockSPIRAM(){ //Largest Free Block
+    return heap_caps_get_largest_free_block(MALLOC_CAP_SPIRAM);
+}
+
+
+size_t getMinEverFreeMemInternal(){ //Min. Ever Free Size
+    return heap_caps_get_minimum_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
+}
+
+size_t getMinEverFreeMemSPIRAM(){ //Min. Ever Free Size
+    return heap_caps_get_minimum_free_size(MALLOC_CAP_SPIRAM);
+}
+
+#ifdef USE_HIMEM_IF_AVAILABLE
+    size_t getHimemTotSpace(){ 
+        return esp_himem_get_phys_size();
+    }
+
+    size_t getHimemFreeSpace(){ 
+        return esp_himem_get_free_size();
+    }
+
+    size_t getHimemReservedArea(){ 
+        return esp_himem_reserved_area_size();
+    }
+#endif
+
+#endif //DEBUG_ENABLE_SYSINFO
--- a/code/components/jomjol_helper/esp_sys.h
+++ b/code/components/jomjol_helper/esp_sys.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "../../include/defines.h"
+
+#ifdef DEBUG_ENABLE_SYSINFO
+
+#ifndef ESP_SYS_H
+#define ESP_SYS_H
+
+
+#include <string>
+
+
+// Device libraries (ESP-IDF)
+#include <esp_system.h>
+#include <esp_spi_flash.h>
+#include <esp_heap_caps.h>
+
+// for esp_psram_get_size
+extern "C" {
+    #include "esp_psram.h"
+    #ifdef USE_HIMEM_IF_AVAILABLE
+        #include <esp32/himem.h>
+    #endif
+}
+
+
+
+    void Restart();
+    char *GetChipModel();
+    uint8_t GetChipCoreCount();
+    uint16_t GetChipRevision();
+    uint32_t  GetChipfeatures();
+    uint32_t GetFreeHeap();
+    uint32_t GetLeastHeapFreeSinceBoot();
+
+    std::string get_device_info();
+
+    size_t getFreeMemoryInternal();
+    size_t getFreeMemorySPIRAM();
+    size_t getLargestFreeBlockInternal();
+    size_t getLargestFreeBlockSPIRAM();
+    size_t getMinEverFreeMemInternal();
+    size_t getMinEverFreeMemSPIRAM();
+    #ifdef USE_HIMEM_IF_AVAILABLE
+        size_t getHimemTotSpace();
+        size_t getHimemFreeSpace();
+        size_t getHimemReservedArea();
+    #endif
+
+
+#endif //ESP_SYS_H
+
+#endif // DEBUG_ENABLE_SYSINFO
--- a/code/components/jomjol_helper/himem_memory_check.cpp
+++ b/code/components/jomjol_helper/himem_memory_check.cpp
@@ -0,0 +1,115 @@
+
+// need [env:esp32cam-dev-himem]
+//CONFIG_SPIRAM_BANKSWITCH_ENABLE=y
+//CONFIG_SPIRAM_BANKSWITCH_RESERVE=4
+
+
+
+#include "../../include/defines.h"
+
+#ifdef DEBUG_HIMEM_MEMORY_CHECK
+
+#include "himem_memory_check.h"
+
+//source adapted from : https://github.com/espressif/esp-idf/blob/master/examples/system/himem/main/himem_example_main.c
+
+
+//Fill memory with pseudo-random data generated from the given seed.
+//Fills the memory in 32-bit words for speed.
+static void fill_mem_seed(int seed, void *mem, int len)
+{
+    uint32_t *p = (uint32_t *)mem;
+    unsigned int rseed = seed ^ 0xa5a5a5a5;
+    for (int i = 0; i < len / 4; i++) {
+        *p++ = rand_r(&rseed);
+    }
+}
+
+//Check the memory filled by fill_mem_seed. Returns true if the data matches the data
+//that fill_mem_seed wrote (when given the same seed).
+//Returns true if there's a match, false when the region differs from what should be there.
+static bool check_mem_seed(int seed, void *mem, int len, int phys_addr)
+{
+    uint32_t *p = (uint32_t *)mem;
+    unsigned int rseed = seed ^ 0xa5a5a5a5;
+    for (int i = 0; i < len / 4; i++) {
+        uint32_t ex = rand_r(&rseed);
+        if (ex != *p) {
+            //printf("check_mem_seed: %x has 0x%08"PRIx32" expected 0x%08"PRIx32"\n", phys_addr+((char*)p-(char*)mem), *p, ex);
+            return false;
+        }
+        p++;
+    }
+    return true;
+}
+
+//Allocate a himem region, fill it with data, check it and release it.
+static bool test_region(int check_size, int seed)
+{
+    esp_himem_handle_t mh; //Handle for the address space we're using
+    esp_himem_rangehandle_t rh; //Handle for the actual RAM.
+    bool ret = true;
+
+    //Allocate the memory we're going to check.
+    ESP_ERROR_CHECK(esp_himem_alloc(check_size, &mh));
+    //Allocate a block of address range
+    ESP_ERROR_CHECK(esp_himem_alloc_map_range(ESP_HIMEM_BLKSZ, &rh));
+    for (int i = 0; i < check_size; i += ESP_HIMEM_BLKSZ) {
+        uint32_t *ptr = NULL;
+        //Map in block, write pseudo-random data, unmap block.
+        ESP_ERROR_CHECK(esp_himem_map(mh, rh, i, 0, ESP_HIMEM_BLKSZ, 0, (void**)&ptr));
+        fill_mem_seed(i ^ seed, ptr, ESP_HIMEM_BLKSZ); //
+        ESP_ERROR_CHECK(esp_himem_unmap(rh, ptr, ESP_HIMEM_BLKSZ));
+    }
+    vTaskDelay(5); //give the OS some time to do things so the task watchdog doesn't bark
+    for (int i = 0; i < check_size; i += ESP_HIMEM_BLKSZ) {
+        uint32_t *ptr;
+        //Map in block, check against earlier written pseudo-random data, unmap block.
+        ESP_ERROR_CHECK(esp_himem_map(mh, rh, i, 0, ESP_HIMEM_BLKSZ, 0, (void**)&ptr));
+        if (!check_mem_seed(i ^ seed, ptr, ESP_HIMEM_BLKSZ, i)) {
+            //printf("Error in block %d\n", i / ESP_HIMEM_BLKSZ);
+            ret = false;
+        }
+        ESP_ERROR_CHECK(esp_himem_unmap(rh, ptr, ESP_HIMEM_BLKSZ));
+        if (!ret) break; //don't check rest of blocks if error occurred
+    }
+    //Okay, all done!
+    ESP_ERROR_CHECK(esp_himem_free(mh));
+    ESP_ERROR_CHECK(esp_himem_free_map_range(rh));
+    return ret;
+}
+
+
+std::string himem_memory_check()
+{
+    size_t memcnt=esp_himem_get_phys_size();
+    size_t memfree=esp_himem_get_free_size();
+
+	std::string espInfoResultStr = "";
+    char aMsgBuf[40];
+
+	espInfoResultStr += "Running HIMEM memory check";
+
+	sprintf(aMsgBuf,"Himem has %dKiB of memory", (int)memcnt/1024);
+	espInfoResultStr += std::string(aMsgBuf);
+
+	sprintf(aMsgBuf,"%dKiB of which is free", (int)memfree/1024);
+	espInfoResultStr += std::string(aMsgBuf);
+
+	espInfoResultStr += "\n please wait ....\n";
+
+	//running memory checks
+	//assert(test_region(memfree, 0xaaaa));
+
+	if(test_region(memfree, 0xaaaa)) {
+		espInfoResultStr += "Himem check Failed!\n";
+	} else {
+		espInfoResultStr += "Himem check Done!\n";
+	}
+
+	return espInfoResultStr; 
+
+}
+
+
+#endif // DEBUG_HIMEM_MEMORY_CHECK
--- a/code/components/jomjol_helper/himem_memory_check.h
+++ b/code/components/jomjol_helper/himem_memory_check.h
@@ -0,0 +1,41 @@
+
+// need [env:esp32cam-dev-himem]
+//CONFIG_SPIRAM_BANKSWITCH_ENABLE=y
+//CONFIG_SPIRAM_BANKSWITCH_RESERVE=4
+
+#pragma once
+
+#include "../../include/defines.h"
+
+#ifdef DEBUG_HIMEM_MEMORY_CHECK
+
+#ifndef HIMEM_MEMORY_CHECK_H
+#define HIMEM_MEMORY_CHECK_H
+
+
+
+//source : //source : https://github.com/espressif/esp-idf/blob/master/examples/system/himem/main/himem_example_main.c
+
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "esp_system.h"
+#include "esp_heap_caps.h"
+#include "esp32/himem.h"
+
+#include <string>
+#include "esp32/himem.h"
+
+
+std::string himem_memory_check();
+
+#endif //HIMEM_MEMORY_CHECK_H
+
+#endif // DEBUG_HIMEM_MEMORY_CHECK
--- a/code/components/jomjol_helper/perfmon.c
+++ b/code/components/jomjol_helper/perfmon.c
@@ -0,0 +1,87 @@
+//source : https://github.com/Carbon225/esp32-perfmon
+
+#include "../../include/defines.h"
+
+/*
+ESP32 CPU usage monitor
+Gives you a rough idea of how the Xtensa cores are utilized.
+
+Works by attaching idle hooks and measuring how often they get called. The core usage is calculated: usage% = idle ticks since last measurement / expected idle ticks if core were idle * 100%. The expected idle tick count was measured by running an empty program.
+
+Limitations:
+Should only be used for user information, not in logic that needs accurate values
+New IDF versions could optimize performance and therefore introduce an error to usage estimation.
+When one core is at 100% the other might report a negative value
+
+Usage:
+#include "perfmon.h"
+Call perfmon_start() once
+
+*/
+
+#ifdef DEBUG_ENABLE_PERFMON
+
+#include "perfmon.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_freertos_hooks.h"
+#include "sdkconfig.h"
+
+#include "esp_log.h"
+static const char *TAG = "perfmon";
+
+static uint64_t idle0Calls = 0;
+static uint64_t idle1Calls = 0;
+
+#if defined(CONFIG_ESP32_DEFAULT_CPU_FREQ_240)
+static const uint64_t MaxIdleCalls = 1855000;
+#elif defined(CONFIG_ESP32_DEFAULT_CPU_FREQ_160)
+static const uint64_t MaxIdleCalls = 1233100;
+#else
+#error "Unsupported CPU frequency"
+#endif
+
+static bool idle_task_0()
+{
+	idle0Calls += 1;
+	return false;
+}
+
+static bool idle_task_1()
+{
+	idle1Calls += 1;
+	return false;
+}
+
+static void perfmon_task(void *args)
+{
+	while (1)
+	{
+		float idle0 = idle0Calls;
+		float idle1 = idle1Calls;
+		idle0Calls = 0;
+		idle1Calls = 0;
+
+		int cpu0 = 100.f -  idle0 / MaxIdleCalls * 100.f;
+		int cpu1 = 100.f - idle1 / MaxIdleCalls * 100.f;
+
+		ESP_LOGI(TAG, "Core 0 at %d%%", cpu0);
+		ESP_LOGI(TAG, "Core 1 at %d%%", cpu1);
+		// TODO configurable delay
+		vTaskDelay(5000 / portTICK_PERIOD_MS);
+	}
+	vTaskDelete(NULL);
+}
+
+esp_err_t perfmon_start()
+{
+	ESP_ERROR_CHECK(esp_register_freertos_idle_hook_for_cpu(idle_task_0, 0));
+	ESP_ERROR_CHECK(esp_register_freertos_idle_hook_for_cpu(idle_task_1, 1));
+	// TODO calculate optimal stack size
+	xTaskCreate(perfmon_task, "perfmon", 2048, NULL, 1, NULL);
+	return ESP_OK;
+}
+
+
+#endif // DEBUG_ENABLE_PERFMON
--- a/code/components/jomjol_helper/perfmon.h
+++ b/code/components/jomjol_helper/perfmon.h
@@ -0,0 +1,24 @@
+
+#include "../../include/defines.h"
+
+#ifdef DEBUG_ENABLE_PERFMON
+
+#ifndef COMPONENTS_PERFMON_INCLUDE_PERFMON_H_
+#define COMPONENTS_PERFMON_INCLUDE_PERFMON_H_
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp_err.h"
+
+esp_err_t perfmon_start();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* COMPONENTS_PERFMON_INCLUDE_PERFMON_H_ */
+
+#endif //DEBUG_ENABLE_PERFMON 
--- a/code/components/jomjol_helper/psram.cpp
+++ b/code/components/jomjol_helper/psram.cpp
@@ -0,0 +1,211 @@
+#include "ClassLogFile.h"
+#include "../../include/defines.h"
+#include "psram.h"
+
+static const char* TAG = "PSRAM";
+
+using namespace std;
+
+
+void *shared_region = NULL;
+uint32_t allocatedBytesForSTBI = 0;
+std::string sharedMemoryInUseFor = "";
+
+
+/** Reserve a large block in the PSRAM which will be shared between the different steps.
+ * Each step uses it differently but only wiuthin itself. */
+bool reserve_psram_shared_region(void) {
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Allocating shared PSRAM region (" + 
+            std::to_string(TENSOR_ARENA_SIZE + MAX_MODEL_SIZE) + " bytes)...");
+    shared_region = malloc_psram_heap("Shared PSRAM region", TENSOR_ARENA_SIZE + MAX_MODEL_SIZE, 
+            MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
+
+    if (shared_region == NULL) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to allocating shared PSRAM region!");
+        return false;
+    }
+    else {
+        return true;
+    }
+}
+
+
+
+/*******************************************************************
+ * Memory used in Take Image (STBI)
+ *******************************************************************/
+bool psram_init_shared_memory_for_take_image_step(void) {
+    if (sharedMemoryInUseFor != "") {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Shared memory in PSRAM already in use for " + sharedMemoryInUseFor + "!");
+        return false;
+    }
+
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Init shared memory for step 'Take Image' (STBI buffers)");
+    allocatedBytesForSTBI = 0;
+    sharedMemoryInUseFor = "TakeImage";
+
+    return true;
+}
+
+
+void psram_deinit_shared_memory_for_take_image_step(void) {
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Deinit shared memory for step 'Take Image' (STBI buffers)");
+    allocatedBytesForSTBI = 0;
+    sharedMemoryInUseFor = "";
+}
+
+
+void *psram_reserve_shared_stbi_memory(size_t size) {
+    /* Only large buffers should be placed in the shared PSRAM 
+     * If we also place all smaller STBI buffers here, we get artefacts for some reasons. */
+    if (size >= 100000) {
+        if ((allocatedBytesForSTBI + size) > TENSOR_ARENA_SIZE + MAX_MODEL_SIZE) { // Check if it still fits in the shared region
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Shared memory in PSRAM too small (STBI) to fit additional " + 
+                    std::to_string(size) + " bytes! Available: " + std::to_string(TENSOR_ARENA_SIZE + MAX_MODEL_SIZE - allocatedBytesForSTBI) + " bytes!");
+
+            return NULL;
+        }
+        
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Allocating memory (" + std::to_string(size) + " bytes) for STBI (use shared memory in PSRAM)...");
+        allocatedBytesForSTBI += size;
+        return (uint8_t *)shared_region + allocatedBytesForSTBI - size;
+    }
+    else { // Normal PSRAM
+        return malloc_psram_heap("STBI", size, MALLOC_CAP_SPIRAM);
+    }
+}
+
+
+void *psram_reallocate_shared_stbi_memory(void *ptr, size_t newsize) {
+    char buf[20];
+    sprintf(buf, "%p", ptr);
+    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "STBI requested realloc for " + std::string(buf) + " but this is currently unsupported!");
+    return NULL;
+}
+
+
+void psram_free_shared_stbi_memory(void *p) {
+    if ((p >= shared_region) && (p <= ((uint8_t *)shared_region + allocatedBytesForSTBI))) { // was allocated inside the shared memory
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Part of shared memory used for STBI (PSRAM, part of shared memory) is free again");
+    }
+    else { // Normal PSRAM
+        free_psram_heap("STBI", p);
+    }
+}
+
+
+
+/*******************************************************************
+ * Memory used in Aligning Step 
+ * During this step we only use the shared part of the PSRAM
+ * for the tmpImage. 
+ *******************************************************************/
+void *psram_reserve_shared_tmp_image_memory(void) {
+    if (sharedMemoryInUseFor != "") {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Shared memory in PSRAM already in use for " + sharedMemoryInUseFor + "!");
+        return NULL;
+    }
+
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Allocating tmpImage (" + std::to_string(IMAGE_SIZE) + " bytes, use shared memory in PSRAM)...");
+    sharedMemoryInUseFor = "Aligning";
+    return shared_region; // Use 1th part of the shared memory for the tmpImage (only user)
+}
+
+
+void psram_free_shared_temp_image_memory(void) {
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Shared memory used for tmpImage (PSRAM, part of shared memory) is free again");
+    sharedMemoryInUseFor = "";
+}
+
+
+
+/*******************************************************************
+ * Memory used in Digitization Steps
+ * During this step we only use the shared part of the PSRAM for the
+ * Tensor Arena and one of the Models.
+ * The shared memory is large enough for the largest model and the
+ * Tensor Arena. Therefore we do not need to monitor the usage.
+ *******************************************************************/
+void *psram_get_shared_tensor_arena_memory(void) {
+    if ((sharedMemoryInUseFor == "") || (sharedMemoryInUseFor == "Digitization_Model")) {
+        sharedMemoryInUseFor = "Digitization_Tensor";
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Allocating Tensor Arena (" + std::to_string(TENSOR_ARENA_SIZE) + " bytes, use shared memory in PSRAM)...");
+        return shared_region; // Use 1th part of the shared memory for Tensor
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Shared memory in PSRAM already in use for " + sharedMemoryInUseFor + "!");
+        return NULL;
+    }
+}
+
+
+void *psram_get_shared_model_memory(void) {
+    if ((sharedMemoryInUseFor == "") || (sharedMemoryInUseFor == "Digitization_Tensor")) {
+        sharedMemoryInUseFor = "Digitization_Model";
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Allocating Model memory (" + std::to_string(MAX_MODEL_SIZE) + " bytes, use shared memory in PSRAM)...");
+        return (uint8_t *)shared_region + TENSOR_ARENA_SIZE; // Use 2nd part of the shared memory (after Tensor Arena) for the model
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Shared memory in PSRAM already in use for " + sharedMemoryInUseFor + "!");
+        return NULL;
+    }
+}
+
+
+void psram_free_shared_tensor_arena_and_model_memory(void) {
+    sharedMemoryInUseFor = "";
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Shared memory used for Tensor Arena and model (PSRAM, part of shared memory) is free again");
+}
+
+
+
+/*******************************************************************
+ * General
+ *******************************************************************/
+void *malloc_psram_heap(std::string name, size_t size, uint32_t caps) {
+	void *ptr;
+
+	ptr = heap_caps_malloc(size, caps);
+    if (ptr != NULL) {
+	    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Allocated " + to_string(size) + " bytes in PSRAM for '" + name + "'");
+	}
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to allocate " + to_string(size) + " bytes in PSRAM for '" + name + "'!");
+    }
+
+	return ptr;
+}
+
+
+void *realloc_psram_heap(std::string name, void *ptr, size_t size, uint32_t caps) {
+	ptr = heap_caps_realloc(ptr, size, caps);
+    if (ptr != NULL) {
+	    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Reallocated " + to_string(size) + " bytes in PSRAM for '" + name + "'");
+	}
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to reallocate " + to_string(size) + " bytes in PSRAM for '" + name + "'!");
+    }
+
+	return ptr;
+}
+
+
+void *calloc_psram_heap(std::string name, size_t n, size_t size, uint32_t caps) {
+	void *ptr;
+
+	ptr = heap_caps_calloc(n, size, caps);
+    if (ptr != NULL) {
+	    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Allocated " + to_string(size) + " bytes in PSRAM for '" + name + "'");
+	}
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to allocate " + to_string(size) + " bytes in PSRAM for '" + name + "'!");
+    }
+
+	return ptr;
+}
+
+
+void free_psram_heap(std::string name, void *ptr) {
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Freeing memory in PSRAM used for '" + name + "'...");
+    heap_caps_free(ptr);
+}
--- a/code/components/jomjol_helper/psram.h
+++ b/code/components/jomjol_helper/psram.h
@@ -0,0 +1,35 @@
+#pragma once
+#ifndef PSRAM_h
+#define PSRAM_h
+
+#include "esp_heap_caps.h"
+
+
+bool reserve_psram_shared_region(void);
+
+
+/* Memory used in Take Image Step */
+bool psram_init_shared_memory_for_take_image_step(void);
+void psram_deinit_shared_memory_for_take_image_step(void);
+void *psram_reserve_shared_stbi_memory(size_t size);
+void *psram_reallocate_shared_stbi_memory(void *ptr, size_t newsize);
+void psram_free_shared_stbi_memory(void *p);
+
+
+/* Memory used in Aligning Step */
+void *psram_reserve_shared_tmp_image_memory(void);
+void psram_free_shared_temp_image_memory(void);
+
+/* Memory used in Digitization Steps */
+void *psram_get_shared_tensor_arena_memory(void);
+void *psram_get_shared_model_memory(void);
+void psram_free_shared_tensor_arena_and_model_memory(void);
+
+/* General */
+void *malloc_psram_heap(std::string name, size_t size, uint32_t caps);
+void *realloc_psram_heap(std::string name, void *ptr, size_t size, uint32_t caps);
+void *calloc_psram_heap(std::string name, size_t n, size_t size, uint32_t caps);
+
+void free_psram_heap(std::string name, void *ptr);
+
+#endif // PSRAM_h
--- a/code/components/jomjol_helper/sdcard_check.cpp
+++ b/code/components/jomjol_helper/sdcard_check.cpp
@@ -0,0 +1,161 @@
+#include "sdcard_check.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <sys/stat.h>
+
+#include "esp_rom_crc.h" 
+#include "ClassLogFile.h"
+
+static const char *TAG = "SDCARD";
+
+int SDCardCheckRW(void)
+{
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Basic R/W check started...");
+    FILE* pFile = NULL;
+    int iCRCMessage = 0;
+   
+    pFile = fopen("/sdcard/sdcheck.txt","w");
+    if (pFile == NULL) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E1) No able to open file to write");
+        return -1;
+    } 
+    else {
+        std::string sMessage = "This message is used for a SD-Card basic check!";
+        iCRCMessage = esp_rom_crc16_le(0, (uint8_t*)sMessage.c_str(), sMessage.length());
+        if (fwrite(sMessage.c_str(), sMessage.length(), 1, pFile) == 0 ) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E2) Not able to write file");
+            fclose(pFile);
+            unlink("/sdcard/sdcheck.txt");
+            return -2;
+        }
+        fclose(pFile); 
+    }
+
+    pFile = fopen("/sdcard/sdcheck.txt","r");
+    if (pFile == NULL) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E3) Not able to open file to read back");
+        unlink("/sdcard/sdcheck.txt");
+        return -3;
+    } 
+    else {
+        char cReadBuf[50];
+        if (fgets(cReadBuf, sizeof(cReadBuf), pFile) == 0) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E4) Not able to read file back");
+            fclose(pFile);
+            unlink("/sdcard/sdcheck.txt");
+            return -4;
+        }
+        else {
+            if (esp_rom_crc16_le(0, (uint8_t*)cReadBuf, strlen(cReadBuf)) != iCRCMessage) {                 
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E5) Read back, but wrong CRC");
+                fclose(pFile);
+                unlink("/sdcard/sdcheck.txt");
+                return -5;
+            }
+        }      
+        fclose(pFile);
+    }
+
+    if (unlink("/sdcard/sdcheck.txt") != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E6) Unable to delete the file");
+        return -6;
+    }
+
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Basic R/W check successful");
+    return 0;
+}
+
+
+bool SDCardCheckFolderFilePresence()
+{
+    struct stat sb;
+    bool bRetval = true;
+
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Folder/file presence check started...");
+    /* check if folder exists: config */
+    if (stat("/sdcard/config", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /config not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: html */
+    if (stat("/sdcard/html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /html not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: firmware */
+    if (stat("/sdcard/firmware", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /firmware not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: img_tmp */
+    if (stat("/sdcard/img_tmp", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /img_tmp not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: log */
+    if (stat("/sdcard/log", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /log not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: demo */
+    if (stat("/sdcard/demo", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /demo not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: wlan.ini */
+    if (stat("/sdcard/wlan.ini", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /wlan.ini not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: config.ini */
+    if (stat("/sdcard/config/config.ini", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /config/config.ini not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: index.html */
+    if (stat("/sdcard/html/index.html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/index.html not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: ota.html */
+    if (stat("/sdcard/html/ota_page.html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/ota.html not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: log.html */
+    if (stat("/sdcard/html/log.html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/log.html not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: common.js */
+    if (stat("/sdcard/html/common.js", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/common.js not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: version.txt */
+    if (stat("/sdcard/html/version.txt", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/version.txt not found");
+        bRetval = false;
+    }
+
+    if (bRetval)
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Folder/file presence check successful");
+    
+    return bRetval;
+}
--- a/code/components/jomjol_helper/sdcard_check.h
+++ b/code/components/jomjol_helper/sdcard_check.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef COMPONENTS_HELPER_SDCARD_CHECK_H
+#define COMPONENTS_HELPER_SDCARD_CHECK_H
+
+#include "../../include/defines.h"
+
+int SDCardCheckRW(void);
+bool SDCardCheckFolderFilePresence(void);
+
+#endif /* COMPONENTS_HELPER_SDCARD_CHECK_H */
--- a/code/components/jomjol_helper/sdcard_init.c
+++ b/code/components/jomjol_helper/sdcard_init.c
@@ -0,0 +1,646 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "sdcard_init.h"
+
+#include "esp_log.h"
+#include "ffconf.h"
+#include "esp_compiler.h"
+#include "esp_vfs.h"
+#include "vfs_fat_internal.h"
+#include "diskio_impl.h"
+#include "diskio_sdmmc.h"
+#include "soc/soc_caps.h"
+#include "driver/sdmmc_defs.h"
+
+#if SOC_SDMMC_HOST_SUPPORTED
+	#include "driver/sdmmc_host.h"
+#endif
+
+static sdmmc_card_t* s_cards[FF_VOLUMES] = { NULL };
+static bool s_disk_status_check_en[FF_VOLUMES] = { };
+
+static const char* TAG = "sdcard_init";
+
+#define CHECK_EXECUTE_RESULT(err, str) do { \
+    if ((err) !=ESP_OK) { \
+        ESP_LOGE(TAG, str" (0x%x).", err); \
+        goto cleanup; \
+    } \
+    } while(0)
+
+typedef struct mh_vfs_fat_sd_ctx_t {
+    BYTE pdrv;                                  //Drive number that is mounted
+    esp_vfs_fat_mount_config_t mount_config;    //Mount configuration
+    FATFS *fs;                                  //FAT structure pointer that is registered
+    sdmmc_card_t *card;                         //Card info
+    char *base_path;                            //Path where partition is registered
+} mh_vfs_fat_sd_ctx_t;
+
+static mh_vfs_fat_sd_ctx_t *s_ctx[FF_VOLUMES] = {};
+
+/**
+ * This `s_saved_ctx_id` is only used by `esp_vfs_fat_sdmmc_unmount`, which is deprecated.
+ * This variable together with `esp_vfs_fat_sdmmc_unmount` should be removed in next major version
+ */
+static uint32_t s_saved_ctx_id = FF_VOLUMES;
+
+
+static void call_host_deinit_mh(const sdmmc_host_t *host_config);
+static esp_err_t partition_card_mh(const esp_vfs_fat_mount_config_t *mount_config, const char *drv, sdmmc_card_t *card, BYTE pdrv);
+
+
+//Check if SD/MMC card is present
+static DSTATUS ff_sdmmc_card_available_mh(BYTE pdrv)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    esp_err_t err = sdmmc_get_status(card);
+	
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "Check status failed (0x%x)", err);
+        return STA_NOINIT;
+    }
+    return 0;
+}
+
+/**
+*   ff_sdmmc_status() and ff_sdmmc_initialize() return STA_NOINIT when sdmmc_get_status()
+*   fails. This error value is checked throughout the FATFS code.
+*   Both functions return 0 on success.
+*/
+DSTATUS ff_sdmmc_initialize_mh (BYTE pdrv)
+{
+    return ff_sdmmc_card_available_mh(pdrv);
+}
+
+DSTATUS ff_sdmmc_status_mh(BYTE pdrv)
+{
+    if (s_disk_status_check_en[pdrv]) {
+        return ff_sdmmc_card_available_mh(pdrv);
+    }
+    return 0;
+}
+
+DRESULT ff_sdmmc_read_mh (BYTE pdrv, BYTE* buff, DWORD sector, UINT count)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    esp_err_t err = sdmmc_read_sectors(card, buff, sector, count);
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "sdmmc_read_blocks failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+
+DRESULT ff_sdmmc_write_mh (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    esp_err_t err = sdmmc_write_sectors(card, buff, sector, count);
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "sdmmc_write_blocks failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+
+#if FF_USE_TRIM
+DRESULT ff_sdmmc_trim_mh (BYTE pdrv, DWORD start_sector, DWORD sector_count)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    sdmmc_erase_arg_t arg;
+
+    arg = sdmmc_can_discard(card) == ESP_OK ? SDMMC_DISCARD_ARG : SDMMC_ERASE_ARG;
+    esp_err_t err = sdmmc_erase_sectors(card, start_sector, sector_count, arg);
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "sdmmc_erase_sectors failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+#endif //FF_USE_TRIM
+
+DRESULT ff_sdmmc_ioctl_mh (BYTE pdrv, BYTE cmd, void* buff)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    switch(cmd) {
+        case CTRL_SYNC:
+            return RES_OK;
+        case GET_SECTOR_COUNT:
+            *((DWORD*) buff) = card->csd.capacity;
+            return RES_OK;
+        case GET_SECTOR_SIZE:
+            *((WORD*) buff) = card->csd.sector_size;
+            return RES_OK;
+        case GET_BLOCK_SIZE:
+            return RES_ERROR;
+#if FF_USE_TRIM
+        case CTRL_TRIM:
+            if (sdmmc_can_trim(card) != ESP_OK) {
+                return RES_PARERR;
+            }
+            return ff_sdmmc_trim_mh (pdrv, *((DWORD*)buff), //start_sector
+                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
+#endif //FF_USE_TRIM
+    }
+    return RES_ERROR;
+}
+
+void ff_sdmmc_set_disk_status_check_mh(BYTE pdrv, bool enable)
+{
+    s_disk_status_check_en[pdrv] = enable;
+}
+
+void ff_diskio_register_sdmmc_mh(BYTE pdrv, sdmmc_card_t* card)
+{
+    static const ff_diskio_impl_t sdmmc_impl = {
+        .init = &ff_sdmmc_initialize_mh,
+        .status = &ff_sdmmc_status_mh,
+        .read = &ff_sdmmc_read_mh,
+        .write = &ff_sdmmc_write_mh,
+        .ioctl = &ff_sdmmc_ioctl_mh
+    };
+    s_cards[pdrv] = card;
+    s_disk_status_check_en[pdrv] = false;
+    ff_diskio_register(pdrv, &sdmmc_impl);
+}
+
+BYTE ff_diskio_get_pdrv_card_mh(const sdmmc_card_t* card)
+{
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        if (card == s_cards[i]) {
+            return i;
+        }
+    }
+    return 0xff;
+}
+
+static bool s_get_context_id_by_card_mh(const sdmmc_card_t *card, uint32_t *out_id)
+{
+    mh_vfs_fat_sd_ctx_t *p_ctx = NULL;
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        p_ctx = s_ctx[i];
+        if (p_ctx) {
+            if (p_ctx->card == card) {
+                *out_id = i;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static uint32_t s_get_unused_context_id_mh(void)
+{
+    for (uint32_t i = 0; i < FF_VOLUMES; i++) {
+        if (!s_ctx[i]) {
+            return i;
+        }
+    }
+    return FF_VOLUMES;
+}
+
+static esp_err_t mount_prepare_mem_mh(const char *base_path, BYTE *out_pdrv, char **out_dup_path, sdmmc_card_t** out_card)
+{
+    esp_err_t err = ESP_OK;
+    char* dup_path = NULL;
+    sdmmc_card_t* card = NULL;
+
+    // connect SDMMC driver to FATFS
+    BYTE pdrv = FF_DRV_NOT_USED;
+
+    if (ff_diskio_get_drive(&pdrv) != ESP_OK || pdrv == FF_DRV_NOT_USED) {
+        ESP_LOGD(TAG, "the maximum count of volumes is already mounted");
+        return ESP_ERR_NO_MEM;
+    }
+
+    // not using ff_memalloc here, as allocation in internal RAM is preferred
+    card = (sdmmc_card_t*)malloc(sizeof(sdmmc_card_t));
+
+    if (card == NULL) {
+        ESP_LOGD(TAG, "could not locate new sdmmc_card_t");
+        err = ESP_ERR_NO_MEM;
+        goto cleanup;
+    }
+
+    dup_path = strdup(base_path);
+
+    if(!dup_path){
+        ESP_LOGD(TAG, "could not copy base_path");
+        err = ESP_ERR_NO_MEM;
+        goto cleanup;
+    }
+
+    *out_card = card;
+    *out_pdrv = pdrv;
+    *out_dup_path = dup_path;
+    return ESP_OK;
+cleanup:
+    free(card);
+    free(dup_path);
+    return err;
+}
+
+static esp_err_t s_f_mount_mh(sdmmc_card_t *card, FATFS *fs, const char *drv, uint8_t pdrv, const esp_vfs_fat_mount_config_t *mount_config)
+{
+    esp_err_t err = ESP_OK;
+    FRESULT res = f_mount(fs, drv, 1);
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGW(TAG, "failed to mount card (%d)", res);
+
+        bool need_mount_again = (res == FR_NO_FILESYSTEM || res == FR_INT_ERR) && mount_config->format_if_mount_failed;
+
+        if (!need_mount_again) {
+            return ESP_FAIL;
+        }
+
+        err = partition_card_mh(mount_config, drv, card, pdrv);
+
+        if (err != ESP_OK) {
+            return err;
+        }
+
+        ESP_LOGW(TAG, "mounting again");
+        res = f_mount(fs, drv, 0);
+
+        if (res != FR_OK) {
+            err = ESP_FAIL;
+            ESP_LOGD(TAG, "f_mount failed after formatting (%d)", res);
+            return err;
+        }
+    }
+
+    return ESP_OK;
+}
+
+static esp_err_t mount_to_vfs_fat_mh(const esp_vfs_fat_mount_config_t *mount_config, sdmmc_card_t *card, uint8_t pdrv, const char *base_path, FATFS **out_fs)
+{
+    FATFS *fs = NULL;
+    esp_err_t err;
+    ff_diskio_register_sdmmc_mh(pdrv, card);
+    ff_sdmmc_set_disk_status_check_mh(pdrv, mount_config->disk_status_check_enable);
+    ESP_LOGD(TAG, "using pdrv=%i", pdrv);
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+    // connect FATFS to VFS
+    err = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs);
+    *out_fs = fs;
+
+    if (err == ESP_ERR_INVALID_STATE) {
+        // it's okay, already registered with VFS
+    } else if (err != ESP_OK) {
+        ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", err);
+        goto fail;
+    }
+
+    // Try to mount partition
+    err = s_f_mount_mh(card, fs, drv, pdrv, mount_config);
+
+    if (err != ESP_OK) {
+        goto fail;
+    }
+    return ESP_OK;
+
+fail:
+    if (fs) {
+        f_mount(NULL, drv, 0);
+    }
+    esp_vfs_fat_unregister_path(base_path);
+    ff_diskio_unregister(pdrv);
+    return err;
+}
+
+static esp_err_t partition_card_mh(const esp_vfs_fat_mount_config_t *mount_config, const char *drv, sdmmc_card_t *card, BYTE pdrv)
+{
+    FRESULT res = FR_OK;
+    esp_err_t err;
+    const size_t workbuf_size = 4096;
+    void* workbuf = NULL;
+    ESP_LOGW(TAG, "partitioning card");
+
+    workbuf = ff_memalloc(workbuf_size);
+
+    if (workbuf == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    LBA_t plist[] = {100, 0, 0, 0};
+    res = f_fdisk(pdrv, plist, workbuf);
+
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGD(TAG, "f_fdisk failed (%d)", res);
+        goto fail;
+    }
+
+    size_t alloc_unit_size = esp_vfs_fat_get_allocation_unit_size(card->csd.sector_size, mount_config->allocation_unit_size);
+
+    ESP_LOGW(TAG, "formatting card, allocation unit size=%d", alloc_unit_size);
+    const MKFS_PARM opt = {(BYTE)FM_ANY, 0, 0, 0, alloc_unit_size};
+    res = f_mkfs(drv, &opt, workbuf, workbuf_size);
+
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGD(TAG, "f_mkfs failed (%d)", res);
+        goto fail;
+    }
+
+    free(workbuf);
+    return ESP_OK;
+fail:
+    free(workbuf);
+    return err;
+}
+
+#if SOC_SDMMC_HOST_SUPPORTED
+static esp_err_t init_sdmmc_host_mh(int slot, const void *slot_config, int *out_slot)
+{
+    *out_slot = slot;
+    return sdmmc_host_init_slot(slot, (const sdmmc_slot_config_t*) slot_config);
+}
+
+esp_err_t esp_vfs_fat_sdmmc_mount_mh(const char* base_path, const sdmmc_host_t* host_config, const void* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card)
+{
+    esp_err_t err;
+    mh_vfs_fat_sd_ctx_t *ctx = NULL;
+    uint32_t ctx_id = FF_VOLUMES;
+    FATFS *fs = NULL;
+    int card_handle = -1;   //uninitialized
+    sdmmc_card_t* card = NULL;
+    BYTE pdrv = FF_DRV_NOT_USED;
+    char* dup_path = NULL;
+    bool host_inited = false;
+
+    err = mount_prepare_mem_mh(base_path, &pdrv, &dup_path, &card);
+
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "mount_prepare failed");
+        return err;
+    }
+
+    err = (*host_config->init)();
+    CHECK_EXECUTE_RESULT(err, "host init failed");
+    //deinit() needs to be called to revert the init
+    host_inited = true;
+    //If this failed (indicated by card_handle != -1), slot deinit needs to called()
+    //leave card_handle as is to indicate that (though slot deinit not implemented yet.
+    err = init_sdmmc_host_mh(host_config->slot, slot_config, &card_handle);
+    CHECK_EXECUTE_RESULT(err, "slot init failed");
+
+    // probe and initialize card
+    err = sdmmc_card_init(host_config, card);
+    CHECK_EXECUTE_RESULT(err, "sdmmc_card_init failed");
+
+    err = mount_to_vfs_fat_mh(mount_config, card, pdrv, dup_path, &fs);
+    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
+
+    if (out_card != NULL) {
+        *out_card = card;
+    }
+
+    //For deprecation backward compatibility
+    if (s_saved_ctx_id == FF_VOLUMES) {
+        s_saved_ctx_id = 0;
+    }
+
+    ctx = calloc(sizeof(mh_vfs_fat_sd_ctx_t), 1);
+
+    if (!ctx) {
+        CHECK_EXECUTE_RESULT(ESP_ERR_NO_MEM, "no mem");
+    }
+
+    ctx->pdrv = pdrv;
+    memcpy(&ctx->mount_config, mount_config, sizeof(esp_vfs_fat_mount_config_t));
+    ctx->card = card;
+    ctx->base_path = dup_path;
+    ctx->fs = fs;
+    ctx_id = s_get_unused_context_id_mh();
+    assert(ctx_id != FF_VOLUMES);
+    s_ctx[ctx_id] = ctx;
+
+    return ESP_OK;
+cleanup:
+    if (host_inited) {
+        call_host_deinit_mh(host_config);
+    }
+
+    free(card);
+    free(dup_path);
+    return err;
+}
+#endif
+
+static esp_err_t init_sdspi_host_mh(int slot, const void *slot_config, int *out_slot)
+{
+    esp_err_t err = sdspi_host_init_device((const sdspi_device_config_t*)slot_config, out_slot);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG,
+"Failed to attach sdspi device onto an SPI bus (rc=0x%x), please initialize the \
+bus first and check the device parameters."
+            , err);
+    }
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdspi_mount_mh(const char* base_path, const sdmmc_host_t* host_config_input, const sdspi_device_config_t* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card)
+{
+    const sdmmc_host_t* host_config = host_config_input;
+    esp_err_t err;
+    mh_vfs_fat_sd_ctx_t *ctx = NULL;
+    uint32_t ctx_id = FF_VOLUMES;
+    FATFS *fs = NULL;
+    int card_handle = -1;   //uninitialized
+    bool host_inited = false;
+    BYTE pdrv = FF_DRV_NOT_USED;
+    sdmmc_card_t* card = NULL;
+    char* dup_path = NULL;
+
+    err = mount_prepare_mem_mh(base_path, &pdrv, &dup_path, &card);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "mount_prepare failed");
+        return err;
+    }
+
+    //the init() function is usually empty, doesn't require any deinit to revert it
+    err = (*host_config->init)();
+    CHECK_EXECUTE_RESULT(err, "host init failed");
+
+    err = init_sdspi_host_mh(host_config->slot, slot_config, &card_handle);
+    CHECK_EXECUTE_RESULT(err, "slot init failed");
+    //Set `host_inited` to true to indicate that host_config->deinit() needs
+    //to be called to revert `init_sdspi_host`
+    host_inited = true;
+
+    //The `slot` argument inside host_config should be replaced by the SD SPI handled returned
+    //above. But the input pointer is const, so create a new variable.
+
+    sdmmc_host_t new_config;
+
+    if (card_handle != host_config->slot) {
+        new_config = *host_config_input;
+        host_config = &new_config;
+        new_config.slot = card_handle;
+    }
+
+    // probe and initialize card
+    err = sdmmc_card_init(host_config, card);
+    CHECK_EXECUTE_RESULT(err, "sdmmc_card_init failed");
+
+    err = mount_to_vfs_fat_mh(mount_config, card, pdrv, dup_path, &fs);
+    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
+
+    if (out_card != NULL) {
+        *out_card = card;
+    }
+
+    //For deprecation backward compatibility
+    if (s_saved_ctx_id == FF_VOLUMES) {
+        s_saved_ctx_id = 0;
+    }
+
+    ctx = calloc(sizeof(mh_vfs_fat_sd_ctx_t), 1);
+
+    if (!ctx) {
+        CHECK_EXECUTE_RESULT(ESP_ERR_NO_MEM, "no mem");
+    }
+
+    ctx->pdrv = pdrv;
+    memcpy(&ctx->mount_config, mount_config, sizeof(esp_vfs_fat_mount_config_t));
+    ctx->card = card;
+    ctx->base_path = dup_path;
+    ctx->fs = fs;
+    ctx_id = s_get_unused_context_id_mh();
+    assert(ctx_id != FF_VOLUMES);
+    s_ctx[ctx_id] = ctx;
+
+    return ESP_OK;
+
+cleanup:
+    if (host_inited) {
+        call_host_deinit_mh(host_config);
+    }
+
+    free(card);
+    free(dup_path);
+    return err;
+}
+
+static void call_host_deinit_mh(const sdmmc_host_t *host_config)
+{
+    if (host_config->flags & SDMMC_HOST_FLAG_DEINIT_ARG) {
+        host_config->deinit_p(host_config->slot);
+    } else {
+        host_config->deinit();
+    }
+}
+
+static esp_err_t unmount_card_core_mh(const char *base_path, sdmmc_card_t *card)
+{
+    BYTE pdrv = ff_diskio_get_pdrv_card_mh(card);
+
+    if (pdrv == 0xff) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    // unmount
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+    f_mount(0, drv, 0);
+    // release SD driver
+    ff_diskio_unregister(pdrv);
+
+    call_host_deinit_mh(&card->host);
+    free(card);
+
+    esp_err_t err = esp_vfs_fat_unregister_path(base_path);
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdmmc_unmount_mh(void)
+{
+    esp_err_t err = unmount_card_core_mh(s_ctx[s_saved_ctx_id]->base_path, s_ctx[s_saved_ctx_id]->card);
+    free(s_ctx[s_saved_ctx_id]);
+    s_ctx[s_saved_ctx_id] = NULL;
+    s_saved_ctx_id = FF_VOLUMES;
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdcard_unmount_mh(const char *base_path, sdmmc_card_t *card)
+{
+    uint32_t id = FF_VOLUMES;
+    bool found = s_get_context_id_by_card_mh(card, &id);
+
+    if (!found) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    free(s_ctx[id]);
+    s_ctx[id] = NULL;
+
+    esp_err_t err = unmount_card_core_mh(base_path, card);
+
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdcard_format_mh(const char *base_path, sdmmc_card_t *card)
+{
+    esp_err_t ret = ESP_OK;
+
+    if (!card) {
+        ESP_LOGE(TAG, "card not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    BYTE pdrv = ff_diskio_get_pdrv_card_mh(card);
+
+    if (pdrv == 0xff) {
+        ESP_LOGE(TAG, "card driver not registered");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    const size_t workbuf_size = 4096;
+    void *workbuf = ff_memalloc(workbuf_size);
+
+    if (workbuf == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    //unmount
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+    f_mount(0, drv, 0);
+
+    //format
+    uint32_t id = FF_VOLUMES;
+    bool found = s_get_context_id_by_card_mh(card, &id);
+    assert(found);
+    size_t alloc_unit_size = esp_vfs_fat_get_allocation_unit_size(card->csd.sector_size, s_ctx[id]->mount_config.allocation_unit_size);
+    ESP_LOGI(TAG, "Formatting card, allocation unit size=%d", alloc_unit_size);
+    const MKFS_PARM opt = {(BYTE)FM_ANY, 0, 0, 0, alloc_unit_size};
+    FRESULT res = f_mkfs(drv, &opt, workbuf, workbuf_size);
+    free(workbuf);
+
+    if (res != FR_OK) {
+        ret = ESP_FAIL;
+        ESP_LOGD(TAG, "f_mkfs failed (%d)", res);
+    }
+
+    //mount back
+    esp_err_t err = s_f_mount_mh(card, s_ctx[id]->fs, drv, pdrv, &s_ctx[id]->mount_config);
+
+    if (err != ESP_OK) {
+        unmount_card_core_mh(base_path, card);
+        ESP_LOGE(TAG, "failed to format, resources recycled, please mount again");
+    }
+
+    return ret;
+}
--- a/code/components/jomjol_helper/sdcard_init.h
+++ b/code/components/jomjol_helper/sdcard_init.h
@@ -0,0 +1,111 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include "esp_err.h"
+#include "driver/gpio.h"
+#include "sdmmc_cmd.h"
+#include "driver/sdmmc_types.h"
+#include "driver/sdspi_host.h"
+#include "ff.h"
+#include "esp_vfs_fat.h"
+#include "wear_levelling.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Convenience function to get FAT filesystem on SD card registered in VFS
+ *
+ * This is an all-in-one function which does the following:
+ * - initializes SDMMC driver or SPI driver with configuration in host_config
+ * - initializes SD card with configuration in slot_config
+ * - mounts FAT partition on SD card using FATFS library, with configuration in mount_config
+ * - registers FATFS library with VFS, with prefix given by base_prefix variable
+ *
+ * This function is intended to make example code more compact.
+ * For real world applications, developers should implement the logic of
+ * probing SD card, locating and mounting partition, and registering FATFS in VFS,
+ * with proper error checking and handling of exceptional conditions.
+ *
+ * @note Use this API to mount a card through SDSPI is deprecated. Please call
+ *       `esp_vfs_fat_sdspi_mount()` instead for that case.
+ *
+ * @param base_path     path where partition should be registered (e.g. "/sdcard")
+ * @param host_config   Pointer to structure describing SDMMC host. When using
+ *                      SDMMC peripheral, this structure can be initialized using
+ *                      SDMMC_HOST_DEFAULT() macro. When using SPI peripheral,
+ *                      this structure can be initialized using SDSPI_HOST_DEFAULT()
+ *                      macro.
+ * @param slot_config   Pointer to structure with slot configuration.
+ *                      For SDMMC peripheral, pass a pointer to sdmmc_slot_config_t
+ *                      structure initialized using SDMMC_SLOT_CONFIG_DEFAULT.
+ * @param mount_config  pointer to structure with extra parameters for mounting FATFS
+ * @param[out] out_card  if not NULL, pointer to the card information structure will be returned via this argument
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount was already called
+ *      - ESP_ERR_NO_MEM if memory can not be allocated
+ *      - ESP_FAIL if partition can not be mounted
+ *      - other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
+ */
+esp_err_t esp_vfs_fat_sdmmc_mount_mh(const char* base_path, const sdmmc_host_t* host_config, const void* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card);
+
+/**
+ * @brief Convenience function to get FAT filesystem on SD card registered in VFS
+ *
+ * This is an all-in-one function which does the following:
+ * - initializes an SPI Master device based on the SPI Master driver with configuration in
+ *   slot_config, and attach it to an initialized SPI bus.
+ * - initializes SD card with configuration in host_config_input
+ * - mounts FAT partition on SD card using FATFS library, with configuration in mount_config
+ * - registers FATFS library with VFS, with prefix given by base_prefix variable
+ *
+ * This function is intended to make example code more compact.
+ * For real world applications, developers should implement the logic of
+ * probing SD card, locating and mounting partition, and registering FATFS in VFS,
+ * with proper error checking and handling of exceptional conditions.
+ *
+ * @note This function try to attach the new SD SPI device to the bus specified in host_config.
+ *       Make sure the SPI bus specified in `host_config->slot` have been initialized by
+ *       `spi_bus_initialize()` before.
+ *
+ * @param base_path     path where partition should be registered (e.g. "/sdcard")
+ * @param host_config_input Pointer to structure describing SDMMC host. This structure can be
+ *                          initialized using SDSPI_HOST_DEFAULT() macro.
+ * @param slot_config   Pointer to structure with slot configuration.
+ *                      For SPI peripheral, pass a pointer to sdspi_device_config_t
+ *                      structure initialized using SDSPI_DEVICE_CONFIG_DEFAULT().
+ * @param mount_config  pointer to structure with extra parameters for mounting FATFS
+ * @param[out] out_card If not NULL, pointer to the card information structure will be returned via
+ *                      this argument. It is suggested to hold this handle and use it to unmount the card later if
+ *                      needed. Otherwise it's not suggested to use more than one card at the same time and unmount one
+ *                      of them in your application.
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount was already called
+ *      - ESP_ERR_NO_MEM if memory can not be allocated
+ *      - ESP_FAIL if partition can not be mounted
+ *      - other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
+ */
+esp_err_t esp_vfs_fat_sdspi_mount_mh(const char* base_path, const sdmmc_host_t* host_config_input, const sdspi_device_config_t* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+
+
+
+
+
+
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`powershell Compress-Archive -Path "..\..\sd-card\html\." -DestinationPath "..\..\firmware\html.zip"`