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
407 changed files with 44134 additions and 26708 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,31 +0,0 @@
---
-name: Bug report
-about: Create a bug report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
---
-
-Thank you for taking your time to report a bug.
-
-Before you proceed, please check:
- Do you use the latest version? See https://github.com/jomjol/AI-on-the-edge-device/releases.
- Is there already another similar issue? Check for open and closed Issue in https://github.com/jomjol/AI-on-the-edge-device/issues.
- Are instructions in the readme solving your issue (https://github.com/jomjol/AI-on-the-edge-device/tree/master#readme)?
- Are instructions in the wiki solving your issue? (https://github.com/jomjol/AI-on-the-edge-device/wiki)?
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**Version**
-Which version are you using? (See menu `System > Info`).
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Additional context**
-Add any other context about the problem here.
--- 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/general_question.md
+++ b/.github/ISSUE_TEMPLATE/general_question.md
@@ -1,10 +0,0 @@
---
-name: General  Question
-about: General Question => Open a discussion instead
-title: ''
-labels: ''
-assignees: ''
-
---
-
-If its not a bug, please open a discussion instead, see https://github.com/jomjol/AI-on-the-edge-device/discussions
--- 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
@@ -1,6 +1,6 @@
 name: Build and Pack

-on: [push]
+on: [push, pull_request]

 jobs:
 #########################################################################################
@@ -10,211 +10,262 @@ jobs:
    runs-on: ubuntu-latest

    steps:
-    - uses: actions/checkout@v2
+    - 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 "::set-output name=sha_short::$(git rev-parse --short HEAD)"
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT

-    - name: Cache PlatformIO
-      uses: actions/cache@v2
+    - 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: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
+        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@v2
+      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: 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: Store generated files in cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          ./code/.pio/build/esp32cam/firmware.bin
-          ./code/.pio/build/esp32cam/partitions.bin
-          ./code/.pio/build/esp32cam/bootloader.bin
-          ./sd-card/html/version.txt
-        key: ${{ github.run_number }}
-
-
-
-#########################################################################################
-## Pack for old OTA (v1)
-#########################################################################################
-  pack-for-OTA-v1:
-    # Old OTA concept
-    # firmware__*.zip needs to be unpacked before attaching to the release!
-    # The bin filename can contain versioning.
-    runs-on: ubuntu-latest
-    needs: build
-
-    steps:
-    - uses: actions/checkout@v2
-
-    - name: Get generated files from cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          ./code/.pio/build/esp32cam/firmware.bin
-          ./code/.pio/build/esp32cam/partitions.bin
-          ./code/.pio/build/esp32cam/bootloader.bin
-          ./sd-card/html/version.txt
-        key: ${{ github.run_number }}
-
-    - name: Set Variables
-      id: vars
+    - name: Prepare Web UI (generate tooltip pages and update hashes in all files)
      run: |
-        echo "::set-output name=sha_short::$(git rev-parse --short HEAD)"
+        rm -rf ./html
+        mkdir html
+        cp -r ./sd-card/html/* ./html/

-    - name: Rename firmware file to contain versioning (old ota)
-      run: |
-        mkdir -p ./dist_old_ota
-        cp "./code/.pio/build/esp32cam/firmware.bin" "./dist_old_ota/firmware__${{ github.ref_name }}_(${{ steps.vars.outputs.sha_short }}).bin"
+        python -m pip install markdown
+        mkdir html/param-tooltips
+        cd tools/parameter-tooltip-generator
+        python generate-param-doc-tooltips.py
+        cd ../..

-    - name: Upload Firmware artifact (old OTA concept)
-      uses: actions/upload-artifact@v3
-      with:
-#        name: "firmware__${{ github.ref_name }}__(${{ steps.vars.outputs.sha_short }})__(extract_before_upload__only_needed_for_migration_from_11.3.1)"
-        name: "firmware__(extract_before_upload)__${{ github.ref_name }}__(${{ steps.vars.outputs.sha_short }})"
-        path: ./dist_old_ota/*
-
-    - name: Upload Web interface artifact (old OTA concept)
-      uses: actions/upload-artifact@v3
-      with:
-        name: "html__${{ github.ref_name }}__(${{ steps.vars.outputs.sha_short }})"
-        path: ./sd-card/html/*
+        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 new OTA (v2)
+## Pack for Update
 #########################################################################################
-  pack-for-OTA-v2:
+  pack-for-update:
    # New OTA concept
    # update__version.zip file with following content:
    #  - /firmware.bin
-    #  - (optional) /html/*
+    #  - (optional) /html/* (inkl. subfolders)
    #  - (optional) /config/*.tfl
    runs-on: ubuntu-latest
    needs: build

    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4

-    - name: Get generated files from cache
-      uses: actions/cache@v3
+    - 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
-          ./sd-card/html/version.txt
-        key: ${{ github.run_number }}
+          ./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 "::set-output name=sha_short::$(git rev-parse --short HEAD)"
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT

-    - name: Prepare update.zip artifact
+    - name: Prepare update__*.zip artifact
      run: |
-        mkdir -p ./dist
-        cp "./code/.pio/build/esp32cam/firmware.bin" "dist/firmware.bin"
+        rm -rf ./update
+        mkdir -p ./update
+        cp "./code/.pio/build/esp32cam/firmware.bin" "update/firmware.bin"

-#    - name: Upload update.zip Artifact (Firmware only)
-#      uses: actions/upload-artifact@v3
-#      with:
-#        name: "update_firmware_only__${{ github.ref_name }}_(${{ steps.vars.outputs.sha_short }})"
-#        path: ./dist/*
-        
-    - name: Add Web UI to dist
-      run: cp -r ./sd-card/html ./dist/
+    - name: Add Web UI to update
+      run: cp -r ./html ./update/

-#    - name: Upload update.zip artifact (Firmware + Web UI)
-#      uses: actions/upload-artifact@v3
-#      with:
-#        name: "update_firmware+webinterface__${{ github.ref_name }}_(${{ steps.vars.outputs.sha_short }})"
-#        path: ./dist/*
-        
-    - name: Add CNN to dist
+    - name: Add CNN to update
      run: |
-        mkdir ./dist/config/
-        cp ./sd-card/config/*.tfl ./dist/config/ 2>/dev/null || true
-        cp ./sd-card/config/*.tflite ./dist/config/ 2>/dev/null || true
+        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 dist as update.zip artifact (Firmware + Web UI + CNN)
-      uses: actions/upload-artifact@v3
+    - name: Upload update as update.zip artifact (Firmware + Web UI + CNN)
+      uses: actions/upload-artifact@v4
      with:
-        name: "update__${{ github.ref_name }}_(${{ steps.vars.outputs.sha_short }})"
-        path: ./dist/*
+        name: "AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./update/*

-    - name: Store generated files in cache
-      uses: actions/cache@v3
+
+#########################################################################################
+## 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: |
-          ./dist
-        key: ${{ github.run_number }}-pack-for-OTA-v2
+          ./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) (initial_esp32_setup)
+## Pack for a fresh install (USB flashing) (manual_setup)
 #########################################################################################
-  pack-for-fresh-install:
+  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@v2
+    - uses: actions/checkout@v4

-    - name: Get generated files from cache
-      uses: actions/cache@v3
+    - 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
-          ./sd-card/html/version.txt
-        key: ${{ github.run_number }}
+          ./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: Prepare artifacts for release
+    - 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: |
-        mkdir -p firmware
-        rm -rf firmware/*.zip
+        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 firmware folder
-        cp -f "./code/.pio/build/esp32cam/firmware.bin" "firmware/firmware.bin"
-        cp -f "./code/.pio/build/esp32cam/bootloader.bin" "firmware/bootloader.bin"
-        cp -f "./code/.pio/build/esp32cam/partitions.bin" "firmware/partitions.bin"
-        zip -r ./firmware/sd-card.zip sd-card
-        cd ./firmware
-  
-    - name: Upload initial_esp32_setup.zip artifact (Firmware + Bootloader + Partitions + Web UI)
-      uses: actions/upload-artifact@v3
+        # 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: "initial_esp32_setup__${{ github.ref_name }}_(${{ steps.vars.outputs.sha_short }})"
-        path: ./firmware
-
-    - name: Store generated files in cache
-      uses: actions/cache@v3
-      with:
-        path: |
-          ./firmware
-        key: ${{ github.run_number }}-pack-for-fresh-install
-
-
+        name: "AI-on-the-edge-device__manual-setup__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./manual_setup


 #########################################################################################
@@ -222,98 +273,153 @@ jobs:
 #########################################################################################
  release: 
    runs-on: ubuntu-latest
-    needs: [pack-for-OTA-v2, pack-for-fresh-install]
+    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@v2
+    - uses: actions/checkout@v4

-    - name: Get generated files from cache
-      uses: actions/cache@v3
+    - name: Update update 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
-          ./sd-card/html/version.txt
-        key: ${{ github.run_number }}
+        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

-    # import the changes from 
-    - name: Get generated files from cache
-      uses: actions/cache@v3
+    - name: Update remote_setup cache on every commit
+      uses: actions/cache@v4
      with:
-        path: |
-            ./dist
-        key: ${{ github.run_number }}-pack-for-OTA-v2
+        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

-    # import cached artifacts from pack-for-fresh-install
-    - name: Get generated files from cache
-      uses: actions/cache@v3
+    - name: Update manual_setup cache on every commit
+      uses: actions/cache@v4
      with:
-        path: |
-          ./firmware
-        key: ${{ github.run_number }}-pack-for-fresh-install
+        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 "::set-output name=sha_short::$(git rev-parse --short HEAD)"
-
+        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 a update.zip like "update__rolling"
-        cd ./dist
-        zip -r ../release/update.zip .
-        cd ../firmware
-        zip -r ../release/initial_esp32_setup.zip .
-        cd ../sd-card/html
-        zip -r ../../firmware/html-from-11.3.1.zip .

-        
+        # 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
-      if: startsWith(github.ref, 'refs/tags/') 
-      uses: battila7/get-version-action@v2
+      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
-      if: startsWith(github.ref, 'refs/tags/') 
-      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
-      if: startsWith(github.ref, 'refs/tags/') 
-      uses: ffurrer2/extract-release-notes@v1
-      with:
-          changelog_file: Changelog.md
-          
+#    # 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@v1
-      if: startsWith(github.ref, 'refs/tags/')
+      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/*
-          firmware/firmware.bin
-          firmware/html-from-11.3.1.zip   
-          

-    # Commit&Push Changelog to master branch. Must be manually merged back to rolling
-    - name: Commit changes and push changes
-      if: startsWith(github.ref, 'refs/tags/') 
+#    # 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: |
-        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
+        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
@@ -23,3 +23,5 @@ 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
@@ -4,6 +4,9 @@
 [submodule "code/components/esp-nn"]
 	path = code/components/esp-nn
 	url = https://github.com/espressif/esp-nn.git
-[submodule "code/components/tflite-micro-esp-examples"]
-	path = code/components/tflite-micro-esp-examples
-	url = https://github.com/espressif/tflite-micro-esp-examples.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
@@ -1,111 +1,579 @@
-# Changelog
+## [16.0.0-RC3] - 2024-10-05

-## [Unreleased]
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.7.0...v16.0.0-RC1)

-Improve **u**ser e**x**perience 
+#### Known issues
+Please check the [issues](https://github.com/jomjol/AI-on-the-edge-device/issues) and
+[discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions) before reporting a new issue.
+
+#### Core Changes
+Only changes since RC2 are listed:
+- Renamed MQTT topic from `rate_per_digitalization_round` to `rate_per_digitization_round` (change happened already in RC1)
+
+#### Bug Fixes
+Only changes since RC2 are listed:
+- Re-did revertion of TFlite submodule update as certain modules crash with it (#3269) (change was lost)
+
+
+## [16.0.0-RC2] - 2024-10-04
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.7.0...v16.0.0-RC1)
+
+#### Known issues
+Please check the [issues](https://github.com/jomjol/AI-on-the-edge-device/issues) and
+[discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions) before reporting a new issue.
+
+#### Core Changes
+Only changes since RC1 are listed:
+- Updated parameter documentation pages
+- Rename/remove unused parameters (#3291)
+- Migrate-cam-parameters (#3288)
+
+#### Bug Fixes
+Only changes since RC1 are listed:
+- Reverted TFlite submodule update as certain modules crash with it (#3269)
+- Changed the webhook UploadImg to false (#3279)
+- Changed default value from boolean to numeric value in parameter camDenoise documentation
+- Updated config page
+
+## [16.0.0-RC1] - 2024-09-24
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.7.0...v16.0.0-RC1)
+
+#### Known issues
+Please check the [issues](https://github.com/jomjol/AI-on-the-edge-device/issues) and
+[discussions](https://github.com/jomjol/AI-on-the-edge-device/discussions) before reporting a new issue.
+
+#### Core Changes
+Those are just the major changes:
+- Add support for OV5640 camera (#3063)
+- New tflite-Models
+- Homeassistant service discovery: derive node_id when using nested topics (#3088)
+- Added Prometheus/OpenMetrics exporter (#3081)
+- Added Webhook (#3148, #3163, #3174)
+- Add rate threshold parameter (#3195)
+- Added a Delay between the WiFi reconnections (#3068)
+- Web UI improvements
+- Various minor changes
+- Update platformIO to 6.9.0 (Contains ESP IDF 5.3.1)
+
+#### Bug Fixes
+Those are just the major changes:
+- Handle crash on corrupted model (#3220)
+- Bugfix for boot loop (#3175)
+- Bugfix for time stamp (#3180)
+- Handle empty prevalue.ini gracefully (#3162)
+- Added note about only TLS 1.2 is supported (#3213)
+
+## [15.7.0] - 2024-02-17
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.6.0...v15.7.0)
+
+#### Core Changes
+- Added new camera settings (See `Settings > Alignment > Reference Image and Camera Settings`). You might need to re-create the reference image and alignment marks. Note worthy:
+  - You can now crop the image
+  - Support to configure sharpness, grayscale, negatoive and exposure
+- Enhanced various WebUI pages with better explanations and usability
+- Add Firmware Version to MQTT
+
+#### Bug Fixes
+- Reverted "Implemented late analog / digit transition [#2778](https://github.com/jomjol/AI-on-the-edge-device/pull/2778) (introduced in `v15.5`) as is seems to cause issues for many users.
+
+
+## [15.6.0] - 2024-02-09
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.5.0...v15.6.0)
+
+#### Fixed
+
+* Fixed issues with the SD-Card initialization
+
+## [15.5.0] - 2024-02-02
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.4.0...v15.5.0)
+
+#### Changed
+
+ - Update PlattformIO to v6.5.0, which means esp-idf to v5.1
+ - Enhance busy notification
+ - Implemented late analog / digit transition
+
+#### Fixed
+
+* ATA-TRIM: workaround for old SD-cards with no trim function to work with esp-idf v5.x
+* InfluxDB: Modified the time conversions to be more stable (UTC vs. local time shifts)
+* Fix negatives on extended resolution false
+* Show chip infos on info page
+* Fix memory leaks in tflite integration
+
+## [15.4.0] - 2023-12-22
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.3.0...v15.4.0)
+
+#### Changed
+
+ - Updates submodules (esp-nn, tflite-micro-example, esp-camera)
+
+ - Explicitly included needed tflite network layers (instead of all) , resulting in much smaller firmware size
+
+ - Added shortcut icon
+
+ - Rename in InfluxDB 'Database' to 'Bucket'
+
+ - Updated analog tflite files
+   - dig-class100-0167_s2_q.tflite
+   - dig-class11_1700_s2.tflite
+   - ana-cont_1208_s2_q.tflite
+  
+ - Added config entries for MQTT TLS
+
+
+#### Fixed
+
+* InfluxDB: consider DST setting for UTC time conversion
+
+* Minor html response bugfix 
+
+ - Memory leakage (MQTT)
+   
+
+## [15.3.0] - 2023-07-22
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.3.0...v15.2.4)
+
+#### Changed
+
+ - Updated PlatformIO to `6.3.2`
+ - Updated analog tflite files
+   - ana-cont_1207_s2_q.tflite
+   - dig-cont_0620_s3_q.tflite
+
+## [15.2.4] - 2023-05-02
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.2.1...v15.2.4)
+
+#### Changed
+ - Updated PlatformIO to `6.2.0`
+ - [#2376](https://github.com/jomjol/AI-on-the-edge-device/pull/2376) Improve logging if Autostart is not enabled
+
+#### Fixed
+ - [#2373](https://github.com/jomjol/AI-on-the-edge-device/pull/2373) Allow the Alignment Mark step while status is "Initializing" or "Initialization (delayed)" or while in setup mode
+ - [#2381](https://github.com/jomjol/AI-on-the-edge-device/pull/2381) Fix broken sysinfo REST API
+
+
+## [15.2.1] - 2023-04-27
+
+### Changes
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.2.0...v15.2.1)
+
+#### Fixed
+ - [#2357](https://github.com/jomjol/AI-on-the-edge-device/pull/2357) Fix Alignment Mark issue
+
+
+## [15.2.0] - 2023-04-23
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.1.1...v15.2.0)
+
+#### Added
+
+-  [#2286](https://github.com/jomjol/AI-on-the-edge-device/pull/2286) Implement a camera livestream handler
+-  [#2252](https://github.com/jomjol/AI-on-the-edge-device/pull/2252) Set prevalue using MQTT + set prevalue to RAW value (REST+MQTT)
+-  [#2319](https://github.com/jomjol/AI-on-the-edge-device/pull/2319) Extend InfluxDBv1 with individual topic names
+
+#### Changed
+
+-  [#2285](https://github.com/jomjol/AI-on-the-edge-device/pull/2285) Re-implemented PSRAM usage
+-  [#2325](https://github.com/jomjol/AI-on-the-edge-device/pull/2325) Keep MainFlowTask alive to handle reboot
+-  [#2233](https://github.com/jomjol/AI-on-the-edge-device/pull/2233) Remove trailing slash in influxDBv1
+-  [#2305](https://github.com/jomjol/AI-on-the-edge-device/pull/2305) Migration of PlatformIO `5.2.0` to `6.1.0` (resp. ESP IDF from `4.4.2` to `5.0.1`)
+-  Various cleanup and refactoring
+
+#### Fixed
+
+-  [#2326](https://github.com/jomjol/AI-on-the-edge-device/pull/2326) Activate save button after Analogue ROI creationSet prevalue using MQTT + set prevalue to RAW value (REST+MQTT)
+-  [#2283](https://github.com/jomjol/AI-on-the-edge-device/pull/2283) Fix Timezone issues on InfluxDB
+-  Various minor fixes
+
+#### Removed
+
+-   n.a.
+
+
+## [15.1.1] - 2023-03-23
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.1.0...v15.1.1)
+
+#### Added
+
+- [#2206](https://github.com/jomjol/AI-on-the-edge-device/pull/2206) Log PSRAM usage
+- [#2216](https://github.com/jomjol/AI-on-the-edge-device/pull/2216) Log MQTT connection refused reasons
+
+#### Changed
+
+- n.a.
+
+#### Fixed
+
+-  [#2224](https://github.com/jomjol/AI-on-the-edge-device/pull/2224), [#2213](https://github.com/jomjol/AI-on-the-edge-device/pull/2213) Reverted some of the PSRAM usage changes due to negative sideffects 
+-  [#2203](https://github.com/jomjol/AI-on-the-edge-device/issues/2203) Correct API for pure InfluxDB v1
+-  [#2180](https://github.com/jomjol/AI-on-the-edge-device/pull/2180) Fixed links in Parameter Documentation
+-  Various minor fixes
+
+#### Removed
+
+-   n.a.
+
+## [15.1.0] - 2023-03-12
+
+### Update Procedure
+
+Update Procedure see [online documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#update-ota-over-the-air)
+
+:bangbang: Afterwards you should force-reload the Web Interface (usually Ctrl-F5 will do it)!
+
+:bangbang: Afterwards you should check your configuration for errors!
+
+### Changes
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v15.0.3...v15.1.0)
+
+#### Added
+- The Configuration page has now tooltips with enhanced documentation
+- MQTT:
+    - Added `GJ` (`gigajoule`) as an energy meter unit
+    - Removed State Class and unit from `raw` topic
+    - Various Improvements (Only send Homeassistant Discovery the first time we connect, ...) (https://github.com/jomjol/AI-on-the-edge-device/pull/2091
+- Added Expert Parameter to change CPU Clock from `160` to `240 Mhz`
+- SD card basic read/write check and a folder/file presence check at boot to indicate SD card issues or missing folders / files ([#2085](https://github.com/jomjol/AI-on-the-edge-device/pull/2085))
+- Simplified "WIFI roaming" by client triggered channel scan (AP switching at low RSSI) -> using expert parameter "RSSIThreshold" ([#2120](https://github.com/jomjol/AI-on-the-edge-device/pull/2120))
+- Log WLAN disconnect reason codes (see [WLAN disconnect reasons](https://jomjol.github.io/AI-on-the-edge-device-docs/WLAN-disconnect-reason))
+- Support of InfluxDB v2 ([#2004](https://github.com/jomjol/AI-on-the-edge-device/pull/2004))
+
+
+#### Changed
+- Updated models (tflite files), removed old versions (https://github.com/jomjol/AI-on-the-edge-device/pull/2089, https://github.com/jomjol/AI-on-the-edge-device/pull/2133)
+  :bangbang: **Attention:** Update your configuration!
+    -   Hybrid CNN network to `dig-cont_0611_s3` 
+    -   Analog CNN network to `ana-cont-11.0.5` and `ana-clas100-1.5.7`
+    -   Digit CNN network to `dig-class100-1.6.0`
+-   Various Web interface Improvements/Enhancements:
+    - Restructured Menu (Needs cache clearing to be applied)
+    - Enhanced `Previous Value` page
+    - Improved/faster Graph page
+    - Various minor improvements
+    - ROI config pages improvements
+    - Improved Backup Functionality
+- Added log file logs for Firmware Update
+- Improved memory management (moved various stuff to external PSRAM, https://github.com/jomjol/AI-on-the-edge-device/pull/2117)
+- Camera driver update: Support of contrast and saturation ([#2048](https://github.com/jomjol/AI-on-the-edge-device/pull/2048))   
+  :bangbang:  **Attention**: This could have impact to old configurations. Please check your configuration and potentially adapt parametrization, if detection is negativly affected.
+- Improved error handling and provide more verbose output in error cases during boot phase ([#2020](https://github.com/jomjol/AI-on-the-edge-device/pull/2020))
+- Red board LED is indicating more different errors and states (see [Status LED Blink Codes](https://jomjol.github.io/AI-on-the-edge-device-docs/StatusLED-BlinkCodes))
+- Logfile: Print start indication block after time is synced to indicate start in logfile after a cold boot
+- `Image Quality Index`: Limit lower input range to 8 to avoid system instabilities
+
+#### Fixed
+- Various minor fixes
+- Added State Class "measurement" to rate_per_time_unit
+- GPIO: Avoid MQTT publishing to empty topic when "MQTT enable" flag is not set
+- Fix timezone config parser
+- Remote Setup truncated long passwords (https://github.com/jomjol/AI-on-the-edge-device/issues/2167)
+-  Problem with timestamp in InfluxDB interface
+
+#### Removed
+-   n.a.
+
+
+## [15.0.3] - 2023-02-28
+
+**Name: Parameter Migration**
+
+### Update Procedure
+
+Update Procedure see [online documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#update-ota-over-the-air)
+
+:bangbang: Afterwards you should force-reload the Web Interface (usually Ctrl-F5 will do it).
+
+### Changes
+
+This release only migrates some parameters, see #2023 for details and a list of all parameter changes.
+The parameter migration happens automatically on the next startup. No user interaction is required.
+A backup of the config is stored on the SD-card as `config.bak`.
+
+Beside of the parameter change and the bugfix listed below, no changes are contained in this release!
+
+If you want to revert back to `v14` or earlier, you will have to revert the migration changes in `config.ini` manually!
+
+#### Added
+
+-   n.a.
+
+#### Changed
+
+-   [#2023](https://github.com/jomjol/AI-on-the-edge-device/pull/2023) Migrated Parameters
+-   Removed old `Topic` parameter, it is not used anymore
+
+#### Fixed
+
+-   [#2036](https://github.com/jomjol/AI-on-the-edge-device/issues/2036) Fix wrong url-encoding
+-   **NEW v15.0.2:**  [#1933](https://github.com/jomjol/AI-on-the-edge-device/issues/1933) Bugfix InfluxDB Timestamp
+-   **NEW v15.0.3:**  Re-added lost dropdownbox filling for Postprocessing Individual Parameters
+
+#### Removed
+
+-   n.a.
+
+
+## [14.0.3] -2023-02-05
+
+**Name: Stabilization and Improved User Experience**
+
+Thanks to over 80 Pull Requests from 6 contributors, we can anounce another great release with many many improvements and new features:
+
+### Update Procedure
+
+Update Procedure see [online documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#update-ota-over-the-air)
+
+### Changes
+
+For a full list of changes see [Full list of changes](https://github.com/jomjol/AI-on-the-edge-device/compare/v13.0.8...v14.0.0)
+
+#### Added
+
+-   [1877](https://github.com/jomjol/AI-on-the-edge-device/pull/1877) Show WIFI signal text labels / Log RSSI value to logfile
+-   [1671](https://github.com/jomjol/AI-on-the-edge-device/pull/1671) Added experimental support for WLAN 802.11k und 802.11v (Mesh-Support)
+-   Web UI caching of static files
+-   Added various debug tools
+-   [1798](https://github.com/jomjol/AI-on-the-edge-device/pull/1798) Add error handling for memory intensive tasks
+-   [1784](https://github.com/jomjol/AI-on-the-edge-device/pull/1784) Add option to disable brownout detector
+-   Added full web browser based installation mode (including initial setup of SD-card) - see [WebInstaller](https://jomjol.github.io/AI-on-the-edge-device/index.html)
+-   Added [Demo Mode](https://jomjol.github.io/AI-on-the-edge-device-docs/Demo-Mode)
+-   [1648](https://github.com/jomjol/AI-on-the-edge-device/pull/1648) Added trigger to start a flow by [REST](https://jomjol.github.io/AI-on-the-edge-device-docs/REST-API) API or [MQTT](https://jomjol.github.io/AI-on-the-edge-device-docs/MQTT-API/)
+-   Show special images during steps `Initializing` and `Take Image` as the current camera image might be incomplete or outdated
+
+#### Changed
+
+-   Migrated documentation (Wiki) to <https://jomjol.github.io/AI-on-the-edge-device-docs>. Please help us to make it even better.
+-   New OTA Update page with progress indication
+-   Various memory optimizations
+-   Cleanup code/Web UI
+-   Updated models
+-   [1809](https://github.com/jomjol/AI-on-the-edge-device/pull/1809) Store preprocessed image with ROI to RAM
+-   Better log messages on some errors/issues
+-   [1742](https://github.com/jomjol/AI-on-the-edge-device/pull/1742) Replace alert boxes with overlay info boxes
+-   Improve log message when web UI is installed incomplete
+-   [1676](https://github.com/jomjol/AI-on-the-edge-device/pull/1676) Improve NTP handling
+-   HTML: improved user informations (info boxes, error hints, ...)
+-   [1904](https://github.com/jomjol/AI-on-the-edge-device/pull/1904) Removed newlines in JSON and replaced all whitespaces where there was more than one
+
+#### Fixed
+
+-   Fixed many many things
+-   [1509](https://github.com/jomjol/AI-on-the-edge-device/pull/1509) Protect `wifi.ini` from beeing deleted.
+-   [1530](https://github.com/jomjol/AI-on-the-edge-device/pull/1530) Homeassistant `Problem Sensor`
+-   [1518](https://github.com/jomjol/AI-on-the-edge-device/pull/1518) JSON Strings
+-   [1817](https://github.com/jomjol/AI-on-the-edge-device/pull/1817) DataGraph: datafiles sorted -> newest on top
+
+#### Removed
+
+-   n.a.
+
+## [13.0.8] - 2022-12-19
+
+**Name: Home Assistant MQTT Discovery Support**
+
+### Update Procedure see [online documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#update-ota-over-the-air)
+
+### Added
+
+-   Implementation of [Home Assistant MQTT Discovery](https://www.home-assistant.io/integrations/mqtt/#mqtt-discovery)
+-   Improved ROIs configuration: locked ROI geometry, equidistant delta x
+-   Improved OTA Update mechanism (only working after installation for next update)
+-   Added data logging in `/log/data` - One day per file and each measurement is on one line
+    -   Format: csv - comma separated
+    -   Content: `time`, `name-of-number`, `raw-value`, `return-value`, `pre-value`, `change-rate`, `change-absolute`, `error-text`, `cnn-digit`, `cnn-analog`
+-   Show graph of values direct in the user interface (thanks to [@rdmueller](https://github.com/rdmueller))
+
+    -   Using new data logging (see above)
+    -   Possibility to choose different values and switch between different numbers (if present)
+
+    Note: You need to activate data logging for this feature to work, see above!
+-   PreValue is now contained in `/json` ([#1154](https://github.com/jomjol/AI-on-the-edge-device/issues/1154))
+-   SD card info into the `System>Info` menu (thanks to [@Slider007](https://github.com/Slider0007))
+-   Version check (Firmware vs. Web UI)
+-   Various minor new features
+
+### Changed
+
+-   Updated tflite (`dig-cont_0600_s3.tflite`)
+-   Updated OTA functionality (more robust, but not fully bullet prove yet)
+-   Updated Espressif library to `espressif32@v5.2.0`
+-   [#1176](https://github.com/jomjol/AI-on-the-edge-device/discussions/1176) accept minor negative values (-0.2) if extended resolution is enabled
+-   [#1143](https://github.com/jomjol/AI-on-the-edge-device/issues/1143) added config parameter `AnalogDigTransitionStart`. It can setup very early and very late digit transition starts.
+-   New version of `dig-class100` (v1.4.0): added images of heliowatt powermeter 
+-   NEW v13.0.2: Update Tool "Logfile downloader and combiner" to handle the new csv file format.
+-   NEW v13.0.2: MQTT: Added MQTT topic `status` (Digitization Status), Timezone to MQTT topic `timestamp`.#
+-   NEW v13.0.2: Logging: Disable heap logs by default, cleanup
+-   NEW v13.0.7:
+    -   log NTP server name
+    -   Improved log messages
+    -   Various preparations for next release
+-   **NEW v13.0.8**: 
+    -   Continue booting on PSRAM issues, Web UI will show an error
+    -   Updated models
+    -   Various UI enhancements
+    -   Various internal improvements
+    -   Show uptime in log
+    -   Show uptime and round on overview page
+
+### Fixed
+
+-   [#1116](https://github.com/jomjol/AI-on-the-edge-device/issues/1116) precision problem at setting prevalue
+-   [#1119](https://github.com/jomjol/AI-on-the-edge-device/issues/1119) renamed `firmware.bin` not working in OTA
+-   [#1143](https://github.com/jomjol/AI-on-the-edge-device/issues/1143) changed postprocess for `analog->digit` (lowest digit processing)
+-   [#1280](https://github.com/jomjol/AI-on-the-edge-device/issues/1280) check ROIs name for unsupported characters
+-   [#983](https://github.com/jomjol/AI-on-the-edge-device/issues/983) old log files did not get deleted 
+-   Failed NTP time sync during startup gets now retried every round if needed
+-   Whitespaces and `=` in MQTT and InfluxDB passwords
+-   Various minor fixes and improvements
+-   NEW v13.0.2: Corrected Version comparison between firmware and Web UI.
+-   NEW v13.0.3: Re-updated build environment to v5.2.0 (from accidental downgrad to v4.4.0)
+-   NEW v13.0.4: Fix for reboot in case of MQTT not used
+-   NEW v13.0.5: No reboot in case of missing NTP-connection
+-   NEW v13.0.7:
+    -   Prevent autoreboot on cam framebuffer init error
+    -   Properly protect `wlan.ini` against deletion
+    -   Fixed various MQTT topic content issues
+    -   Fix Digit detected as 10 (<https://github.com/jomjol/AI-on-the-edge-device/pull/1525>)
+    -   Fix frozen time in datafile on error
+    -   Various minor fixes
+-   **NEW v13.0.8**: 
+    -   Fix Rate Problem ([#1578](https://github.com/jomjol/AI-on-the-edge-device/issues/1578), [#1572](https://github.com/jomjol/AI-on-the-edge-device/issues/1572))
+    -   Stabilized MQTT
+    -   Fixed redundant calls in OTA
+    -   Block REST API calls till resource is ready
+    -   Fixed number renaming ([#1635](https://github.com/jomjol/AI-on-the-edge-device/issues/1635))
+
+### Removed
+
+-   n.a.
+
+## [12.0.1] 2022-09-29
+
+Name: Improve **u**ser e**x**perience 

 :bangbang: The release breaks a few things in ota update :bangbang:

 **Make sure to read the instructions below carfully!**.

-1. Backup your configuration (use the `System > Backup/Restore` page)!
-2. You should update to `11.3.1` before you update to this release. All other migrations are not tested. 
+1.  Backup your configuration (use the `System > Backup/Restore` page)!
+2.  You should update to `11.3.1` before you update to this release. All other migrations are not tested. 
    Rolling newer than `11.3.1` can also be used, but no guaranty.
-3. Upload and update the `firmware.bin` file from this release. **but do not reboot**
-4. Upload the `html-from-11.3.1.zip` in html upload and update the web interface.
-5. Now you can reboot.
+3.  Upload and update the `firmware.bin` file from this release. **but do not reboot**
+4.  Upload the `html-from-11.3.1.zip` in html upload and update the web interface.
+5.  Now you can reboot.

-If anything bricks you can try to
-1. Call `http://<IP>/ota?task=update&file=firmware.bin` resp. `http://<IP>/ota?task=update&file=html.zip` if the upload successed but the extraction failed.
-1. Use the initial_esp32_setup.zip ( <https://github.com/jomjol/AI-on-the-edge-device/wiki/Installation> ) as alternative.
+If anything breaks you can try to
+1\. Call `http://<IP>/ota?task=update&file=firmware.bin` resp. `http://<IP>/ota?task=update&file=html.zip` if the upload successed but the extraction failed.
+1\. Use the initial_esp32_setup.zip ( <https://github.com/jomjol/AI-on-the-edge-device/wiki/Installation> ) as alternative.

 ### Added

- Automatic release creation
- Newest firmware of rolling branch now automatically build and provided in [Github Actions Output](https://github.com/jomjol/AI-on-the-edge-device/actions) (developers only)
- [\#1068](https://github.com/jomjol/AI-on-the-edge-device/issues/1068) New update mechanism: 
-  - Handling of all files (`zip`, `tfl`, `tflite`, `bin`) within in one common update interface
-  - Using the `update.zip` from the [Release page](https://github.com/jomjol/AI-on-the-edge-device/releases)
-  - Status (`upload`, `processing`, ...) displayed on Web Interface
-  - Automatical detection and suggestion for reboot where needed (Web Interface uupdates only need a page refresh)
-  - :bangbang: Best for OTA use Firefox. Chrome works with warnings. Safari stuck in upload.
+-   Automatic release creation
+-   Newest firmware of rolling branch now automatically build and provided in [Github Actions Output](https://github.com/jomjol/AI-on-the-edge-device/actions) (developers only)
+-   [#1068](https://github.com/jomjol/AI-on-the-edge-device/issues/1068) New update mechanism: 
+    -   Handling of all files (`zip`, `tfl`, `tflite`, `bin`) within in one common update interface
+    -   Using the `update.zip` from the [Release page](https://github.com/jomjol/AI-on-the-edge-device/releases)
+    -   Status (`upload`, `processing`, ...) displayed on Web Interface
+    -   Automatical detection and suggestion for reboot where needed (Web Interface uupdates only need a page refresh)
+    -   :bangbang: Best for OTA use Firefox. Chrome works with warnings. Safari stuck in upload.

 ### Changed
- Integrated version info better shown on the Info page and in the log
- Updated menu
- Update used libraries (`tflite`, `esp32-cam`, `esp-nn`, as of 20220924) 
+
+-   Integrated version info better shown on the Info page and in the log
+-   Updated menu
+-   Update used libraries (`tflite`, `esp32-cam`, `esp-nn`, as of 20220924) 
+
 ### Fixed

- [\#1092](https://github.com/jomjol/AI-on-the-edge-device/issues/1092) censor passwords in log outputs 
- [\#1029](https://github.com/jomjol/AI-on-the-edge-device/issues/1029) wrong change of `checkDigitConsistency` now working like releases before `11.3.1` 
- Spelling corrections (**[cristianmitran](https://github.com/cristianmitran)**) 
-
+-   [#1092](https://github.com/jomjol/AI-on-the-edge-device/issues/1092) censor passwords in log outputs 
+-   [#1029](https://github.com/jomjol/AI-on-the-edge-device/issues/1029) wrong change of `checkDigitConsistency` now working like releases before `11.3.1` 
+-   Spelling corrections (**[cristianmitran](https://github.com/cristianmitran)**) 

 ### Removed
- Remove the folder `/firmware` from GitHub repository. 
-  If you want to get the latest `firmware.bin` and `html.zip` files, please download from the automated [build action](https://github.com/jomjol/AI-on-the-edge-device/actions) or [release page](https://github.com/jomjol/AI-on-the-edge-device/releases)

-## [11.3.1] - (2022-09-17)
+-   Remove the folder `/firmware` from GitHub repository. 
+    If you want to get the latest `firmware.bin` and `html.zip` files, please download from the automated [build action](https://github.com/jomjol/AI-on-the-edge-device/actions) or [release page](https://github.com/jomjol/AI-on-the-edge-device/releases)
+
+## [11.3.1](https://github.com/jomjol/AI-on-the-edge-device/releases/tag/v11.3.1), 2022-09-17
+
 Intermediate Digits

- **ATTENTION**: 
-  - first update the `firmware.bin` and ensure that the new version is running
+-   **ATTENTION**: 

-  - Only afterwards update the `html.zip`
-  
-  - Otherwise the downwards compatibility of the new counter clockwise feature is not given and you end in a reboot loop, that needs manual flashing!
-  
+    -   first update the `firmware.bin` and ensure that the new version is running
+
+    -   Only afterwards update the `html.zip`
+
+    -   Otherwise the downwards compatibility of the new counter clockwise feature is not given and you end in a reboot loop, that needs manual flashing!


- **NEW v11.3.1**: corrected corrupted asset `firmware.bin`
- Increased precision (more than 6-7 digits)
- Implements Counter Clockwise Analog Pointers
- Improved post processing algorithm
- Debugging: intensive use of testcases
- MQTT: improved handling, extended logging, automated reconnect
- HTML: Backup Option for Configuration
- HTML: Improved Reboot
- HTML: Update WebUI (Reboot, Infos, CPU Temp, RSSI)
- This version is largely also based on the work of **[caco3](https://github.com/caco3)**,  **[adellafave](https://github.com/adellafave)**,  **[haverland](https://github.com/haverland)**,  **[stefanbode](https://github.com/stefanbode)**, **[PLCHome](https://github.com/PLCHome)**
+-   **NEW v11.3.1**: corrected corrupted asset `firmware.bin`
+-   Increased precision (more than 6-7 digits)
+-   Implements Counter Clockwise Analog Pointers
+-   Improved post processing algorithm
+-   Debugging: intensive use of testcases
+-   MQTT: improved handling, extended logging, automated reconnect
+-   HTML: Backup Option for Configuration
+-   HTML: Improved Reboot
+-   HTML: Update WebUI (Reboot, Infos, CPU Temp, RSSI)
+-   This version is largely also based on the work of **[caco3](https://github.com/caco3)**,  **[adellafave](https://github.com/adellafave)**,  **[haverland](https://github.com/haverland)**,  **[stefanbode](https://github.com/stefanbode)**, **[PLCHome](https://github.com/PLCHome)**
+
+## [11.2.0](https://github.com/jomjol/AI-on-the-edge-device/releases/tag/v11.2.0), 2022-08-28

-## [11.2.0] -  (2022-08-28)
 Intermediate Digits

- Updated Tensorflow / TFlite to newest tflite (version as of 2022-07-27)
- Updated analog neural network file (`ana-cont_11.3.0_s2.tflite` - default, `ana-class100_0120_s1_q.tflite`)
- Updated digital neural network file (`dig-cont_0570_s3.tflite` - default, `dig-class100_0120_s2_q.tflite`)
+-   Updated Tensorflow / TFlite to newest tflite (version as of 2022-07-27)

- Added automated filtering of tflite-file in the graphical configuration (thanks to @**[caco3](https://github.com/caco3)**)
- Updated consistency algorithm & test cases
- HTML: added favicon and system name, Improved reboot dialog  (thanks to @**[caco3](https://github.com/caco3)**)
+-   Updated analog neural network file (`ana-cont_11.3.0_s2.tflite` - default, `ana-class100_0120_s1_q.tflite`)
+
+-   Updated digit neural network file (`dig-cont_0570_s3.tflite` - default, `dig-class100_0120_s2_q.tflite`)
+
+-   Added automated filtering of tflite-file in the graphical configuration (thanks to @**[caco3](https://github.com/caco3)**)
+
+-   Updated consistency algorithm & test cases
+
+-   HTML: added favicon and system name, Improved reboot dialog  (thanks to @**[caco3](https://github.com/caco3)**)
+
+## [11.1.1](https://github.com/jomjol/AI-on-the-edge-device/releases/tag/v11.1.1), 2022-08-22

-## [11.1.1] -  (2022-08-22)
 Intermediate Digits

- New and improved consistency check (especially with analog and digital counters mixed)
- Bug Fix: digital counter algorithm
+-   New and improved consistency check (especially with analog and digit counters mixed)
+-   Bug Fix: digit counter algorithm
+
+## [11.0.1](https://github.com/jomjol/AI-on-the-edge-device/releases/tag/v11.0.1), 2022-08-18

-## [11.0.1] - (2022-08-18)
 Intermediate Digits

- **NEW v11.0.1**: Bug Fix InfluxDB configuration (only update of html.zip necessary)
+-   **NEW v11.0.1**: Bug Fix InfluxDB configuration (only update of html.zip necessary)

- Implementation of new CNN types to detect intermediate values of digits with rolling numbers
+-   Implementation of new CNN types to detect intermediate values of digits with rolling numbers

-  - By default the old algo (0, 1, ..., 9, "N") is active (due to the limited types of digits trained so far)
-  - Activation can be done by selection a tflite file with the new trained model in the 'config.ini'
-  - **Details can be found in the [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Neural-Network-Types)** (different types, trained image types, naming convention)
+    -   By default the old algo (0, 1, ..., 9, "N") is active (due to the limited types of digits trained so far)
+    -   Activation can be done by selection a tflite file with the new trained model in the 'config.ini'
+    -   **Details can be found in the [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Neural-Network-Types)** (different types, trained image types, naming convention)

- Updated  neural network files (and adaption to new naming convention)
+-   Updated  neural network files (and adaption to new naming convention)

- Published a tool to download and combine log files - **Thanks to **
+-   Published a tool to download and combine log files - **Thanks to **

-  - Files see ['/tools/logfile-tool'](tbd), How-to see [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Gasmeter-Log-Downloader)
+    -   Files see ['/tools/logfile-tool'](tbd), How-to see [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Gasmeter-Log-Downloader)

- Bug Fix: InfluxDB enabling in grahic configuration
+-   Bug Fix: InfluxDB enabling in grahic configuration

-
-## [10.6.2] - (2022-07-24)
+## [10.6.2](https://github.com/jomjol/AI-on-the-edge-device/releases/tag/v10.6.2), 2022-07-24

 Stability Increase

@@ -123,7 +591,7 @@ Stability Increase

 -   `config.ini`: removal of modelsize (readout from tflite)

-   Updated analog neural network file (`ana1000s2.tflite`) & digital neural network file (`dig1400s2q.tflite`)
+-   Updated analog neural network file (`ana1000s2.tflite`) & digit neural network file (`dig1400s2q.tflite`)

 -   TFMicro/Lite: Update (espressif Version 20220716)

@@ -135,7 +603,7 @@ Stability Increase

 -   Bug Fix: no time with fixed IP, Postprocessing, MQTT

-## [10.5.2] - (2022-02-22)
+## [10.5.2](https://github.com/jomjol/AI-on-the-edge-device/releases/tag/v10.5.2), 2022-02-22

 Stability Increase

@@ -148,7 +616,7 @@ Stability Increase
 -   Refactoring of check postprocessing consistency (e.g. max rate, negative rate, ...)
 -   Bug Fix: corrected error in "Check Consistency Increase"

-## [10.4.0] - (2022-02-12)
+## [10.4.0](https://github.com/jomjol/AI-on-the-edge-device/releases/tag/v10.4.0), 2022-02-12

 Stability Increase

@@ -159,7 +627,7 @@ Stability Increase
    -   In the future the new files will also be copied to the `firmware` directory of the repository
 -   Added Wifi RSSI to MQTT information
 -   Updated analog neural network file (`ana-s3-q-20220105.tflite`)
-   Updated digital neural network file (`dig-s1-q-20220102.tflite`)
+-   Updated digit neural network file (`dig-s1-q-20220102.tflite`)
 -   Updated build environment to `Espressif 3.5.0`

 ## [10.3.0] - (2022-01-29)
@@ -225,7 +693,7 @@ Stability Increase

 -   Update analog neural network (ana-s3-q-20220105.tflite)

-   Update digital neural network (dig-s1-q-20220102.tflite)
+-   Update digit neural network (dig-s1-q-20220102.tflite)

 -   Increased web-server buffers

@@ -262,7 +730,7 @@ External Illumination
 -   Direct JSON access: `http://IP-ADRESS/json`
 -   Error message in log file in case camera error during startup
 -   Upgrade analog CNN to v9.1.0
-   Upgrade digital CNN to v13.3.0 (added new images)
+-   Upgrade digit CNN to v13.3.0 (added new images)
 -   html: support of different ports

 ## [9.1.1] - External Illumination (2021-11-16)
@@ -287,7 +755,7 @@ External Illumination

 ### Changed

-   Upgrade digital CNN to v13.1.0 (added new images)
+-   Upgrade digit CNN to v13.1.0 (added new images)
 -   bug fix: wlan password with space, double digit output

 ## [8.4.0] - Multi Meter Support (2021-09-25)
@@ -317,7 +785,7 @@ External Illumination

 ### Changed

-   Upgrade digital CNN to v12.1.0 (added new images)
+-   Upgrade digit CNN to v12.1.0 (added new images)
 -   Dedicated NaN handling, internal refactoring (CNN-Handling)
 -   HTML: confirmation after config.ini update
 -   Bug fixing
@@ -339,7 +807,7 @@ External Illumination
 -   GPIO: using the general mqtt main topic for GPIO


-   Upgrade digital CNN to v12.0.0  (added new images)
+-   Upgrade digit CNN to v12.0.0  (added new images)
 -   Update tfmicro to new master (2021-08-07)
 -   Bug fix: remove text in mqtt value, remove connect limit in wlan reconnet

@@ -375,7 +843,7 @@ External Illumination

 -   Update wlan handling to esp-idf 4.1

-   Upgrade digital CNN to v8.7.0  (added new images)
+-   Upgrade digit CNN to v8.7.0  (added new images)

 -   Bug fix: MQTT, WLAN, LED-Controll, GPIO usage, fixed IP, calculation flow rate

@@ -386,7 +854,7 @@ External Illumination
 -   NEW: 7.0.1: bug fix wlan password with "="


-   Upgrade digital CNN to v8.5.0  (added new images)
+-   Upgrade digit CNN to v8.5.0  (added new images)

 -   New MQTT topics: flow rate (units/minute), time stamp (last correct read readout)

@@ -403,7 +871,7 @@ External Illumination

 -   NEW 6.7.1: Improved stability of camera (back to v6.6.1) - remove black strips and areas

-   Upgrade digital CNN to v8.3.0  (added new type of digits)
+-   Upgrade digit CNN to v8.3.0  (added new type of digits)

 -   Internal update: TFlite (v2.5), esp32cam, startup sequence

@@ -424,7 +892,7 @@ External Illumination

 ### Changed

-   Upgrade digital CNN to v8.2.0  (added new type of digits)
+-   Upgrade digit CNN to v8.2.0  (added new type of digits)


 -   Supporting alignment structures in ROI definition
@@ -460,7 +928,7 @@ External Illumination

 -   Determination of fixed illumination settings during startup - speed up of 5s in each run

-   Update digital CNN to v8.1.1 (additional digital images trained)
+-   Update digit CNN to v8.1.1 (additional digit images trained)

 -   Extended error message in MQTT error message

@@ -472,7 +940,7 @@ External Illumination

 ### Changed

-   Disabling of analog / digital counters in configuration
+-   Disabling of analog / digit counters in configuration


 -   Improved Alignment Algorithm (`AlignmentAlgo`  = `Default`,  `Accurate` , `Fast`)
@@ -492,7 +960,7 @@ External Illumination

 -   MQTT: Last Will Testament (LWT) implemented: "connection lost" in case of connection lost to `TopicError`
 -   Disabled `CheckDigitIncreaseConsistency` in default configuration - must now be explicit enabled if needed
-   Update digital CNN to v7.2.1 (additional digital images trained)
+-   Update digit CNN to v7.2.1 (additional digit images trained)
 -   Setting of arbitrary time server in `config.ini`
 -   Option for fixed IP-, DNS-Settings in `wlan.ini`
 -   Increased stability (internal image and camera handling)
@@ -526,7 +994,7 @@ External Illumination

 -   standardized access to current logfile via `http://IP-ADRESS/logfileact`

-   Update digital CNN to v7.2.0, analog CNN to 6.3.0
+-   Update digit CNN to v7.2.0, analog CNN to 6.3.0

 -   Bug fixing: truncation error,  CheckDigitConsistency & PreValue implementation

@@ -545,7 +1013,7 @@ External Illumination

 ### Changed

-   Update digital CNN to v6.5.0 and HTML (Info to hostname, IP, ssid)
+-   Update digit CNN to v6.5.0 and HTML (Info to hostname, IP, ssid)

 -   New implementation of "checkDigitConsistency" also for digits

@@ -660,10 +1128,20 @@ External Illumination

 -   Initial Version

-[Unreleased]: https://github.com/haverland/AI-on-the-edge-device/compare/11.4.3...HEAD

-[11.4.3]: https://github.com/haverland/AI-on-the-edge-device/compare/10.6.2...11.4.3
-
-[11.4.2]: https://github.com/haverland/AI-on-the-edge-device/compare/10.6.2...11.4.2
-
-[11.3.9]: https://github.com/haverland/AI-on-the-edge-device/compare/10.6.2...11.3.9
+[15.2.4]: https://github.com/jomjol/AI-on-the-edge-device/compare/v15.2.1...v15.2.4
+[15.2.1]: https://github.com/jomjol/AI-on-the-edge-device/compare/v15.2.0...v15.2.1
+[15.2.0]: https://github.com/jomjol/AI-on-the-edge-device/compare/v15.1.1...v15.2.0
+[15.1.1]: https://github.com/jomjol/AI-on-the-edge-device/compare/v15.1.0...v15.1.1
+[15.1.0]: https://github.com/jomjol/AI-on-the-edge-device/compare/v15.0.3...v15.1.0
+[15.0.3]: https://github.com/jomjol/AI-on-the-edge-device/compare/v14.0.3...v15.0.3
+[14.0.3]: https://github.com/jomjol/AI-on-the-edge-device/compare/v13.0.8...v14.0.3
+[13.0.8]: https://github.com/jomjol/AI-on-the-edge-device/compare/v12.0.1...v13.0.8
+[13.0.7]: https://github.com/jomjol/AI-on-the-edge-device/compare/v12.0.1...v13.0.7
+[13.0.5]: https://github.com/jomjol/AI-on-the-edge-device/compare/v12.0.1...v13.0.5
+[13.0.4]: https://github.com/jomjol/AI-on-the-edge-device/compare/v12.0.1...v13.0.4
+[13.0.1]: https://github.com/jomjol/AI-on-the-edge-device/compare/v12.0.1...v13.0.1
+[12.0.1]: https://github.com/jomjol/AI-on-the-edge-device/compare/v11.3.1...v12.0.1
+[11.4.3]: https://github.com/haverland/AI-on-the-edge-device/compare/v10.6.2...v11.4.3
+[11.4.2]: https://github.com/haverland/AI-on-the-edge-device/compare/v10.6.2...v11.4.2
+[11.3.9]: https://github.com/haverland/AI-on-the-edge-device/compare/v10.6.2...v11.3.9
--- a/FeatureRequest.md
+++ b/FeatureRequest.md
@@ -2,18 +2,82 @@

 **There are a lot of ideas for further improvements, but only limited capacity on side of the developer.** Therefore I have created this page as a collection of ideas. 

-1. Who ever has a new idea can put it here, so it that it is not forgotten. 
+1. Whoever has a new idea can put it here, so that it is not forgotten. 

-2. Who ever has time, capacity and passion to support, can take any of the ideas and implement them. 
-   I will support and help where ever I can!
+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~~
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/927~~

 #### #28 Improved error handling for ROIs

@@ -51,7 +115,7 @@ ____

 #### ~~#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~~
+* ~~https://github.com/jomjol/AI-on-the-edge-device/issues/644~~

  

--- a/README.md
+++ b/README.md
@@ -1,26 +1,31 @@
 # Welcome to the AI-on-the-edge-device
-Artificial intelligence based systems have been established in our every days live. Just think of speech or image recognition. Most of the systems relay on either powerful processors or a direct connection to the cloud for doing the calculations up 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 brought into a practical oriented example, where a AI network is implemented on a ESP32 device so: **AI on the edge**.
+<img src="images/icon/watermeter.svg" width="100px">

-This projects allows you to digitalize your **analoge** water, gas, power and other meters using cheap and easily available 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**.

-All you need is an [ESP32 board with a supported camera](https://github.com/jomjol/AI-on-the-edge-device/wiki/Hardware-Compatibility) and a bit of a practical hand.
+This project allows you to digitize your **analog** water, gas, power and other meters using cheap and easily available hardware.

-<img src="images/esp32-cam.png" width="200">
+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
- **Small** and **cheap** device (3x4.5x2 cm³, < 10 EUR)
- camera and illumination integrated
- Web surface for administration and control
- OTA-Interface to update directly through the web interface
- API for easy integration
- Inline Image processing (feature detection, alignment, ROI extraction)
- Tensorflow Lite (TFlite) integration - including easy to use wrapper
+- 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 (ROI's) out of it and runs them through an artificial inteligence. As a result, you get the digitalized value of your meter.
+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 what to do with that value. Either send it to a MQTT broker, write it to an InfluxDb or simply provide it throug a REST API.
+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"> 

@@ -36,173 +41,68 @@ There are several options what to do with that value. Either send it to a MQTT b


 ## Setup
-There is a growing [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki) which provides you with a lot of information.
+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.

-Head there to get a start, set it up and configure it.
+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)

-There are also a articles in the German Heise magazine "make:" about the setup and the technical background (!not for free!)
+A lot of people created useful Youtube videos which might help you getting started.
+Here a small selection:

-*  [DIY - Setup](https://www.heise.de/select/make/2021/2/2103513300897420296)
-* Background [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) 
+- [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)

-## Download
-The latest available version is available on the [Releases page](https://github.com/jomjol/AI-on-the-edge-device/releases).
+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).

-Initially you will have to flash it through an USB connection. Later an update is possible directly over the Air (OTA).
+### Download
+The latest available version can be found on the [Releases page](https://github.com/jomjol/AI-on-the-edge-device/releases).

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

-A 3d-printable housing can be found here:
+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.
+
+### 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!
+
+## 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:4571627 (ESP32-Cam housing only)
-
-## Build it yourself
-See [Build Instructions](code/README.md).
+  - 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).
+If you would like to support the developer with a cup of coffee, you can do that via [PayPal](https://www.paypal.com/donate?hosted_button_id=8TRSVYNYKDSWL).

-<form action="https://www.paypal.com/donate" method="post" target="_top">
-<input type="hidden" name="hosted_button_id" value="8TRSVYNYKDSWL" />
-<input type="image" src="https://www.paypalobjects.com/en_US/DK/i/btn/btn_donateCC_LG.gif" border="0" name="submit" title="PayPal - The safer, easier way to pay online!" alt="Donate with PayPal button" />
-<img alt="" border="0" src="https://www.paypal.com/en_DE/i/scr/pixel.gif" width="1" height="1" />
-</form>
-If you have any technical topics, you can file a issue in this repository. 
+<a href="https://www.paypal.com/donate?hosted_button_id=8TRSVYNYKDSWL"><img border="0" src="images/paypal.png" width="200px" target="_blank"></a>

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

-## Changelog
-**General remark:** Besides the file `firmware.bin`, typically the content of `/html` will need to be updated!
+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">

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

-##### Rolling (2022-09-27)
-
- Internal improvements
- Bug fix: html update page
-
-##### Rolling (2022-09-24)
-
- Updated menue 
- Update tflite, esp32-cam-master, esp-nn (as of today 20220924) 
-
-##### Rolling (2022-09-21)
-
- Spelling corrections (**[cristianmitran](https://github.com/cristianmitran)**) 
-
-##### Rolling (2022-09-21)
-
- New update mechanism: 
-  - handling of all files (zip, tfl, tflite, bin) within in one updload
-  - status (upload, processing, ...) displayed
-  - auto suggestion for reboot (or not in case of web ui update only)
-
-##### Rolling (2022-09-19)
-
- Integrated version info better into the html (main page, logfile)
- Updated autobuild
- Remove `/firmware` from GitHub. 
-  - If you want to get the latest firmware and html files, please download from the automated build action.
-
-##### Rolling (2022-09-18)
-
- Updated PostProcessing with respect to `CheckDigitIncreaseConsistency`
-
-##### 11.3.1 - Intermediate Digits (2022-09-17)
-
- **ATTENTION**: 
-  - first update the 'firmware.bin' and ensure that the new version is running
-
-  - Only afterwards update the 'html.zip'
-  
-  - Otherwise the downwards compatibility of the new counter clockwise feature is not given and you end in a reboot loop, that needs manual flashing!
-  
-
-
- **NEW v11.3.1**: corrected corrupted asset `firmware.bin`
- Increased precision (more than 6-7 digits)
- Implements Counter Clockwise Analog Pointers
- Improved post processing algorithm
- Debugging: intensive use of testcases
- MQTT: improved handling, extended logging, automated reconnect
- HTML: Backup Option for Configuration
- HTML: Improved Reboot
- HTML: Update WebUI (Reboot, Infos, CPU Temp, RSSI)
- This version is largely also based on the work of **[caco3](https://github.com/caco3)**,  **[adellafave](https://github.com/adellafave)**,  **[haverland](https://github.com/haverland)**,  **[stefanbode](https://github.com/stefanbode)**, **[PLCHome](https://github.com/PLCHome)**
-
-##### 11.2.0 - Intermediate Digits (2022-08-28)
-
- Updated Tensorflow / TFlite to newest tflite (version as of 2022-07-27)
- Updated analog neural network file (`ana-cont_11.3.0_s2.tflite` - default, `ana-class100_0120_s1_q.tflite`)
- Updated digital neural network file (`dig-cont_0570_s3.tflite` - default, `dig-class100_0120_s2_q.tflite`)
-
- Added automated filtering of tflite-file in the graphical configuration (thanks to @**[caco3](https://github.com/caco3)**)
- Updated consistency algorithm & test cases
- HTML: added favicon and system name, Improved reboot dialog  (thanks to @**[caco3](https://github.com/caco3)**)
-
-##### 11.1.1 - Intermediate Digits (2022-08-22)
-
- New and improved consistency check (especially with analog and digital counters mixed)
- Bug Fix: digital counter algorithm
-
-##### 11.0.1 - Intermediate Digits (2022-08-18)
-
- **NEW v11.0.1**: Bug Fix InfluxDB configuration (only update of html.zip necessary)
-
- Implementation of new CNN types to detect intermediate values of digits with rolling numbers
-
-  - By default the old algo (0, 1, ..., 9, "N") is active (due to the limited types of digits trained so far)
-  - Activation can be done by selection a tflite file with the new trained model in the 'config.ini'
-  - **Details can be found in the [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Neural-Network-Types)** (different types, trained image types, naming convention)
-
- Updated  neural network files (and adaption to new naming convention)
-
- Published a tool to download and combine log files - **Thanks to **
-
-  - Files see ['/tools/logfile-tool'](tbd), How-to see [wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Gasmeter-Log-Downloader)
-
- Bug Fix: InfluxDB enabling in grahic configuration
+## Build It Yourself
+See [Build Instructions](code/README.md).

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

 ## Additional Ideas
-There are some ideas and feature requests which are not followed currently - mainly due to capacity reasons on side of the developer. They are collected here: [FeatureRequest.md](FeatureRequest.md)
-
------
-
-## History
-
-##### 10.6.2 - Stability Increase (2022-07-24)
-
-##### 9.2.0 - External Illumination (2021-12-02)
-
-##### 8.5.0 Multi Meter Support (2021-10-07)
-
-##### 7.1.2 MQTT-Update - (2021-06-17)
-
-##### 6.7.2 Image Processing in Memory - (2021-05-01)
-
-##### 5.0.0 Setup Modus - (2020-12-06)
-
-##### 4.1.1 Configuration editor - (2020-12-02)
-
-##### 4.0.0 Tflite Core - (2020-11-15)
-##### 3.1.0 MQTT-Client - (2020-10-26)
-
-##### 2.2.1 Version Control - (2020-09-27)
-
-
-##### 2.1.0 Decimal Shift, Chrome & Edge - (2020-09-25)
-
-
-##### 2.0.0 Layout update - (2020-09-12)
-
-##### 1.1.3 Initial Version - (2020-09-09)
-
-
-#### [Full Changelog](Changelog.md)
-
+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,7 +1,16 @@
 .pio
+.idea
 .vscode/.browse.c_cpp.db*
 .vscode/c_cpp_properties.json
 .vscode/launch.json
 .vscode/ipch
 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/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -1,6 +1,6 @@
-cmake_minimum_required(VERSION 3.13.4)
+cmake_minimum_required(VERSION 3.16.0)

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

 ADD_CUSTOM_COMMAND(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/version.cpp
@@ -8,6 +8,15 @@ ADD_CUSTOM_COMMAND(
    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
@@ -8,6 +8,15 @@ 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
@@ -18,16 +27,14 @@ platformio run --environment esp32cam

 ### Upload
 ```
-pio run --target upload
+pio run --target upload --upload-port /dev/ttyUSB0
 ```

-If it doesnt find the device:
-1. make sure it is in bootloader mode
-1. set the UART device correctly: In `platformio.ini`, set `upload_port` correctly, eg. `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
+pio device monitor -p /dev/ttyUSB0
 ```

 ## Build and Flash with Visual Code IDE
@@ -62,3 +69,6 @@ pio device monitor
 - `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/configFile.cpp
+++ b/code/components/jomjol_configfile/configFile.cpp
@@ -4,13 +4,16 @@

 #include "Helper.h"
 #include "configFile.h"
+#include <esp_log.h>

-//static const char *TAGCONFIGFILE = "configFile";
+#include "../../include/defines.h"
+
+static const char *TAG = "CONFIG";

 ConfigFile::ConfigFile(std::string filePath)
 {
    std::string config = FormatFileName(filePath);
-    pFile = OpenFileAndWait(config.c_str(), "r");
+    pFile = fopen(config.c_str(), "r");
 }

 ConfigFile::~ConfigFile()
@@ -48,7 +51,7 @@ bool ConfigFile::getNextLine(std::string *rt, bool &disabled, bool &eof)

 	if (fgets(zw, 1024, pFile))
 	{
-		printf("%s", zw);
+		ESP_LOGD(TAG, "%s", zw);
 		if ((strlen(zw) == 0) && feof(pFile))
 		{
 			*rt = "";
@@ -64,10 +67,10 @@ bool ConfigFile::getNextLine(std::string *rt, bool &disabled, bool &eof)
 	}
 	*rt = zw;
 	*rt = trim(*rt);
-	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))			// Kommentarzeilen (; oder #) und Leerzeilen überspringen, es sei denn es ist ein neuer auskommentierter Paragraph
+	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))
 	{
 		fgets(zw, 1024, pFile);
-		printf("%s", zw);		
+		ESP_LOGD(TAG, "%s", zw);
 		if (feof(pFile))
 		{
 			*rt = "";
@@ -81,25 +84,3 @@ bool ConfigFile::getNextLine(std::string *rt, bool &disabled, bool &eof)
    disabled = ((*rt)[0] == ';');
 	return true;
 }
-
-std::vector<string> ConfigFile::ZerlegeZeile(std::string input, std::string delimiter)
-{
-	std::vector<string> Output;
-//	std::string delimiter = " =,";
-
-	input = trim(input, delimiter);
-	size_t pos = findDelimiterPos(input, delimiter);
-	std::string token;
-	while (pos != std::string::npos) {
-		token = input.substr(0, pos);
-		token = trim(token, delimiter);
-		Output.push_back(token);
-		input.erase(0, pos + 1);
-		input = trim(input, delimiter);
-		pos = findDelimiterPos(input, delimiter);
-	}
-	Output.push_back(input);
-
-	return Output;
-
-}
--- a/code/components/jomjol_configfile/configFile.h
+++ b/code/components/jomjol_configfile/configFile.h
@@ -1,3 +1,8 @@
+#pragma once
+
+#ifndef CONFIGFILE_H
+#define CONFIGFILE_H
+
 #include <string>
 #include <vector>

@@ -9,8 +14,10 @@ public:
    bool isNewParagraph(std::string input);
    bool GetNextParagraph(std::string& aktparamgraph, bool &disabled, bool &eof);
 	bool getNextLine(std::string* rt, bool &disabled, bool &eof);
-    std::vector<std::string> ZerlegeZeile(std::string input, std::string delimiter = " =, \t");
+    bool ConfigFileExists(){return pFile;};
    
 private:
    FILE* pFile;
-};
+};
+
+#endif //CONFIGFILE_H
--- a/code/components/jomjol_controlGPIO/Color.h
+++ b/code/components/jomjol_controlGPIO/Color.h
@@ -1,5 +1,8 @@
 #pragma once

+#ifndef COLOR_H
+#define COLOR_H
+
 #include <cstdint>
 #include "esp_attr.h"
 union Hsv;
@@ -67,3 +70,5 @@ union Hsv {
    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
@@ -1,5 +1,32 @@
 #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;

--- a/code/components/jomjol_controlGPIO/SmartLeds.h
+++ b/code/components/jomjol_controlGPIO/SmartLeds.h
@@ -1,5 +1,8 @@
 #pragma once

+#ifndef SMARTLEDS_H
+#define SMARTLEDS_H
+
 /*
 * A C++ driver for the WS2812 LEDs using the RMT peripheral on the ESP32.
 *
@@ -32,6 +35,20 @@
 #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"
@@ -62,6 +79,27 @@
    #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 {
@@ -528,3 +566,5 @@ private:
    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
@@ -6,32 +6,29 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_system.h"
-#include "esp_event.h"

-#include "server_tflite.h"
-
-//#define LOG_LOCAL_LEVEL ESP_LOG_DEBUG
 #include "esp_log.h"
-//#include "errno.h"

 #include <sys/stat.h>
 #include <vector>
-//#include <regex>

-#include "defines.h"
+#include "../../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_SERVERGPIO = "server_GPIO";
+
+static const char *TAG = "GPIO";
 QueueHandle_t gpio_queue_handle = NULL;

-#define DEBUG_DETAIL_ON 
-
 GpioPin::GpioPin(gpio_num_t gpio, const char* name, gpio_pin_mode_t mode, gpio_int_type_t interruptType, uint8_t dutyResolution, std::string mqttTopic, bool httpEnable) 
 {
    _gpio = gpio;
@@ -43,7 +40,7 @@ GpioPin::GpioPin(gpio_num_t gpio, const char* name, gpio_pin_mode_t mode, gpio_i

 GpioPin::~GpioPin()
 {
-    ESP_LOGD(TAG_SERVERGPIO,"reset GPIO pin %d", _gpio);
+    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);
@@ -66,13 +63,13 @@ static void IRAM_ATTR gpio_isr_handler(void* arg)
 }

 static void gpioHandlerTask(void *arg) {
-    ESP_LOGD(TAG_SERVERGPIO,"start interrupt task");
+    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_SERVERGPIO,"gpio: %d state: %d", gpioResult.gpio, gpioResult.value);
+                ESP_LOGD(TAG,"gpio: %d state: %d", gpioResult.gpio, gpioResult.value);
                ((GpioHandler*)arg)->gpioInterrupt(&gpioResult);
            }  
        }
@@ -83,12 +80,14 @@ static void gpioHandlerTask(void *arg) {
 }

 void GpioPin::gpioInterrupt(int value) {
-    if (_mqttTopic != "") {
-        ESP_LOGD(TAG_SERVERGPIO, "gpioInterrupt %s %d", _mqttTopic.c_str(), value);
+#ifdef ENABLE_MQTT    
+    if (_mqttTopic.compare("") != 0) {
+        ESP_LOGD(TAG, "gpioInterrupt %s %d", _mqttTopic.c_str(), value);

-        MQTTPublish(_mqttTopic, value ? "true" : "false");
-        currentState = value;
+        MQTTPublish(_mqttTopic, value ? "true" : "false", 1);        
    }
+#endif //ENABLE_MQTT
+    currentState = value;
 }

 void GpioPin::init()
@@ -110,14 +109,16 @@ void GpioPin::init()
 //    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_SERVERGPIO, "GpioPin::init add isr handler for GPIO %d\r\n", _gpio);
+        ESP_LOGD(TAG, "GpioPin::init add isr handler for GPIO %d", _gpio);
        gpio_isr_handler_add(_gpio, gpio_isr_handler, (void*)&_gpio);
    }

-    if ((_mqttTopic != "") && ((_mode == GPIO_PIN_MODE_OUTPUT) || (_mode == GPIO_PIN_MODE_OUTPUT_PWM) || (_mode == GPIO_PIN_MODE_BUILT_IN_FLASH_LED))) {
+#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)
@@ -131,30 +132,36 @@ bool GpioPin::getValue(std::string* errorText)

 void GpioPin::setValue(bool value, gpio_set_source setSource, std::string* errorText)
 {
-    ESP_LOGD(TAG_SERVERGPIO, "GpioPin::setValue %d\r\n", value);
+    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);

-        if ((_mqttTopic != "") && (setSource != GPIO_SET_SOURCE_MQTT)) {
-            MQTTPublish(_mqttTopic, value ? "true" : "false");
+#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_SERVERGPIO,"publish state of GPIO %d new state %d", _gpio, newState);
-        MQTTPublish(_mqttTopic, newState ? "true" : "false");
+        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_SERVERGPIO, "GpioPin::handleMQTT data %.*s\r\n", data_len, data);
+    ESP_LOGD(TAG, "GpioPin::handleMQTT data %.*s", data_len, data);

    std::string dataStr(data, data_len);
    dataStr = toLower(dataStr);
@@ -169,16 +176,16 @@ bool GpioPin::handleMQTT(std::string, char* data, int data_len) {
    }

    if (errorText != "") {
-        ESP_LOGE(TAG_SERVERGPIO, "%s", errorText.c_str());
+        ESP_LOGE(TAG, "%s", errorText.c_str());
    }

    return (errorText == "");
 }
-
+#endif //ENABLE_MQTT

 esp_err_t callHandleHttpRequest(httpd_req_t *req)
 {
-    ESP_LOGD(TAG_SERVERGPIO,"callHandleHttpRequest");
+    ESP_LOGD(TAG,"callHandleHttpRequest");

    GpioHandler *gpioHandler = (GpioHandler*)req->user_ctx;
    return gpioHandler->handleHttpRequest(req);
@@ -186,17 +193,17 @@ esp_err_t callHandleHttpRequest(httpd_req_t *req)

 void taskGpioHandler(void *pvParameter)
 {
-    ESP_LOGD(TAG_SERVERGPIO,"taskGpioHandler");
+    ESP_LOGD(TAG,"taskGpioHandler");
    ((GpioHandler*)pvParameter)->init();
 }

 GpioHandler::GpioHandler(std::string configFile, httpd_handle_t httpServer) 
 {
-    ESP_LOGI(TAG_SERVERGPIO,"start GpioHandler");
+    ESP_LOGI(TAG,"start GpioHandler");
    _configFile = configFile;
    _httpServer = httpServer;

-    ESP_LOGI(TAG_SERVERGPIO, "register GPIO Uri");
+    ESP_LOGI(TAG, "register GPIO Uri");
    registerGpioUri();
 }

@@ -210,10 +217,10 @@ GpioHandler::~GpioHandler()  {
 void GpioHandler::init()
 {
    // TickType_t xDelay = 60000 / portTICK_PERIOD_MS;
-    // printf("wait before start %ldms\r\n", (long) xDelay);
+    // ESP_LOGD(TAG, "wait before start %ldms", (long) xDelay);
    // vTaskDelay( xDelay );

-    printf("*************** Start GPIOHandler_Init *****************\n");
+    ESP_LOGD(TAG, "*************** Start GPIOHandler_Init *****************");

    if (gpioMap == NULL) {
        gpioMap = new std::map<gpio_num_t, GpioPin*>();
@@ -222,12 +229,12 @@ void GpioHandler::init()
    }
    
    
-    ESP_LOGI(TAG_SERVERGPIO, "read GPIO config and init GPIO");
+    ESP_LOGI(TAG, "read GPIO config and init GPIO");
    if (!readConfig()) {
        clear();
        delete gpioMap;
        gpioMap = NULL;
-        ESP_LOGI(TAG_SERVERGPIO, "GPIO init completed, handler is disabled");
+        ESP_LOGI(TAG, "GPIO init completed, handler is disabled");
        return;
    }

@@ -236,20 +243,22 @@ void GpioHandler::init()
        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", configMINIMAL_STACK_SIZE * 8, (void *)this, tskIDLE_PRIORITY + 2, &xHandleTaskGpio);
+        BaseType_t  xReturned = xTaskCreate(&gpioHandlerTask, "gpio_int", 3 * 1024, (void *)this, tskIDLE_PRIORITY + 4, &xHandleTaskGpio);
        if(xReturned == pdPASS ) {
-            ESP_LOGD(TAG_SERVERGPIO, "xHandletaskGpioHandler started");
+            ESP_LOGD(TAG, "xHandletaskGpioHandler started");
        } else {
-            ESP_LOGD(TAG_SERVERGPIO, "xHandletaskGpioHandler not started %d ", (int)xHandleTaskGpio);
+            ESP_LOGD(TAG, "xHandletaskGpioHandler not started %d ", (int)xHandleTaskGpio);
        }
    }

-    ESP_LOGI(TAG_SERVERGPIO, "GPIO init completed, is enabled");
+    ESP_LOGI(TAG, "GPIO init completed, is enabled");
 }

 void GpioHandler::taskHandler() {
@@ -261,7 +270,7 @@ void GpioHandler::taskHandler() {
    }
 }

-
+#ifdef ENABLE_MQTT
 void GpioHandler::handleMQTTconnect()
 {
    if (gpioMap != NULL) {
@@ -271,9 +280,12 @@ void GpioHandler::handleMQTTconnect()
        }
    }
 }
+#endif //ENABLE_MQTT

 void GpioHandler::deinit() {
+#ifdef ENABLE_MQTT
    MQTTunregisterConnectFunction("gpio-handler");
+#endif //ENABLE_MQTT
    clear();
    if (xHandleTaskGpio != NULL) {
        vTaskDelete(xHandleTaskGpio);
@@ -294,19 +306,19 @@ bool GpioHandler::readConfig()

    ConfigFile configFile = ConfigFile(_configFile); 

-    std::vector<std::string> zerlegt;
+    std::vector<std::string> splitted;
    std::string line = "";
    bool disabledLine = false;
    bool eof = false;
    gpio_num_t gpioExtLED = (gpio_num_t) 0;
    
-//    printf("readConfig - Start 1\n");
+//    ESP_LOGD(TAG, "readConfig - Start 1");
        
    while ((!configFile.GetNextParagraph(line, disabledLine, eof) || (line.compare("[GPIO]") != 0)) && !eof) {}
    if (eof)
        return false;

-//    printf("readConfig - Start 2 line: %s, disabbledLine: %d\n", line.c_str(), (int) disabledLine);
+//    ESP_LOGD(TAG, "readConfig - Start 2 line: %s, disabbledLine: %d", line.c_str(), (int) disabledLine);


    _isEnabled = !disabledLine;
@@ -314,52 +326,59 @@ bool GpioHandler::readConfig()
    if (!_isEnabled)
        return false;

-//    printf("readConfig - Start 3\n");
+//    ESP_LOGD(TAG, "readConfig - Start 3");

+#ifdef ENABLE_MQTT
 //    std::string mainTopicMQTT = "";
-    std::string mainTopicMQTT = GetMQTTMainTopic();
+    std::string mainTopicMQTT = mqttServer_getMainTopic();
    if (mainTopicMQTT.length() > 0)
    {
        mainTopicMQTT = mainTopicMQTT + "/GPIO";
-        ESP_LOGD(TAG_SERVERGPIO, "MAINTOPICMQTT found\r\n");
+        ESP_LOGD(TAG, "MAINTOPICMQTT found");
    }
-
+#endif // ENABLE_MQTT
    bool registerISR = false;
    while (configFile.getNextLine(&line, disabledLine, eof) && !configFile.isNewParagraph(line))
    {
-        zerlegt = configFile.ZerlegeZeile(line);
+        splitted = ZerlegeZeile(line);
        // const std::regex pieces_regex("IO([0-9]{1,2})");
        // std::smatch pieces_match;
-        // if (std::regex_match(zerlegt[0], pieces_match, pieces_regex) && (pieces_match.size() == 2))
+        // if (std::regex_match(splitted[0], pieces_match, pieces_regex) && (pieces_match.size() == 2))
        // {
        //     std::string gpioStr = pieces_match[1];
-        ESP_LOGD(TAG_SERVERGPIO, "conf param %s\r\n", toUpper(zerlegt[0]).c_str());
-        if (toUpper(zerlegt[0]) == "MAINTOPICMQTT") {
-//            ESP_LOGD(TAG_SERVERGPIO, "MAINTOPICMQTT found\r\n");
-//            mainTopicMQTT = zerlegt[1];
-        } else if ((zerlegt[0].rfind("IO", 0) == 0) && (zerlegt.size() >= 6))
+        ESP_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_SERVERGPIO,"Enable GP%s in %s mode", zerlegt[0].c_str(), zerlegt[1].c_str());
-            std::string gpioStr = zerlegt[0].substr(2, 2);
+            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(zerlegt[1]));
-            gpio_int_type_t intType = resolveIntType(toLower(zerlegt[2]));
-            uint16_t dutyResolution = (uint8_t)atoi(zerlegt[3].c_str());
-            bool mqttEnabled = toLower(zerlegt[4]) == "true";
-            bool httpEnabled = toLower(zerlegt[5]) == "true";
+            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 (zerlegt.size() >= 7) {
-                strcpy(gpioName, trim(zerlegt[6]).c_str());
+            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)
            {
-                printf("Set WS2812 to GPIO %d\n", gpioNr);
+                ESP_LOGD(TAG, "Set WS2812 to GPIO %d", gpioNr);
                gpioExtLED = gpioNr;
            }

@@ -367,28 +386,28 @@ bool GpioHandler::readConfig()
                registerISR = true;
            }
        }
-        if (toUpper(zerlegt[0]) == "LEDNUMBERS")
+        if (toUpper(splitted[0]) == "LEDNUMBERS")
        {
-            LEDNumbers = stoi(zerlegt[1]);
+            LEDNumbers = stoi(splitted[1]);
        }
-        if (toUpper(zerlegt[0]) == "LEDCOLOR")
+        if (toUpper(splitted[0]) == "LEDCOLOR")
        {
            uint8_t _r, _g, _b;
-            _r = stoi(zerlegt[1]);
-            _g = stoi(zerlegt[2]);
-            _b = stoi(zerlegt[3]);
+            _r = stoi(splitted[1]);
+            _g = stoi(splitted[2]);
+            _b = stoi(splitted[3]);

            LEDColor = Rgb{_r, _g, _b};
        }
-        if (toUpper(zerlegt[0]) == "LEDTYPE")
+        if (toUpper(splitted[0]) == "LEDTYPE")
        {
-            if (zerlegt[1] == "WS2812")
+            if (splitted[1] == "WS2812")
                LEDType = LED_WS2812;
-            if (zerlegt[1] == "WS2812B")
+            if (splitted[1] == "WS2812B")
                LEDType = LED_WS2812B;
-            if (zerlegt[1] == "SK6812")
+            if (splitted[1] == "SK6812")
                LEDType = LED_SK6812;
-            if (zerlegt[1] == "WS2813")
+            if (splitted[1] == "WS2813")
                LEDType = LED_WS2813;
        }
    }
@@ -400,10 +419,10 @@ bool GpioHandler::readConfig()

    if (gpioExtLED > 0)
    {
-    //     LogFile.WriteToFile("Startsequence 06");      // Nremove
+    //     LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Startsequence 06");      // Nremove
 //        vTaskDelay( xDelay );   
 //        xDelay = 5000 / portTICK_PERIOD_MS;
-//        printf("main: sleep for : %ldms\n", (long) xDelay);
+//        ESP_LOGD(TAG, "main: sleep for: %ldms", (long) xDelay);

 //        SmartLed leds( LED_WS2812, 2, GPIO_NUM_12, 0, DoubleBuffer );

@@ -420,7 +439,7 @@ bool GpioHandler::readConfig()

 void GpioHandler::clear() 
 {
-    ESP_LOGD(TAG_SERVERGPIO, "GpioHandler::clear\r\n");
+    ESP_LOGD(TAG, "GpioHandler::clear");

    if (gpioMap != NULL) {
        for(std::map<gpio_num_t, GpioPin*>::iterator it = gpioMap->begin(); it != gpioMap->end(); ++it) {
@@ -434,7 +453,7 @@ void GpioHandler::clear()
 
 void GpioHandler::registerGpioUri() 
 {
-    ESP_LOGI(TAG_SERVERGPIO, "server_GPIO - Registering URI handlers");
+    ESP_LOGI(TAG, "server_GPIO - Registering URI handlers");
    
    httpd_uri_t camuri = { };
    camuri.method    = HTTP_GET;
@@ -446,7 +465,7 @@ void GpioHandler::registerGpioUri()

 esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
 {
-    ESP_LOGD(TAG_SERVERGPIO, "handleHttpRequest");
+    ESP_LOGD(TAG, "handleHttpRequest");

    if (gpioMap == NULL) {
        std::string resp_str = "GPIO handler not initialized";
@@ -458,18 +477,18 @@ esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
    LogFile.WriteHeapInfo("handler_switch_GPIO - Start");    
 #endif

-    LogFile.WriteToFile("handler_switch_GPIO");    
+    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_SERVERGPIO, "Query: %s", _query);
+        ESP_LOGD(TAG, "Query: %s", _query);
        
        if (httpd_query_key_value(_query, "GPIO", _valueGPIO, 30) == ESP_OK)
        {
-            ESP_LOGD(TAG_SERVERGPIO, "GPIO is found %s", _valueGPIO); 
+            ESP_LOGD(TAG, "GPIO is found %s", _valueGPIO); 
            gpio = std::string(_valueGPIO);
        } else {
            std::string resp_str = "GPIO No is not defined";
@@ -478,7 +497,7 @@ esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)
        }
        if (httpd_query_key_value(_query, "Status", _valueStatus, 30) == ESP_OK)
        {
-            ESP_LOGD(TAG_SERVERGPIO, "Status is found %s", _valueStatus); 
+            ESP_LOGD(TAG, "Status is found %s", _valueStatus); 
            status = std::string(_valueStatus);
        }
    } else {
@@ -541,7 +560,7 @@ esp_err_t GpioHandler::handleHttpRequest(httpd_req_t *req)

 void GpioHandler::flashLightEnable(bool value) 
 {
-    ESP_LOGD(TAG_SERVERGPIO, "GpioHandler::flashLightEnable %s\r\n", value ? "true" : "false");
+    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) 
@@ -552,9 +571,9 @@ void GpioHandler::flashLightEnable(bool value)
                it->second->setValue(value, GPIO_SET_SOURCE_INTERNAL, &resp_str);

                if (resp_str == "") {
-                    ESP_LOGD(TAG_SERVERGPIO, "Flash light pin GPIO %d switched to %s\r\n", (int)it->first, (value ? "on" : "off"));
+                    ESP_LOGD(TAG, "Flash light pin GPIO %d switched to %s", (int)it->first, (value ? "on" : "off"));
                } else {
-                    ESP_LOGE(TAG_SERVERGPIO, "Can't set flash light pin GPIO %d.  Error: %s\r\n", (int)it->first, resp_str.c_str());
+                    ESP_LOGE(TAG, "Can't set flash light pin GPIO %d.  Error: %s", (int)it->first, resp_str.c_str());
                }
            } else 
                {
@@ -562,7 +581,7 @@ void GpioHandler::flashLightEnable(bool value)
                    {
 #ifdef __LEDGLOBAL
                        if (leds_global == NULL) {
-                            ESP_LOGI(TAG_SERVERGPIO, "init SmartLed: LEDNumber=%d, GPIO=%d", LEDNumbers, (int)it->second->getGPIO());
+                            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
@@ -673,6 +692,7 @@ void gpio_handler_deinit() {
 void gpio_handler_destroy()
 {
    if (gpioHandler != NULL) {
+        gpio_handler_deinit();
        delete gpioHandler;
        gpioHandler = NULL;
    }
@@ -682,3 +702,4 @@ GpioHandler* gpio_handler_get()
 {
    return gpioHandler;
 }
+
--- a/code/components/jomjol_controlGPIO/server_GPIO.h
+++ b/code/components/jomjol_controlGPIO/server_GPIO.h
@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef SERVER_GPIO_H
 #define SERVER_GPIO_H

@@ -9,11 +11,6 @@

 #include "SmartLeds.h"

-//#include "ClassControllCamera.h"
-
-// wenn __LEDGLOBAL definiert ist, wird eine globale Variable für die LED-Ansteuerung verwendet, ansonsten lokal und jedesmal neu
-#define __LEDGLOBAL
-
 typedef enum {
    GPIO_PIN_MODE_DISABLED              = 0x0,
    GPIO_PIN_MODE_INPUT                 = 0x1,
@@ -45,7 +42,9 @@ public:
    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; }
@@ -77,7 +76,9 @@ public:
    void gpioInterrupt(GpioResult* gpioResult);  
    void flashLightEnable(bool value);
    bool isEnabled() { return _isEnabled; }
+#ifdef ENABLE_MQTT
    void handleMQTTconnect();
+#endif //ENABLE_MQTT

 private:
    std::string _configFile;
@@ -109,4 +110,5 @@ GpioHandler* gpio_handler_get();



-#endif //SERVER_GPIO_H
+#endif //SERVER_GPIO_H
+
--- a/code/components/jomjol_controlcamera/CMakeLists.txt
+++ b/code/components/jomjol_controlcamera/CMakeLists.txt
@@ -4,6 +4,6 @@ list(APPEND EXTRA_COMPONENT_DIRS $ENV{IDF_PATH}/examples/common_components/proto

 idf_component_register(SRCS ${app_sources}
                    INCLUDE_DIRS "."
-                    REQUIRES esp32-camera esp_http_server jomjol_logfile jomjol_image_proc nvs_flash jomjol_fileserver_ota jomjol_controlGPIO)
+                    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
@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef CLASSCONTROLLCAMERA_H
 #define CLASSCONTROLLCAMERA_H

@@ -11,46 +13,101 @@
 #include <string>
 #include <esp_http_server.h>
 #include "CImageBasis.h"
+#include "../../include/defines.h"

+typedef struct
+{
+    uint16_t CamSensor_id;

-#define CAMERA_MODEL_AI_THINKER
+    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)

-class CCamera {
-    protected:
-        int ActualQuality;
-        framesize_t ActualResolution;
-        int brightness, contrast, saturation;
-        bool isFixedExposure;
-        int waitbeforepicture_org;
-        int led_intensity = 4095;
+    int ImageDenoiseLevel; // The OV2640 does not support it, OV3660 and OV5640 (0 to 8)

-        void ledc_init(void);
+    int ImageWidth;
+    int ImageHeight;

-    public:
-        int image_height, image_width;
-        
-        CCamera();
-        esp_err_t InitCam();
+    int ImageLedIntensity;

-        void LightOnOff(bool status);
-        void LEDOnOff(bool status);
-        esp_err_t CaptureToHTTP(httpd_req_t *req, int delay = 0);
-        void SetQualitySize(int qual, framesize_t resol);
-        bool SetBrightnessContrastSaturation(int _brightness, int _contrast, int _saturation);
-        void GetCameraParameter(httpd_req_t *req, int &qual, framesize_t &resol);
-        void SetLEDIntensity(float _intrel);
+    bool ImageZoomEnabled;
+    int ImageZoomOffsetX;
+    int ImageZoomOffsetY;
+    int ImageZoomSize;

-        void EnableAutoExposure(int flashdauer);
-        
+    int WaitBeforePicture;
+    bool isImageSize;

-        framesize_t TextToFramesize(const char * text);
+    bool CameraInitSuccessful;
+    bool changedCameraSettings;
+    bool DemoMode;
+    bool SaveAllFiles;
+} camera_controll_config_temp_t;

-        esp_err_t CaptureToFile(std::string nm, int delay = 0);
-        esp_err_t CaptureToBasisImage(CImageBasis *_Image, int delay = 0);
+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/img_converters.h
+++ b/code/components/jomjol_controlcamera/img_converters.h
@@ -1,126 +0,0 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#ifndef _IMG_CONVERTERS_H_
-#define _IMG_CONVERTERS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include "esp_camera.h"
-
-typedef size_t (* jpg_out_cb)(void * arg, size_t index, const void* data, size_t len);
-
-/**
- * @brief Convert image buffer to JPEG
- *
- * @param src       Source buffer in RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param quality   JPEG quality of the resulting image
- * @param cp        Callback to be called to write the bytes of the output JPEG
- * @param arg       Pointer to be passed to the callback
- *
- * @return true on success
- */
-bool fmt2jpg_cb(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, jpg_out_cb cb, void * arg);
-
-/**
- * @brief Convert camera frame buffer to JPEG
- *
- * @param fb        Source camera frame buffer
- * @param quality   JPEG quality of the resulting image
- * @param cp        Callback to be called to write the bytes of the output JPEG
- * @param arg       Pointer to be passed to the callback
- *
- * @return true on success
- */
-bool frame2jpg_cb(camera_fb_t * fb, uint8_t quality, jpg_out_cb cb, void * arg);
-
-/**
- * @brief Convert image buffer to JPEG buffer
- *
- * @param src       Source buffer in RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param quality   JPEG quality of the resulting image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool fmt2jpg(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t quality, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert camera frame buffer to JPEG buffer
- *
- * @param fb        Source camera frame buffer
- * @param quality   JPEG quality of the resulting image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool frame2jpg(camera_fb_t * fb, uint8_t quality, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert image buffer to BMP buffer
- *
- * @param src       Source buffer in JPEG, RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param width     Width in pixels of the source image
- * @param height    Height in pixels of the source image
- * @param format    Format of the source image
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool fmt2bmp(uint8_t *src, size_t src_len, uint16_t width, uint16_t height, pixformat_t format, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert camera frame buffer to BMP buffer
- *
- * @param fb        Source camera frame buffer
- * @param out       Pointer to be populated with the address of the resulting buffer
- * @param out_len   Pointer to be populated with the length of the output buffer
- *
- * @return true on success
- */
-bool frame2bmp(camera_fb_t * fb, uint8_t ** out, size_t * out_len);
-
-/**
- * @brief Convert image buffer to RGB888 buffer (used for face detection)
- *
- * @param src       Source buffer in JPEG, RGB565, RGB888, YUYV or GRAYSCALE format
- * @param src_len   Length in bytes of the source buffer
- * @param format    Format of the source image
- * @param rgb_buf   Pointer to the output buffer (width * height * 3)
- *
- * @return true on success
- */
-bool fmt2rgb888(const uint8_t *src_buf, size_t src_len, pixformat_t format, uint8_t * rgb_buf);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _IMG_CONVERTERS_H_ */
--- 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/sensor_old.h
+++ b/code/components/jomjol_controlcamera/sensor_old.h
@@ -1,245 +0,0 @@
-/*
- * This file is part of the OpenMV project.
- * Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
- * This work is licensed under the MIT license, see the file LICENSE for details.
- *
- * Sensor abstraction layer.
- *
- */
-#ifndef __SENSOR_H__
-#define __SENSOR_H__
-#include <stdint.h>
-#include <stdbool.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-    OV9650_PID = 0x96,
-    OV7725_PID = 0x77,
-    OV2640_PID = 0x26,
-    OV3660_PID = 0x3660,
-    OV5640_PID = 0x5640,
-    OV7670_PID = 0x76,
-    NT99141_PID = 0x1410,
-    GC2145_PID = 0x2145,
-    GC032A_PID = 0x232a,
-    GC0308_PID = 0x9b,
-} camera_pid_t;
-
-typedef enum {
-    CAMERA_OV7725,
-    CAMERA_OV2640,
-    CAMERA_OV3660,
-    CAMERA_OV5640,
-    CAMERA_OV7670,
-    CAMERA_NT99141,
-    CAMERA_GC2145,
-    CAMERA_GC032A,
-    CAMERA_GC0308,
-    CAMERA_MODEL_MAX,
-    CAMERA_NONE,
-} camera_model_t;
-
-typedef enum {
-    OV2640_SCCB_ADDR   = 0x30,// 0x60 >> 1
-    OV5640_SCCB_ADDR   = 0x3C,// 0x78 >> 1
-    OV3660_SCCB_ADDR   = 0x3C,// 0x78 >> 1
-    OV7725_SCCB_ADDR   = 0x21,// 0x42 >> 1
-    OV7670_SCCB_ADDR   = 0x21,// 0x42 >> 1
-    NT99141_SCCB_ADDR  = 0x2A,// 0x54 >> 1
-    GC2145_SCCB_ADDR   = 0x3C,// 0x78 >> 1
-    GC032A_SCCB_ADDR   = 0x21,// 0x42 >> 1
-    GC0308_SCCB_ADDR   = 0x21,// 0x42 >> 1
-} camera_sccb_addr_t;
-
-typedef enum {
-    PIXFORMAT_RGB565,    // 2BPP/RGB565
-    PIXFORMAT_YUV422,    // 2BPP/YUV422
-    PIXFORMAT_GRAYSCALE, // 1BPP/GRAYSCALE
-    PIXFORMAT_JPEG,      // JPEG/COMPRESSED
-    PIXFORMAT_RGB888,    // 3BPP/RGB888
-    PIXFORMAT_RAW,       // RAW
-    PIXFORMAT_RGB444,    // 3BP2P/RGB444
-    PIXFORMAT_RGB555,    // 3BP2P/RGB555
-} pixformat_t;
-
-typedef enum {
-    FRAMESIZE_96X96,    // 96x96
-    FRAMESIZE_QQVGA,    // 160x120
-    FRAMESIZE_QCIF,     // 176x144
-    FRAMESIZE_HQVGA,    // 240x176
-    FRAMESIZE_240X240,  // 240x240
-    FRAMESIZE_QVGA,     // 320x240
-    FRAMESIZE_CIF,      // 400x296
-    FRAMESIZE_HVGA,     // 480x320
-    FRAMESIZE_VGA,      // 640x480
-    FRAMESIZE_SVGA,     // 800x600
-    FRAMESIZE_XGA,      // 1024x768
-    FRAMESIZE_HD,       // 1280x720
-    FRAMESIZE_SXGA,     // 1280x1024
-    FRAMESIZE_UXGA,     // 1600x1200
-    // 3MP Sensors
-    FRAMESIZE_FHD,      // 1920x1080
-    FRAMESIZE_P_HD,     //  720x1280
-    FRAMESIZE_P_3MP,    //  864x1536
-    FRAMESIZE_QXGA,     // 2048x1536
-    // 5MP Sensors
-    FRAMESIZE_QHD,      // 2560x1440
-    FRAMESIZE_WQXGA,    // 2560x1600
-    FRAMESIZE_P_FHD,    // 1080x1920
-    FRAMESIZE_QSXGA,    // 2560x1920
-    FRAMESIZE_INVALID
-} framesize_t;
-
-typedef struct {
-    const camera_model_t model;
-    const char *name;
-    const camera_sccb_addr_t sccb_addr;
-    const camera_pid_t pid;
-    const framesize_t max_size;
-    const bool support_jpeg;
-} camera_sensor_info_t;
-
-typedef enum {
-    ASPECT_RATIO_4X3,
-    ASPECT_RATIO_3X2,
-    ASPECT_RATIO_16X10,
-    ASPECT_RATIO_5X3,
-    ASPECT_RATIO_16X9,
-    ASPECT_RATIO_21X9,
-    ASPECT_RATIO_5X4,
-    ASPECT_RATIO_1X1,
-    ASPECT_RATIO_9X16
-} aspect_ratio_t;
-
-typedef enum {
-    GAINCEILING_2X,
-    GAINCEILING_4X,
-    GAINCEILING_8X,
-    GAINCEILING_16X,
-    GAINCEILING_32X,
-    GAINCEILING_64X,
-    GAINCEILING_128X,
-} gainceiling_t;
-
-typedef struct {
-        uint16_t max_width;
-        uint16_t max_height;
-        uint16_t start_x;
-        uint16_t start_y;
-        uint16_t end_x;
-        uint16_t end_y;
-        uint16_t offset_x;
-        uint16_t offset_y;
-        uint16_t total_x;
-        uint16_t total_y;
-} ratio_settings_t;
-
-typedef struct {
-        const uint16_t width;
-        const uint16_t height;
-        const aspect_ratio_t aspect_ratio;
-} resolution_info_t;
-
-// Resolution table (in sensor.c)
-extern const resolution_info_t resolution[];
-// camera sensor table (in sensor.c)
-extern const camera_sensor_info_t camera_sensor[];
-
-typedef struct {
-    uint8_t MIDH;
-    uint8_t MIDL;
-    uint16_t PID;
-    uint8_t VER;
-} sensor_id_t;
-
-typedef struct {
-    framesize_t framesize;//0 - 10
-    bool scale;
-    bool binning;
-    uint8_t quality;//0 - 63
-    int8_t brightness;//-2 - 2
-    int8_t contrast;//-2 - 2
-    int8_t saturation;//-2 - 2
-    int8_t sharpness;//-2 - 2
-    uint8_t denoise;
-    uint8_t special_effect;//0 - 6
-    uint8_t wb_mode;//0 - 4
-    uint8_t awb;
-    uint8_t awb_gain;
-    uint8_t aec;
-    uint8_t aec2;
-    int8_t ae_level;//-2 - 2
-    uint16_t aec_value;//0 - 1200
-    uint8_t agc;
-    uint8_t agc_gain;//0 - 30
-    uint8_t gainceiling;//0 - 6
-    uint8_t bpc;
-    uint8_t wpc;
-    uint8_t raw_gma;
-    uint8_t lenc;
-    uint8_t hmirror;
-    uint8_t vflip;
-    uint8_t dcw;
-    uint8_t colorbar;
-} camera_status_t;
-
-typedef struct _sensor sensor_t;
-typedef struct _sensor {
-    sensor_id_t id;             // Sensor ID.
-    uint8_t  slv_addr;          // Sensor I2C slave address.
-    pixformat_t pixformat;
-    camera_status_t status;
-    int xclk_freq_hz;
-
-    // Sensor function pointers
-    int  (*init_status)         (sensor_t *sensor);
-    int  (*reset)               (sensor_t *sensor);
-    int  (*set_pixformat)       (sensor_t *sensor, pixformat_t pixformat);
-    int  (*set_framesize)       (sensor_t *sensor, framesize_t framesize);
-    int  (*set_contrast)        (sensor_t *sensor, int level);
-    int  (*set_brightness)      (sensor_t *sensor, int level);
-    int  (*set_saturation)      (sensor_t *sensor, int level);
-    int  (*set_sharpness)       (sensor_t *sensor, int level);
-    int  (*set_denoise)         (sensor_t *sensor, int level);
-    int  (*set_gainceiling)     (sensor_t *sensor, gainceiling_t gainceiling);
-    int  (*set_quality)         (sensor_t *sensor, int quality);
-    int  (*set_colorbar)        (sensor_t *sensor, int enable);
-    int  (*set_whitebal)        (sensor_t *sensor, int enable);
-    int  (*set_gain_ctrl)       (sensor_t *sensor, int enable);
-    int  (*set_exposure_ctrl)   (sensor_t *sensor, int enable);
-    int  (*set_hmirror)         (sensor_t *sensor, int enable);
-    int  (*set_vflip)           (sensor_t *sensor, int enable);
-
-    int  (*set_aec2)            (sensor_t *sensor, int enable);
-    int  (*set_awb_gain)        (sensor_t *sensor, int enable);
-    int  (*set_agc_gain)        (sensor_t *sensor, int gain);
-    int  (*set_aec_value)       (sensor_t *sensor, int gain);
-
-    int  (*set_special_effect)  (sensor_t *sensor, int effect);
-    int  (*set_wb_mode)         (sensor_t *sensor, int mode);
-    int  (*set_ae_level)        (sensor_t *sensor, int level);
-
-    int  (*set_dcw)             (sensor_t *sensor, int enable);
-    int  (*set_bpc)             (sensor_t *sensor, int enable);
-    int  (*set_wpc)             (sensor_t *sensor, int enable);
-
-    int  (*set_raw_gma)         (sensor_t *sensor, int enable);
-    int  (*set_lenc)            (sensor_t *sensor, int enable);
-
-    int  (*get_reg)             (sensor_t *sensor, int reg, int mask);
-    int  (*set_reg)             (sensor_t *sensor, int reg, int mask, int value);
-    int  (*set_res_raw)         (sensor_t *sensor, int startX, int startY, int endX, int endY, int offsetX, int offsetY, int totalX, int totalY, int outputX, int outputY, bool scale, bool binning);
-    int  (*set_pll)             (sensor_t *sensor, int bypass, int mul, int sys, int root, int pre, int seld5, int pclken, int pclk);
-    int  (*set_xclk)            (sensor_t *sensor, int timer, int xclk);
-} sensor_t;
-
-camera_sensor_info_t *esp_camera_sensor_get_info(sensor_id_t *id);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __SENSOR_H__ */
--- a/code/components/jomjol_controlcamera/server_camera.cpp
+++ b/code/components/jomjol_controlcamera/server_camera.cpp
@@ -5,245 +5,299 @@

 #include "esp_camera.h"
 #include "ClassControllCamera.h"
+#include "MainFlowControl.h"

 #include "ClassLogFile.h"
+#include "esp_log.h"

-#define SCRATCH_BUFSIZE2  8192 
-char scratch2[SCRATCH_BUFSIZE2];
+#include "../../include/defines.h"

-//#define DEBUG_DETAIL_ON   
-static const char *TAGPARTCAMERA = "server_camera";
+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);

-void PowerResetCamera(){
-        ESP_LOGD(TAGPARTCAMERA, "Resetting camera by power down line");
-        gpio_config_t conf;
-        conf.intr_type = GPIO_INTR_DISABLE;
-        conf.pin_bit_mask = 1LL << GPIO_NUM_32;
-        conf.mode = GPIO_MODE_OUTPUT;
-        conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
-        conf.pull_up_en = GPIO_PULLUP_DISABLE;
-        gpio_config(&conf);
-
-        // carefull, logic is inverted compared to reset pin
-        gpio_set_level(GPIO_NUM_32, 1);
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
-        gpio_set_level(GPIO_NUM_32, 0);
-        vTaskDelay(1000 / portTICK_PERIOD_MS);
+    // 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   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_lightOn - Start");
-    printf("handler_lightOn uri:\n"); printf(req->uri); printf("\n");
+    ESP_LOGD(TAG, "handler_lightOn uri: %s", req->uri);
 #endif

-    Camera.LightOnOff(true);
-    const char* resp_str = (const char*) req->user_ctx;
-    httpd_resp_send(req, resp_str, strlen(resp_str));  
+    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   
+#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   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_lightOff - Start");
-    printf("handler_lightOff uri:\n"); printf(req->uri); printf("\n");
+    ESP_LOGD(TAG, "handler_lightOff uri: %s", req->uri);
 #endif
-    Camera.LightOnOff(false);
-    const char* resp_str = (const char*) req->user_ctx;
-    httpd_resp_send(req, resp_str, strlen(resp_str));       

-#ifdef DEBUG_DETAIL_ON   
+    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   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_capture - Start");
 #endif

-    int quality;
-    framesize_t res;
-
-    Camera.GetCameraParameter(req, quality, res);
-
-#ifdef DEBUG_DETAIL_ON   
-    printf("Size: %d", res); printf(" Quality: %d\n", quality);
-#endif
-
-    Camera.SetQualitySize(quality, res);
-
-    esp_err_t ressult;
-    ressult = Camera.CaptureToHTTP(req);
-
-#ifdef DEBUG_DETAIL_ON   
-    LogFile.WriteHeapInfo("handler_capture - Done");
-#endif
-
-    return ressult;
-};
-
-
-esp_err_t handler_capture_with_ligth(httpd_req_t *req)
-{
-#ifdef DEBUG_DETAIL_ON  
-    LogFile.WriteHeapInfo("handler_capture_with_ligth - Start");
-#endif
-    char _query[100];
-    char _delay[10];
-
-    int quality;
-    framesize_t res;    
-    int delay = 2500;
-
-    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    if (Camera.getCameraInitSuccessful())
    {
-        printf("Query: "); printf(_query); printf("\n");
-        if (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
+        // If the camera settings were changed by creating a new reference image, they must be reset
+        if (CFstatus.changedCameraSettings)
        {
-#ifdef DEBUG_DETAIL_ON   
-            printf("Delay: "); printf(_delay); printf("\n");    
-#endif        
-            delay = atoi(_delay);
-
-            if (delay < 0)
-                delay = 0;
+            Camera.setSensorDatenFromCCstatus(); // CCstatus >>> Kamera
+            Camera.SetQualityZoomSize(CCstatus.ImageQuality, CCstatus.ImageFrameSize, CCstatus.ImageZoomEnabled, CCstatus.ImageZoomOffsetX, CCstatus.ImageZoomOffsetY, CCstatus.ImageZoomSize, CCstatus.ImageVflip);
+            CFstatus.changedCameraSettings = false;
        }
-    };

-    Camera.GetCameraParameter(req, quality, res);
+#ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Size: %d, Quality: %d", CCstatus.ImageFrameSize, CCstatus.ImageQuality);
+#endif        

-#ifdef DEBUG_DETAIL_ON   
-    printf("Size: %d", res); printf(" Quality: %d\n", quality);
+        esp_err_t result;
+        result = Camera.CaptureToHTTP(req);
+
+#ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("handler_capture - Done");
 #endif

-    Camera.SetQualitySize(quality, res);
-    Camera.LightOnOff(true);
-    const TickType_t xDelay = delay / portTICK_PERIOD_MS;
-    vTaskDelay( xDelay );
+        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 ressult;
-    ressult = Camera.CaptureToHTTP(req);  
-
-    Camera.LightOnOff(false);
-
-#ifdef DEBUG_DETAIL_ON   
-    LogFile.WriteHeapInfo("handler_capture_with_ligth - Done");
+esp_err_t handler_capture_with_light(httpd_req_t *req)
+{
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_capture_with_light - Start");
 #endif

-    return ressult;
-};
+    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   
+#ifdef DEBUG_DETAIL_ON
    LogFile.WriteHeapInfo("handler_capture_save_to_file - Start");
 #endif

-    char _query[100];
-    char _delay[10];
-    int delay = 0;
-    char filename[100];
-    std::string fn = "/sdcard/";
-
-
-    int quality;
-    framesize_t res;    
-
-    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    if (Camera.getCameraInitSuccessful())
    {
-        printf("Query: "); printf(_query); printf("\n");
-        if (httpd_query_key_value(_query, "filename", filename, 100) == ESP_OK)
+        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)
        {
-            fn.append(filename);
-#ifdef DEBUG_DETAIL_ON   
-            printf("Filename: "); printf(fn.c_str()); printf("\n");            
+            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 (httpd_query_key_value(_query, "delay", _delay, 10) == ESP_OK)
        {
-#ifdef DEBUG_DETAIL_ON   
-            printf("Delay: "); printf(_delay); printf("\n");            
-#endif
-            delay = atoi(_delay);
-
-            if (delay < 0)
-                delay = 0;
+            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
-        fn.append("noname.jpg");
-
-    Camera.GetCameraParameter(req, quality, res);
-#ifdef DEBUG_DETAIL_ON   
-    printf("Size: %d", res); printf(" Quality: %d\n", quality);
-#endif
-    Camera.SetQualitySize(quality, res);
-
-    esp_err_t ressult;
-    ressult = 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 ressult;
-};
-
-
+    {
+        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(TAGPARTCAMERA, "server_part_camera - Registering URI handlers");
+#ifdef DEBUG_DETAIL_ON
+    ESP_LOGI(TAG, "server_part_camera - Registering URI handlers");
 #endif

-    httpd_uri_t camuri = { };
-    camuri.method    = HTTP_GET;
+    httpd_uri_t camuri = {};
+    camuri.method = HTTP_GET;

-    camuri.uri       = "/lighton";
-    camuri.handler   = handler_lightOn;
-    camuri.user_ctx  = (void*) "Light On";    
+    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 = "/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";
+    camuri.handler = handler_capture;
+    camuri.user_ctx = NULL;
+    httpd_register_uri_handler(server, &camuri);

-    camuri.uri       = "/capture_with_flashlight";
-    camuri.handler   = handler_capture_with_ligth;
-    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);    
+    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

@@ -8,7 +10,6 @@
 //#include "ClassControllCamera.h"

 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
@@ -1,7 +1,7 @@
 FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)

 idf_component_register(SRCS ${app_sources}
-                    INCLUDE_DIRS "." "../../include"
-                    REQUIRES tflite-lib esp_http_server app_update esp_http_client nvs_flash jomjol_tfliteclass jomjol_flowcontroll spiffs jomjol_helper jomjol_controlGPIO)
+                    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
@@ -0,0 +1,22 @@
+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
@@ -1,12 +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/");
+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
@@ -21,29 +21,55 @@ extern "C" {

 #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];
+
+
+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 = OpenFileAndWait(filename.c_str(), "r");
+    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 ...", filename.c_str());
+    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 */
@@ -51,7 +77,7 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)
    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) {
@@ -69,7 +95,7 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)

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

--- 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"
@@ -7,4 +12,6 @@ const char* get_path_from_uri(char *dest, const char *base_path, const char *uri

 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
@@ -3,7 +3,10 @@
 #include <string>
 #include "string.h"

-#include <esp_int_wdt.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>


@@ -11,14 +14,13 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_system.h"
-#include "esp_event.h"
-#include "esp_event.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"
@@ -26,44 +28,118 @@

 #include <sys/stat.h>

-#include "server_tflite.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"
-
-
-// #define DEBUG_DETAIL_ON 
-
-
-#define BUFFSIZE 1024
-#define HASH_LEN 32 /* SHA-256 digest length */
-
+#include "statusled.h"
+#include "../../include/defines.h"

 /*an ota data write buffer ready to write to the flash*/
-static char ota_write_data[BUFFSIZE + 1] = { 0 };
+static char ota_write_data[SERVER_OTA_SCRATCH_BUFSIZE + 1] = { 0 };

-
-#define OTA_URL_SIZE 256
-static const char *TAGPARTOTA = "server_ota";
+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;
-    ESP_LOGI(TAGPARTOTA, "When a new firmware is available on the server, press the reset button to download it");
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "When a new firmware is available on the server, press the reset button to download it");
    while(1) {
-        ESP_LOGI(TAGPARTOTA, "Waiting for a new firmware ... %d", ++i);
-        vTaskDelay(2000 / portTICK_PERIOD_MS);
+        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)
 {
@@ -72,23 +148,23 @@ static bool ota_update_task(std::string fn)
    esp_ota_handle_t update_handle = 0 ;
    const esp_partition_t *update_partition = NULL;

-    ESP_LOGI(TAGPARTOTA, "Starting OTA update");
+    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) {
-        ESP_LOGW(TAGPARTOTA, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x",
-                 configured->address, running->address);
-        ESP_LOGW(TAGPARTOTA, "(This can happen if either the OTA boot data or preferred boot image become somehow corrupted.)");
+    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(TAGPARTOTA, "Running partition type %d subtype %d (offset 0x%08x)",
-             running->type, running->subtype, running->address);
+    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(TAGPARTOTA, "Writing to partition subtype %d at offset 0x%x",
-             update_partition->subtype, update_partition->address);
+    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;
@@ -98,17 +174,17 @@ static bool ota_update_task(std::string fn)

    int data_read;     

-    FILE* f = OpenFileAndWait(fn.c_str(), "rb");     // vorher  nur "r"
+    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, BUFFSIZE, f);
+    data_read = fread(ota_write_data, 1, SERVER_OTA_SCRATCH_BUFSIZE, f);

    while (data_read > 0) {
        if (data_read < 0) {
-            ESP_LOGE(TAGPARTOTA, "Error: SSL data read error");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Error: SSL data read error");
            return false;
        } else if (data_read > 0) {
            if (image_header_was_checked == false) {
@@ -116,32 +192,33 @@ static bool ota_update_task(std::string fn)
                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(TAGPARTOTA, "New firmware version: %s", new_app_info.version);
+                    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(TAGPARTOTA, "Running firmware version: %s", running_app_info.version);
+                        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(TAGPARTOTA, "Last invalid firmware version: %s", invalid_app_info.version);
+                        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) {
-                            ESP_LOGW(TAGPARTOTA, "New version is the same as invalid version.");
-                            ESP_LOGW(TAGPARTOTA, "Previously, there was an attempt to launch the firmware with %s version, but it failed.", invalid_app_info.version);
-                            ESP_LOGW(TAGPARTOTA, "The firmware has been rolled back to the previous version.");
+                            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) {
-                        ESP_LOGW(TAGPARTOTA, "Current running version is the same as a new. We will not continue the update.");
+                        LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Current running version is the same as a new. We will not continue the update");
                        infinite_loop();
                    }
 */
@@ -149,12 +226,12 @@ static bool ota_update_task(std::string fn)

                    err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
                    if (err != ESP_OK) {
-                        ESP_LOGE(TAGPARTOTA, "esp_ota_begin failed (%s)", esp_err_to_name(err));
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_begin failed (" + string(esp_err_to_name(err)) + ")");
                        return false;
                    }
-                    ESP_LOGI(TAGPARTOTA, "esp_ota_begin succeeded");
+                    ESP_LOGI(TAG, "esp_ota_begin succeeded");
                } else {
-                    ESP_LOGE(TAGPARTOTA, "received package is not fit len");
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "received package is not fit len");
                    return false;
                }
            }            
@@ -163,38 +240,38 @@ static bool ota_update_task(std::string fn)
                return false;
            }
            binary_file_length += data_read;
-            ESP_LOGD(TAGPARTOTA, "Written image length %d", binary_file_length);
+            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) {
-                ESP_LOGE(TAGPARTOTA, "Connection closed, errno = %d", errno);
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Connection closed, errno = " + to_string(errno));
                break;
            }
        }
-        data_read = fread(ota_write_data, 1, BUFFSIZE, f);
+        data_read = fread(ota_write_data, 1, SERVER_OTA_SCRATCH_BUFSIZE, f);
    }
    fclose(f);  

-    ESP_LOGI(TAGPARTOTA, "Total Write binary data length: %d", binary_file_length);
+    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) {
-            ESP_LOGE(TAGPARTOTA, "Image validation failed, image is corrupted");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Image validation failed, image is corrupted");
        }
-        ESP_LOGE(TAGPARTOTA, "esp_ota_end failed (%s)!", esp_err_to_name(err));
+        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) {
-        ESP_LOGE(TAGPARTOTA, "esp_ota_set_boot_partition failed (%s)!", esp_err_to_name(err));
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_set_boot_partition failed (" + string(esp_err_to_name(err)) + ")!");

    }
-//    ESP_LOGI(TAGPARTOTA, "Prepare to restart system!");
+//    ESP_LOGI(TAG, "Prepare to restart system!");
 //    esp_restart();

    return true ;
@@ -208,7 +285,7 @@ static void print_sha256 (const uint8_t *image_hash, const char *label)
    for (int i = 0; i < HASH_LEN; ++i) {
        sprintf(&hash_print[i * 2], "%02x", image_hash[i]);
    }
-    ESP_LOGI(TAGPARTOTA, "%s: %s", label, hash_print);
+    ESP_LOGI(TAG, "%s: %s", label, hash_print);
 }


@@ -217,10 +294,10 @@ static bool diagnostic(void)
    return true;
 }

+
 void CheckOTAUpdate(void)
 {
-    ESP_LOGI(TAGPARTOTA, "Start CheckOTAUpdateCheck ...");
-    printf("Start CheckOTAUpdateCheck ...\n");
+    ESP_LOGI(TAG, "Start CheckOTAUpdateCheck...");

    uint8_t sha_256[HASH_LEN] = { 0 };
    esp_partition_t partition;
@@ -249,31 +326,29 @@ void CheckOTAUpdate(void)
    switch (res_stat_partition)
    {
        case ESP_OK:
-            printf("CheckOTAUpdate Partition: ESP_OK\n");
+            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(TAGPARTOTA, "Diagnostics completed successfully! Continuing execution ...");
-                        printf("Diagnostics completed successfully! Continuing execution ...\n");
+                        ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
                        esp_ota_mark_app_valid_cancel_rollback();
                    } else {
-                        ESP_LOGE(TAGPARTOTA, "Diagnostics failed! Start rollback to the previous version ...");
-                        printf("Diagnostics failed! Start rollback to the previous version ...\n");
+                        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:
-            printf("CheckOTAUpdate Partition: ESP_ERR_INVALID_ARG\n");
+            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_INVALID_ARG");
            break;
        case ESP_ERR_NOT_SUPPORTED:
-            printf("CheckOTAUpdate Partition: ESP_ERR_NOT_SUPPORTED\n");
+            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_SUPPORTED");
            break;
        case ESP_ERR_NOT_FOUND:
-            printf("CheckOTAUpdate Partition: ESP_ERR_NOT_FOUND\n");
+            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_FOUND");
            break;
    }
    if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
@@ -281,12 +356,10 @@ void CheckOTAUpdate(void)
            // run diagnostic function ...
            bool diagnostic_is_ok = diagnostic();
            if (diagnostic_is_ok) {
-                ESP_LOGI(TAGPARTOTA, "Diagnostics completed successfully! Continuing execution ...");
-                printf("Diagnostics completed successfully! Continuing execution ...\n");
+                ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
                esp_ota_mark_app_valid_cancel_rollback();
            } else {
-                ESP_LOGE(TAGPARTOTA, "Diagnostics failed! Start rollback to the previous version ...");
-                printf("Diagnostics failed! Start rollback to the previous version ...\n");
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Diagnostics failed! Start rollback to the previous version...");
                esp_ota_mark_app_invalid_rollback_and_reboot();
            }
        }
@@ -294,14 +367,13 @@ void CheckOTAUpdate(void)
 }


-
 esp_err_t handler_ota_update(httpd_req_t *req)
 {
 #ifdef DEBUG_DETAIL_ON     
    LogFile.WriteHeapInfo("handler_ota_update - Start");    
 #endif

-    LogFile.WriteToFile("handler_ota_update");    
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "handler_ota_update");
    char _query[200];
    char _filename[100];
    char _valuechar[30];    
@@ -311,27 +383,44 @@ esp_err_t handler_ota_update(httpd_req_t *req)

    if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK)
    {
-        printf("Query: "); printf(_query); printf("\n");
+        ESP_LOGD(TAG, "Query: %s", _query);
        
        if (httpd_query_key_value(_query, "task", _valuechar, 30) == ESP_OK)
        {
-            printf("task is found: "); printf(_valuechar); printf("\n"); 
+            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);
-            printf("File: "); printf(fn.c_str()); printf("\n");            
+            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;
-            printf("Delete Default File: "); printf(fn.c_str()); printf("\n");            
+            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)
    {
@@ -359,42 +448,35 @@ esp_err_t handler_ota_update(httpd_req_t *req)
        }


-        if (filetype == "ZIP")
+        if ((filetype == "ZIP") || (filetype == "BIN"))
        {
-            std::string in, out, outbin, zw, retfirmware;
+           	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);

-            out = "/sdcard/html";
-            outbin = "/sdcard/firmware";
+            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;                

-            retfirmware = unzip_new(fn, out+"/", outbin+"/");
-
-            if (retfirmware.length() > 0)
-            {
-                filetype = "BIN";
-                fn = retfirmware;
-            }
-            else
-            {
-                zw = "Web Interface Update Successfull!\nNo reboot necessary.\n";
-                httpd_resp_sendstr_chunk(req, zw.c_str());
-                httpd_resp_sendstr_chunk(req, NULL);  
-                return ESP_OK;        
-            }
        }

-
+/*
        if (filetype == "BIN")
        {
            const char* resp_str; 

-            KillTFliteTasks();
+            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);  
-                printf("Send reboot\n");
+                ESP_LOGD(TAG, "Send reboot");
                return ESP_OK;                
            }

@@ -407,7 +489,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)

            return ESP_OK;
        }
-
+*/

        std::string zw = "Update failed - no valid file specified (zip, bin, tfl, tlite)!";
        httpd_resp_sendstr_chunk(req, zw.c_str());
@@ -418,7 +500,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)

    if (_task.compare("unziphtml") == 0)
    {
-        printf("Task unziphmtl\n");
+        ESP_LOGD(TAG, "Task unziphtml");
        std::string in, out, zw;

        in = "/sdcard/firmware/html.zip";
@@ -435,30 +517,38 @@ esp_err_t handler_ota_update(httpd_req_t *req)

    if (_file_del)
    {
-        printf("Delete !! _file_del: %s\n", fn.c_str());
+        ESP_LOGD(TAG, "Delete !! _file_del: %s", fn.c_str());
        struct stat file_stat;
        int _result = stat(fn.c_str(), &file_stat);
-        printf("Ergebnis %d\n", _result);
+        ESP_LOGD(TAG, "Ergebnis %d\n", _result);
        if (_result == 0) {
-            printf("Deleting file : %s\n", fn.c_str());
+            ESP_LOGD(TAG, "Deleting file: %s", fn.c_str());
            /* Delete file */
            unlink(fn.c_str());
        }
        else
        {
-            printf("File does not exist: %s\n", fn.c_str());
+            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";
-        printf((zw + "\n").c_str());
+        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;    

-    KillTFliteTasks();
+    DeleteMainFlowTask();
    gpio_handler_deinit();
    if (ota_update_task(fn))
    {
@@ -470,69 +560,132 @@ esp_err_t handler_ota_update(httpd_req_t *req)
    }

    httpd_resp_send(req, resp_str, strlen(resp_str));  
+*/

-#ifdef DEBUG_DETAIL_ON 
-    LogFile.WriteHeapInfo("handler_ota_update - Done");    
-#endif
+    #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));

-void hard_restart() {
-  esp_task_wdt_init(1,true);
  esp_task_wdt_add(NULL);
  while(true);
 }

-void task_reboot(void *pvParameter)
+
+void task_reboot(void *DeleteMainFlow)
 {
-    while(1)
-    {
-        vTaskDelay(5000 / portTICK_PERIOD_MS);
-        esp_restart();
-        hard_restart();
+    // 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
    }

-    vTaskDelete(NULL); //Delete this task if it exits from the loop above
+    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.SwitchOnOff(true);
-    LogFile.WriteToFile("Reboot triggered by Software (5s).");
-    ESP_LOGI(TAGPARTOTA, "Reboot in 5sec");
-    LogFile.WriteToFile("Reboot in 5sec");
-    xTaskCreate(&task_reboot, "reboot", configMINIMAL_STACK_SIZE * 64, NULL, 10, NULL);
-    // KillTFliteTasks(); // kills itself 
-    gpio_handler_destroy();
+
+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();
-    hard_restart();
+    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    
+    #ifdef DEBUG_DETAIL_ON     
+        LogFile.WriteHeapInfo("handler_reboot - Start");
+    #endif    

-    LogFile.WriteToFile("handler_reboot");
-    ESP_LOGI(TAGPARTOTA, "!!! System will restart within 5 sec!!!");
-    const char* resp_str = "<body style='font-family: arial'> <h3 id=t></h3></body><script>var h='Rebooting!<br>The page will automatically reload in about 25s.<br>'; document.getElementById('t').innerHTML=h; setInterval(function (){h +='.'; document.getElementById('t').innerHTML=h; fetch(window.location.hostname,{mode: 'no-cors'}).then(r=>{parent.location.href=('/index.html');})}, 1000);</script>";
-    httpd_resp_send(req, resp_str, strlen(resp_str)); 
+    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
+    #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(TAGPARTOTA, "server_ota - Registering URI handlers");
+    ESP_LOGI(TAG, "Registering URI handlers");
    
    httpd_uri_t camuri = { };
    camuri.method    = HTTP_GET;
--- a/code/components/jomjol_fileserver_ota/server_ota.h
+++ b/code/components/jomjol_fileserver_ota/server_ota.h
@@ -1,11 +1,20 @@
+#pragma once
+
+#ifndef SERVEROTA_H
+#define SERVEROTA_H
+
 #include <esp_log.h>

 #include <esp_http_server.h>

-//#include "ClassControllCamera.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
@@ -2,6 +2,6 @@ FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)

 idf_component_register(SRCS ${app_sources}
                    INCLUDE_DIRS "."
-                    REQUIRES jomjol_tfliteclass jomjol_helper jomjol_controlcamera jomjol_mqtt jomjol_influxdb jomjol_fileserver_ota jomjol_image_proc jomjol_wlan)
+                    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
@@ -3,7 +3,10 @@
 #include <string>
 #include <iostream>
 #include <string.h>
+#include "esp_log.h"
+#include "../../include/defines.h"

+static const char *TAG = "CLASS";


 void ClassFlow::SetInitialParameter(void)
@@ -13,30 +16,6 @@ void ClassFlow::SetInitialParameter(void)
 	disabled = false;
 }

-
-
-
-std::vector<string> ClassFlow::ZerlegeZeile(std::string input, std::string delimiter)
-{
-	std::vector<string> Output;
-
-	input = trim(input, delimiter);
-	size_t pos = findDelimiterPos(input, delimiter);
-	std::string token;
-	while (pos != std::string::npos) {
-		token = input.substr(0, pos);
-		token = trim(token, delimiter);
-		Output.push_back(token);
-		input.erase(0, pos + 1);
-		input = trim(input, delimiter);
-		pos = findDelimiterPos(input, delimiter);
-	}
-	Output.push_back(input);
-
-	return Output;
-
-}
-
 bool ClassFlow::isNewParagraph(string input)
 {
 	if ((input[0] == '[') || ((input[0] == ';') && (input[1] == '[')))
@@ -88,11 +67,6 @@ string ClassFlow::getHTMLSingleStep(string host){
 	return "";
 }

-string ClassFlow::getReadout()
-{
-	return string();
-}
-
 std::string ClassFlow::GetParameterName(std::string _input)
 {
    string _param;
@@ -105,7 +79,7 @@ std::string ClassFlow::GetParameterName(std::string _input)
    {
        _param = _input;
    }
-//    printf("Parameter: %s, Pospunkt: %d\n", _param.c_str(), _pospunkt);
+//    ESP_LOGD(TAG, "Parameter: %s, Pospunkt: %d", _param.c_str(), _pospunkt);
 	return _param;
 }

@@ -121,18 +95,18 @@ bool ClassFlow::getNextLine(FILE* pfile, string *rt)
 	if (!fgets(zw, 1024, pfile))
 	{
 		*rt = "";
-		printf("END OF FILE\n");
+		ESP_LOGD(TAG, "END OF FILE");
 		return false;
 	}
-	printf("%s", zw);
+	ESP_LOGD(TAG, "%s", zw);
 	*rt = zw;
 	*rt = trim(*rt);
-	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))			// Kommentarzeilen (; oder #) und Leerzeilen überspringen, es sei denn es ist ein neuer auskommentierter Paragraph
+	while ((zw[0] == ';' || zw[0] == '#' || (rt->size() == 0)) && !(zw[1] == '['))
 	{
 		*rt = "";
 		if (!fgets(zw, 1024, pfile))
 			return false;
-		printf("%s", zw);		
+		ESP_LOGD(TAG, "%s", zw);
 		*rt = zw;
 		*rt = trim(*rt);
 	}
--- a/code/components/jomjol_flowcontroll/ClassFlow.h
+++ b/code/components/jomjol_flowcontroll/ClassFlow.h
@@ -1,5 +1,8 @@
 #pragma once

+#ifndef CLASSFLOW_H
+#define CLASSFLOW_H
+
 #include <fstream>
 #include <string>
 #include <vector>
@@ -9,10 +12,6 @@

 using namespace std;

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

 #include"ClassFlowDefineTypes.h"
 #include "ClassFlowAlignment.h"
@@ -9,10 +11,10 @@ enum t_CNNType {
    AutoDetect,
    Analogue,
    Analogue100,
-    Digital,
-    DigitalHyprid10,
+    Digit,
+    DigitHyprid10,
    DoubleHyprid10,
-    Digital100,
+    Digit100,
    None
 };

@@ -23,14 +25,6 @@ protected:
    t_CNNType CNNType;
    std::vector<general*> GENERAL;
    float CNNGoodThreshold;
-    float AnalogFehler = 3.0;
-    float AnalogToDigtalFehler = 0.8;
-    float DigitalUnschaerfe = 0.2;
-    int DigitalBand = 3;
-    float DigitalAnalogerVorgaengerUebergangsbereich = 2;
-    float DigitalUebergangsbereichVorgaengerAnalogToDigit = 1; // war vorher 2
-    float DigitalUebergangsbereichVorgaenger = 0.7; // 9.3 - 0.7
-    float DigitalUebergangsbereichVorlauf = 9.7; // Vorlauf-Nulldurchgang passiert erst ab ca. 9.7

    string cnnmodelfile;
    int modelxsize, modelysize, modelchannel;
@@ -40,9 +34,9 @@ protected:

    bool SaveAllFiles;   

-    int ZeigerEvalAnalogNeu(float zahl, int ziffer_vorgaenger);
-    int ZeigerEvalAnalogToDigitNeu(float zahl, float ziffer_vorgaenger,  int eval_vorgaenger);
-    int ZeigerEvalHybridNeu(float zahl, float zahl_vorgaenger, int eval_vorgaenger, bool AnalogerVorgaenger = false);
+    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);



@@ -58,13 +52,15 @@ public:
    bool doFlow(string time);

    string getHTMLSingleStep(string host);
-    string getReadout(int _analog, bool _extendedResolution = false, int prev = -1, float _vorgaengerAnalog = -1);   
+    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 getAnzahlGENERAL();
+    int getNumberGENERAL();
    general* GetGENERAL(int _analog);
    general* GetGENERAL(string _name, bool _create);
    general* FindGENERAL(string _name_number);    
--- a/code/components/jomjol_flowcontroll/ClassFlowControll.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowControll.cpp
--- a/code/components/jomjol_flowcontroll/ClassFlowControll.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowControll.h
@@ -1,24 +1,26 @@
-#ifndef __FLOWCONTROLL__
-#define __FLOWCONTROLL__
+#pragma once
+
+#ifndef CLASSFLOWCONTROLL_H
+#define CLASSFLOWCONTROLL_H

 #include <string>

 #include "ClassFlow.h"
-#include "ClassFlowMakeImage.h"
+#include "ClassFlowTakeImage.h"
 #include "ClassFlowAlignment.h"
 #include "ClassFlowCNNGeneral.h"
 #include "ClassFlowPostProcessing.h"
-#include "ClassFlowMQTT.h"
-#include "ClassFlowInfluxDB.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"
-#include "ClassFlowWriteList.h"
-
-
-#define READOUT_TYPE_VALUE 0
-#define READOUT_TYPE_PREVALUE 1
-#define READOUT_TYPE_RAWVALUE 2
-#define READOUT_TYPE_ERROR 3
-

 class ClassFlowControll :
    public ClassFlow
@@ -30,46 +32,60 @@ protected:
 	ClassFlowCNNGeneral* flowanalog;
 	ClassFlowCNNGeneral* flowdigit;
 //	ClassFlowDigit* flowdigit;
-	ClassFlowMakeImage* flowmakeimage;
+	ClassFlowTakeImage* flowtakeimage;
 	ClassFlow* CreateClassFlow(std::string _type);

 	bool AutoStart;
-	float AutoIntervall;
-	bool SetupModeActive;
+	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 doFlowMakeImageOnly(string time);
+	void doFlowTakeImageOnly(string time);
 	bool getStatusSetupModus(){return SetupModeActive;};
-	string getReadout(bool _rawvalue, bool _noerror);
+	string getReadout(bool _rawvalue, bool _noerror, int _number);
 	string getReadoutAll(int _type);	
-	string UpdatePrevalue(std::string _newvalue, std::string _numbers, bool _extern);
+	bool UpdatePrevalue(std::string _newvalue, std::string _numbers, bool _extern);
 	string GetPrevalue(std::string _number = "");	
 	bool ReadParameter(FILE* pfile, string& aktparamgraph);	
-	string getJSON(std::string _id = "", std::string _mac = "");
+	string getJSON();
+	const std::vector<NumberPost*> &getNumbers();
+	string getNumbersName();

 	string TranslateAktstatus(std::string _input);

-	string GetMQTTMainTopic();
+	#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 isAutoStart(long &_intervall);
+	bool getIsAutoStart();
+	void setAutoStartInterval(long &_interval);

+	std::string* getActStatusWithTime();
 	std::string* getActStatus();
+	void setActStatus(std::string _aktstatus);

-	std::vector<HTMLInfo*> GetAllDigital();
+	std::vector<HTMLInfo*> GetAllDigit();
 	std::vector<HTMLInfo*> GetAllAnalog();	

-	t_CNNType GetTypeDigital();
+	t_CNNType GetTypeDigit();
 	t_CNNType GetTypeAnalog();
+	
+	#ifdef ENABLE_MQTT
+	bool StartMQTTService();
+	#endif //ENABLE_MQTT

 	int CleanTempFolder();

@@ -79,3 +95,4 @@ public:
 #endif


+
--- a/code/components/jomjol_flowcontroll/ClassFlowDefineTypes.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowDefineTypes.h
@@ -1,8 +1,14 @@
-#ifndef __CLASSFLOWIMAGE_CLASS__
-#define __CLASSFLOWIMAGE_CLASS__
+#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;
@@ -12,48 +18,66 @@ struct roi {
    CImageBasis *image, *image_org;
 };

+/**
+ * FIXME: Why is this additional layer needed?
+ */
 struct general {
    string name;
    std::vector<roi*> ROI;
 };

 enum t_RateType {
-    AbsoluteChange,
-    RateChange
+    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;
-    bool useMaxRateValue;
-    t_RateType RateType;
-    bool ErrorMessage;
-    bool PreValueOkay;
-    bool AllowNegativeRates;
-    bool checkDigitIncreaseConsistency;
-    time_t lastvalue;
-    string timeStamp;
-    double FlowRateAct;          // m3 / min
-    double PreValue;             // letzter Wert, der gut ausgelesen wurde
-    double Value;                // letzer ausgelesener Wert, inkl. Korrekturen
-    string ReturnRateValue;      // RückgabewertRate
-    string ReturnChangeAbsolute;      // RückgabewertRate
-    string ReturnRawValue;      // Rohwert (mit N & führenden 0)    
-    string ReturnValue;         // korrigierter Rückgabewert, ggf. mit Fehlermeldung
-    string ReturnPreValue;      // korrigierter Rückgabewert ohne Fehlermeldung
-    string ErrorMessageText;        // Fehlermeldung bei Consistency Check
-    int AnzahlAnalog;
-    int AnzahlDigital;
-    int DecimalShift;
-    int DecimalShiftInitial;
-    int Nachkomma;
+    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

-    bool isExtendedResolution;
+    string FieldV1;             // influxdbFieldName_v1; Name of the Field in InfluxDBv1
+    string MeasurementV1;       // influxdbMeasurementName_v1; Name of the Measurement in InfluxDBv1

-    general *digit_roi;
-    general *analog_roi;
+    string FieldV2;             // influxdbFieldName_v2; Name of the Field in InfluxDBv2
+    string MeasurementV2;       // influxdbMeasurementName_v2; Name of the Measurement in InfluxDBv2

-    string name;
+    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
@@ -14,13 +14,18 @@ extern "C" {
 #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)
@@ -28,6 +33,7 @@ ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, const char* logTag
 	this->logTag = logTag;
 	isLogImage = false;
    disabled = false;
+    this->imagesRetention = 5;
 }

 ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, ClassFlow *_prev, const char* logTag) :  ClassFlow(lfc, _prev)
@@ -35,6 +41,7 @@ ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, ClassFlow *_prev,
 	this->logTag = logTag;
 	isLogImage = false;
    disabled = false;
+    this->imagesRetention = 5;
 }


@@ -42,11 +49,10 @@ string ClassFlowImage::CreateLogFolder(string time) {
 	if (!isLogImage)
 		return "";

-	string logPath = LogImageLocation + "/" + time.LOGFILE_TIME_FORMAT_DATE_EXTR + "/" + time.LOGFILE_TIME_FORMAT_HOUR_EXTR;
+	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) {
-        ESP_LOGW(logTag, "Can't create log folder for analog images. Path %s", logPath.c_str());
-        LogFile.WriteToFile("Can't create log folder for analog images. Path " + logPath);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't create log folder for analog images. Path " + logPath);
    }

 	return logPath;
@@ -65,7 +71,7 @@ void ClassFlowImage::LogImage(string logPath, string name, float *resultFloat, i
        else
        {
            sprintf(buf, "%.1f_", *resultFloat);
-            if (strcmp(buf, "10.0_"))
+            if (strcmp(buf, "10.0_") == 0)
                sprintf(buf, "0.0_");
        }
            
@@ -79,7 +85,7 @@ void ClassFlowImage::LogImage(string logPath, string name, float *resultFloat, i
 	nm = FormatFileName(nm);
 	string output = "/sdcard/img_tmp/" + name + ".jpg";
 	output = FormatFileName(output);
-	printf("save to file: %s\n", nm.c_str());
+	ESP_LOGD(logTag, "save to file: %s", nm.c_str());
 	_img->SaveToFile(nm);
 //	CopyFile(output, nm);
 }
@@ -89,8 +95,8 @@ void ClassFlowImage::RemoveOldLogs()
 	if (!isLogImage)
 		return;
 	
-	ESP_LOGI(logTag, "remove old log images");
-    if (logfileRetentionInDays == 0) {
+	ESP_LOGD(TAG, "remove old images");
+    if (imagesRetention == 0) {
        return;
    }

@@ -99,16 +105,17 @@ void ClassFlowImage::RemoveOldLogs()
    char cmpfilename[30];

    time(&rawtime);
-    rawtime = addDays(rawtime, -logfileRetentionInDays);
+    rawtime = addDays(rawtime, -1 * imagesRetention + 1);
    timeinfo = localtime(&rawtime);
+    //ESP_LOGD(TAG, "ImagefileRetentionInDays: %d", imagesRetention);
    
    strftime(cmpfilename, 30, LOGFILE_TIME_FORMAT, timeinfo);
-    //ESP_LOGE(TAG, "log file name to compare: %s", cmpfilename);
+    //ESP_LOGD(TAG, "file name to compare: %s", cmpfilename);
 	string folderName = string(cmpfilename).LOGFILE_TIME_FORMAT_DATE_EXTR;

-    DIR *dir = opendir(LogImageLocation.c_str());
+    DIR *dir = opendir(imagesLocation.c_str());
    if (!dir) {
-        ESP_LOGI(logTag, "Failed to stat dir : %s", LogImageLocation.c_str());
+        ESP_LOGE(TAG, "Failed to stat dir: %s", imagesLocation.c_str());
        return;
    }

@@ -116,17 +123,18 @@ void ClassFlowImage::RemoveOldLogs()
    int deleted = 0;
    int notDeleted = 0;
    while ((entry = readdir(dir)) != NULL) {
-        string folderPath = LogImageLocation + "/" + entry->d_name;
+        string folderPath = imagesLocation + "/" + entry->d_name;
 		if (entry->d_type == DT_DIR) {
-			//ESP_LOGI(logTag, "Compare %s %s", entry->d_name, folderName.c_str());	
+			//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)) {
-                deleted += removeFolder(folderPath.c_str(), logTag);
+                removeFolder(folderPath.c_str(), logTag);
+                deleted++;
 			} else {
                notDeleted ++;
            }
 		}
    }
-    ESP_LOGI(logTag, "%d older log files deleted. %d current log files not deleted.", deleted, 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
@@ -1,4 +1,8 @@
 #pragma once
+
+#ifndef CLASSFLOWIMAGE_H
+#define CLASSFLOWIMAGE_H
+
 #include "ClassFlow.h"

 using namespace std;
@@ -6,9 +10,9 @@ using namespace std;
 class ClassFlowImage : public ClassFlow
 {
 protected:
-	string LogImageLocation;
+	string imagesLocation;
    bool isLogImage;
-    unsigned short logfileRetentionInDays;
+    unsigned short imagesRetention;
 	const char* logTag;

 	string CreateLogFolder(string time);
@@ -22,3 +26,5 @@ public:
 	
 	void RemoveOldLogs();
 };
+
+#endif //CLASSFLOWIMAGE_H
--- a/code/components/jomjol_flowcontroll/ClassFlowInfluxDB.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowInfluxDB.cpp
@@ -1,3 +1,4 @@
+#ifdef ENABLE_INFLUXDB
 #include <sstream>
 #include "ClassFlowInfluxDB.h"
 #include "Helper.h"
@@ -5,15 +6,21 @@

 #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 = "";
-    measurement = "";

    OldValue = "";
    flowpostprocessing = NULL;  
@@ -63,7 +70,7 @@ ClassFlowInfluxDB::ClassFlowInfluxDB(std::vector<ClassFlow*>* lfc, ClassFlow *_p

 bool ClassFlowInfluxDB::ReadParameter(FILE* pfile, string& aktparamgraph)
 {
-    std::vector<string> zerlegt;
+    std::vector<string> splitted;

    aktparamgraph = trim(aktparamgraph);

@@ -76,59 +83,61 @@ bool ClassFlowInfluxDB::ReadParameter(FILE* pfile, string& aktparamgraph)

    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
    {
-        printf("while loop reading line: %s\n", aktparamgraph.c_str());
-        zerlegt = this->ZerlegeZeile(aktparamgraph);
-        if ((toUpper(zerlegt[0]) == "USER") && (zerlegt.size() > 1))
+        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 = zerlegt[1];
+            this->user = splitted[1];
        }  
-        if ((toUpper(zerlegt[0]) == "PASSWORD") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "PASSWORD") && (splitted.size() > 1))
        {
-            this->password = zerlegt[1];
+            this->password = splitted[1];
        }               
-        if ((toUpper(zerlegt[0]) == "URI") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "URI") && (splitted.size() > 1))
        {
-            this->uri = zerlegt[1];
+            this->uri = splitted[1];
        }
-        if (((toUpper(zerlegt[0]) == "MEASUREMENT")) && (zerlegt.size() > 1))
+        if (((toUpper(_param) == "DATABASE")) && (splitted.size() > 1))
        {
-            this->measurement = zerlegt[1];
+            this->database = splitted[1];
        }
-        if (((toUpper(zerlegt[0]) == "DATABASE")) && (zerlegt.size() > 1))
+        if (((toUpper(_param) == "MEASUREMENT")) && (splitted.size() > 1))
        {
-            this->database = zerlegt[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) && (measurement.length() > 0)) 
+    if ((uri.length() > 0) && (database.length() > 0)) 
    { 
-        printf("Init InfluxDB with uri: %s, measurement: %s, user: %s, password: %s\n", uri.c_str(), measurement.c_str(), user.c_str(), password.c_str());
-        InfluxDBInit(uri, database, measurement, user, password); 
+//        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 {
-        printf("InfluxDB init skipped as we are missing some parameters");
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "InfluxDB init skipped as we are missing some parameters");
    }
   
    return true;
 }

-
-string ClassFlowInfluxDB::GetInfluxDBMeasurement()
-{
-    return measurement;
-}
-
-
 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 = "";

@@ -138,20 +147,29 @@ bool ClassFlowInfluxDB::doFlow(string zwtime)

        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;

-            namenumber = (*NUMBERS)[i]->name;
-            if (namenumber == "default")
-                namenumber = "value";
+            if ((*NUMBERS)[i]->FieldV1.length() > 0)
+            {
+                namenumber = (*NUMBERS)[i]->FieldV1;
+            }
            else
-                namenumber = namenumber + "/value";
+            {
+                namenumber = (*NUMBERS)[i]->name;
+                if (namenumber == "default")
+                    namenumber = "value";
+                else
+                    namenumber = namenumber + "/value";
+            }

-            if (result.length() > 0 && resulttimestamp.length() > 0)   
-                InfluxDBPublish(namenumber, result, resulttimestamp);
+            if (result.length() > 0)   
+                InfluxDBPublish(measurement, namenumber, result, timeutc);
        }
    }
   
@@ -159,3 +177,51 @@ bool ClassFlowInfluxDB::doFlow(string zwtime)
    
    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
@@ -1,4 +1,10 @@
+#ifdef ENABLE_INFLUXDB
+
 #pragma once
+
+#ifndef CLASSFINFLUXDB_H
+#define CLASSFINFLUXDB_H
+
 #include "ClassFlow.h"

 #include "ClassFlowPostProcessing.h"
@@ -15,17 +21,24 @@ protected:
    std::string user, password; 
    bool InfluxDBenable;

-    void SetInitialParameter(void);        
+    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();
+//    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
@@ -1,16 +1,29 @@
+#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 "ClassLogFile.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);

-#define __HIDE_PASSWORD

 void ClassFlowMQTT::SetInitialParameter(void)
 {
@@ -19,22 +32,25 @@ void ClassFlowMQTT::SetInitialParameter(void)
    topicError = "";
    topicRate = "";
    topicTimeStamp = "";
-    maintopic = "";
-    mainerrortopic = ""; 
+    maintopic = wlan_config.hostname;

    topicUptime = "";
    topicFreeMem = "";
-    clientname = "watermeter";
+
+    caCertFilename = "";
+    clientCertFilename = "";
+    clientKeyFilename = "";
+    clientname = wlan_config.hostname;
+
    OldValue = "";
    flowpostprocessing = NULL;  
    user = "";
    password = ""; 
-    SetRetainFlag = 0;  
+    SetRetainFlag = false;
    previousElement = NULL;
    ListFlowControll = NULL; 
    disabled = false;
-    MQTTenable = false;
-    keepAlive = 600; // TODO This must be greater than the Flow Interval!
+    keepAlive = 25*60;
 }       

 ClassFlowMQTT::ClassFlowMQTT()
@@ -75,7 +91,7 @@ ClassFlowMQTT::ClassFlowMQTT(std::vector<ClassFlow*>* lfc, ClassFlow *_prev)

 bool ClassFlowMQTT::ReadParameter(FILE* pfile, string& aktparamgraph)
 {
-    std::vector<string> zerlegt;
+    std::vector<string> splitted;

    aktparamgraph = trim(aktparamgraph);

@@ -83,178 +99,163 @@ bool ClassFlowMQTT::ReadParameter(FILE* pfile, string& aktparamgraph)
        if (!this->GetNextParagraph(pfile, aktparamgraph))
            return false;

-    if (toUpper(aktparamgraph).compare("[MQTT]") != 0)       // Paragraph passt nich zu MakeImage
+    if (toUpper(aktparamgraph).compare("[MQTT]") != 0)       // Paragraph does not fit MQTT
        return false;

    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
    {
-        zerlegt = this->ZerlegeZeile(aktparamgraph);
-        if ((toUpper(zerlegt[0]) == "USER") && (zerlegt.size() > 1))
+        splitted = ZerlegeZeile(aktparamgraph);
+        if ((toUpper(splitted[0]) == "CACERT") && (splitted.size() > 1))
        {
-            this->user = zerlegt[1];
+            this->caCertFilename = splitted[1];
        }  
-        if ((toUpper(zerlegt[0]) == "PASSWORD") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "CLIENTCERT") && (splitted.size() > 1))
        {
-            this->password = zerlegt[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(zerlegt[0]) == "URI") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "URI") && (splitted.size() > 1))
        {
-            this->uri = zerlegt[1];
+            this->uri = splitted[1];
        }
-        if ((toUpper(zerlegt[0]) == "SETRETAINFLAG") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "RETAINMESSAGES") && (splitted.size() > 1))
        {
-            if (toUpper(zerlegt[1]) == "TRUE")
-                SetRetainFlag = 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(zerlegt[0]) == "CLIENTID") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "CLIENTID") && (splitted.size() > 1))
        {
-            this->clientname = zerlegt[1];
+            this->clientname = splitted[1];
        }

-        if (((toUpper(zerlegt[0]) == "TOPIC") || (toUpper(zerlegt[0]) == "MAINTOPIC")) && (zerlegt.size() > 1))
+        if (((toUpper(splitted[0]) == "TOPIC") || (toUpper(splitted[0]) == "MAINTOPIC")) && (splitted.size() > 1))
        {
-            maintopic = zerlegt[1];
+            maintopic = splitted[1];
        }
    }

-#ifdef __HIDE_PASSWORD
-    printf("Init Read with uri: %s, clientname: %s, user: %s, password: XXXXXX, maintopic: %s\n", uri.c_str(), clientname.c_str(), user.c_str(), mainerrortopic.c_str());
-#else
-    printf("Init Read with uri: %s, clientname: %s, user: %s, password: %s, maintopic: %s\n", uri.c_str(), clientname.c_str(), user.c_str(), password.c_str(), mainerrortopic.c_str());
-#endif
+    /* 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() */

-    if (!MQTTisConnected() && (uri.length() > 0) && (maintopic.length() > 0)) 
-    { 
-        printf("InitMQTTInit\n");
-        mainerrortopic = maintopic + "/connection";
-#ifdef __HIDE_PASSWORD
-        printf("Init MQTT with uri: %s, clientname: %s, user: %s, password: XXXXXXXX, maintopic: %s\n", uri.c_str(), clientname.c_str(), user.c_str(), mainerrortopic.c_str());
-#else
-        printf("Init MQTT with uri: %s, clientname: %s, user: %s, password: %s, maintopic: %s\n", uri.c_str(), clientname.c_str(), user.c_str(), password.c_str(), mainerrortopic.c_str());
-#endif
-        if (!MQTTInit(uri, clientname, user, password, mainerrortopic, keepAlive))
-        { // Failed
-            MQTTenable = false;
-            return true; // We need to return true despite we failed, else it will retry 5x and then reboot!
-        }
-    }
+    mqttServer_setMainTopic(maintopic);

-    // Try sending mainerrortopic. If it fails, re-run init
-    if (!MQTTPublish(mainerrortopic, "connected", SetRetainFlag))
-    { // Failed
-        LogFile.WriteToFile("MQTT - Re-running init...!");
-        if (!MQTTInit(this->uri, this->clientname, this->user, this->password, this->mainerrortopic, keepAlive))
-        { // Failed
-            MQTTenable = false;
-            return false;
-        } 
-    }
-
-    // Try again and quit if it fails
-    if (!MQTTPublish(mainerrortopic, "connected", SetRetainFlag))
-    { // Failed
-        MQTTenable = false;
-        return false;
-    }
-
-
-
-   
- /*   if (!MQTTPublish(mainerrortopic, "connected", SetRetainFlag))
-    { // Failed
-        LogFile.WriteToFile("MQTT - Could not publish connection status!");
-        MQTTenable = false;
-        return true; // We need to return true despite we failed, else it will retry 5x and then reboot!
-    }*/
-
- /*   if(!MQTTPublish(_LWTContext, "", 1))
-    {
-        LogFile.WriteToFile("MQTT - Could not publish LWT!");
-        MQTTenable = false;
-        return true; // We need to return true despite we failed, else it will retry 5x and then reboot!
-    }*/
-
-
-    MQTTenable = true;
    return true;
 }


-string ClassFlowMQTT::GetMQTTMainTopic()
+bool ClassFlowMQTT::Start(float AutoInterval) 
 {
-    return maintopic;
+    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)
 {
-    // Try sending mainerrortopic. If it fails, re-run init
-    if (!MQTTPublish(mainerrortopic, "connected", SetRetainFlag))
-    { // Failed
-        LogFile.WriteToFile("MQTT - Re-running init...!");
-        if (!MQTTInit(this->uri, this->clientname, this->user, this->password, this->mainerrortopic, keepAlive))
-        { // Failed
-            MQTTenable = false;
-            return true; // We need to return true despite we failed, else it will retry 5x and then reboot!
-        } 
-    }
-
-    // Try again and quit if it fails
-    if (!MQTTPublish(mainerrortopic, "connected", SetRetainFlag))
-    { // Failed
-        MQTTenable = false;
-        return true; // We need to return true despite we failed, else it will retry 5x and then reboot!
-    }
-
+    bool success;
    std::string result;
    std::string resulterror = "";
    std::string resultraw = "";
-    std::string resultrate = "";
+    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;

-    // if (!MQTTPublish(mainerrortopic, "connected", SetRetainFlag))
-    //{ // Failed, skip other topics
-    //    return true; // We need to return true despite we failed, else it will retry 5x and then reboot!
-    //}
-    
-    zw = maintopic + "/" + "uptime";
-    char uptimeStr[11];
-    sprintf(uptimeStr, "%ld", (long)getUpTime());
-    MQTTPublish(zw, uptimeStr, SetRetainFlag);
+    /* Send the the Homeassistant Discovery and the Static Topics in case they where scheduled */
+    sendDiscovery_and_static_Topics();

-    zw = maintopic + "/" + "freeMem";
-    char freeheapmem[11];
-    sprintf(freeheapmem, "%zu", esp_get_free_heap_size());
-    if (!MQTTPublish(zw, freeheapmem, SetRetainFlag))
-    { // Failed, skip other topics
-        return true; // We need to return true despite we failed, else it will retry 5x and then reboot!
-    }
+    success = publishSystemData(qos);

-    zw = maintopic + "/" + "wifiRSSI";
-    char rssi[11];
-    sprintf(rssi, "%d", get_WIFI_RSSI());
-    MQTTPublish(zw, rssi, SetRetainFlag);
-
-    zw = maintopic + "/" + "CPUtemp";
-    std::string cputemp = std::to_string(temperatureRead());
-    MQTTPublish(zw, cputemp, SetRetainFlag);
-
-    if (flowpostprocessing)
+    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;
-            resultchangabs = (*NUMBERS)[i]->ReturnChangeAbsolute;
+            resultrate = (*NUMBERS)[i]->ReturnRateValue; // Unit per minutes
+            resultchangabs = (*NUMBERS)[i]->ReturnChangeAbsolute; // Units per round
            resulttimestamp = (*NUMBERS)[i]->timeStamp;

            namenumber = (*NUMBERS)[i]->name;
@@ -263,67 +264,67 @@ bool ClassFlowMQTT::doFlow(string zwtime)
            else
                namenumber = maintopic + "/" + namenumber + "/";

-            zw = namenumber + "value"; 
+
            if (result.length() > 0)   
-                MQTTPublish(zw, result, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "value", result, qos, SetRetainFlag);

-            zw = namenumber + "error"; 
            if (resulterror.length() > 0)  
-                MQTTPublish(zw, resulterror, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "error", resulterror, qos, SetRetainFlag);

-            zw = namenumber + "rate"; 
-            if (resultrate.length() > 0)   
-                MQTTPublish(zw, resultrate, SetRetainFlag);
-
-            zw = namenumber + "changeabsolut"; 
-            if (resultchangabs.length() > 0)   
-                MQTTPublish(zw, resultchangabs, SetRetainFlag);
-
-            zw = namenumber + "raw"; 
-            if (resultraw.length() > 0)   
-                MQTTPublish(zw, resultraw, SetRetainFlag);
-
-            zw = namenumber + "timestamp";
-            if (resulttimestamp.length() > 0)
-                MQTTPublish(zw, resulttimestamp, SetRetainFlag);
-
-
-            std::string json = "";
-            
-            if (result.length() > 0)
-                json += "{\"value\":"+result;
-            else
-                json += "{\"value\":\"\"";
-
-            json += ",\"raw\":\""+resultraw;
-            json += "\",\"error\":\""+resulterror;
-            if (resultrate.length() > 0)
-                json += "\",\"rate\":"+resultrate;
-            else
-                json += "\",\"rate\":\"\"";
-            json += ",\"timestamp\":\""+resulttimestamp+"\"}";
-
-            zw = namenumber + "json";
-            MQTTPublish(zw, json, SetRetainFlag);
-        }
-    }
-    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;
+            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);
        }
-        MQTTPublish(topic, result, 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
@@ -1,4 +1,10 @@
+#ifdef ENABLE_MQTT
+
 #pragma once
+
+#ifndef CLASSFFLOWMQTT_H
+#define CLASSFFLOWMQTT_H
+
 #include "ClassFlow.h"

 #include "ClassFlowPostProcessing.h"
@@ -13,11 +19,12 @@ protected:
    std::string OldValue;
 	ClassFlowPostProcessing* flowpostprocessing;  
    std::string user, password; 
-    int SetRetainFlag;
-    bool MQTTenable;
-    int keepAlive;
+    std::string caCertFilename, clientCertFilename, clientKeyFilename; 
+    bool SetRetainFlag;
+    int keepAlive; // Seconds
+    float roundInterval; // Minutes

-    std::string maintopic, mainerrortopic; 
+    std::string maintopic; 
 	void SetInitialParameter(void);        

 public:
@@ -25,10 +32,11 @@ public:
    ClassFlowMQTT(std::vector<ClassFlow*>* lfc);
    ClassFlowMQTT(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);

-    string GetMQTTMainTopic();
+    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/ClassFlowMakeImage.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowMakeImage.cpp
@@ -1,237 +0,0 @@
-#include "ClassFlowMakeImage.h"
-#include "Helper.h"
-#include "ClassLogFile.h"
-
-#include "CImageBasis.h"
-#include "ClassControllCamera.h"
-
-#include "esp_wifi.h"
-
-#include <time.h>
-
-// #define DEBUG_DETAIL_ON 
-
-// #define WIFITURNOFF
-
-static const char* TAG = "flow_make_image";
-
-esp_err_t ClassFlowMakeImage::camera_capture(){
-    string nm =  namerawimage;
-    Camera.CaptureToFile(nm);
-    time(&TimeImageTaken);
-    localtime(&TimeImageTaken);
-
-    return ESP_OK;
-}
-
-void ClassFlowMakeImage::takePictureWithFlash(int flashdauer)
-{
-    // für den Fall, dass das Bild geflippt wird, muss es hier zurück gesetzt werden ////
-    rawImage->width = image_width;          
-    rawImage->height = image_height;
-    /////////////////////////////////////////////////////////////////////////////////////
-    printf("Flashdauer: %d\n", flashdauer);
-    Camera.CaptureToBasisImage(rawImage, flashdauer);
-    time(&TimeImageTaken);
-    localtime(&TimeImageTaken);
-
-    if (SaveAllFiles) rawImage->SaveToFile(namerawimage);
-}
-
-void ClassFlowMakeImage::SetInitialParameter(void)
-{
-    waitbeforepicture = 5;
-    isImageSize = false;
-    ImageQuality = -1;    
-    TimeImageTaken = 0;
-    ImageQuality = 5;
-    rawImage = NULL;
-    ImageSize = FRAMESIZE_VGA;
-    SaveAllFiles = false;
-    disabled = false;
-    FixedExposure = false;
-    namerawimage =  "/sdcard/img_tmp/raw.jpg";
-}     
-
-
-ClassFlowMakeImage::ClassFlowMakeImage(std::vector<ClassFlow*>* lfc) : ClassFlowImage(lfc, TAG)
-{
-    SetInitialParameter();
-}
-
-bool ClassFlowMakeImage::ReadParameter(FILE* pfile, string& aktparamgraph)
-{
-    std::vector<string> zerlegt;
-
-    aktparamgraph = trim(aktparamgraph);
-    int _brightness = -100;
-    int _contrast = -100;
-    int _saturation = -100;
-
-    if (aktparamgraph.size() == 0)
-        if (!this->GetNextParagraph(pfile, aktparamgraph))
-            return false;
-
-    if (aktparamgraph.compare("[MakeImage]") != 0)       // Paragraph passt nich zu MakeImage
-        return false;
-
-    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
-    {
-        zerlegt = this->ZerlegeZeile(aktparamgraph);
-        if ((zerlegt[0] ==  "LogImageLocation") && (zerlegt.size() > 1))
-        {
-            LogImageLocation = "/sdcard" + zerlegt[1];
-            isLogImage = true;
-        }
-        if ((zerlegt[0] == "ImageQuality") && (zerlegt.size() > 1))
-            ImageQuality = std::stod(zerlegt[1]);
-
-        if ((zerlegt[0] == "ImageSize") && (zerlegt.size() > 1))
-        {
-            ImageSize = Camera.TextToFramesize(zerlegt[1].c_str());
-            isImageSize = true;
-        }
-
-        if ((toUpper(zerlegt[0]) == "SAVEALLFILES") && (zerlegt.size() > 1))
-        {
-            if (toUpper(zerlegt[1]) == "TRUE")
-                SaveAllFiles = true;
-        }
-        
-        if ((toUpper(zerlegt[0]) == "WAITBEFORETAKINGPICTURE") && (zerlegt.size() > 1))
-        {
-            waitbeforepicture = stoi(zerlegt[1]);
-        }
-
-
-        if ((toUpper(zerlegt[0]) == "BRIGHTNESS") && (zerlegt.size() > 1))
-        {
-            _brightness = stoi(zerlegt[1]);
-        }
-
-        if ((toUpper(zerlegt[0]) == "CONTRAST") && (zerlegt.size() > 1))
-        {
-            _contrast = stoi(zerlegt[1]);
-        }
-
-        if ((toUpper(zerlegt[0]) == "SATURATION") && (zerlegt.size() > 1))
-        {
-            _saturation = stoi(zerlegt[1]);
-        }
-
-        if ((toUpper(zerlegt[0]) == "FIXEDEXPOSURE") && (zerlegt.size() > 1))
-        {
-            if (toUpper(zerlegt[1]) == "TRUE")
-                FixedExposure = true;  
-        }
-
-        if ((toUpper(zerlegt[0]) == "LEDINTENSITY") && (zerlegt.size() > 1))
-        {
-            float ledintensity = stof(zerlegt[1]);
-            ledintensity = min((float) 100, ledintensity);
-            ledintensity = max((float) 0, ledintensity);
-            Camera.SetLEDIntensity(ledintensity);
-        }
-    }
-
-    Camera.SetBrightnessContrastSaturation(_brightness, _contrast, _saturation);
-    Camera.SetQualitySize(ImageQuality, ImageSize);
-
-    image_width = Camera.image_width;
-    image_height = Camera.image_height;
-    rawImage = new CImageBasis();
-    rawImage->CreateEmptyImage(image_width, image_height, 3);
-
-    waitbeforepicture_store = waitbeforepicture;
-    if (FixedExposure && (waitbeforepicture > 0))
-    {
-//        printf("Fixed Exposure enabled!\n");
-        int flashdauer = (int) (waitbeforepicture * 1000);
-        Camera.EnableAutoExposure(flashdauer);
-        waitbeforepicture = 0.2;
-//        flashdauer = (int) (waitbeforepicture * 1000);
-//        takePictureWithFlash(flashdauer);
-//        rawImage->SaveToFile("/sdcard/init2.jpg");
-    }
-
-    return true;
-}
-
-string ClassFlowMakeImage::getHTMLSingleStep(string host)
-{
-    string result;
-    result = "Raw Image: <br>\n<img src=\"" + host + "/img_tmp/raw.jpg\">\n";
-    return result;
-}
-
-bool ClassFlowMakeImage::doFlow(string zwtime)
-{
-    string logPath = CreateLogFolder(zwtime);
-
-    int flashdauer = (int) (waitbeforepicture * 1000);
- 
- #ifdef DEBUG_DETAIL_ON  
-    LogFile.WriteHeapInfo("ClassFlowMakeImage::doFlow - Before takePictureWithFlash");
-#endif
-
-
-#ifdef WIFITURNOFF
-    esp_wifi_stop();        // to save power usage and 
-#endif
-
-    takePictureWithFlash(flashdauer);
-
-#ifdef WIFITURNOFF
-     esp_wifi_start();
-#endif
-
-
-#ifdef DEBUG_DETAIL_ON  
-    LogFile.WriteHeapInfo("ClassFlowMakeImage::doFlow - After takePictureWithFlash");
-#endif
-
-    LogImage(logPath, "raw", NULL, NULL, zwtime, rawImage);
-
-    RemoveOldLogs();
-
-#ifdef DEBUG_DETAIL_ON  
-    LogFile.WriteHeapInfo("ClassFlowMakeImage::doFlow - After RemoveOldLogs");
-#endif
-
-    return true;
-}
-
-esp_err_t ClassFlowMakeImage::SendRawJPG(httpd_req_t *req)
-{
-    int flashdauer = (int) (waitbeforepicture * 1000);
-    time(&TimeImageTaken);
-    localtime(&TimeImageTaken);
-
-    return Camera.CaptureToHTTP(req, flashdauer);
-}
-
-
-ImageData* ClassFlowMakeImage::SendRawImage()
-{
-    CImageBasis *zw = new CImageBasis(rawImage);
-    ImageData *id;
-    int flashdauer = (int) (waitbeforepicture * 1000);
-    Camera.CaptureToBasisImage(zw, flashdauer);
-    time(&TimeImageTaken);
-    localtime(&TimeImageTaken);
-
-    id = zw->writeToMemoryAsJPG();    
-    delete zw;
-    return id;  
-}
-
-time_t ClassFlowMakeImage::getTimeImageTaken()
-{
-    return TimeImageTaken;
-}
-
-ClassFlowMakeImage::~ClassFlowMakeImage(void)
-{
-    delete rawImage;
-}
-
--- a/code/components/jomjol_flowcontroll/ClassFlowMakeImage.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowMakeImage.h
@@ -1,55 +0,0 @@
-#pragma once
-#include "ClassFlowImage.h"
-#include "ClassControllCamera.h"
-
-#include <string>
-
-#define BLINK_GPIO GPIO_NUM_4
-
-#define CAMERA_MODEL_AI_THINKER
-
-
-
-class ClassFlowMakeImage :
-    public ClassFlowImage
-{
-protected:
-    float waitbeforepicture;
-    float waitbeforepicture_store;
-    framesize_t ImageSize;
-    bool isImageSize;
-    int ImageQuality;
-    time_t TimeImageTaken;
-    string namerawimage;
-    int image_height, image_width;
-    bool SaveAllFiles;
-    bool FixedExposure;
-
-
-
-    void CopyFile(string input, string output);
-
-    esp_err_t camera_capture();
-    void takePictureWithFlash(int flashdauer);
-
-
-    void SetInitialParameter(void);       
-
-public:
-    CImageBasis *rawImage;
-
-    ClassFlowMakeImage(std::vector<ClassFlow*>* lfc);
-
-    bool ReadParameter(FILE* pfile, string& aktparamgraph);
-    bool doFlow(string time);
-    string getHTMLSingleStep(string host);
-    time_t getTimeImageTaken();
-    string name(){return "ClassFlowMakeImage";};
-
-    ImageData* SendRawImage();
-    esp_err_t SendRawJPG(httpd_req_t *req);
-
-    ~ClassFlowMakeImage(void);
-};
-
-
--- 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
@@ -1,8 +1,10 @@
-#ifndef __FLOWPOSTPROCESSING__
-#define __FLOWPOSTPROCESSING__
+#pragma once
+
+#ifndef CLASSFFLOWPOSTPROCESSING_H
+#define CLASSFFLOWPOSTPROCESSING_H

 #include "ClassFlow.h"
-#include "ClassFlowMakeImage.h"
+#include "ClassFlowTakeImage.h"
 #include "ClassFlowCNNGeneral.h"
 #include "ClassFlowDefineTypes.h"

@@ -13,42 +15,44 @@ class ClassFlowPostProcessing :
    public ClassFlow
 {
 protected:
-    std::vector<NumberPost*> NUMBERS;
    bool UpdatePreValueINI;

    int PreValueAgeStartup; 
    bool ErrorMessage;
-    bool IgnoreLeadingNaN;          // SPEZIALFALL für User Gustl
-
+    bool IgnoreLeadingNaN;          // SPECIAL CASE for User Gustl ???

    ClassFlowCNNGeneral* flowAnalog;
    ClassFlowCNNGeneral* flowDigit;    

-
    string FilePreValue;

-    ClassFlowMakeImage *flowMakeImage;
+    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);
-    string RundeOutput(double _in, int _anzNachkomma);

    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);
@@ -57,10 +61,12 @@ public:
    string getReadoutRate(int _number = 0);
    string getReadoutTimeStamp(int _number = 0);
    void SavePreValue();
+    string getJsonFromNumber(int i, std::string _lineend);
    string GetPreValue(std::string _number = "");
-    void SetPreValue(double zw, string _numbers, bool _extern = false);
+    bool SetPreValue(double zw, string _numbers, bool _extern = false);

-    std::string GetJSON(std::string _id = "", std::string _mac = "", std::string _lineend = "\n");
+    std::string GetJSON(std::string _lineend = "\n");
+    std::string getNumbersName();

    void UpdateNachkommaDecimalShift();

@@ -70,4 +76,4 @@ public:
 };


-#endif
+#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/ClassFlowWriteList.cpp
+++ b/code/components/jomjol_flowcontroll/ClassFlowWriteList.cpp
@@ -1,97 +0,0 @@
-#include <sstream>
-#include "ClassFlowWriteList.h"
-#include "Helper.h"
-
-#include "time_sntp.h"
-
-
-#include <time.h>
-
-void ClassFlowWriteList::SetInitialParameter(void)
-{
-    flowpostprocessing = NULL;  
-    previousElement = NULL;
-    ListFlowControll = NULL; 
-    disabled = false;
-}       
-
-ClassFlowWriteList::ClassFlowWriteList()
-{
-    SetInitialParameter();
-}
-
-ClassFlowWriteList::ClassFlowWriteList(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];
-        }
-    }
-}
-
-
-bool ClassFlowWriteList::ReadParameter(FILE* pfile, string& aktparamgraph)
-{
-    std::vector<string> zerlegt;
-
-    aktparamgraph = trim(aktparamgraph);
-
-    if (aktparamgraph.size() == 0)
-        if (!this->GetNextParagraph(pfile, aktparamgraph))
-            return false;
-
-    if (toUpper(aktparamgraph).compare("[MQTT]") != 0)       // Paragraph passt nich zu MakeImage
-        return false;
-
-    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
-    {
-        zerlegt = this->ZerlegeZeile(aktparamgraph);
-/*
-        if ((toUpper(zerlegt[0]) == "USER") && (zerlegt.size() > 1))
-        {
-            this->user = zerlegt[1];
-        }  
-*/
-    }
-   
-    return true;
-}
-
-
-
-bool ClassFlowWriteList::doFlow(string zwtime)
-{
-    std::string line = "";
-
-    std::string result;
-    std::string resulterror = "";
-    std::string resultraw = "";
-    std::string resultrate = "";
-    std::string resulttimestamp = "";
-    string zw = "";
-    string namenumber = "";
-
-    if (flowpostprocessing)
-    {
-        std::vector<NumberPost*>* NUMBERS = flowpostprocessing->GetNumbers();
-
-        for (int i = 0; i < (*NUMBERS).size(); ++i)
-        {
-            result =  (*NUMBERS)[i]->ReturnValue;
-            resultraw =  (*NUMBERS)[i]->ReturnRawValue;
-            resulterror = (*NUMBERS)[i]->ErrorMessageText;
-            resultrate = (*NUMBERS)[i]->ReturnRateValue;
-            resulttimestamp = (*NUMBERS)[i]->timeStamp;
-
-            line = line + resulttimestamp + "\t" + resultraw + "\t" + result + "\t" + resultraw + "\t" + resultrate + "\t" + resulttimestamp + "\t"; 
-
-        }
-    }
-    
-    return true;
-}
--- a/code/components/jomjol_flowcontroll/ClassFlowWriteList.h
+++ b/code/components/jomjol_flowcontroll/ClassFlowWriteList.h
@@ -1,22 +0,0 @@
-#pragma once
-#include "ClassFlow.h"
-#include "ClassFlowPostProcessing.h"
-
-#include <string>
-
-class ClassFlowWriteList :
-    public ClassFlow
-{
-protected:
-	ClassFlowPostProcessing* flowpostprocessing;  
-	void SetInitialParameter(void);        
-
-public:
-    ClassFlowWriteList();
-    ClassFlowWriteList(std::vector<ClassFlow*>* lfc);
-
-    bool ReadParameter(FILE* pfile, string& aktparamgraph);
-    bool doFlow(string time);
-    string name(){return "ClassFlowWriteList";};
-};
-
--- 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_flowcontroll/camera_define.h
+++ b/code/components/jomjol_flowcontroll/camera_define.h
@@ -1,101 +0,0 @@
-#ifndef CAMERADEFINED
-#define CAMERADEFINED
-
-
-#if defined(CAMERA_MODEL_WROVER_KIT)
-#define PWDN_GPIO_NUM    -1
-#define RESET_GPIO_NUM   -1
-#define XCLK_GPIO_NUM    21
-#define SIOD_GPIO_NUM    26
-#define SIOC_GPIO_NUM    27
-
-#define Y9_GPIO_NUM      35
-#define Y8_GPIO_NUM      34
-#define Y7_GPIO_NUM      39
-#define Y6_GPIO_NUM      36
-#define Y5_GPIO_NUM      19
-#define Y4_GPIO_NUM      18
-#define Y3_GPIO_NUM       5
-#define Y2_GPIO_NUM       4
-#define VSYNC_GPIO_NUM   25
-#define HREF_GPIO_NUM    23
-#define PCLK_GPIO_NUM    22
-
-#elif defined(CAMERA_MODEL_M5STACK_PSRAM)
-#define PWDN_GPIO_NUM     -1
-#define RESET_GPIO_NUM    15
-#define XCLK_GPIO_NUM     27
-#define SIOD_GPIO_NUM     25
-#define SIOC_GPIO_NUM     23
-
-#define Y9_GPIO_NUM       19
-#define Y8_GPIO_NUM       36
-#define Y7_GPIO_NUM       18
-#define Y6_GPIO_NUM       39
-#define Y5_GPIO_NUM        5
-#define Y4_GPIO_NUM       34
-#define Y3_GPIO_NUM       35
-#define Y2_GPIO_NUM       32
-#define VSYNC_GPIO_NUM    22
-#define HREF_GPIO_NUM     26
-#define PCLK_GPIO_NUM     21
-
-#elif defined(CAMERA_MODEL_AI_THINKER)
-#define PWDN_GPIO_NUM     GPIO_NUM_32
-#define RESET_GPIO_NUM    -1
-#define XCLK_GPIO_NUM      GPIO_NUM_0
-#define SIOD_GPIO_NUM     GPIO_NUM_26
-#define SIOC_GPIO_NUM     GPIO_NUM_27
-
-#define Y9_GPIO_NUM       GPIO_NUM_35
-#define Y8_GPIO_NUM       GPIO_NUM_34
-#define Y7_GPIO_NUM       GPIO_NUM_39
-#define Y6_GPIO_NUM       GPIO_NUM_36
-#define Y5_GPIO_NUM       GPIO_NUM_21
-#define Y4_GPIO_NUM       GPIO_NUM_19
-#define Y3_GPIO_NUM       GPIO_NUM_18
-#define Y2_GPIO_NUM        GPIO_NUM_5
-#define VSYNC_GPIO_NUM    GPIO_NUM_25
-#define HREF_GPIO_NUM     GPIO_NUM_23
-#define PCLK_GPIO_NUM     GPIO_NUM_22
-
-#else
-#error "Camera model not selected"
-#endif
-
-
-
-static camera_config_t camera_config = {
-    .pin_pwdn  = PWDN_GPIO_NUM,
-    .pin_reset = RESET_GPIO_NUM,
-    .pin_xclk = XCLK_GPIO_NUM,
-    .pin_sscb_sda = SIOD_GPIO_NUM,
-    .pin_sscb_scl = SIOC_GPIO_NUM,
-
-    .pin_d7 = Y9_GPIO_NUM,
-    .pin_d6 = Y8_GPIO_NUM,
-    .pin_d5 = Y7_GPIO_NUM,
-    .pin_d4 = Y6_GPIO_NUM,
-    .pin_d3 = Y5_GPIO_NUM,
-    .pin_d2 = Y4_GPIO_NUM,
-    .pin_d1 = Y3_GPIO_NUM,
-    .pin_d0 = Y2_GPIO_NUM,
-    .pin_vsync = VSYNC_GPIO_NUM,
-    .pin_href = HREF_GPIO_NUM,
-    .pin_pclk = PCLK_GPIO_NUM,
-
-    //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
-    .xclk_freq_hz = 20000000,
-    .ledc_timer = LEDC_TIMER_0,
-    .ledc_channel = LEDC_CHANNEL_0,
-
-    .pixel_format = PIXFORMAT_JPEG,//YUV422,GRAYSCALE,RGB565,JPEG
-//    .pixel_format = PIXFORMAT_RGB888,//YUV422,GRAYSCALE,RGB565,JPEG
-//    .frame_size = FRAMESIZE_QVGA,//QQVGA-QXGA Do not use sizes above QVGA when not JPEG
-    .frame_size = FRAMESIZE_SVGA,//QQVGA-QXGA Do not use sizes above QVGA when not JPEG
-
-    .jpeg_quality = 12, //0-63 lower number means higher quality
-    .fb_count = 1 //if more than one, i2s runs in continuous mode. Use only with JPEG
-};
-
-#endif
--- a/code/components/jomjol_helper/CMakeLists.txt
+++ b/code/components/jomjol_helper/CMakeLists.txt
@@ -2,6 +2,6 @@ FILE(GLOB_RECURSE app_sources ${CMAKE_CURRENT_SOURCE_DIR}/*.*)

 idf_component_register(SRCS ${app_sources}
                    INCLUDE_DIRS "."
-                    REQUIRES tflite-lib jomjol_logfile)
+                    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
@@ -1,20 +1,27 @@
 #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);

-void CopyFile(string input, string output);
-void DeleteFile(string fn);
-void RenameFile(string from, string to);
+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);

-
-FILE* OpenFileAndWait(const char* nm, const char* _mode, int _waitsec = 1);
+string RundeOutput(double _in, int _anzNachkomma);

 size_t findDelimiterPos(string input, string delimiter);
 //string trim(string istring);
@@ -38,6 +45,7 @@ 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();
@@ -45,3 +53,60 @@ 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/Show More
+++ b/Show More