Merge branch 'mqtt-logfile' of https://github.com/jomjol/AI-on-the-edge-device into mqtt-logfile

* Fix pipeline (#2860)

fix action

* ATA-Trim support (#2864)

Fix issues with the SD-Card initialization

* Update Changelog.md

---------

Co-authored-by: michael <Heinrich-Tuning@web.de>

.github/ISSUE_TEMPLATE/feature.yaml

@@ -1,6 +1,6 @@
 name: 💡 Feature Request
 description: Use this form if you have an idea or wish for a new feature
-labels: feature
+labels: enhancement
 body:
 
 

.github/label-commenter-config.yml

@@ -1,7 +1,53 @@
 # 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
   #######################################################################
@@ -11,11 +57,41 @@
           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
@@ -24,13 +100,24 @@
     labeled:
       issue:
           body: |
-            You can use the latest [Automatic Build](https://github.com/jomjol/AI-on-the-edge-device/actions/workflows/build.yaml?query=branch%3Arolling) of the the `rolling` branch. It might already contain a fix for your issue.
-            Pick the most top passing entry (it has a green circle with a tick in it), then scoll down to the **Artifacts** and download the file named `update_*`.
+            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 use the latest [Automatic Build](https://github.com/jomjol/AI-on-the-edge-device/actions/workflows/build.yaml?query=branch%3Arolling) of the the `rolling` branch. It might already contain a fix for your issue.
-            Pick the most top passing entry (it has a green circle with a tick in it), then scoll down to the **Artifacts** and download the file named `update_*`.
-
-
-
-
+            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 [Digital 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 [Digital 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/).

.github/workflows/build.yaml

@@ -1,252 +0,0 @@
-name: Build and Pack
-
-on: [push, pull_request]
-
-jobs:
-#########################################################################################
-## Build Firmware
-#########################################################################################
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - id: skip_check
-      uses: fkirc/skip-duplicate-actions@v5
-      with:
-        concurrent_skipping: same_content_newer
-    
-    - uses: actions/checkout@v3
-      with:
-        submodules: recursive
-
-    - name: Set Variables
-      id: vars
-      run: |
-        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-
-    - name: Cache PlatformIO
-      uses: actions/cache@v3
-      with:
-        path: ~/.platformio
-        key: ${{ runner.os }}-${{ hashFiles('**/lockfiles') }}
-
-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: '3.10'
-    - name: Install PlatformIO
-      run: |
-        python -m pip install --upgrade pip
-        pip install --upgrade platformio
-
-    - name: Build Firmware
-      #run: echo "Testing... ${{ github.ref_name }}, ${{ steps.vars.outputs.sha_short }}" > ./sd-card/html/version.txt; mkdir -p ./code/.pio/build/esp32cam/; cd ./code/.pio/build/esp32cam/; echo "${{ steps.vars.outputs.sha_short }}" > firmware.bin; cp firmware.bin partitions.bin; cp firmware.bin bootloader.bin # Testing
-      run: cd code; platformio run --environment esp32cam
-
-    - name: 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 new OTA 
-#########################################################################################
-  pack-for-OTA:
-    # New OTA concept
-    # update__version.zip file with following content:
-    #  - /firmware.bin
-    #  - (optional) /html/*
-    #  - (optional) /config/*.tfl
-    runs-on: ubuntu-latest
-    needs: build
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - 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
-      run: |
-        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
-
-    - name: Prepare update.zip artifact
-      run: |
-        mkdir -p ./dist
-        cp "./code/.pio/build/esp32cam/firmware.bin" "dist/firmware.bin"
-
-    - name: Add Web UI to dist
-      run: cp -r ./sd-card/html ./dist/
-
-    - name: Add CNN to dist
-      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
-
-    - name: Upload dist as update.zip artifact (Firmware + Web UI + CNN)
-      uses: actions/upload-artifact@v3
-      with:
-        name: "update__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
-        path: ./dist/*
-
-    - name: Store generated files in cache
-      uses: actions/cache@v3
-      with:
-        path: dist
-        key: ${{ github.run_number }}-pack-for-OTA
-
-
-
-
-#########################################################################################
-## Pack for a fresh install (USB flashing) (initial_esp32_setup)
-#########################################################################################
-  pack-for-fresh-install:
-    # creates old style binaries for fresh installation (backward compatible to wiki)
-    runs-on: ubuntu-latest
-    needs: build
-
-    steps:
-    - uses: actions/checkout@v3
-
-    - 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
-      run: |
-        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
-
-    - name: Prepare artifacts for release
-      run: |
-        mkdir -p firmware
-        rm -rf firmware/*.zip
-        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
-      with:
-        name: "initial_esp32_setup__${{ steps.vars.outputs.branch }}_(${{ 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
-
-
-
-
-#########################################################################################
-## Prepare and create release
-#########################################################################################
-  release: 
-    runs-on: ubuntu-latest
-    needs: [pack-for-OTA, pack-for-fresh-install]
-    if: startsWith(github.ref, 'refs/tags/') 
-      
-    steps:
-    - uses: actions/checkout@v3
-    - name: Set Variables
-      id: vars
-      run: |
-        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-
-    # import the changes from 
-    - name: Get generated files from cache
-      uses: actions/cache@v3
-      with:
-        path: dist
-        key: ${{ github.run_number }}-pack-for-OTA
-
-    # import cached artifacts from pack-for-fresh-install
-    - name: Get generated files from cache
-      uses: actions/cache@v3
-      with:
-        path: firmware
-        key: ${{ github.run_number }}-pack-for-fresh-install
-
-    - name: Prepare artifacts for release
-      run: |
-        mkdir -p release
-        mkdir -p dist
-        # create a update.zip like "update__rolling"
-        pwd
-        cd ./dist
-        zip -r ../release/update.zip .
-        cd ../firmware
-        zip -r ../release/initial_esp32_setup.zip .
-    # extract the version used in next step
-    - id: get_version
-      if: startsWith(github.ref, 'refs/tags/') 
-      uses: battila7/get-version-action@v2
-
-    # 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
-          
-
-    # 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/')
-      with:
-        name:  ${{ steps.get_version.outputs.version-without-v }}
-        body: ${{ steps.extract-release-notes.outputs.release_notes }}
-        files: |
-          release/*
-          
-
-    # Commit&Push Changelog to master branch. Must be manually merged back to rolling
-    - name: Commit changes and push changes
-      if: startsWith(github.ref, 'refs/tags/') 
-      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

.github/workflows/build.yml

@@ -0,0 +1,430 @@
+name: Build and Pack
+
+on: [push, pull_request]
+
+jobs:
+#########################################################################################
+## Build Firmware
+#########################################################################################
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - id: skip_check
+      uses: fkirc/skip-duplicate-actions@v5
+      with:
+        concurrent_skipping: same_content_newer
+    
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+    - name: Update PIP cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: pip-${{ github.run_id }}
+        restore-keys: pip # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update PlatformIO cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ~/.platformio
+        key: platformio-${{ github.run_id }}
+        restore-keys: platformio # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+          
+    - name: Update Build cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: ./code/.pio/
+        key: build-${{ github.run_id }}
+        restore-keys: build # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+          
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache          
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.10'
+
+    - name: Install PlatformIO
+      run: |
+        python -m pip install --upgrade pip
+        pip install --upgrade platformio
+
+    - name: Build Firmware
+      #run: echo "Testing... ${{ github.ref_name }}, ${{ steps.vars.outputs.sha_short }}" > ./sd-card/html/version.txt; mkdir -p ./code/.pio/build/esp32cam/; cd ./code/.pio/build/esp32cam/; echo "${{ steps.vars.outputs.sha_short }}" > firmware.bin; cp firmware.bin partitions.bin; cp firmware.bin bootloader.bin # Testing
+      run: cd code; platformio run --environment esp32cam
+
+    - name: Prepare Web UI (generate tooltip pages and update hashes in all files)
+      run: |
+        rm -rf ./html
+        mkdir html
+        cp -r ./sd-card/html/* ./html/
+
+        python -m pip install markdown
+        mkdir html/param-tooltips
+        cd tools/parameter-tooltip-generator
+        python generate-param-doc-tooltips.py
+        cd ../..
+
+        cp -r ./sd-card/html/* ./html/
+
+        echo "Replacing variables..."
+        cd html; find . -type f -exec sed -i 's/$COMMIT_HASH/${{ steps.vars.outputs.sha_short }}/g' {} \;
+        
+
+#########################################################################################
+## Pack for Update
+#########################################################################################
+  pack-for-update:
+    # New OTA concept
+    # update__version.zip file with following content:
+    #  - /firmware.bin
+    #  - (optional) /html/* (inkl. subfolders)
+    #  - (optional) /config/*.tfl
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update update cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: update
+        key: update-${{ github.run_id }}
+        restore-keys: update # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+    
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare update__*.zip artifact
+      run: |
+        rm -rf ./update
+        mkdir -p ./update
+        cp "./code/.pio/build/esp32cam/firmware.bin" "update/firmware.bin"
+
+    - name: Add Web UI to update
+      run: cp -r ./html ./update/
+
+    - name: Add CNN to update
+      run: |
+        rm -rf ./update/config/
+        mkdir -p ./update/config/
+        cp ./sd-card/config/*.tfl ./update/config/ 2>/dev/null || true
+        cp ./sd-card/config/*.tflite ./update/config/ 2>/dev/null || true
+
+    - name: Upload update as update.zip artifact (Firmware + Web UI + CNN)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./update/*
+
+
+
+#########################################################################################
+## Pack for Remote Setup 
+#########################################################################################
+  pack-for-remote_setup:
+    # New Remote Setup concept
+    # remote_setup__version.zip file with following content:
+    #  - /firmware.bin
+    #  - /html/* (inkl. subfolders)
+    #  - /config/*
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+          
+    - name: Update remote_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: remote_setup
+        key: remote_setup-${{ github.run_id }}
+        restore-keys: remote_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare remote_setup__*.zip artifact
+      run: |
+        rm -rf ./remote_setup
+        mkdir -p ./remote_setup
+
+    - name: Add Web UI to remote_setup
+      run: cp -r ./html ./remote_setup/
+
+    - name: Add whole config folder to remote_setup
+      run: |
+        rm -rf ./remote_setup/config/
+        mkdir -p ./remote_setup/config/
+        cp ./sd-card/config/* ./remote_setup/config/ 2>/dev/null || true
+
+    - name: Upload remote_setup as remote_setup.zip artifact (Firmware + Web UI + Config)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__remote-setup__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./remote_setup/*
+
+
+#########################################################################################
+## Pack for a fresh install (USB flashing) (manual_setup)
+#########################################################################################
+  pack-for-manual_setup:
+    # creates old style binaries for fresh installation (backward compatible to wiki)
+    runs-on: ubuntu-latest
+    needs: build
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Update generated-files cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: |
+          ./code/.pio/build/esp32cam/firmware.bin
+          ./code/.pio/build/esp32cam/partitions.bin
+          ./code/.pio/build/esp32cam/bootloader.bin
+          ./html/*
+        key: generated-files-${{ github.run_id }}
+        restore-keys: generated-files # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Update manual_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: manual_setup
+        key: manual_setup-${{ github.run_id }}
+        restore-keys: manual_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare manual_setup__*.zip artifact
+      run: |
+        rm -rf manual_setup
+        mkdir -p manual_setup
+        rm -rf manual_setup/*.zip
+        rm -rf release
+        mkdir -p release
+        # copy builds to manual_setup folder
+        cp -f "./code/.pio/build/esp32cam/firmware.bin" "manual_setup/firmware.bin"
+        cp -f "./code/.pio/build/esp32cam/bootloader.bin" "manual_setup/bootloader.bin"
+        cp -f "./code/.pio/build/esp32cam/partitions.bin" "manual_setup/partitions.bin"
+        rm -rf ./sd-card/html
+        cp -r ./html ./sd-card/ # Overwrite the Web UI with the preprocessed files
+        cd sd-card; zip -r ../manual_setup/sd-card.zip *; cd ..
+        cd ./manual_setup
+  
+    - name: Upload manual_setup.zip artifact (Firmware + Bootloader + Partitions + Web UI)
+      uses: actions/upload-artifact@v4
+      with:
+        name: "AI-on-the-edge-device__manual-setup__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
+        path: ./manual_setup
+
+
+#########################################################################################
+## Prepare and create release
+#########################################################################################
+  release: 
+    runs-on: ubuntu-latest
+    needs: [pack-for-update, pack-for-manual_setup, pack-for-remote_setup]
+    if: startsWith(github.ref, 'refs/tags/') 
+
+    # Sets permissions of the GITHUB_TOKEN to allow updating the branches
+    permissions:
+      contents: write
+      pages: write
+      id-token: write
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Update update cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: update
+        key: update-${{ github.run_id }}
+        restore-keys: update # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+    
+    - name: Update remote_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: remote_setup
+        key: remote_setup-${{ github.run_id }}
+        restore-keys: remote_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+    
+    - name: Update manual_setup cache on every commit
+      uses: actions/cache@v4
+      with:
+        path: manual_setup
+        key: manual_setup-${{ github.run_id }}
+        restore-keys: manual_setup # This matches above key as it is only used as a prefix. it the restores the nearest cache, see https://github.com/restore-keys:/blob/main/tips-and-workarounds.md#update-a-cache
+
+    - name: Set Variables
+      id: vars
+      run: |
+        echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+        echo "branch=$(echo ${{ github.ref_name }} | tr / __)" >> $GITHUB_OUTPUT
+
+    - name: Prepare artifacts for release
+      run: |
+        rm -rf release
+        mkdir -p release
+
+        # create AI-on-the-edge-device__update__*.zip like "AI-on-the-edge-device__update__v13.0.5.zip"
+        cd ./update
+        zip -r ../release/AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}.zip .
+
+        # create AI-on-the-edge-device__manual-setup__*.zip like "AI-on-the-edge-device__manual-setup__v13.0.5.zip"
+        cd ../manual_setup
+        zip -r ../release/AI-on-the-edge-device__manual-setup__${{ steps.vars.outputs.branch }}.zip .
+
+        # create AI-on-the-edge-device__remote-setup__*.zip like "AI-on-the-edge-device__remote-setup__v13.0.5.zip"
+        cd ../remote_setup
+        zip -r ../release/AI-on-the-edge-device__remote-setup__${{ steps.vars.outputs.branch }}.zip .
+
+    # extract the version used in next step
+    - id: get_version
+      if: startsWith(github.ref, 'refs/tags/') 
+      uses: Simply007/get-version-action@v2
+
+#    # 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
+
+    # 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
+      # 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
+      if: startsWith(github.ref, 'refs/tags/')
+      with:
+        name:  ${{ steps.get_version.outputs.version-without-v }}
+        body: ${{ steps.extract-release-notes.outputs.release_notes }}
+        files: |
+          release/*
+
+#    # Commit&Push Changelog to master branch. Must be manually merged back to rolling
+#    - name: Commit changes and push changes
+#      if: startsWith(github.ref, 'refs/tags/') 
+#      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:    
+    needs: [release]
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+
+    # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+    permissions:
+      contents: read
+      pages: write
+      id-token: write
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v4
+      
+    - name: Get version of last release
+      id: last_release
+      uses: mindojo/get-latest-release@0b8ef1434d7468d6bffcc8263baff5c777f72321
+      with:
+        myToken: ${{ github.token }}
+        exclude_types: "draft|prerelease"
+        view_top: 1     
+      
+    - name: Add binary to Web Installer and update manifest
+      run: |
+        echo "Updating Web installer to use firmware from ${{ steps.last_release.outputs.tag_name }}..."
+        rm -f docs/binary/firmware.bin
+        wget ${{ github.server_url }}/${{ github.repository }}/releases/download/${{ steps.last_release.outputs.tag_name }}/AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        unzip AI-on-the-edge-device__update__${{ steps.last_release.outputs.tag_name }}.zip
+        cp -f firmware.bin docs/binary/firmware.bin
+        echo "Updating index and manifest file..."
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/index.html
+        sed -i 's/$VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/manifest.json
+
+    - name: Setup Pages
+      uses: actions/configure-pages@v4
+
+    - name: Upload artifact
+      uses: actions/upload-pages-artifact@v2
+      with:
+        path: 'docs'
+
+    - name: Deploy to GitHub Pages
+      id: deployment
+      uses: actions/deploy-pages@v3  # Note: v4 does not work!

.github/workflows/clear_cache.yml

@@ -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")

.github/workflows/manual-update-webinstaller.yml

@@ -0,0 +1,63 @@
+# 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   
+  

.github/workflows/reply-bot.yml

@@ -22,20 +22,57 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       
-      - name: Remove 'Web Console' label again (issues only)
-        if: github.event.label.name == 'bot-reply Web Console'
-        uses: actions-cool/issues-helper@v2
-        with:
-          actions: 'remove-labels'
-          labels: 'bot-reply Web Console'
-
-      - name: Remove 'Rolling Build' label again (issues only)
-        if: github.event.label.name == 'bot-reply Rolling Build'
-        uses: actions-cool/issues-helper@v2
-        with:
-          actions: 'remove-labels'
-          labels: 'bot-reply Rolling Build'
-          
+      
+      ####################################################################
+      ## Remove labels again (issues only)
+      ## Make sure to also add the reply message to .github/label-commenter-config.yml!
+      ## 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:

.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

.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

Changelog.md

@@ -1,39 +1,305 @@
-# Changelog
+## [15.6.0] - 2024-02-09
 
-## [Unreleased]
+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)
 
-**Home Assistant MQTT Discovery Support**
+#### 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 / digital 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
+
+
+#### 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
 
-:bangbang: **Make sure to read the instructions below carfully!**
+Update Procedure see [online documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/#update-ota-over-the-air)
 
-1.  Backup your configuration (use the `System -> Backup/Restore` page)!
+:bangbang: Afterwards you should force-reload the Web Interface (usually Ctrl-F5 will do it)!
 
-2.  You should update to `12.0.1` before you update to this release. All other migrations are untested. 
+:bangbang: Afterwards you should check your configuration for errors!
 
-3.  Upload and update the `update-*.zip` file from this release.
+### Changes
 
-4.  Let it restart and check on the `System -> Info` page that the Firmware as well as the Web UI got updated. If only one got updated, redo the update. If it fails several times, you also can update the Firmware and the Web UI separately.
+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)
 
-5.  Safe way: 
-    1.  Update first the `firmware.bin` (extract it from one of the provided zip files) and do the Reboot
-    2.  Update with the full zip file (`update-*.zip`, ignore the version warning after the reboot)
+#### 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))
 
-6.  Please go to `Settings -> Configuration` and address the changed parameters:
-    -   DataLogging (storing the values for data graph)
-    -   Debug (extended by different debug reporting levels)
 
-7.  Make sure it starts to do the digitalization (check the Error field on the overview page). If it does not start a round within a minute, restart the device.
+#### 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`
+    -   Digital 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
 
-If anything breaks you can try to enforce manual update as following:
+#### 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
 
-**OTA:**
-  1. Make sure the last run of the update completed the **Uploading** step.
-  1. Call `http://<IP>/ota?task=update&file=<UPLOAD_FILENAME>` to enforce the extraction/flashing.
+#### Removed
+-   n.a.
 
-**Initial Setup:**
-  1. Use the initial_esp32_setup.zip ( <https://github.com/jomjol/AI-on-the-edge-device/wiki/Installation> ) as alternative to have a clean install.
+
+## [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
 
@@ -66,16 +332,16 @@ If anything breaks you can try to enforce manual update as following:
 -   NEW v13.0.2: MQTT: Added MQTT topic `status` (Digitalization 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
+    -   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
+    -   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
 
@@ -92,12 +358,12 @@ If anything breaks you can try to enforce manual update as following:
 -   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
+    -   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
@@ -111,7 +377,7 @@ If anything breaks you can try to enforce manual update as following:
 
 ## [12.0.1] 2022-09-29
 
-Improve **u**ser e**x**perience 
+Name: Improve **u**ser e**x**perience 
 
 :bangbang: The release breaks a few things in ota update :bangbang:
 
@@ -125,8 +391,8 @@ Improve **u**ser e**x**perience
 5.  Now you can reboot.
 
 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.
+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
 
@@ -778,20 +1044,20 @@ External Illumination
 
 -   Initial Version
 
-[Unreleased]: https://github.com/jomjol/AI-on-the-edge-device/compare/13.0.7...HEAD
 
-[13.0.7]: https://github.com/jomjol/AI-on-the-edge-device/compare/12.0.1...13.0.7
-
-[13.0.5]: https://github.com/jomjol/AI-on-the-edge-device/compare/12.0.1...13.0.5
-
-[13.0.4]: https://github.com/jomjol/AI-on-the-edge-device/compare/12.0.1...13.0.4
-
-[13.0.1]: https://github.com/jomjol/AI-on-the-edge-device/compare/12.0.1...13.0.1
-
-[12.0.1]: https://github.com/jomjol/AI-on-the-edge-device/compare/11.3.1...12.0.1
-
-[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

FeatureRequest.md

@@ -2,14 +2,48 @@
 
 **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)
@@ -43,7 +77,7 @@ haveing this state in the mqtt broker can trigger functions like closing the ate
 
 #### ~~#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
 
@@ -81,7 +115,7 @@ haveing this state in the mqtt broker can trigger functions like closing the ate
 
 #### ~~#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~~
 
   
 

README.md

@@ -1,28 +1,31 @@
 # Welcome to the AI-on-the-edge-device
 <img src="images/icon/watermeter.svg" width="100px">
 
-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**.
+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**.
 
-This projects allows you to digitalize your **analoge** water, gas, power and other meters using cheap and easily available hardware.
+This project allows you to digitize your **analog** water, gas, power and other meters using cheap and easily available hardware.
 
-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.
+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"> 
 
@@ -38,62 +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.
-Head there to get a start, set it up and configure it.
+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.
 
-There are also a articles in the German Heise magazine "make:" about the setup and the technical background (behind a paywall) : [DIY - Setup](https://www.heise.de/select/make/2021/2/2103513300897420296)
+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)
 
-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) 
+A lot of people created useful Youtube videos which might help you getting started.
+Here a small selection:
+
+- [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)
+
+For further background information, head to [Neural Networks](https://www.heise.de/select/make/2021/6/2126410443385102621), [Training Neural Networks](https://www.heise.de/select/make/2022/1/2134114065999161585) and [Programming on the ESP32](https://www.heise.de/select/make/2022/2/2204010051597422030).
 
 ### Download
-The latest available version is available on the [Releases page](https://github.com/jomjol/AI-on-the-edge-device/releases).
+The latest available version can be found on the [Releases page](https://github.com/jomjol/AI-on-the-edge-device/releases).
 
-### Flashing of the ESP32
-Initially you will have to flash the ESP32 through an USB connection. Later an update is possible directly over the Air (OTA).
+### Flashing the ESP32
+Initially you will have to flash the ESP32 via a USB connection. Later updates are possible directly over the air (OTA using WIFI).
 
 There are different ways to flash your ESP32:
-- [Web Installer and Console](https://jomjol.github.io/AI-on-the-edge-device/index.html) (Webbrowser based tool to flash the ESP32 and extract the Log over USB)
+- The prefered 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)
+- ESPtool (command-line tool)
 
-See the [Wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Installation) for more information.
+See the [documentation](https://jomjol.github.io/AI-on-the-edge-device-docs/Installation/) for more information.
 
-### Flashing the SD-Card
-The SD-Card must be flashed separately, see the [Wiki](https://github.com/jomjol/AI-on-the-edge-device/wiki/Installation) for details.
+### 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
-
-A 3d-printable housing can be found here:
+Various 3D-printable housing can be found here:
   - https://www.thingiverse.com/thing:4573481 (Water Meter)
   - https://www.thingiverse.com/thing:5028229 (Power Meter)
   - https://www.thingiverse.com/thing:5224101 (Gas Meter)
-  - https://www.thingiverse.com/thing:4571627 (ESP32-Cam housing only)
-
-## Build it yourself
-See [Build Instructions](code/README.md).
+  - 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 create an [Issue](https://github.com/jomjol/AI-on-the-edge-device/issues). 
+<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).
+
+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)
+See [Changelog](Changelog.md).
+
+## 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)
-
-------
-
+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).

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

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)

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
@@ -60,3 +69,6 @@ pio device monitor -p /dev/ttyUSB0
 - `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.

code/components/jomjol_configfile/configFile.cpp

@@ -6,12 +6,14 @@
 #include "configFile.h"
 #include <esp_log.h>
 
+#include "../../include/defines.h"
+
 static const char *TAG = "CONFIG";
 
 ConfigFile::ConfigFile(std::string filePath)
 {
     std::string config = FormatFileName(filePath);
-    pFile = OpenFileAndWait(config.c_str(), "r");
+    pFile = fopen(config.c_str(), "r");
 }
 
 ConfigFile::~ConfigFile()
@@ -65,7 +67,7 @@ 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);
 		ESP_LOGD(TAG, "%s", zw);

code/components/jomjol_configfile/configFile.h

@@ -1,3 +1,8 @@
+#pragma once
+
+#ifndef CONFIGFILE_H
+#define CONFIGFILE_H
+
 #include <string>
 #include <vector>
 
@@ -9,7 +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);
+    bool ConfigFileExists(){return pFile;};
     
 private:
     FILE* pFile;
-};
+};
+
+#endif //CONFIGFILE_H

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

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;
 

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

code/components/jomjol_controlGPIO/server_GPIO.cpp

@@ -6,34 +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 "interface_mqtt.h"
+#include "server_mqtt.h"
 #endif //ENABLE_MQTT
 
+
 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;
@@ -86,10 +81,10 @@ static void gpioHandlerTask(void *arg) {
 
 void GpioPin::gpioInterrupt(int value) {
 #ifdef ENABLE_MQTT    
-    if (_mqttTopic != "") {
+    if (_mqttTopic.compare("") != 0) {
         ESP_LOGD(TAG, "gpioInterrupt %s %d", _mqttTopic.c_str(), value);
 
-        MQTTPublish(_mqttTopic, value ? "true" : "false");        
+        MQTTPublish(_mqttTopic, value ? "true" : "false", 1);        
     }
 #endif //ENABLE_MQTT
     currentState = value;
@@ -119,7 +114,7 @@ void GpioPin::init()
     }
 
 #ifdef ENABLE_MQTT
-    if ((_mqttTopic != "") && ((_mode == GPIO_PIN_MODE_OUTPUT) || (_mode == GPIO_PIN_MODE_OUTPUT_PWM) || (_mode == GPIO_PIN_MODE_BUILT_IN_FLASH_LED))) {
+    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);
     }
@@ -145,8 +140,8 @@ void GpioPin::setValue(bool value, gpio_set_source setSource, std::string* error
         gpio_set_level(_gpio, value);
 
 #ifdef ENABLE_MQTT
-        if ((_mqttTopic != "") && (setSource != GPIO_SET_SOURCE_MQTT)) {
-            MQTTPublish(_mqttTopic, value ? "true" : "false");
+        if ((_mqttTopic.compare("") != 0) && (setSource != GPIO_SET_SOURCE_MQTT)) {
+            MQTTPublish(_mqttTopic, value ? "true" : "false", 1);
         }
 #endif //ENABLE_MQTT
     }
@@ -157,7 +152,8 @@ void GpioPin::publishState() {
     if (newState != currentState) {
         ESP_LOGD(TAG,"publish state of GPIO %d new state %d", _gpio, newState);
 #ifdef ENABLE_MQTT
-        MQTTPublish(_mqttTopic, newState ? "true" : "false");
+    if (_mqttTopic.compare("") != 0)
+        MQTTPublish(_mqttTopic, newState ? "true" : "false", 1);
 #endif //ENABLE_MQTT
         currentState = newState;
     }
@@ -254,7 +250,7 @@ void GpioHandler::init()
 
     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, "xHandletaskGpioHandler started");
         } else {
@@ -310,7 +306,7 @@ 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;
@@ -334,7 +330,7 @@ bool GpioHandler::readConfig()
 
 #ifdef ENABLE_MQTT
 //    std::string mainTopicMQTT = "";
-    std::string mainTopicMQTT = GetMQTTMainTopic();
+    std::string mainTopicMQTT = mqttServer_getMainTopic();
     if (mainTopicMQTT.length() > 0)
     {
         mainTopicMQTT = mainTopicMQTT + "/GPIO";
@@ -344,31 +340,31 @@ bool GpioHandler::readConfig()
     bool registerISR = false;
     while (configFile.getNextLine(&line, disabledLine, eof) && !configFile.isNewParagraph(line))
     {
-        zerlegt = 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, "conf param %s", toUpper(zerlegt[0]).c_str());
-        if (toUpper(zerlegt[0]) == "MAINTOPICMQTT") {
+        ESP_LOGD(TAG, "conf param %s", toUpper(splitted[0]).c_str());
+        if (toUpper(splitted[0]) == "MAINTOPICMQTT") {
 //            ESP_LOGD(TAG, "MAINTOPICMQTT found");
-//            mainTopicMQTT = zerlegt[1];
-        } else if ((zerlegt[0].rfind("IO", 0) == 0) && (zerlegt.size() >= 6))
+//            mainTopicMQTT = splitted[1];
+        } else if ((splitted[0].rfind("IO", 0) == 0) && (splitted.size() >= 6))
         {
-            ESP_LOGI(TAG,"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());
+            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(zerlegt[4]) == "true";
+            bool mqttEnabled = (toLower(splitted[4]) == "true");
 #endif // ENABLE_MQTT
-            bool httpEnabled = toLower(zerlegt[5]) == "true";
+            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);
             }
@@ -390,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;
         }
     }
@@ -696,6 +692,7 @@ void gpio_handler_deinit() {
 void gpio_handler_destroy()
 {
     if (gpioHandler != NULL) {
+        gpio_handler_deinit();
         delete gpioHandler;
         gpioHandler = NULL;
     }

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,

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)
 
 

code/components/jomjol_controlcamera/ClassControllCamera.cpp

@@ -7,14 +7,13 @@
 #include "esp_log.h"
 
 #include "Helper.h"
+#include "statusled.h"
 #include "CImageBasis.h"
 
 #include "server_ota.h"
 #include "server_GPIO.h"
 
-
-#define BOARD_ESP32CAM_AITHINKER
-
+#include "../../include/defines.h"
 
 #include <esp_event.h>
 #include <esp_log.h>
@@ -22,54 +21,39 @@
 #include <nvs_flash.h>
 #include <sys/param.h>
 #include <string.h>
+#include <sys/stat.h>
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 
 #include "esp_camera.h"
 
-// #define DEBUG_DETAIL_ON
-
-#define USE_PWM_LEDFLASH
-
-#ifdef USE_PWM_LEDFLASH
-
-//// PWM für Flash-LED
-#define LEDC_TIMER              LEDC_TIMER_1 // LEDC_TIMER_0
-#define LEDC_MODE               LEDC_LOW_SPEED_MODE
-#define LEDC_OUTPUT_IO          (4) // Define the output GPIO
-#define LEDC_CHANNEL            LEDC_CHANNEL_1
-#define LEDC_DUTY_RES           LEDC_TIMER_13_BIT // Set duty resolution to 13 bits
-//#define LEDC_DUTY               (195) // Set duty to 50%. ((2 ** 13) - 1) * 50% = 4095
-#define LEDC_FREQUENCY          (5000) // Frequency in Hertz. Set frequency at 5 kHz
+#include "driver/ledc.h"
+#include "MainFlowControl.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
 
-
-
-// ESP32Cam (AiThinker) PIN Map
-
-#define CAM_PIN_PWDN 32
-#define CAM_PIN_RESET -1 //software reset will be performed
-#define CAM_PIN_XCLK 0
-#define CAM_PIN_SIOD 26
-#define CAM_PIN_SIOC 27
-
-#define CAM_PIN_D7 35
-#define CAM_PIN_D6 34
-#define CAM_PIN_D5 39
-#define CAM_PIN_D4 36
-#define CAM_PIN_D3 21
-#define CAM_PIN_D2 19
-#define CAM_PIN_D1 18
-#define CAM_PIN_D0 5
-#define CAM_PIN_VSYNC 25
-#define CAM_PIN_HREF 23
-#define CAM_PIN_PCLK 22
-
-
 static const char *TAG = "CAM"; 
 
+
+/* Camera live stream */
+#define PART_BOUNDARY "123456789000000000000987654321"
+static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
+static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
+static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";
+
+
 static camera_config_t camera_config = {
     .pin_pwdn = CAM_PIN_PWDN,
     .pin_reset = CAM_PIN_RESET,
@@ -90,8 +74,8 @@ static camera_config_t camera_config = {
     .pin_pclk = CAM_PIN_PCLK,
 
     //XCLK 20MHz or 10MHz for OV2640 double FPS (Experimental)
-    .xclk_freq_hz = 20000000,             // Orginalwert
-//    .xclk_freq_hz =    5000000,               // Test, um die Bildfehler los zu werden !!!! Hängt in Version 9.2 !!!!
+    .xclk_freq_hz = 20000000,             // Orginal value
+//    .xclk_freq_hz =    5000000,         // Test to get rid of the image errors !!!! Hangs in version 9.2 !!!!
     .ledc_timer = LEDC_TIMER_0,
     .ledc_channel = LEDC_CHANNEL_0,
 
@@ -101,18 +85,15 @@ static camera_config_t camera_config = {
     .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
     .fb_location = CAMERA_FB_IN_PSRAM, /*!< The location where the frame buffer will be allocated */
-//    .grab_mode = CAMERA_GRAB_WHEN_EMPTY,
-    .grab_mode = CAMERA_GRAB_LATEST,      // erst ab neuer esp32cam-version
-    
+    .grab_mode = CAMERA_GRAB_LATEST,      // only from new esp32cam version
 };
 
 
-#include "driver/ledc.h"
-
 CCamera Camera;
 
-#define FLASH_GPIO GPIO_NUM_4
-#define BLINK_GPIO GPIO_NUM_33
+uint8_t *demoImage = NULL; // Buffer holding the demo image in bytes
+
+#define DEMO_IMAGE_SIZE 30000 // Max size of demo image in bytes
 
 typedef struct {
         httpd_req_t *req;
@@ -120,6 +101,21 @@ typedef struct {
 } jpg_chunking_t;
 
 
+bool CCamera::testCamera(void) {
+    bool success;
+    camera_fb_t *fb = esp_camera_fb_get();
+    if (fb)  {
+        success = true;
+    }
+    else {
+        success = false;
+    }
+    
+    esp_camera_fb_return(fb);
+    return success;
+}
+
+
 void CCamera::ledc_init(void)
 {
 #ifdef USE_PWM_LEDFLASH
@@ -152,63 +148,97 @@ void CCamera::ledc_init(void)
 }
 
 
-static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){
+static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len)
+{
     jpg_chunking_t *j = (jpg_chunking_t *)arg;
-    if(!index){
+
+    if(!index) {
         j->len = 0;
     }
-    if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){
+
+    if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK) {
         return 0;
     }
+
     j->len += len;
+
     return len;
 }
 
 
 bool CCamera::SetBrightnessContrastSaturation(int _brightness, int _contrast, int _saturation)
 {
-    bool result = false;
-    sensor_t * s = esp_camera_sensor_get(); 
-    if (_brightness > -100)
-        _brightness = min(2, max(-2, _brightness));
-    if (_contrast > -100)
-        _contrast = min(2, max(-2, _contrast));
-    if (_saturation > -100)
-        _saturation = min(2, max(-2, _saturation));
+    _brightness = min(2, max(-2, _brightness));
+    _contrast = min(2, max(-2, _contrast));
+    _saturation = min(2, max(-2, _saturation));
 
-    if (_saturation > -100)
+    sensor_t * s = esp_camera_sensor_get();
+    if (s) {
         s->set_saturation(s, _saturation);
-    if (_contrast > -100)
         s->set_contrast(s, _contrast);
-    if (_brightness > -100)
         s->set_brightness(s, _brightness);
 
-    if ((_brightness != brightness) && (_brightness > -100))
-        result = true;
-    if ((_contrast != contrast) && (_contrast > -100))
-        result = true;
-    if ((_saturation != saturation) && (_saturation > -100))
-        result = true;
-    
-    if (_brightness > -100)
-        brightness = _brightness;
-    if (_contrast > -100)
-        contrast = _contrast;
-    if (_saturation > -100)
-       saturation = _saturation;
+        /* Workaround - bug in cam library - enable bits are set without using bitwise OR logic -> only latest enable setting is used */
+        /* Library version: https://github.com/espressif/esp32-camera/commit/5c8349f4cf169c8a61283e0da9b8cff10994d3f3 */
+        /* Reference: https://esp32.com/viewtopic.php?f=19&t=14376#p93178 */
+        /* The memory structure is as follows for 
+        byte_0 = enable_bits
+            byte_0->bit0 = enable saturation and hue --> OK
+            byte_0->bit1 = enable saturation --> OK
+            byte_0->bit2 = enable brightness and contrast --> OK
+            byte_0->bit3 = enable green -> blue spitial effect (Antique and blunish and greenish and readdish and b&w) enable
+            byte_0->bit4 = anable gray -> read spitial effect (Antique and blunish and greenish and readdish and b&w) enable
+            byte_0->bit5 = remove (UV) in YUV color system
+            byte_0->bit6 = enable negative
+            byte_0->bit7 = remove (Y) in YUV color system
+        byte_1 = saturation1 0-255 --> ?
+        byte_2 = hue 0-255 --> OK
+        byte_3 = saturation2 0-255 --> OK
+        byte_4 = reenter saturation2 in documents --> ?
+        byte_5 = spital effect green -> blue 0-255 --> ?
+        byte_6 = spital effect gray -> read 0-255 --> ?
+        byte_7 = contrast lower byte 0-255 --> OK
+        byte_8 = contrast higher byte 0-255 --> OK
+        byte_9 = brightness 0-255 --> OK
+        byte_10= if byte_10==4 contrast effective --> ?
+        */
 
-    if (result && isFixedExposure)
+        //s->set_reg(s, 0x7C, 0xFF, 2); // Optional feature - hue setting: Select byte 2 in register 0x7C to set hue value
+        //s->set_reg(s, 0x7D, 0xFF, 0); // Optional feature - hue setting: Hue value 0 - 255
+        s->set_reg(s, 0xFF, 0x01, 0); // Select DSP bank
+        s->set_reg(s, 0x7C, 0xFF, 0); // Select byte 0 in register 0x7C
+        s->set_reg(s, 0x7D, 7, 7); // Set bit 0, 1, 2 in register 0x7D to enable saturation, contrast, brightness and hue control
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "SetBrightnessContrastSaturation: Failed to get control structure");
+    }
+
+    if (((_brightness != brightness) || (_contrast != contrast) || (_saturation != saturation)) && isFixedExposure)
         EnableAutoExposure(waitbeforepicture_org);
 
-    return result;
+    brightness = _brightness;
+    contrast = _contrast;
+    saturation = _saturation;
+
+    ESP_LOGD(TAG, "brightness %d, contrast: %d, saturation %d", brightness, contrast, saturation);
+
+    return true;
 }
 
 
 void CCamera::SetQualitySize(int qual, framesize_t resol)
 {
-    sensor_t * s = esp_camera_sensor_get();   
-    s->set_quality(s, qual);    
-    s->set_framesize(s, resol); 
+    qual = min(63, max(8, qual)); // Limit quality from 8..63 (values lower than 8 tent to be unstable)
+    
+    sensor_t * s = esp_camera_sensor_get();
+    if (s) {
+        s->set_quality(s, qual);    
+        s->set_framesize(s, resol);
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "SetQualitySize: Failed to get control structure");
+    }
+
     ActualResolution = resol;
     ActualQuality = qual;
 
@@ -217,124 +247,104 @@ void CCamera::SetQualitySize(int qual, framesize_t resol)
         image_height = 240;
         image_width = 320;             
     }
-    if (resol == FRAMESIZE_VGA)
+    else if (resol == FRAMESIZE_VGA)
     {
         image_height = 480;
         image_width = 640;             
     }
-    // No higher Mode than VGA, damit der Kameraspeicher ausreicht.
-/*
-    if (resol == FRAMESIZE_SVGA)
-    {
-        image_height = 600;
-        image_width = 800;             
-    }
-    if (resol == FRAMESIZE_XGA)
-    {
-        image_height = 768;
-        image_width = 1024;             
-    }
-    if (resol == FRAMESIZE_SXGA)
-    {
-        image_height = 1024;
-        image_width = 1280;             
-    }
-    if (resol == FRAMESIZE_UXGA)
-    {
-        image_height = 1200;
-        image_width = 1600;             
-    }
-*/
 }
 
 
-void CCamera::EnableAutoExposure(int flashdauer)
+void CCamera::EnableAutoExposure(int flash_duration)
 {
     ESP_LOGD(TAG, "EnableAutoExposure");
+    
     LEDOnOff(true);
-    if (flashdauer > 0)
+    if (flash_duration > 0) {
         LightOnOff(true);
-    const TickType_t xDelay = flashdauer / portTICK_PERIOD_MS;
-    vTaskDelay( xDelay );
+        const TickType_t xDelay = flash_duration / portTICK_PERIOD_MS;
+        vTaskDelay( xDelay );
+    }
 
     camera_fb_t * fb = esp_camera_fb_get();
     esp_camera_fb_return(fb);
     fb = esp_camera_fb_get();
     if (!fb) {
-        ESP_LOGE(TAG, "Camera Capture Failed");
         LEDOnOff(false);
         LightOnOff(false);
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Capture Failed (Procedure 'EnableAutoExposure') --> Reboot! "
-                "Check that your camera module is working and connected properly.");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "EnableAutoExposure: Capture Failed. "
+                                                "Check camera module and/or proper electrical connection");
         //doReboot();
     }
     esp_camera_fb_return(fb);        
 
     sensor_t * s = esp_camera_sensor_get(); 
-    s->set_gain_ctrl(s, 0);
-    s->set_exposure_ctrl(s, 0);
-
+    if (s) {
+        s->set_gain_ctrl(s, 0);
+        s->set_exposure_ctrl(s, 0);
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "EnableAutoExposure: Failed to get control structure to set gain+exposure");
+    }
 
     LEDOnOff(false);  
     LightOnOff(false);
     isFixedExposure = true;
-    waitbeforepicture_org = flashdauer;
+    waitbeforepicture_org = flash_duration;
 }
 
 
 esp_err_t CCamera::CaptureToBasisImage(CImageBasis *_Image, int delay)
 {
-    string ftype;
-
-    uint8_t *zwischenspeicher = NULL;
-
+	#ifdef DEBUG_DETAIL_ON
+	    LogFile.WriteHeapInfo("CaptureToBasisImage - Start");
+	#endif
 
+    _Image->EmptyImage(); //Delete previous stored raw image -> black image
+    
     LEDOnOff(true);
 
-#ifdef DEBUG_DETAIL_ON
-    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - Start");
-#endif
-
-    if (delay > 0) 
-    {
+    if (delay > 0) {
         LightOnOff(true);
         const TickType_t xDelay = delay / portTICK_PERIOD_MS;
         vTaskDelay( xDelay );
     }
 
-#ifdef DEBUG_DETAIL_ON
-    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After LightOn");
-#endif
+	#ifdef DEBUG_DETAIL_ON
+	    LogFile.WriteHeapInfo("CaptureToBasisImage - After LightOn");
+	#endif
 
     camera_fb_t * fb = esp_camera_fb_get();
     esp_camera_fb_return(fb);        
     fb = esp_camera_fb_get();
     if (!fb) {
-        ESP_LOGE(TAG, "CaptureToBasisImage: Capture Failed");
         LEDOnOff(false);
         LightOnOff(false);
 
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "is not working anymore (CCamera::CaptureToBasisImage) - most probably caused by a hardware problem (instablility, ...). "
-                "System will reboot.");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "is not working anymore (CaptureToBasisImage) - most probably caused "
+                                                "by a hardware problem (instablility, ...). System will reboot.");
         doReboot();
 
         return ESP_FAIL;
     }
 
-    int _size = fb->len;
-    zwischenspeicher = (uint8_t*) malloc(_size);
-    if (!zwischenspeicher)
-    {
-        ESP_LOGE(TAG, "Insufficient memory space for image in function CaptureToBasisImage()");
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Insufficient memory space for image in function CaptureToBasisImage()");
+    if (demoMode) { // Use images stored on SD-Card instead of camera image
+        /* Replace Framebuffer with image from SD-Card */
+        loadNextDemoImage(fb);
+    }
+
+    CImageBasis* _zwImage = new CImageBasis("zwImage");
+    if (_zwImage) {
+        _zwImage->LoadFromMemory(fb->buf, fb->len);
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "CaptureToBasisImage: Can't allocate _zwImage");
     }
-    for (int i = 0; i < _size; ++i)
-        *(zwischenspeicher + i) = *(fb->buf + i);
     esp_camera_fb_return(fb);        
 
-#ifdef DEBUG_DETAIL_ON
-    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After fb_get");
-#endif
+    #ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("CaptureToBasisImage - After fb_get");
+    #endif
 
     LEDOnOff(false);  
 
@@ -344,15 +354,9 @@ esp_err_t CCamera::CaptureToBasisImage(CImageBasis *_Image, int delay)
 //    TickType_t xDelay = 1000 / portTICK_PERIOD_MS;     
 //    vTaskDelay( xDelay );  // wait for power to recover
     
-    uint8_t * buf = NULL;
-
-    CImageBasis _zwImage;
-    _zwImage.LoadFromMemory(zwischenspeicher, _size);
-    free(zwischenspeicher);
-
-#ifdef DEBUG_DETAIL_ON
-    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After LoadFromMemory");
-#endif
+    #ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("CaptureToBasisImage - After LoadFromMemory");
+    #endif
 
     stbi_uc* p_target;
     stbi_uc* p_source;    
@@ -360,31 +364,27 @@ esp_err_t CCamera::CaptureToBasisImage(CImageBasis *_Image, int delay)
     int width = image_width;
     int height = image_height;
 
-#ifdef DEBUG_DETAIL_ON
-    std::string _zw = "Targetimage: " + std::to_string((int) _Image->rgb_image) + " Size: " + std::to_string(_Image->width) + ", " + std::to_string(_Image->height);
-    _zw = _zw + " _zwImage: " + std::to_string((int) _zwImage.rgb_image)  + " Size: " + std::to_string(_zwImage.width) + ", " + std::to_string(_zwImage.height);
-    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, _zw);
-#endif
+    #ifdef DEBUG_DETAIL_ON
+        std::string _zw = "Targetimage: " + std::to_string((int) _Image->rgb_image) + " Size: " + std::to_string(_Image->width) + ", " + std::to_string(_Image->height);
+        _zw = _zw + " _zwImage: " + std::to_string((int) _zwImage->rgb_image)  + " Size: " + std::to_string(_zwImage->width) + ", " + std::to_string(_zwImage->height);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, _zw);
+    #endif
 
     for (int x = 0; x < width; ++x)
         for (int y = 0; y < height; ++y)
         {
             p_target = _Image->rgb_image + (channels * (y * width + x));
-            p_source = _zwImage.rgb_image + (channels * (y * width + x));
+            p_source = _zwImage->rgb_image + (channels * (y * width + x));
             p_target[0] = p_source[0];
             p_target[1] = p_source[1];
             p_target[2] = p_source[2];
         }
 
-#ifdef DEBUG_DETAIL_ON
-    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - After Copy To Target");
-#endif
+    delete _zwImage;
 
-    free(buf);
-
-#ifdef DEBUG_DETAIL_ON
-    LogFile.WriteHeapInfo("CCamera::CaptureToBasisImage - Done");
-#endif
+    #ifdef DEBUG_DETAIL_ON
+        LogFile.WriteHeapInfo("CaptureToBasisImage - Done");
+    #endif
 
     return ESP_OK;    
 }
@@ -394,10 +394,9 @@ esp_err_t CCamera::CaptureToFile(std::string nm, int delay)
 {
     string ftype;
 
-     LEDOnOff(true);              // Abgeschaltet, um Strom zu sparen !!!!!!
+     LEDOnOff(true);              // Switched off to save power !
 
-    if (delay > 0) 
-    {
+    if (delay > 0) {
         LightOnOff(true);
         const TickType_t xDelay = delay / portTICK_PERIOD_MS;
         vTaskDelay( xDelay );
@@ -407,32 +406,31 @@ esp_err_t CCamera::CaptureToFile(std::string nm, int delay)
     esp_camera_fb_return(fb);
     fb = esp_camera_fb_get();
     if (!fb) {
-        ESP_LOGE(TAG, "CaptureToFile: Camera Capture Failed");
         LEDOnOff(false);
         LightOnOff(false);
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Capture Failed (CCamera::CaptureToFile) --> Reboot! "
-                "Check that your camera module is working and connected properly.");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "CaptureToFile: Capture Failed. "
+                                                "Check camera module and/or proper electrical connection");
         //doReboot();
 
         return ESP_FAIL;
     }
     LEDOnOff(false);    
 
-#ifdef DEBUG_DETAIL_ON    
-    ESP_LOGD(TAG, "w %d, h %d, size %d", fb->width, fb->height, fb->len);
-#endif
+    #ifdef DEBUG_DETAIL_ON    
+        ESP_LOGD(TAG, "w %d, h %d, size %d", fb->width, fb->height, fb->len);
+    #endif
 
     nm = FormatFileName(nm);
 
-#ifdef DEBUG_DETAIL_ON
-    ESP_LOGD(TAG, "Save Camera to: %s", nm.c_str());
-#endif
+    #ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Save Camera to: %s", nm.c_str());
+    #endif
 
     ftype = toUpper(getFileType(nm));
 
-#ifdef DEBUG_DETAIL_ON
-    ESP_LOGD(TAG, "Filetype: %s", ftype.c_str());
-#endif
+    #ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Filetype: %s", ftype.c_str());
+    #endif
 
     uint8_t * buf = NULL;
     size_t buf_len = 0;   
@@ -457,25 +455,22 @@ esp_err_t CCamera::CaptureToFile(std::string nm, int delay)
         }
     }
 
-    FILE * fp = OpenFileAndWait(nm.c_str(), "wb");
-    if (fp == NULL)  /* If an error occurs during the file creation */
-    {
-        fprintf(stderr, "fopen() failed for '%s'\n", nm.c_str());
+    FILE * fp = fopen(nm.c_str(), "wb");
+    if (fp == NULL) { // If an error occurs during the file creation
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "CaptureToFile: Failed to open file " + nm);
     }
-    else
-    {
+    else {
         fwrite(buf, sizeof(uint8_t), buf_len, fp); 
         fclose(fp);
-    }    
+    }   
+
     if (converted)
         free(buf);
 
     esp_camera_fb_return(fb);
 
     if (delay > 0) 
-    {
         LightOnOff(false);
-    }
 
     return ESP_OK;    
 }
@@ -483,29 +478,26 @@ esp_err_t CCamera::CaptureToFile(std::string nm, int delay)
 
 esp_err_t CCamera::CaptureToHTTP(httpd_req_t *req, int delay)
 {
-    camera_fb_t * fb = NULL;
     esp_err_t res = ESP_OK;
     size_t fb_len = 0;
     int64_t fr_start = esp_timer_get_time();
 
-
     LEDOnOff(true);
 
-    if (delay > 0) 
-    {
+    if (delay > 0) {
         LightOnOff(true);
         const TickType_t xDelay = delay / portTICK_PERIOD_MS;
         vTaskDelay( xDelay );
     }
 
-
-    fb = esp_camera_fb_get();
+    camera_fb_t *fb = esp_camera_fb_get();
     esp_camera_fb_return(fb);
     fb = esp_camera_fb_get();
     if (!fb) {
-        ESP_LOGE(TAG, "Camera capture failed");
         LEDOnOff(false);
         LightOnOff(false);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "CaptureToFile: Capture Failed. "
+                                        "Check camera module and/or proper electrical connection");
         httpd_resp_send_500(req);
 //        doReboot();
 
@@ -520,26 +512,101 @@ esp_err_t CCamera::CaptureToHTTP(httpd_req_t *req, int delay)
     }
 
     if(res == ESP_OK){
-        if(fb->format == PIXFORMAT_JPEG){
-            fb_len = fb->len;
+        if (demoMode) { // Use images stored on SD-Card instead of camera image
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Using Demo image!");
+            /* Replace Framebuffer with image from SD-Card */
+            loadNextDemoImage(fb);
+
             res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
-        } else {
-            jpg_chunking_t jchunk = {req, 0};
-            res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
-            httpd_resp_send_chunk(req, NULL, 0);
-            fb_len = jchunk.len;
+        }
+        else {
+            if(fb->format == PIXFORMAT_JPEG){
+                fb_len = fb->len;
+                res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
+            } else {
+                jpg_chunking_t jchunk = {req, 0};
+                res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
+                httpd_resp_send_chunk(req, NULL, 0);
+                fb_len = jchunk.len;
+            }
         }
     }
     esp_camera_fb_return(fb);
     int64_t fr_end = esp_timer_get_time();
     
-    ESP_LOGI(TAG, "JPG: %uKB %ums", (uint32_t)(fb_len/1024), (uint32_t)((fr_end - fr_start)/1000));
+    ESP_LOGI(TAG, "JPG: %dKB %dms", (int)(fb_len/1024), (int)((fr_end - fr_start)/1000));
 
     if (delay > 0) 
-    {
         LightOnOff(false);
+
+    return res;
+}
+
+
+esp_err_t CCamera::CaptureToStream(httpd_req_t *req, bool FlashlightOn)
+{
+    esp_err_t res = ESP_OK;
+    size_t fb_len = 0;
+    int64_t fr_start;
+    char * part_buf[64];
+
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Live stream started");
+
+    if (FlashlightOn) {
+        LEDOnOff(true);
+        LightOnOff(true);
     }
 
+    //httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");  //stream is blocking web interface, only serving to local
+
+    httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
+    httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
+
+    while(1)
+    {
+        fr_start = esp_timer_get_time();
+        camera_fb_t *fb = esp_camera_fb_get();
+        esp_camera_fb_return(fb);
+        fb = esp_camera_fb_get();
+        if (!fb) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "CaptureToStream: Camera framebuffer not available");
+            break;
+        }
+        fb_len = fb->len;
+   
+        if (res == ESP_OK){
+            size_t hlen = snprintf((char *)part_buf, sizeof(part_buf), _STREAM_PART, fb_len);
+            res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
+        }
+        if (res == ESP_OK){
+            res = httpd_resp_send_chunk(req, (const char *)fb->buf, fb_len);
+        }
+        if (res == ESP_OK){
+            res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
+        }
+        
+        esp_camera_fb_return(fb);
+
+        int64_t fr_end = esp_timer_get_time();
+        ESP_LOGD(TAG, "JPG: %dKB %dms", (int)(fb_len/1024), (int)((fr_end - fr_start)/1000));
+
+        if (res != ESP_OK){ // Exit loop, e.g. also when closing the webpage
+            break;
+        }
+
+        int64_t fr_delta_ms = (fr_end - fr_start) / 1000;
+        if (CAM_LIVESTREAM_REFRESHRATE > fr_delta_ms) {
+            const TickType_t xDelay = (CAM_LIVESTREAM_REFRESHRATE - fr_delta_ms)  / portTICK_PERIOD_MS;
+            ESP_LOGD(TAG, "Stream: sleep for: %ldms", (long) xDelay*10);
+            vTaskDelay(xDelay);        
+        }
+    }
+
+    LEDOnOff(false);
+    LightOnOff(false);
+
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Live stream stopped");
+
     return res;
 }
 
@@ -548,19 +615,18 @@ void CCamera::LightOnOff(bool status)
 {
     GpioHandler* gpioHandler = gpio_handler_get();
     if ((gpioHandler != NULL) && (gpioHandler->isEnabled())) {
-        ESP_LOGD(TAG, "Use gpioHandler flashLigh");
+        ESP_LOGD(TAG, "Use gpioHandler to trigger flashlight");
         gpioHandler->flashLightEnable(status);
-    }  else {
+    }  
+    else {
     #ifdef USE_PWM_LEDFLASH
-        if (status)
-        {
+        if (status) {
             ESP_LOGD(TAG, "Internal Flash-LED turn on with PWM %d", led_intensity);
             ESP_ERROR_CHECK(ledc_set_duty(LEDC_MODE, LEDC_CHANNEL, led_intensity));
             // Update duty to apply the new value
             ESP_ERROR_CHECK(ledc_update_duty(LEDC_MODE, LEDC_CHANNEL));
         }
-        else
-        {
+        else {
             ESP_LOGD(TAG, "Internal Flash-LED turn off PWM");
             ESP_ERROR_CHECK(ledc_set_duty(LEDC_MODE, LEDC_CHANNEL, 0));
             ESP_ERROR_CHECK(ledc_update_duty(LEDC_MODE, LEDC_CHANNEL));
@@ -582,15 +648,17 @@ void CCamera::LightOnOff(bool status)
 
 void CCamera::LEDOnOff(bool status)
 {
-	// Init the GPIO
-    gpio_pad_select_gpio(BLINK_GPIO);
-    /* Set the GPIO as a push/pull output */
-    gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);  
+	if (xHandle_task_StatusLED == NULL) {
+        // Init the GPIO
+        gpio_pad_select_gpio(BLINK_GPIO);
+        /* Set the GPIO as a push/pull output */
+        gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT);  
 
-    if (!status)  
-        gpio_set_level(BLINK_GPIO, 1);
-    else
-        gpio_set_level(BLINK_GPIO, 0);      
+        if (!status)  
+            gpio_set_level(BLINK_GPIO, 1);
+        else
+            gpio_set_level(BLINK_GPIO, 0);   
+    }
 }
 
 
@@ -609,35 +677,35 @@ void CCamera::GetCameraParameter(httpd_req_t *req, int &qual, framesize_t &resol
         ESP_LOGD(TAG, "Query: %s", _query);
         if (httpd_query_key_value(_query, "size", _size, 10) == ESP_OK)
         {
-#ifdef DEBUG_DETAIL_ON   
+            #ifdef DEBUG_DETAIL_ON   
             ESP_LOGD(TAG, "Size: %s", _size);
-#endif
+            #endif
             if (strcmp(_size, "QVGA") == 0)
                 resol = FRAMESIZE_QVGA;       // 320x240
-            if (strcmp(_size, "VGA") == 0)
+            else if (strcmp(_size, "VGA") == 0)
                 resol = FRAMESIZE_VGA;      // 640x480
-            if (strcmp(_size, "SVGA") == 0)
+            else if (strcmp(_size, "SVGA") == 0)
                 resol = FRAMESIZE_SVGA;     // 800x600
-            if (strcmp(_size, "XGA") == 0)
+            else if (strcmp(_size, "XGA") == 0)
                 resol = FRAMESIZE_XGA;      // 1024x768
-            if (strcmp(_size, "SXGA") == 0)
+            else if (strcmp(_size, "SXGA") == 0)
                 resol = FRAMESIZE_SXGA;     // 1280x1024
-            if (strcmp(_size, "UXGA") == 0)
+            else if (strcmp(_size, "UXGA") == 0)
                  resol = FRAMESIZE_UXGA;     // 1600x1200   
         }
         if (httpd_query_key_value(_query, "quality", _qual, 10) == ESP_OK)
         {
-#ifdef DEBUG_DETAIL_ON   
+            #ifdef DEBUG_DETAIL_ON   
             ESP_LOGD(TAG, "Quality: %s", _qual);
-#endif
+            #endif
             qual = atoi(_qual);
                 
-            if (qual > 63)
+            if (qual > 63)      // Limit to max. 63
                 qual = 63;
-            if (qual < 0)
-                qual = 0;
+            else if (qual < 8)  // Limit to min. 8
+                qual = 8;
         }
-    };
+    }
 }
 
 
@@ -645,28 +713,29 @@ framesize_t CCamera::TextToFramesize(const char * _size)
 {
     if (strcmp(_size, "QVGA") == 0)
         return FRAMESIZE_QVGA;       // 320x240
-    if (strcmp(_size, "VGA") == 0)
+    else if (strcmp(_size, "VGA") == 0)
         return FRAMESIZE_VGA;      // 640x480
-    if (strcmp(_size, "SVGA") == 0)
+    else if (strcmp(_size, "SVGA") == 0)
         return FRAMESIZE_SVGA;     // 800x600
-    if (strcmp(_size, "XGA") == 0)
+    else if (strcmp(_size, "XGA") == 0)
         return FRAMESIZE_XGA;      // 1024x768
-    if (strcmp(_size, "SXGA") == 0)
+    else if (strcmp(_size, "SXGA") == 0)
         return FRAMESIZE_SXGA;     // 1280x1024
-    if (strcmp(_size, "UXGA") == 0)
-        return FRAMESIZE_UXGA;     // 1600x1200   
+    else if (strcmp(_size, "UXGA") == 0)
+        return FRAMESIZE_UXGA;     // 1600x1200  
+
     return ActualResolution;
 }
 
 
 CCamera::CCamera()
 {
-#ifdef DEBUG_DETAIL_ON    
-    ESP_LOGD(TAG, "CreateClassCamera");
-#endif
-    brightness = -5;
-    contrast = -5;
-    saturation = -5;
+    #ifdef DEBUG_DETAIL_ON    
+        ESP_LOGD(TAG, "CreateClassCamera");
+    #endif
+    brightness = 0;
+    contrast = 0;
+    saturation = 0;
     isFixedExposure = false;
 
     ledc_init();    
@@ -706,3 +775,86 @@ bool CCamera::getCameraInitSuccessful()
 {
     return CameraInitSuccessful;
 }
+
+
+std::vector<std::string> demoFiles;
+
+void CCamera::useDemoMode()
+{
+    char line[50];
+
+    FILE *fd = fopen("/sdcard/demo/files.txt", "r");
+    if (!fd) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can not start Demo mode, the folder '/sdcard/demo/' does not contain the needed files!");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "See Details on https://jomjol.github.io/AI-on-the-edge-device-docs/Demo-Mode!");
+        return;
+    }
+
+    demoImage = (uint8_t*)malloc(DEMO_IMAGE_SIZE);
+    if (demoImage == NULL) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Unable to acquire required memory for demo image!");
+        return;
+    }
+
+    while (fgets(line, sizeof(line), fd) != NULL) {
+        line[strlen(line) - 1] = '\0';
+        demoFiles.push_back(line);
+    }
+    
+    fclose(fd);
+
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Using Demo mode (" + std::to_string(demoFiles.size()) + 
+            " files) instead of real camera image!");
+
+    for (auto file : demoFiles) {
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, file);
+    }
+
+    demoMode = true;
+}
+
+
+bool CCamera::loadNextDemoImage(camera_fb_t *fb) {
+    char filename[50];
+    int readBytes;
+    long fileSize;
+
+    snprintf(filename, sizeof(filename), "/sdcard/demo/%s", demoFiles[getCountFlowRounds() % demoFiles.size()].c_str());
+
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Using " + std::string(filename) + " as demo image");
+
+    /* Inject saved image */
+
+    FILE * fp = fopen(filename, "rb");
+    if (!fp) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read file: " + std::string(filename) +"!");
+        return false;
+    }
+
+    fileSize = GetFileSize(filename);
+    if (fileSize > DEMO_IMAGE_SIZE) {
+        char buf[100];
+        snprintf(buf, sizeof(buf), "Demo Image (%d bytes) is larger than provided buffer (%d bytes)!",
+                (int)fileSize, DEMO_IMAGE_SIZE);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, std::string(buf));
+        return false;
+    }
+
+    readBytes = fread(demoImage, 1, DEMO_IMAGE_SIZE, fp);
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "read " + std::to_string(readBytes) + " bytes");
+    fclose(fp);
+
+    fb->buf = demoImage; // Update pointer
+    fb->len = readBytes;
+    // ToDo do we also need to set height, width, format and timestamp?
+
+    return true;
+}
+
+
+long CCamera::GetFileSize(std::string filename)
+{
+    struct stat stat_buf;
+    long rc = stat(filename.c_str(), &stat_buf);
+    return rc == 0 ? stat_buf.st_size : -1;
+}

code/components/jomjol_controlcamera/ClassControllCamera.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef CLASSCONTROLLCAMERA_H
 #define CLASSCONTROLLCAMERA_H
 
@@ -11,10 +13,7 @@
 #include <string>
 #include <esp_http_server.h>
 #include "CImageBasis.h"
-
-
-#define CAMERA_MODEL_AI_THINKER
-
+#include "../../include/defines.h"
 
 class CCamera {
     protected:
@@ -27,6 +26,10 @@ class CCamera {
 
         void ledc_init(void);
         bool CameraInitSuccessful = false;
+        bool demoMode = false;
+
+        bool loadNextDemoImage(camera_fb_t *fb);
+        long GetFileSize(std::string filename);
 
     public:
         int image_height, image_width;
@@ -37,14 +40,16 @@ class CCamera {
         void LightOnOff(bool status);
         void LEDOnOff(bool status);
         esp_err_t CaptureToHTTP(httpd_req_t *req, int delay = 0);
+        esp_err_t CaptureToStream(httpd_req_t *req, bool FlashlightOn);
         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);
-
-        void EnableAutoExposure(int flashdauer);
+        bool testCamera(void);
+        void EnableAutoExposure(int flash_duration);
         bool getCameraInitSuccessful();
-        
+        void useDemoMode(void);
+       
 
         framesize_t TextToFramesize(const char * text);
 

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_ */

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__ */

code/components/jomjol_controlcamera/server_camera.cpp

@@ -9,16 +9,13 @@
 #include "ClassLogFile.h"
 #include "esp_log.h"
 
+#include "../../include/defines.h"
+
 static const char *TAG = "server_cam";
 
-#define SCRATCH_BUFSIZE2  8192 
-char scratch2[SCRATCH_BUFSIZE2];
 
-//#define DEBUG_DETAIL_ON   
+void PowerResetCamera(){
 
-
-void PowerResetCamera()
-{
         ESP_LOGD(TAG, "Resetting camera by power down line");
         gpio_config_t conf;
         conf.intr_type = GPIO_INTR_DISABLE;
@@ -51,7 +48,7 @@ esp_err_t handler_lightOn(httpd_req_t *req)
     }
     else 
     {
-        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera Light On API not yet initialized. Please retry later...");
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /lighton not available!");
         return ESP_ERR_NOT_FOUND;
     }
 
@@ -78,7 +75,7 @@ esp_err_t handler_lightOff(httpd_req_t *req)
     }
     else 
     {
-        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera Light Off API not yet initialized. Please retry later...");
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /lightoff not available!");
         return ESP_ERR_NOT_FOUND;
     }
 
@@ -120,16 +117,16 @@ esp_err_t handler_capture(httpd_req_t *req)
     }
         else 
     {
-        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera Capture API not yet initialized. Please retry later...");
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /capture not available!");
         return ESP_ERR_NOT_FOUND;
     }
 }
 
 
-esp_err_t handler_capture_with_ligth(httpd_req_t *req)
+esp_err_t handler_capture_with_light(httpd_req_t *req)
 {
     #ifdef DEBUG_DETAIL_ON  
-        LogFile.WriteHeapInfo("handler_capture_with_ligth - Start");
+        LogFile.WriteHeapInfo("handler_capture_with_light - Start");
     #endif
     
     if (Camera.getCameraInitSuccessful()) 
@@ -173,14 +170,14 @@ esp_err_t handler_capture_with_ligth(httpd_req_t *req)
         Camera.LightOnOff(false);
 
         #ifdef DEBUG_DETAIL_ON   
-            LogFile.WriteHeapInfo("handler_capture_with_ligth - Done");
+            LogFile.WriteHeapInfo("handler_capture_with_light - Done");
         #endif
 
         return result;
     }
         else 
     {
-        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera Capture + flashlight API not yet initialized. Please retry later...");
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /capture_with_flashlight not available!");
         return ESP_ERR_NOT_FOUND;
     }
 }
@@ -251,7 +248,7 @@ esp_err_t handler_capture_save_to_file(httpd_req_t *req)
     }
     else 
     {
-        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera Capture + save API not yet initialized. Please retry later...");
+        httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Camera not initialized: REST API /save not available!");
         return ESP_ERR_NOT_FOUND;
     }
 }
@@ -282,7 +279,7 @@ void register_server_camera_uri(httpd_handle_t server)
     httpd_register_uri_handler(server, &camuri);      
 
     camuri.uri       = "/capture_with_flashlight";
-    camuri.handler   = handler_capture_with_ligth;
+    camuri.handler   = handler_capture_with_light;
     camuri.user_ctx  = NULL; 
     httpd_register_uri_handler(server, &camuri);  
 

code/components/jomjol_controlcamera/server_camera.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #ifndef JOMJOL_CONTROLCAMERA_H
 #define JOMJOL_CONTROLCAMERA_H
 

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 miniz)
+                    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)
 
 

code/components/jomjol_fileserver_ota/miniz/miniz.h

@@ -153,7 +153,7 @@
 /*#define MINIZ_NO_MALLOC */
 
 #ifdef MINIZ_NO_INFLATE_APIS
-#define MINIZ_NO_ARCHIVE_APIS
+//#define MINIZ_NO_ARCHIVE_APIS
 #endif
 
 #ifdef MINIZ_NO_DEFLATE_APIS

code/components/jomjol_fileserver_ota/server_file.cpp

@@ -33,10 +33,10 @@ extern "C" {
 #include <esp_spiffs.h>
 #include "esp_http_server.h"
 
-#include "defines.h"
+#include "../../include/defines.h"
 #include "ClassLogFile.h"
 
-#include "server_tflite.h"
+#include "MainFlowControl.h"
 
 #include "server_help.h"
 #ifdef ENABLE_MQTT
@@ -49,28 +49,12 @@ extern "C" {
 
 static const char *TAG = "OTA FILE";
 
-/* Max length a file path can have on storage */
-// #define FILE_PATH_MAX (ESP_VFS_PATH_MAX + CONFIG_SPIFFS_OBJ_NAME_LEN)
-#define FILE_PATH_MAX (255)
-
-/* Max size of an individual file. Make sure this
- * value is same as that set in upload_script.html */
-#define MAX_FILE_SIZE   (8000*1024) // 8 MB
-#define MAX_FILE_SIZE_STR "8MB"
-
-
-/* Scratch buffer size */
-#define SCRATCH_BUFSIZE  4096 
-
-/* Size of partial log file to return */
-#define LOGFILE_LAST_PART_BYTES SCRATCH_BUFSIZE * 20 /* 80 kBytes */
-
 struct file_server_data {
     /* Base path of file storage */
     char base_path[ESP_VFS_PATH_MAX + 1];
 
     /* Scratch buffer for temporary storage during file transfer */
-    char scratch[SCRATCH_BUFSIZE];
+    char scratch[SERVER_FILER_SCRATCH_BUFSIZE];
 };
 
 
@@ -89,7 +73,7 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file);
 
 esp_err_t get_numbers_file_handler(httpd_req_t *req)
 {
-    std::string ret = tfliteflow.getNumbersName();
+    std::string ret = flowctrl.getNumbersName();
 
 //    ESP_LOGI(TAG, "Result get_numbers_file_handler: %s", ret.c_str());
 
@@ -227,21 +211,23 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
         return ESP_FAIL;
     }
 
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+
     /* Send HTML file header */
     httpd_resp_sendstr_chunk(req, "<!DOCTYPE html><html><body>");
 
 /////////////////////////////////////////////////
     if (!readonly) {
-        FILE *fd = OpenFileAndWait("/sdcard/html/upload_script.html", "r");
+        FILE *fd = fopen("/sdcard/html/file_server.html", "r");
         char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
         size_t chunksize;
         do {
-            chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+            chunksize = fread(chunk, 1, SERVER_FILER_SCRATCH_BUFSIZE, fd);
             //        ESP_LOGD(TAG, "Chunksize %d", chunksize);
             if (chunksize > 0){
                 if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
                 fclose(fd);
-                ESP_LOGE(TAG, "File sending failed!");
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
                 return ESP_FAIL;
                 }
             }
@@ -258,11 +244,11 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
 
     /* Send file-list table definition and column labels */
     httpd_resp_sendstr_chunk(req,
-        "<table class=\"fixed\" border=\"1\">"
+        "<table id=\"files_table\">"
         "<col width=\"800px\" /><col width=\"300px\" /><col width=\"300px\" /><col width=\"100px\" />"
-        "<thead><tr><th>Name</th><th>Type</th><th>Size (Bytes)</th>");
+        "<thead><tr><th>Name</th><th>Type</th><th>Size</th>");
     if (!readonly) {
-        httpd_resp_sendstr_chunk(req, "<th>Delete<br>"
+        httpd_resp_sendstr_chunk(req, "<th>"
             "<form method=\"post\" action=\"");
         httpd_resp_sendstr_chunk(req, _zw.c_str());
         httpd_resp_sendstr_chunk(req,
@@ -280,10 +266,22 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
             strlcpy(entrypath + dirpath_len, entry->d_name, sizeof(entrypath) - dirpath_len);
             ESP_LOGD(TAG, "Entrypath: %s", entrypath);
             if (stat(entrypath, &entry_stat) == -1) {
-                ESP_LOGE(TAG, "Failed to stat %s: %s", entrytype, entry->d_name);
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to stat " + string(entrytype) + ": " + string(entry->d_name));
                 continue;
             }
-            sprintf(entrysize, "%ld", entry_stat.st_size);
+
+            if (entry->d_type == DT_DIR) {
+                strcpy(entrysize, "-\0");
+            }
+            else {
+                if (entry_stat.st_size >= 1024) {
+                    sprintf(entrysize, "%ld KiB", entry_stat.st_size / 1024); // kBytes
+                }
+                else {
+                    sprintf(entrysize, "%ld B", entry_stat.st_size); // Bytes
+                }
+            }
+
             ESP_LOGI(TAG, "Found %s: %s (%s bytes)", entrytype, entry->d_name, entrysize);
 
             /* Send chunk of HTML file containing table entries with file name and size */
@@ -322,10 +320,10 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
     httpd_resp_sendstr_chunk(req, NULL);
     return ESP_OK;
 }
-
+/*
 #define IS_FILE_EXT(filename, ext) \
     (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)
-
+*/
 
 static esp_err_t logfileact_get_full_handler(httpd_req_t *req) {
     return send_logfile(req, true);
@@ -348,22 +346,17 @@ static esp_err_t datafileact_get_last_part_handler(httpd_req_t *req) {
 static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
 {
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "data_get_last_part_handler");
-    char filepath[FILE_PATH_MAX];
     FILE *fd = NULL;
     //struct stat file_stat;
     ESP_LOGD(TAG, "uri: %s", req->uri);
 
-    const char* filename = ""; 
-
     std::string currentfilename = LogFile.GetCurrentFileNameData();
 
-    ESP_LOGD(TAG, "uri: %s, filename: %s, filepath: %s", req->uri, filename, filepath);
+    ESP_LOGD(TAG, "uri: %s, filename: %s, filepath: %s", req->uri, currentfilename.c_str(), currentfilename.c_str());
 
-    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
-
-    fd = OpenFileAndWait(currentfilename.c_str(), "r");
+    fd = fopen(currentfilename.c_str(), "r");
     if (!fd) {
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read existing file: " + std::string(filepath) +"!");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read file: " + currentfilename + "!");
         /* Respond with 404 Error */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
         return ESP_FAIL;
@@ -372,14 +365,14 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
 
 //    ESP_LOGI(TAG, "Sending file: %s (%ld bytes)...", &filename, file_stat.st_size);
-    set_content_type_from_file(req, filename);
+    set_content_type_from_file(req, currentfilename.c_str());
 
     if (!send_full_file) { // Send only last part of file
         ESP_LOGD(TAG, "Sending last %d bytes of the actual datafile!", LOGFILE_LAST_PART_BYTES);
 
         /* Adapted from https://www.geeksforgeeks.org/implement-your-own-tail-read-last-n-lines-of-a-huge-file/ */
         if (fseek(fd, 0, SEEK_END)) {
-            ESP_LOGE(TAG, "Failed to get to end of file!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to get to end of file!");
             return ESP_FAIL;
         }
         else {
@@ -387,7 +380,7 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
             ESP_LOGI(TAG, "File contains %ld bytes", pos);
 
             if (fseek(fd, pos - std::min((long)LOGFILE_LAST_PART_BYTES, pos), SEEK_SET)) { // Go LOGFILE_LAST_PART_BYTES bytes back from EOF
-                ESP_LOGE(TAG, "Failed to go back %ld bytes within the file!", std::min((long)LOGFILE_LAST_PART_BYTES, pos));
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to go back " + to_string(std::min((long)LOGFILE_LAST_PART_BYTES, pos)) + " bytes within the file!");
                 return ESP_FAIL;
             }
         }
@@ -405,12 +398,12 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
     size_t chunksize;
     do {
         /* Read file in chunks into the scratch buffer */
-        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+        chunksize = fread(chunk, 1, SERVER_FILER_SCRATCH_BUFSIZE, fd);
 
         /* Send the buffer contents as HTTP response chunk */
         if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
             fclose(fd);
-            ESP_LOGE(TAG, "File sending failed!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
             /* Abort sending file */
             httpd_resp_sendstr_chunk(req, NULL);
             /* Respond with 500 Internal Server Error */
@@ -434,7 +427,6 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
 static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
 {
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "log_get_last_part_handler");
-    char filepath[FILE_PATH_MAX];
     FILE *fd = NULL;
     //struct stat file_stat;
     ESP_LOGI(TAG, "uri: %s", req->uri);
@@ -443,12 +435,14 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
 
     std::string currentfilename = LogFile.GetCurrentFileName();
 
-    ESP_LOGD(TAG, "uri: %s, filename: %s, filepath: %s", req->uri, filename, filepath);
+    ESP_LOGD(TAG, "uri: %s, filename: %s, filepath: %s", req->uri, filename, currentfilename.c_str());
 
+    // Since the log file is still could open for writing, we need to close it first
+    LogFile.CloseLogFileAppendHandle();
 
-    fd = OpenFileAndWait(currentfilename.c_str(), "r");
+    fd = fopen(currentfilename.c_str(), "r");
     if (!fd) {
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read existing file: " + std::string(filepath) +"!");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read file: " + currentfilename + "!");
         /* Respond with 404 Error */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
         return ESP_FAIL;
@@ -464,7 +458,7 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
 
         /* Adapted from https://www.geeksforgeeks.org/implement-your-own-tail-read-last-n-lines-of-a-huge-file/ */
         if (fseek(fd, 0, SEEK_END)) {
-            ESP_LOGE(TAG, "Failed to get to end of file!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to get to end of file!");
             return ESP_FAIL;
         }
         else {
@@ -472,7 +466,7 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
             ESP_LOGI(TAG, "File contains %ld bytes", pos);
 
             if (fseek(fd, pos - std::min((long)LOGFILE_LAST_PART_BYTES, pos), SEEK_SET)) { // Go LOGFILE_LAST_PART_BYTES bytes back from EOF
-                ESP_LOGE(TAG, "Failed to go back %ld bytes within the file!", std::min((long)LOGFILE_LAST_PART_BYTES, pos));
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to go back " + to_string(std::min((long)LOGFILE_LAST_PART_BYTES, pos)) + " bytes within the file!");
                 return ESP_FAIL;
             }
         }
@@ -490,12 +484,12 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
     size_t chunksize;
     do {
         /* Read file in chunks into the scratch buffer */
-        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+        chunksize = fread(chunk, 1, SERVER_FILER_SCRATCH_BUFSIZE, fd);
 
         /* Send the buffer contents as HTTP response chunk */
         if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
             fclose(fd);
-            ESP_LOGE(TAG, "File sending failed!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
             /* Abort sending file */
             httpd_resp_sendstr_chunk(req, NULL);
             /* Respond with 500 Internal Server Error */
@@ -535,7 +529,7 @@ static esp_err_t download_get_handler(httpd_req_t *req)
 
 
     if (!filename) {
-        ESP_LOGE(TAG, "Filename is too long");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Filename is too long");
         /* Respond with 414 Error */
         httpd_resp_send_err(req, HTTPD_414_URI_TOO_LONG, "Filename too long");
         return ESP_FAIL;
@@ -553,7 +547,7 @@ static esp_err_t download_get_handler(httpd_req_t *req)
                 /* Get value of expected key from query string */
                 if (httpd_query_key_value(buf, "readonly", param, sizeof(param)) == ESP_OK) {
                     ESP_LOGI(TAG, "Found URL query parameter => readonly=%s", param);
-                    readonly = param && strcmp(param,"true")==0;
+                    readonly = (strcmp(param,"true") == 0);
                 }
             }
         }
@@ -574,9 +568,9 @@ static esp_err_t download_get_handler(httpd_req_t *req)
         return ESP_FAIL;
     }
 
-    fd = OpenFileAndWait(filepath, "r");
+    fd = fopen(filepath, "r");
     if (!fd) {
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read existing file: " + std::string(filepath) +"!");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read file: " + std::string(filepath) + "!");
         /* Respond with 404 Error */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
         return ESP_FAIL;
@@ -592,12 +586,14 @@ static esp_err_t download_get_handler(httpd_req_t *req)
     size_t chunksize;
     do {
         /* Read file in chunks into the scratch buffer */
-        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+        chunksize = fread(chunk, 1, SERVER_FILER_SCRATCH_BUFSIZE, fd);
 
-        /* Send the buffer contents as HTTP response chunk */
+        /* Send buffer contents as HTTP chunk. If empty this functions as a
+         * last-chunk message, signaling end-of-response, to the HTTP client.
+         * See RFC 2616, section 3.6.1 for details on Chunked Transfer Encoding. */
         if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
             fclose(fd);
-            ESP_LOGE(TAG, "File sending failed!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
             /* Abort sending file */
             httpd_resp_sendstr_chunk(req, NULL);
             /* Respond with 500 Internal Server Error */
@@ -612,8 +608,6 @@ static esp_err_t download_get_handler(httpd_req_t *req)
     fclose(fd);
     ESP_LOGD(TAG, "File successfully sent");
 
-    /* Respond with an empty chunk to signal HTTP response completion */
-    httpd_resp_send_chunk(req, NULL, 0);
     return ESP_OK;
 }
 
@@ -625,6 +619,8 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
     FILE *fd = NULL;
     struct stat file_stat;
 
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+
     /* Skip leading "/upload" from URI to get filename */
     /* Note sizeof() counts NULL termination hence the -1 */
     const char *filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
@@ -637,14 +633,14 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
     /* Filename cannot have a trailing '/' */
     if (filename[strlen(filename) - 1] == '/') {
-        ESP_LOGE(TAG, "Invalid filename: %s", filename);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Invalid filename: " + string(filename));
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid filename");
         return ESP_FAIL;
     }
 
     if (stat(filepath, &file_stat) == 0) {
-        ESP_LOGE(TAG, "File already exists: %s", filepath);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File already exists: " + string(filepath));
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "File already exists");
         return ESP_FAIL;
@@ -652,7 +648,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
     /* File cannot be larger than a limit */
     if (req->content_len > MAX_FILE_SIZE) {
-        ESP_LOGE(TAG, "File too large: %d bytes", req->content_len);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File too large: " + to_string(req->content_len) + " bytes");
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
                             "File size must be less than "
@@ -662,9 +658,9 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
         return ESP_FAIL;
     }
 
-    fd = OpenFileAndWait(filepath, "w");
+    fd = fopen(filepath, "w");
     if (!fd) {
-        ESP_LOGE(TAG, "Failed to create file: %s", filepath);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to create file: " + string(filepath));
         /* Respond with 500 Internal Server Error */
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to create file");
         return ESP_FAIL;
@@ -684,7 +680,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
         ESP_LOGI(TAG, "Remaining size: %d", remaining);
         /* Receive the file part by part into a buffer */
-        if ((received = httpd_req_recv(req, buf, MIN(remaining, SCRATCH_BUFSIZE))) <= 0) {
+        if ((received = httpd_req_recv(req, buf, MIN(remaining, SERVER_FILER_SCRATCH_BUFSIZE))) <= 0) {
             if (received == HTTPD_SOCK_ERR_TIMEOUT) {
                 /* Retry if timeout occurred */
                 continue;
@@ -695,7 +691,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
             fclose(fd);
             unlink(filepath);
 
-            ESP_LOGE(TAG, "File reception failed!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File reception failed!");
             /* Respond with 500 Internal Server Error */
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
             return ESP_FAIL;
@@ -708,7 +704,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
             fclose(fd);
             unlink(filepath);
 
-            ESP_LOGE(TAG, "File write failed!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File write failed!");
             /* Respond with 500 Internal Server Error */
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write file to storage");
             return ESP_FAIL;
@@ -721,7 +717,8 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
     /* Close file upon upload completion */
     fclose(fd);
-    ESP_LOGI(TAG, "File reception complete");
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "File saved: " + string(filename));
+    ESP_LOGI(TAG, "File reception completed");
 
     std::string directory = std::string(filepath);
 	size_t zw = directory.find("/");
@@ -740,21 +737,27 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 //    ESP_LOGD(TAG, "Directory danach 2: %s", directory.c_str());
 
     /* Redirect onto root to see the updated file list */
-    httpd_resp_set_status(req, "303 See Other");
-    httpd_resp_set_hdr(req, "Location", directory.c_str());
+    if (strcmp(filename, "/config/config.ini") == 0 ||
+        strcmp(filename, "/config/ref0.jpg") == 0 ||
+        strcmp(filename, "/config/ref0_org.jpg") == 0 ||
+        strcmp(filename, "/config/ref1.jpg") == 0 ||
+        strcmp(filename, "/config/ref1_org.jpg") == 0 ||
+        strcmp(filename, "/config/reference.jpg") == 0 ||
+        strcmp(filename, "/img_tmp/ref0.jpg") == 0 ||
+        strcmp(filename, "/img_tmp/ref0_org.jpg") == 0 ||
+        strcmp(filename, "/img_tmp/ref1.jpg") == 0 ||
+        strcmp(filename, "/img_tmp/ref1_org.jpg") == 0 ||
+        strcmp(filename, "/img_tmp/reference.jpg") == 0 ) 
+    { 
+        httpd_resp_set_status(req, HTTPD_200); // Avoid reloading of folder content
+    }
+    else {
+        httpd_resp_set_status(req, "303 See Other"); // Reload folder content after upload
+    }
 
-    /* Redirect onto root to see the updated file list */
-    httpd_resp_set_status(req, "303 See Other");
     httpd_resp_set_hdr(req, "Location", directory.c_str());
     httpd_resp_sendstr(req, "File uploaded successfully");
 
-/*
-    if (strcmp(filepath, CONFIG_FILE) == 0) {
-        ESP_LOGD(TAG, "New config found. Reload handler.");
-        gpio_handler_deinit();
-        MQTTdestroy();
-    }
-*/
 
     return ESP_OK;
 }
@@ -775,13 +778,15 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
     std::string directory;
     std::string zw; 
 
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+
     if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK)
     {
         ESP_LOGD(TAG, "Query: %s", _query);
         
         if (httpd_query_key_value(_query, "task", _valuechar, 30) == ESP_OK)
         {
-            ESP_LOGD(TAG, "task is found: %s", _valuechar);
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "task is found: " + string(_valuechar));
             _task = std::string(_valuechar);
         }
     }
@@ -827,28 +832,27 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
 
         /* Filename cannot have a trailing '/' */
         if (filename[strlen(filename) - 1] == '/') {
-            ESP_LOGE(TAG, "Invalid filename: %s", filename);
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Invalid filename: " + string(filename));
             /* Respond with 400 Bad Request */
             httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid filename");
             return ESP_FAIL;
         }
 
         if (strcmp(filename, "wlan.ini") == 0) {
-            ESP_LOGE(TAG, "Trying to delete protected file : %s", filename);
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to delete protected file : " + string(filename));
             httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Not allowed to delete wlan.ini");
             return ESP_FAIL;
         }
 
-        if (stat(filepath, &file_stat) == -1) {
-            ESP_LOGE(TAG, "File does not exist: %s", filename);
-            /* Respond with 400 Bad Request */
-            httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "File does not exist");
-            return ESP_FAIL;
+        if (stat(filepath, &file_stat) == -1) { // File does not exist
+            /* This is ok, we would delete it anyway */
+            LogFile.WriteToFile(ESP_LOG_INFO, TAG, "File does not exist: " + string(filename));
         }
 
-        ESP_LOGI(TAG, "Deleting file: %s", filename);
         /* Delete file */
         unlink(filepath);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "File deleted: " + string(filename));
+        ESP_LOGI(TAG, "File deletion completed");
 
         directory = std::string(filepath);
         size_t zw = directory.find("/");
@@ -865,16 +869,30 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
         directory = directory.substr(start_fn, found - start_fn + 1);
         directory = "/fileserver" + directory;
         ESP_LOGD(TAG, "Directory danach 4: %s", directory.c_str());
-    }
     
+        //////////////////////////////////////////////////////////////
+
+        /* Redirect onto root to see the updated file list */
+        if (strcmp(filename, "/config/config.ini") == 0 ||
+            strcmp(filename, "/config/ref0.jpg") == 0 ||
+            strcmp(filename, "/config/ref0_org.jpg") == 0 ||
+            strcmp(filename, "/config/ref1.jpg") == 0 ||
+            strcmp(filename, "/config/ref1_org.jpg") == 0 ||
+            strcmp(filename, "/config/reference.jpg") == 0 ||
+            strcmp(filename, "/img_tmp/ref0.jpg") == 0 ||
+            strcmp(filename, "/img_tmp/ref0_org.jpg") == 0 ||
+            strcmp(filename, "/img_tmp/ref1.jpg") == 0 ||
+            strcmp(filename, "/img_tmp/ref1_org.jpg") == 0 ||
+            strcmp(filename, "/img_tmp/reference.jpg") == 0 ) 
+        { 
+            httpd_resp_set_status(req, HTTPD_200); // Avoid reloading of folder content
+        }
+        else {
+            httpd_resp_set_status(req, "303 See Other"); // Reload folder content after upload
+        }
+    }
 
 
-
-
-//////////////////////////////////////////////////////////////
-
-    /* Redirect onto root to see the updated file list */
-    httpd_resp_set_status(req, "303 See Other");
     httpd_resp_set_hdr(req, "Location", directory.c_str());
     httpd_resp_sendstr(req, "File successfully deleted");
     return ESP_OK;
@@ -888,7 +906,7 @@ void delete_all_in_directory(std::string _directory)
     std::string filename;
 
     if (!dir) {
-        ESP_LOGE(TAG, "Failed to stat dir: %s", _directory.c_str());
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to stat dir: " + _directory);
         return;
     }
 
@@ -897,7 +915,7 @@ void delete_all_in_directory(std::string _directory)
         if (!(entry->d_type == DT_DIR)){
             if (strcmp("wlan.ini", entry->d_name) != 0){                    // auf wlan.ini soll nicht zugegriffen werden !!!
                 filename = _directory + "/" + std::string(entry->d_name);
-                ESP_LOGI(TAG, "Deleting file: %s", filename.c_str());
+                LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Deleting file: " + filename);
                 /* Delete file */
                 unlink(filename.c_str());    
             }
@@ -906,7 +924,7 @@ void delete_all_in_directory(std::string _directory)
     closedir(dir);
 }
 
-std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::string _target_bin, std::string _main)
+std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::string _target_bin, std::string _main, bool _initial_setup)
 {
     int i, sort_iter;
     mz_bool status;
@@ -916,13 +934,9 @@ std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::st
     char archive_filename[64];
     std::string zw, ret = "";
     std::string directory = "";
-//    static const char* s_Test_archive_filename = "testhtml.zip";
 
     ESP_LOGD(TAG, "miniz.c version: %s", MZ_VERSION);
     ESP_LOGD(TAG, "Zipfile: %s", _in_zip_file.c_str());
-//    ESP_LOGD(TAG, "Target Dir ZIP: %s", _target_zip.c_str());
-//    ESP_LOGD(TAG, "Target Dir BIN: %s", _target_bin.c_str());
-//    ESP_LOGD(TAG, "Target Dir main: %s", _main.c_str());
 
     // Now try to open the archive.
     memset(&zip_archive, 0, sizeof(zip_archive));
@@ -935,11 +949,9 @@ std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::st
 
     // Get and print information about each file in the archive.
     int numberoffiles = (int)mz_zip_reader_get_num_files(&zip_archive);
-    ESP_LOGI(TAG, "Numbers of files to be extrated: %d", numberoffiles);
-
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Files to be extracted: " + to_string(numberoffiles));
 
     sort_iter = 0;
-//    for (sort_iter = 0; sort_iter < 2; sort_iter++)
     {
         memset(&zip_archive, 0, sizeof(zip_archive));
         status = mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), sort_iter ? MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY : 0);
@@ -960,7 +972,7 @@ std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::st
             p = mz_zip_reader_extract_file_to_heap(&zip_archive, archive_filename, &uncomp_size, 0);
                 if (!p)
                 {
-                    ESP_LOGE(TAG, "mz_zip_reader_extract_file_to_heap() failed on file %s", archive_filename);
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_extract_file_to_heap() failed on file " + string(archive_filename));
                     mz_zip_reader_end(&zip_archive);
                     return ret;
                 }
@@ -977,6 +989,16 @@ std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::st
                 else
                 {
                     std::string _dir = getDirectory(zw);
+                    if ((_dir == "config-initial") && !_initial_setup)
+                    {
+                        continue;
+                    }
+                    else
+                    {
+                        _dir = "config";
+                        std::string _s1 = "config-initial";
+                        FindReplace(zw, _s1, _dir);
+                    }
 
                     if (_dir.length() > 0)
                     {
@@ -991,11 +1013,15 @@ std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::st
             
                 string filename_zw = zw + SUFFIX_ZW;
 
-                ESP_LOGI(TAG, "Filename to extract: %s, Zwischenfilename: %s", zw.c_str(), filename_zw.c_str());
+                ESP_LOGI(TAG, "File to extract: %s, Temp. Filename: %s", zw.c_str(), filename_zw.c_str());
+
+                std::string folder = filename_zw.substr(0, filename_zw.find_last_of('/'));
+                MakeDir(folder);
 
                 // extrahieren in zwischendatei
                 DeleteFile(filename_zw);
-                FILE* fpTargetFile = OpenFileAndWait(filename_zw.c_str(), "wb");
+
+                FILE* fpTargetFile = fopen(filename_zw.c_str(), "wb");
                 uint writtenbytes = fwrite(p, 1, (uint)uncomp_size, fpTargetFile);
                 fclose(fpTargetFile);
                 
@@ -1008,24 +1034,22 @@ std::string unzip_new(std::string _in_zip_file, std::string _target_zip, std::st
                 else
                 {
                     isokay = false;
-                    ESP_LOGD(TAG, "ERROR in writting extracted file (function fwrite) extracted file \"%s\", size %u", archive_filename, (uint)uncomp_size);
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in writting extracted file (function fwrite) extracted file \"" +
+                            string(archive_filename) + "\", size " + to_string(uncomp_size));
                 }
 
                 DeleteFile(zw);
                 if (!isokay)
-                    ESP_LOGE(TAG, "ERROR in fwrite \"%s\", size %u", archive_filename, (uint)uncomp_size);
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in fwrite \"" + string(archive_filename) + "\", size " + to_string(uncomp_size));
                 isokay = isokay && RenameFile(filename_zw, zw);
                 if (!isokay)
-                    ESP_LOGE(TAG, "ERROR in Rename \"%s\" to \"%s\"", filename_zw.c_str(), zw.c_str());
-//                isokay = isokay && DeleteFile(filename_zw);
-//                if (!isokay)
-//                    ESP_LOGE(TAG, "ERROR in Delete \"%s\"", filename_zw.c_str());
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in Rename \"" + filename_zw + "\" to \"" + zw);
 
                 if (isokay)
-                    ESP_LOGI(TAG, "Successfully extracted file \"%s\", size %u", archive_filename, (uint)uncomp_size);
+                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Successfully extracted file \"" + string(archive_filename) + "\", size " + to_string(uncomp_size));
                 else
                 {
-                    ESP_LOGE(TAG, "ERROR in extracting file \"%s\", size %u", archive_filename, (uint)uncomp_size);
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in extracting file \"" + string(archive_filename) + "\", size " + to_string(uncomp_size));
                     ret = "ERROR";
                 }
                 mz_free(p);
@@ -1059,7 +1083,7 @@ void unzip(std::string _in_zip_file, std::string _target_directory){
     status = mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), 0);
     if (!status)
     {
-        ESP_LOGD(TAG, "mz_zip_reader_init_file() failed!");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_init_file() failed!");
         return;
     }
 
@@ -1071,7 +1095,7 @@ void unzip(std::string _in_zip_file, std::string _target_directory){
         status = mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), sort_iter ? MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY : 0);
         if (!status)
         {
-            ESP_LOGD(TAG, "mz_zip_reader_init_file() failed!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_init_file() failed!");
             return;
         }
 
@@ -1085,7 +1109,7 @@ void unzip(std::string _in_zip_file, std::string _target_directory){
             p = mz_zip_reader_extract_file_to_heap(&zip_archive, archive_filename, &uncomp_size, 0);
             if (!p)
             {
-                ESP_LOGD(TAG, "mz_zip_reader_extract_file_to_heap() failed!");
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_extract_file_to_heap() failed!");
                 mz_zip_reader_end(&zip_archive);
                 return;
             }
@@ -1093,8 +1117,8 @@ void unzip(std::string _in_zip_file, std::string _target_directory){
             // Save to File.
             zw = std::string(archive_filename);
             zw = _target_directory + zw;
-            ESP_LOGD(TAG, "Filename to extract: %s", zw.c_str());
-            FILE* fpTargetFile = OpenFileAndWait(zw.c_str(), "wb");
+            ESP_LOGD(TAG, "File to extract: %s", zw.c_str());
+            FILE* fpTargetFile = fopen(zw.c_str(), "wb");
             fwrite(p, 1, (uint)uncomp_size, fpTargetFile);
             fclose(fpTargetFile);
 
@@ -1121,19 +1145,19 @@ void register_server_file_uri(httpd_handle_t server, const char *base_path)
     /* Validate file storage base path */
     if (!base_path) {
 //    if (!base_path || strcmp(base_path, "/spiffs") != 0) {
-        ESP_LOGE(TAG, "File server base_path not set");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File server base_path not set");
 //        return ESP_ERR_INVALID_ARG;
     }
 
     if (server_data) {
-        ESP_LOGE(TAG, "File server already started");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File server already started");
 //        return ESP_ERR_INVALID_STATE;
     }
 
     /* Allocate memory for server data */
     server_data = (file_server_data *) calloc(1, sizeof(struct file_server_data));
     if (!server_data) {
-        ESP_LOGE(TAG, "Failed to allocate memory for server data");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to allocate memory for server data");
 //        return ESP_ERR_NO_MEM;
     }
     strlcpy(server_data->base_path, base_path,

code/components/jomjol_fileserver_ota/server_file.h

@@ -1,10 +1,15 @@
+#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);
@@ -13,3 +18,4 @@ 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

code/components/jomjol_fileserver_ota/server_help.cpp

@@ -21,22 +21,27 @@ extern "C" {
 
 #include "esp_http_server.h"
 
+#include "../../include/defines.h"
+
 
 static const char *TAG = "SERVER HELP";
 
-#define SCRATCH_BUFSIZE  8192 
-char scratch[SCRATCH_BUFSIZE];
+char scratch[SERVER_HELPER_SCRATCH_BUFSIZE];
 
 
-#define IS_FILE_EXT(filename, ext) \
-    (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)
+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());
+        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;
@@ -44,6 +49,27 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)
 
     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) {

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

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,45 +28,40 @@
 
 #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 *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(TAG, "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(TAG, "Waiting for a new firmware... %d", ++i);
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Waiting for a new firmware... (" + to_string(++i) + ")");
         vTaskDelay(1000 / portTICK_PERIOD_MS);
     }
 }
@@ -72,6 +69,8 @@ static void infinite_loop(void)
 
 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);
@@ -84,7 +83,7 @@ void task_do_Update_ZIP(void *pvParameter)
         out = "/sdcard/html";
         outbin = "/sdcard/firmware";
 
-        retfirmware = unzip_new(_file_name_update, out+"/", outbin+"/");
+        retfirmware = unzip_new(_file_name_update, out+"/", outbin+"/", "/sdcard/", initial_setup);
     	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Files unzipped.");
 
         if (retfirmware.length() > 0)
@@ -92,8 +91,15 @@ void task_do_Update_ZIP(void *pvParameter)
         	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.");
-        doReboot();
+
+        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
     {
@@ -107,29 +113,34 @@ void CheckUpdate()
  	FILE *pfile;
     if ((pfile = fopen("/sdcard/update.txt", "r")) == NULL)
     {
-		LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "No update triggered.");
+		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, "Update during boot triggered - Update File: " + _file_name_update);
+	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Start update process (" + _file_name_update + ")");
 
 
-    BaseType_t xReturned;
-    int _i = configMINIMAL_STACK_SIZE;
-    xReturned = xTaskCreate(&task_do_Update_ZIP, "task_do_Update_ZIP", configMINIMAL_STACK_SIZE * 35, NULL, tskIDLE_PRIORITY+1, NULL);
+    xTaskCreate(&task_do_Update_ZIP, "task_do_Update_ZIP", configMINIMAL_STACK_SIZE * 35, NULL, tskIDLE_PRIORITY+1, NULL);
     while(1) { // wait until reboot within task_do_Update_ZIP
         vTaskDelay(1000 / portTICK_PERIOD_MS);
     }
 }
 
 
-
-
 static bool ota_update_task(std::string fn)
 {
     esp_err_t err;
@@ -142,18 +153,18 @@ static bool ota_update_task(std::string fn)
     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(TAG, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x",
-                 configured->address, running->address);
-        ESP_LOGW(TAG, "(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(TAG, "Running partition type %d subtype %d (offset 0x%08x)",
-             running->type, running->subtype, running->address);
+             running->type, running->subtype, (unsigned int)running->address);
 
 
     update_partition = esp_ota_get_next_update_partition(NULL);
     ESP_LOGI(TAG, "Writing to partition subtype %d at offset 0x%x",
-             update_partition->subtype, update_partition->address);
+             update_partition->subtype, (unsigned int)update_partition->address);
 //    assert(update_partition != NULL);
 
     int binary_file_length = 0;
@@ -163,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(TAG, "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) {
@@ -197,16 +208,17 @@ static bool ota_update_task(std::string fn)
                     // 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(TAG, "New version is the same as invalid version.");
-                            ESP_LOGW(TAG, "Previously, there was an attempt to launch the firmware with %s version, but it failed.", invalid_app_info.version);
-                            ESP_LOGW(TAG, "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(TAG, "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();
                     }
 */
@@ -214,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(TAG, "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(TAG, "esp_ota_begin succeeded");
                 } else {
-                    ESP_LOGE(TAG, "received package is not fit len");
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "received package is not fit len");
                     return false;
                 }
             }            
@@ -235,11 +247,11 @@ static bool ota_update_task(std::string fn)
            // * `errno` to check for underlying transport connectivity closure if any
            //
             if (errno == ECONNRESET || errno == ENOTCONN) {
-                ESP_LOGE(TAG, "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);  
 
@@ -248,15 +260,15 @@ static bool ota_update_task(std::string fn)
     err = esp_ota_end(update_handle);
     if (err != ESP_OK) {
         if (err == ESP_ERR_OTA_VALIDATE_FAILED) {
-            ESP_LOGE(TAG, "Image validation failed, image is corrupted");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Image validation failed, image is corrupted");
         }
-        ESP_LOGE(TAG, "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(TAG, "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(TAG, "Prepare to restart system!");
@@ -282,6 +294,7 @@ static bool diagnostic(void)
     return true;
 }
 
+
 void CheckOTAUpdate(void)
 {
     ESP_LOGI(TAG, "Start CheckOTAUpdateCheck...");
@@ -322,7 +335,7 @@ void CheckOTAUpdate(void)
                         ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
                         esp_ota_mark_app_valid_cancel_rollback();
                     } else {
-                        ESP_LOGE(TAG, "Diagnostics failed! Start rollback to the previous version...");
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Diagnostics failed! Start rollback to the previous version...");
                         esp_ota_mark_app_invalid_rollback_and_reboot();
                     }
                 }
@@ -346,7 +359,7 @@ void CheckOTAUpdate(void)
                 ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
                 esp_ota_mark_app_valid_cancel_rollback();
             } else {
-                ESP_LOGE(TAG, "Diagnostics failed! Start rollback to the previous version...");
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Diagnostics failed! Start rollback to the previous version...");
                 esp_ota_mark_app_invalid_rollback_and_reboot();
             }
         }
@@ -354,7 +367,6 @@ void CheckOTAUpdate(void)
 }
 
 
-
 esp_err_t handler_ota_update(httpd_req_t *req)
 {
 #ifdef DEBUG_DETAIL_ON     
@@ -391,7 +403,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)
             ESP_LOGD(TAG, "Delete Default File: %s", fn.c_str());
         }
 
-    };
+    }
 
     if (_task.compare("emptyfirmwaredir") == 0)
     {
@@ -436,10 +448,10 @@ esp_err_t handler_ota_update(httpd_req_t *req)
         }
 
 
-        if (filetype == "ZIP")
+        if ((filetype == "ZIP") || (filetype == "BIN"))
         {
            	FILE *pfile;
-            LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Update for reboot.");
+            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);
@@ -450,37 +462,14 @@ esp_err_t handler_ota_update(httpd_req_t *req)
             ESP_LOGD(TAG, "Send reboot");
             return ESP_OK;                
 
-
-
-/*
-            std::string in, out, outbin, zw, retfirmware;
-
-            out = "/sdcard/html";
-            outbin = "/sdcard/firmware";
-
-            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))
             {
@@ -500,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());
@@ -539,7 +528,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)
         }
         else
         {
-            ESP_LOGD(TAG, "File does not exist: %s", 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";
@@ -554,12 +543,12 @@ esp_err_t handler_ota_update(httpd_req_t *req)
     httpd_resp_send(req, zw.c_str(), strlen(zw.c_str())); 
     httpd_resp_send_chunk(req, NULL, 0);  
 
-    ESP_LOGE(TAG, "ota without parameter - should not be the case!");
+    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))
     {
@@ -571,68 +560,129 @@ esp_err_t handler_ota_update(httpd_req_t *req)
     }
 
     httpd_resp_send(req, resp_str, strlen(resp_str));  
-
-#ifdef DEBUG_DETAIL_ON 
-    LogFile.WriteHeapInfo("handler_ota_update - Done");    
-#endif
 */
 
-    return ESP_OK;
-};
+    #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.WriteToFile(ESP_LOG_INFO, TAG, "Reboot triggered by Software (5s).");
+
+void doReboot()
+{
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Reboot triggered by Software (5s)");
     LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Reboot in 5sec");
-    xTaskCreate(&task_reboot, "reboot", configMINIMAL_STACK_SIZE * 64, NULL, 10, NULL);
-    // KillTFliteTasks(); // kills itself 
-    gpio_handler_destroy();
-    #ifdef ENABLE_MQTT
-        MQTTdestroy_client();
-    #endif //ENABLE_MQTT
+
+    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(ESP_LOG_DEBUG, TAG, "handler_reboot");
-    ESP_LOGI(TAG, "!!! 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 around 25..60s<br>(in case of a firmware update it can take up to 180s).<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_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(TAG, "Registering URI handlers");

code/components/jomjol_fileserver_ota/server_ota.h

@@ -1,3 +1,8 @@
+#pragma once
+
+#ifndef SERVEROTA_H
+#define SERVEROTA_H
+
 #include <esp_log.h>
 
 #include <esp_http_server.h>
@@ -8,6 +13,8 @@
 void register_server_ota_sdcard_uri(httpd_handle_t server);
 void CheckOTAUpdate();
 void doReboot();
+void doRebootOTA();
 void hard_restart();
 void CheckUpdate();
-static bool ota_update_task(std::string fn);
+
+#endif //SERVEROTA_H

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_fileserver_ota jomjol_image_proc jomjol_wlan)
 
 

code/components/jomjol_flowcontroll/ClassFlow.cpp

@@ -4,6 +4,7 @@
 #include <iostream>
 #include <string.h>
 #include "esp_log.h"
+#include "../../include/defines.h"
 
 static const char *TAG = "CLASS";
 
@@ -105,7 +106,7 @@ bool ClassFlow::getNextLine(FILE* pfile, string *rt)
 	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))

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;
@@ -52,3 +51,4 @@ public:
 
 };
 
+#endif //CLASSFLOW_H

code/components/jomjol_flowcontroll/ClassFlowAlignment.cpp

@@ -1,18 +1,19 @@
 #include "ClassFlowAlignment.h"
-#include "ClassFlowMakeImage.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";
 
-bool AlignmentExtendedDebugging = true;
-
 // #define DEBUG_DETAIL_ON  
 
 
@@ -30,11 +31,15 @@ void ClassFlowAlignment::SetInitialParameter(void)
     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();
@@ -42,26 +47,26 @@ ClassFlowAlignment::ClassFlowAlignment(std::vector<ClassFlow*>* lfc)
 
     for (int i = 0; i < ListFlowControll->size(); ++i)
     {
-        if (((*ListFlowControll)[i])->name().compare("ClassFlowMakeImage") == 0)
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowTakeImage") == 0)
         {
-            ImageBasis = ((ClassFlowMakeImage*) (*ListFlowControll)[i])->rawImage;
+            ImageBasis = ((ClassFlowTakeImage*) (*ListFlowControll)[i])->rawImage;
         }
     }
 
-    if (!ImageBasis)            // die Funktion Bilder aufnehmen existiert nicht --> muss erst erzeugt werden NUR ZU TESTZWECKEN
+    if (!ImageBasis)            // the function take pictures does not exist --> must be created first ONLY FOR TEST PURPOSES
     {
-        if (AlignmentExtendedDebugging) ESP_LOGD(TAG, "CImageBasis had to be created");
-        ImageBasis = new CImageBasis(namerawimage);
+        ESP_LOGD(TAG, "CImageBasis had to be created");
+        ImageBasis = new CImageBasis("ImageBasis", namerawimage);
     }
 }
 
 
 bool ClassFlowAlignment::ReadParameter(FILE* pfile, string& aktparamgraph)
 {
-    std::vector<string> zerlegt;
+    std::vector<string> splitted;
     int suchex = 40;
     int suchey = 40;
-    int alg_algo = 0;
+    int alg_algo = 0; //default=0; 1 =HIGHACCURACY; 2= FAST; 3= OFF //add disable aligment algo |01.2023
 
 
     aktparamgraph = trim(aktparamgraph);
@@ -70,62 +75,64 @@ bool ClassFlowAlignment::ReadParameter(FILE* pfile, string& aktparamgraph)
         if (!this->GetNextParagraph(pfile, aktparamgraph))
             return false;
 
-    if (aktparamgraph.compare("[Alignment]") != 0)       // Paragraph passt nich zu MakeImage
+    if (aktparamgraph.compare("[Alignment]") != 0)       //Paragraph does not fit Alignment
         return false;
 
     while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
     {
-        zerlegt = ZerlegeZeile(aktparamgraph);
-        if ((toUpper(zerlegt[0]) == "FLIPIMAGESIZE") && (zerlegt.size() > 1))
+        splitted = ZerlegeZeile(aktparamgraph);
+        if ((toUpper(splitted[0]) == "FLIPIMAGESIZE") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 initialflip = true;
         }
-        if ((toUpper(zerlegt[0]) == "INITIALMIRROR") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "INITIALMIRROR") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 initialmirror = true;
         }
-        if (((toUpper(zerlegt[0]) == "INITALROTATE") || (toUpper(zerlegt[0]) == "INITIALROTATE")) && (zerlegt.size() > 1))
+        if (((toUpper(splitted[0]) == "INITALROTATE") || (toUpper(splitted[0]) == "INITIALROTATE")) && (splitted.size() > 1))
         {
-            this->initalrotate = std::stod(zerlegt[1]);
+            this->initalrotate = std::stod(splitted[1]);
         }
-        if ((toUpper(zerlegt[0]) == "SEARCHFIELDX") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "SEARCHFIELDX") && (splitted.size() > 1))
         {
-            suchex = std::stod(zerlegt[1]);
+            suchex = std::stod(splitted[1]);
         }   
-        if ((toUpper(zerlegt[0]) == "SEARCHFIELDY") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "SEARCHFIELDY") && (splitted.size() > 1))
         {
-            suchey = std::stod(zerlegt[1]);
+            suchey = std::stod(splitted[1]);
         }   
-        if ((toUpper(zerlegt[0]) == "ANTIALIASING") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "ANTIALIASING") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 use_antialiasing = true;
         }   
-        if ((zerlegt.size() == 3) && (anz_ref < 2))
+        if ((splitted.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]);
+            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++;
         }
 
-        if ((toUpper(zerlegt[0]) == "SAVEALLFILES") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "SAVEALLFILES") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 SaveAllFiles = true;
         }
-        if ((toUpper(zerlegt[0]) == "ALIGNMENTALGO") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "ALIGNMENTALGO") && (splitted.size() > 1))
         {
-#ifdef DEBUG_DETAIL_ON
-            std::string zw2 = "Alignmentmodus gewählt: " + zerlegt[1];
-            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, zw2);
-#endif
-            if (toUpper(zerlegt[1]) == "HIGHACCURACY")
+            #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(zerlegt[1]) == "FAST")
+            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;
         }
     }
 
@@ -135,18 +142,22 @@ bool ClassFlowAlignment::ReadParameter(FILE* pfile, string& aktparamgraph)
         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(ESP_LOG_DEBUG, TAG, zw2);
-#endif
+        #ifdef DEBUG_DETAIL_ON
+            std::string zw2 = "Alignment mode written: " + std::to_string(alg_algo);
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, zw2);
+        #endif
     }
 
-    LoadReferenceAlignmentValues();
+    //no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
+    if(References[0].alignment_algo != 3){
+        LoadReferenceAlignmentValues();
+    }
     
     return true;
 
 }
 
+
 string ClassFlowAlignment::getHTMLSingleStep(string host)
 {
     string result;
@@ -160,25 +171,62 @@ string ClassFlowAlignment::getHTMLSingleStep(string host)
 
 bool ClassFlowAlignment::doFlow(string time) 
 {
+    #ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+        if (!AlgROI)  // AlgROI needs to be allocated before ImageTMP to avoid heap fragmentation
+        {
+            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(ImageBasis, 5);
+    {
+        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;
+        }
+    }
 
-    if (AlignAndCutImage)
-        delete AlignAndCutImage;
-    AlignAndCutImage = new CAlignAndCutImage(ImageBasis, ImageTMP);   
+    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(AlignAndCutImage, ImageTMP, initialflip);
+    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 (initialmirror){
+    if (initialmirror)
+    {
         ESP_LOGD(TAG, "do mirror");
         rt.Mirror();
-        if (SaveAllFiles) AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/mirror.jpg"));
+        
+        if (SaveAllFiles)
+            AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/mirror.jpg"));
     }
  
     if ((initalrotate != 0) || initialflip)
@@ -187,41 +235,52 @@ bool ClassFlowAlignment::doFlow(string time)
             rt.RotateAntiAliasing(initalrotate);
         else
             rt.Rotate(initalrotate);
-        if (SaveAllFiles) AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/rot.jpg"));
+        
+        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"));
+        //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.DigitalDrawROI(ImageTMP);
+            flowctrl.AnalogDrawROI(ImageTMP);
+            ImageTMP->writeToMemoryAsJPG((ImageData*)AlgROI, 90);
+        }
+    #endif
+    
     if (SaveAllFiles)
     {
-        if (initialflip)
-        {
-            int _zw = ImageTMP->width;
-            ImageTMP->width = ImageTMP->height;
-            ImageTMP->height = _zw;
-        }
-        DrawRef(ImageTMP);
+        AlignAndCutImage->SaveToFile(FormatFileName("/sdcard/img_tmp/alg.jpg"));
         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;
-    }  
+    // must be deleted to have memory space for loading tflite
+    delete ImageTMP;
+    ImageTMP = NULL;
 
-    LoadReferenceAlignmentValues();
+    //no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
+    if(References[0].alignment_algo != 3){
+        LoadReferenceAlignmentValues();
+    }
 
     return true;
 }
 
 
-
 void ClassFlowAlignment::SaveReferenceAlignmentValues()
 {
     FILE* pFile;
@@ -261,92 +320,74 @@ void ClassFlowAlignment::SaveReferenceAlignmentValues()
 }
 
 
-
-
-
 bool ClassFlowAlignment::LoadReferenceAlignmentValues(void)
 {
     FILE* pFile;
     char zw[1024];
     string zwvalue;
-    std::vector<string> zerlegt;  
+    std::vector<string> splitted;  
 
 
-//    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);
     ESP_LOGD(TAG, "%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)
+    splitted = ZerlegeZeile(std::string(zw), " \t");
+    if (splitted.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]);
+    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);
-    zerlegt = ZerlegeZeile(std::string(zw));
-    if (zerlegt.size() < 6)
+    splitted = ZerlegeZeile(std::string(zw));
+    if (splitted.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]);
+    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
+    /*#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);
+    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);
+    }
 }
-

code/components/jomjol_flowcontroll/ClassFlowAlignment.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#ifndef CLASSFLOWALIGNMENT_H
+#define CLASSFLOWALIGNMENT_H
+
 #include "ClassFlow.h"
 #include "Helper.h"
 #include "CAlignAndCutImage.h"
@@ -31,6 +34,9 @@ protected:
 
 public:
     CImageBasis *ImageBasis, *ImageTMP;
+    #ifdef ALGROI_LOAD_FROM_MEM_AS_JPG 
+    ImageData *AlgROI;
+    #endif
     
     ClassFlowAlignment(std::vector<ClassFlow*>* lfc);
 
@@ -44,3 +50,5 @@ public:
     string name(){return "ClassFlowAlignment";};
 };
 
+
+#endif //CLASSFLOWALIGNMENT_H

code/components/jomjol_flowcontroll/ClassFlowCNNGeneral.cpp

@@ -8,9 +8,16 @@
 #include "CTfLiteClass.h"
 #include "ClassLogFile.h"
 #include "esp_log.h"
+#include "../../include/defines.h"
 
 static const char* TAG = "CNN";
 
+//#ifdef CONFIG_HEAP_TRACING_STANDALONE
+#ifdef HEAP_TRACING_CLASS_FLOW_CNN_GENERAL_DO_ALING_AND_CUT
+    #include <esp_heap_trace.h>
+    #define NUM_RECORDS 300
+    static heap_trace_record_t trace_record[NUM_RECORDS]; // This buffer must be in internal RAM
+#endif
 
 
 ClassFlowCNNGeneral::ClassFlowCNNGeneral(ClassFlowAlignment *_flowalign, t_CNNType _cnntype) : ClassFlowImage(NULL, TAG)
@@ -27,10 +34,11 @@ ClassFlowCNNGeneral::ClassFlowCNNGeneral(ClassFlowAlignment *_flowalign, t_CNNTy
     CNNType = AutoDetect;
     CNNType = _cnntype;
     flowpostalignment = _flowalign;
-    logfileRetentionInDays = 5;
+    imagesRetention = 5;
 }
 
-string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution, int prev, float _vorgaengerAnalog, float analogDigitalTransitionStart)
+
+string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution, int prev, float _before_narrow_Analog, float analogDigitalTransitionStart)
 {
     string result = "";    
 
@@ -40,19 +48,19 @@ string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution
  
     if (CNNType == Analogue || CNNType == Analogue100)
     {
-        float zahl = GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float;
-        int ergebnis_nachkomma = ((int) floor(zahl * 10) + 10) % 10;
+        float number = GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float;
+        int result_after_decimal_point = ((int) floor(number * 10) + 10) % 10;
         
-        prev = ZeigerEvalAnalogNeu(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, prev);
-//        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(analog) zahl=" + std::to_string(zahl) + ", ergebnis_nachkomma=" + std::to_string(ergebnis_nachkomma) + ", prev=" + std::to_string(prev));
+        prev = PointerEvalAnalogNew(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, prev);
+//        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(analog) number=" + std::to_string(number) + ", result_after_decimal_point=" + std::to_string(result_after_decimal_point) + ", prev=" + std::to_string(prev));
         result = std::to_string(prev);
 
-        if (_extendedResolution && (CNNType != Digital))
-            result = result + std::to_string(ergebnis_nachkomma);
+        if (_extendedResolution)
+            result = result + std::to_string(result_after_decimal_point);
 
         for (int i = GENERAL[_analog]->ROI.size() - 2; i >= 0; --i)
         {
-            prev = ZeigerEvalAnalogNeu(GENERAL[_analog]->ROI[i]->result_float, prev);
+            prev = PointerEvalAnalogNew(GENERAL[_analog]->ROI[i]->result_float, prev);
             result = std::to_string(prev) + result;
         }
         return result;
@@ -73,25 +81,24 @@ string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution
     if ((CNNType == DoubleHyprid10) || (CNNType == Digital100))
     {
 
-        float zahl = GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float;
-        if (zahl >= 0)       // NaN?
+        float number = GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float;
+        if (number >= 0)       // NaN?
         {
-            if (_extendedResolution)            // ist nur gesetzt, falls es die erste Ziffer ist (kein Analog vorher!)
+            if (_extendedResolution)            // is only set if it is the first digit (no analogue before!)
             {
-                int ergebnis_nachkomma = ((int) floor(zahl * 10)) % 10;
-                int ergebnis_vorkomma = ((int) floor(zahl)) % 10;
+                int result_after_decimal_point = ((int) floor(number * 10)) % 10;
+                int result_before_decimal_point = ((int) floor(number)) % 10;
 
-                result = std::to_string(ergebnis_vorkomma) + std::to_string(ergebnis_nachkomma);
-                prev = ergebnis_vorkomma;
-                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(dig100-ext) ergebnis_vorkomma=" + std::to_string(ergebnis_vorkomma) + ", ergebnis_nachkomma=" + std::to_string(ergebnis_nachkomma) + ", prev=" + std::to_string(prev));
+                result = std::to_string(result_before_decimal_point) + std::to_string(result_after_decimal_point);
+                prev = result_before_decimal_point;
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(dig100-ext) result_before_decimal_point=" + std::to_string(result_before_decimal_point) + ", result_after_decimal_point=" + std::to_string(result_after_decimal_point) + ", prev=" + std::to_string(prev));
             }
             else
             {
-//                prev = ZeigerEval(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, prev);
-                if (_vorgaengerAnalog >= 0)
-                    prev = ZeigerEvalHybridNeu(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, _vorgaengerAnalog, prev, true, analogDigitalTransitionStart);
+                if (_before_narrow_Analog >= 0)
+                    prev = PointerEvalHybridNew(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, _before_narrow_Analog, prev, true, analogDigitalTransitionStart);
                 else
-                    prev = ZeigerEvalHybridNeu(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, prev, prev);
+                    prev = PointerEvalHybridNew(GENERAL[_analog]->ROI[GENERAL[_analog]->ROI.size() - 1]->result_float, prev, prev);
                 result = std::to_string(prev);
                 LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout(dig100)  prev=" + std::to_string(prev));
         
@@ -108,8 +115,8 @@ string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution
         {
             if (GENERAL[_analog]->ROI[i]->result_float >= 0)
             {
-                prev = ZeigerEvalHybridNeu(GENERAL[_analog]->ROI[i]->result_float, GENERAL[_analog]->ROI[i+1]->result_float, prev);
-                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout#ZeigerEvalHybridNeu()= " + std::to_string(prev));
+                prev = PointerEvalHybridNew(GENERAL[_analog]->ROI[i]->result_float, GENERAL[_analog]->ROI[i+1]->result_float, prev);
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout#PointerEvalHybridNew()= " + std::to_string(prev));
                 result = std::to_string(prev) + result;
                 LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "getReadout#result= " + result);
                 
@@ -124,120 +131,134 @@ string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution
         }
         return result;
     }
-
-
     return result;
 }
 
-int ClassFlowCNNGeneral::ZeigerEvalHybridNeu(float zahl, float zahl_vorgaenger, int eval_vorgaenger, bool AnalogerVorgaenger, float digitalAnalogTransitionStart)
+/**
+ * @brief Determines the number of an ROI in connection with previous ROI results
+ * 
+ * @param number: is the current ROI as float value from recognition
+ * @param number_of_predecessors: is the last (lower) ROI as float from recognition
+ * @param eval_predecessors: is the evaluated number. Sometimes a much lower value can change higer values
+ *                          example: 9.8, 9.9, 0.1
+ *                          0.1 => 0 (eval_predecessors)
+ *                          The 0 makes a 9.9 to 0 (eval_predecessors)
+ *                          The 0 makes a 9.8 to 0 
+ * @param Analog_Predecessors false/true if the last ROI is an analog or digital ROI (default=false)
+ *                              runs in special handling because analog is much less precise
+ * @param digitalAnalogTransitionStart start of the transitionlogic begins on number_of_predecessor (default=9.2)
+ *
+ * @return int the determined number of the current ROI
+ */
+int ClassFlowCNNGeneral::PointerEvalHybridNew(float number, float number_of_predecessors, int eval_predecessors, bool Analog_Predecessors, float digitalAnalogTransitionStart)
 {
     int result;
-    int ergebnis_nachkomma = ((int) floor(zahl * 10)) % 10;
-    int ergebnis_vorkomma = ((int) floor(zahl) + 10) % 10;
+    int result_after_decimal_point = ((int) floor(number * 10)) % 10;
+    int result_before_decimal_point = ((int) floor(number) + 10) % 10;
 
-    if (eval_vorgaenger < 0)
-    {
-        if ((ergebnis_nachkomma <= DigitalUnschaerfe * 10) || (ergebnis_nachkomma >= DigitalUnschaerfe * 10))     // Band um die Ziffer --> Runden, da Ziffer im Rahmen Ungenauigkeit erreicht
-            result = (int) (round(zahl) + 10) % 10;
-        else
-            result = (int) ((int) trunc(zahl) + 10) % 10;
+    if (eval_predecessors < 0)
+    {   
+        // on first digit is no spezial logic for transition needed
+        // we use the recognition as given. The result is the int value of the recognition
+        // add precisition of 2 digits and round before trunc
+        result = (int) ((int) trunc(round((number+10 % 10)*100)) )  / 100;
 
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalHybridNeu - kein Vorgänger - Ergebnis = " + std::to_string(result) +
-                                                    " zahl: " + std::to_string(zahl) + " zahl_vorgaenger = " + std::to_string(zahl_vorgaenger)+ " eval_vorgaenger = " + std::to_string(eval_vorgaenger) + " DigitalUnschaerfe = " +  std::to_string(DigitalUnschaerfe));
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - No predecessor - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digital_Uncertainty = " +  std::to_string(Digital_Uncertainty));
         return result;
     }
 
-    if (AnalogerVorgaenger)
+    if (Analog_Predecessors)
     {
-        result = ZeigerEvalAnalogToDigitNeu(zahl, zahl_vorgaenger, eval_vorgaenger, digitalAnalogTransitionStart);
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalHybridNeu - Analoger Vorgänger, Bewertung über ZeigerEvalAnalogNeu = " + std::to_string(result) +
-                                                    " zahl: " + std::to_string(zahl) + " zahl_vorgaenger = " + std::to_string(zahl_vorgaenger)+ " eval_vorgaenger = " + std::to_string(eval_vorgaenger) + " DigitalUnschaerfe = " +  std::to_string(DigitalUnschaerfe));
+        result = PointerEvalAnalogToDigitNew(number, number_of_predecessors, eval_predecessors, digitalAnalogTransitionStart);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - Analog predecessor, evaluation over PointerEvalAnalogNew = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digital_Uncertainty = " +  std::to_string(Digital_Uncertainty));
         return result;
     }
 
-    if ((zahl_vorgaenger >= DigitalUebergangsbereichVorgaenger ) && (zahl_vorgaenger <= (10.0 - DigitalUebergangsbereichVorgaenger)))
+    if ((number_of_predecessors >= Digital_Transition_Area_Predecessor ) && (number_of_predecessors <= (10.0 - Digital_Transition_Area_Predecessor)))
     {
-        // kein Ziffernwechsel, da Vorgänger weit genug weg ist (0+/-DigitalUebergangsbereichVorgaenger) --> zahl wird gerundet
-        if ((ergebnis_nachkomma <= DigitalBand) || (ergebnis_nachkomma >= (10-DigitalBand)))     // Band um die Ziffer --> Runden, da Ziffer im Rahmen Ungenauigkeit erreicht
-            result = ((int) round(zahl) + 10) % 10;
+        // no digit change, because predecessor is far enough away (0+/-DigitalTransitionRangePredecessor) --> number is rounded
+        if ((result_after_decimal_point <= DigitalBand) || (result_after_decimal_point >= (10-DigitalBand)))     // Band around the digit --> Round off, as digit reaches inaccuracy in the frame
+            result = ((int) round(number) + 10) % 10;
         else
-            result = ((int) trunc(zahl) + 10) % 10;
+            result = ((int) trunc(number) + 10) % 10;
 
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalHybridNeu - KEIN Analoger Vorgänger, kein Ziffernwechsel, da Vorkomma weit genug weg = " + std::to_string(result) +
-                                                    " zahl: " + std::to_string(zahl) + " zahl_vorgaenger = " + std::to_string(zahl_vorgaenger)+ " eval_vorgaenger = " + std::to_string(eval_vorgaenger) + " DigitalUnschaerfe = " +  std::to_string(DigitalUnschaerfe));
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - NO analogue predecessor, no change of digits, as pre-decimal point far enough away = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digital_Uncertainty = " +  std::to_string(Digital_Uncertainty));
         return result;
     }  
 
-    if (eval_vorgaenger <= 1)  // Nulldurchgang beim Vorgänger hat stattgefunden (!Bewertung über Prev_value und nicht Zahl!) --> hier aufrunden (2.8 --> 3, aber auch 3.1 --> 3)
+    if (eval_predecessors <= 1)  // Zero crossing at the predecessor has taken place (! evaluation via Prev_value and not number!) --> round up here (2.8 --> 3, but also 3.1 --> 3)
     {
-        // Wir nehmen einfach an, dass das aktuelle Digit nach dem Nulldurchgang des Vorgängers
-        // mindestens zur Hälfte (x.5) durchlaufen hat
-        if (ergebnis_nachkomma > 5)
-            // Das akt. digit hat noch keinen Nulldurchgang, aber der Vorgänger schon.
-            result =  (ergebnis_vorkomma + 1) % 10;
+        // We simply assume that the current digit after the zero crossing of the predecessor
+        // has passed through at least half (x.5)
+        if (result_after_decimal_point > 5)
+            // The current digit does not yet have a zero crossing, but the predecessor does..
+            result =  (result_before_decimal_point + 1) % 10;
         else
-            // Akt. digit und Vorgänger haben Nulldurchgang
-            result =  ergebnis_vorkomma % 10;
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalHybridNeu - KEIN Analoger Vorgänger, Nulldurchgang hat stattgefunden = " + std::to_string(result) +
-                                                    " zahl: " + std::to_string(zahl) + " zahl_vorgaenger = " + std::to_string(zahl_vorgaenger)+ " eval_vorgaenger = " + std::to_string(eval_vorgaenger) + " DigitalUnschaerfe = " +  std::to_string(DigitalUnschaerfe));
+            // Act. digit and predecessor have zero crossing
+            result =  result_before_decimal_point % 10;
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - NO analogue predecessor, zero crossing has taken placen = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digital_Uncertainty = " +  std::to_string(Digital_Uncertainty));
         return result;
     }
 
     
-    // bleibt nur >= 9.x --> noch kein Nulldurchgang --> 2.8 --> 2, 
-    // und ab 9.7(DigitalUebergangsbereichVorlauf) 3.1 --> 2
-    // alles >=x.4 kann als aktuelle Zahl gelten im Übergang. Bei 9.x Vorgänger kann die aktuelle
-    // Zahl noch x.6 - x.7 sein. 
-    // Vorlauf (else - Zweig) passiert nicht bereits ab 9.
-    if (DigitalUebergangsbereichVorlauf>=zahl_vorgaenger || ergebnis_nachkomma >= 4)
-        // aktuelles digit hat genauso wie das Vorgängerdigit noch keinen Nulldurchgang. 
-        result =  ergebnis_vorkomma % 10;
+    // remains only >= 9.x --> no zero crossing yet --> 2.8 --> 2, 
+    // and from 9.7(DigitalTransitionRangeLead) 3.1 --> 2
+    // everything >=x.4 can be considered as current number in transition. With 9.x predecessor the current
+    // number can still be x.6 - x.7. 
+    // Preceding (else - branch) does not already happen from 9.
+    if (Digital_Transition_Area_Forward>=number_of_predecessors || result_after_decimal_point >= 4)
+        // The current digit, like the previous digit, does not yet have a zero crossing. 
+        result =  result_before_decimal_point % 10;
     else
-        // aktuelles digit läuft dem kleineren digit (9.x) vor. Also schon >=x.0 während das vorherige Digit noch
-        // keinen Nulldurchgang hat. Daher wird um 1 reduziert.
-        result =  (ergebnis_vorkomma - 1 + 10) % 10;
+        // current digit precedes the smaller digit (9.x). So already >=x.0 while the previous digit has not yet
+        // has no zero crossing. Therefore, it is reduced by 1.
+        result =  (result_before_decimal_point - 1 + 10) % 10;
 
-    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalHybridNeu - KEIN Analoger Vorgänger, >= 9.5 --> noch kein Nulldurchgang = " + std::to_string(result) +
-                                                " zahl: " + std::to_string(zahl) + " zahl_vorgaenger = " + std::to_string(zahl_vorgaenger)+ " eval_vorgaenger = " + std::to_string(eval_vorgaenger) + " DigitalUnschaerfe = " +  std::to_string(DigitalUnschaerfe) + " ergebnis_nachkomma = " + std::to_string(ergebnis_nachkomma));
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - O analogue predecessor, >= 9.5 --> no zero crossing yet = " + std::to_string(result) +
+                                                " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digital_Uncertainty = " +  std::to_string(Digital_Uncertainty) + " result_after_decimal_point = " + std::to_string(result_after_decimal_point));
     return result;
 }
 
 
-int ClassFlowCNNGeneral::ZeigerEvalAnalogToDigitNeu(float zahl, float ziffer_vorgaenger,  int eval_vorgaenger, float analogDigitalTransitionStart)
+int ClassFlowCNNGeneral::PointerEvalAnalogToDigitNew(float number, float numeral_preceder,  int eval_predecessors, float analogDigitalTransitionStart)
 {
     int result;
-    int ergebnis_nachkomma = ((int) floor(zahl * 10)) % 10;
-    int ergebnis_vorkomma = ((int) floor(zahl) + 10) % 10;
+    int result_after_decimal_point = ((int) floor(number * 10)) % 10;
+    int result_before_decimal_point = ((int) floor(number) + 10) % 10;
     bool roundedUp = false;
 
-    // Innerhalb der digitalen Unschaefe 
-    if ((ergebnis_nachkomma >= (10-DigitalUnschaerfe * 10))     // Band um die Ziffer --> Runden, da Ziffer im Rahmen Ungenauigkeit erreicht
-        || (eval_vorgaenger <= 4 && ergebnis_nachkomma>=6))  {   // oder digit läuft nach (analog =0..4, digit >=6)
-        result = (int) (round(zahl) + 10) % 10;
+    // Within the digital inequalities 
+    if ((result_after_decimal_point >= (10-Digital_Uncertainty * 10))     // Band around the digit --> Round off, as digit reaches inaccuracy in the frame
+        || (eval_predecessors <= 4 && result_after_decimal_point>=6))  {   // or digit runs after (analogue =0..4, digit >=6)
+        result = (int) (round(number) + 10) % 10;
         roundedUp = true;
-        // vor/nachkomma neu berechnen, da wir anhand der Unschaefe die Zahl anpassen.
-        ergebnis_nachkomma = ((int) floor(result * 10)) % 10;
-        ergebnis_vorkomma = ((int) floor(result) + 10) % 10;
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalAnalogToDigitNeu - digitaleUnschaerfe - Ergebnis = " + std::to_string(result) +
-                                                    " zahl: " + std::to_string(zahl) + " ziffer_vorgaenger: " + std::to_string(ziffer_vorgaenger) +
-                                                    " erg_vorkomma: " + std::to_string(ergebnis_vorkomma) + 
-                                                    " erg_nachkomma: " + std::to_string(ergebnis_nachkomma));
+        // before/ after decimal point, because we adjust the number based on the uncertainty.
+        result_after_decimal_point = ((int) floor(result * 10)) % 10;
+        result_before_decimal_point = ((int) floor(result) + 10) % 10;
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogToDigitNew - Digital Uncertainty - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " numeral_preceder: " + std::to_string(numeral_preceder) +
+                                                    " erg before comma: " + std::to_string(result_before_decimal_point) + 
+                                                    " erg after comma: " + std::to_string(result_after_decimal_point));
     } else {
-        result = (int) ((int) trunc(zahl) + 10) % 10;
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalAnalogToDigitNeu - KEINE digitaleUnschaerfe - Ergebnis = " + std::to_string(result) +
-                                                    " zahl: " + std::to_string(zahl) + " ziffer_vorgaenger = " + std::to_string(ziffer_vorgaenger));
+        result = (int) ((int) trunc(number) + 10) % 10;
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogToDigitNew - NO digital Uncertainty - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder));
     }
 
-    // Kein Nulldurchgang hat stattgefunden.
-    // Nur eval_vorgaenger verwendet, da ziffer_vorgaenger hier falsch sein könnte.
-    // ziffer_vorgaenger<=0.1 & eval_vorgaenger=9 entspricht analog wurde zurückgesetzt wegen vorhergehender analog, die noch nicht auf 0 sind.
-    if ((eval_vorgaenger>=6 && (ziffer_vorgaenger>analogDigitalTransitionStart || ziffer_vorgaenger<=0.2) && roundedUp))
+    // No zero crossing has taken place.
+    // Only eval_predecessors used because numeral_preceder could be wrong here.
+    // numeral_preceder<=0.1 & eval_predecessors=9 corresponds to analogue was reset because of previous analogue that are not yet at 0.
+    if ((eval_predecessors>=6 && (numeral_preceder>analogDigitalTransitionStart || numeral_preceder<=0.2) && roundedUp))
     {
-        result =  ((ergebnis_vorkomma+10) - 1) % 10;
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalAnalogToDigitNeu - Nulldurchgang noch nicht stattgefunden = " + std::to_string(result) +
-                                    " zahl: " + std::to_string(zahl) + 
-                                    " ziffer_vorgaenger = " + std::to_string(ziffer_vorgaenger) + 
-                                    " erg_nachkomma = " +  std::to_string(ergebnis_nachkomma));
+        result =  ((result_before_decimal_point+10) - 1) % 10;
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogToDigitNew - Nulldurchgang noch nicht stattgefunden = " + std::to_string(result) +
+                                    " number: " + std::to_string(number) + 
+                                    " numeral_preceder = " + std::to_string(numeral_preceder) + 
+                                    " eerg after comma = " +  std::to_string(result_after_decimal_point));
 
     }
 
@@ -245,53 +266,53 @@ int ClassFlowCNNGeneral::ZeigerEvalAnalogToDigitNeu(float zahl, float ziffer_vor
 
 }
 
-int ClassFlowCNNGeneral::ZeigerEvalAnalogNeu(float zahl, int ziffer_vorgaenger)
+
+int ClassFlowCNNGeneral::PointerEvalAnalogNew(float number, int numeral_preceder)
 {
-    float zahl_min, zahl_max;
+    float number_min, number_max;
     int result;
 
-    if (ziffer_vorgaenger == -1)
+    if (numeral_preceder == -1)
     {
-        result = (int) floor(zahl);
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalAnalogNeu - kein Vorgänger - Ergebnis = " + std::to_string(result) +
-                                                    " zahl: " + std::to_string(zahl) + " ziffer_vorgaenger = " + std::to_string(ziffer_vorgaenger) + " AnalogFehler = " +  std::to_string(AnalogFehler));
+        result = (int) floor(number);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - No predecessor - Result = " + std::to_string(result) +
+                                                    " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
         return result;
     }
 
-    zahl_min = zahl - AnalogFehler / 10.0;
-    zahl_max = zahl + AnalogFehler / 10.0;
+    number_min = number - Analog_error / 10.0;
+    number_max = number + Analog_error / 10.0;
 
-    if ((int) floor(zahl_max) - (int) floor(zahl_min) != 0)
+    if ((int) floor(number_max) - (int) floor(number_min) != 0)
     {
-        if (ziffer_vorgaenger <= AnalogFehler)
+        if (numeral_preceder <= Analog_error)
         {
-            result = ((int) floor(zahl_max) + 10) % 10;
-            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalAnalogNeu - Zahl uneindeutig, Korrektur nach oben - Ergebnis = " + std::to_string(result) +
-                                                        " zahl: " + std::to_string(zahl) + " ziffer_vorgaenger = " + std::to_string(ziffer_vorgaenger) + " AnalogFehler = " +  std::to_string(AnalogFehler));
+            result = ((int) floor(number_max) + 10) % 10;
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - number ambiguous, correction upwards - result = " + std::to_string(result) +
+                                                        " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
             return result;
         }
-        if (ziffer_vorgaenger >= 10 - AnalogFehler)
+        if (numeral_preceder >= 10 - Analog_error)
         {
-            result = ((int) floor(zahl_min) + 10) % 10;
-            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalAnalogNeu - Zahl uneindeutig, Korrektur nach unten - Ergebnis = " + std::to_string(result) +
-                                                        " zahl: " + std::to_string(zahl) + " ziffer_vorgaenger = " + std::to_string(ziffer_vorgaenger) + " AnalogFehler = " +  std::to_string(AnalogFehler));
+            result = ((int) floor(number_min) + 10) % 10;
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - number ambiguous, downward correction - result = " + std::to_string(result) +
+                                                        " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
             return result;
         }
     }
     
 
-    result = ((int) floor(zahl) + 10) % 10;
-    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "ZeigerEvalAnalogNeu - Zahl eindeutig, keine Korrektur notwendig - Ergebnis = " + std::to_string(result) +
-                                                " zahl: " + std::to_string(zahl) + " ziffer_vorgaenger = " + std::to_string(ziffer_vorgaenger) + " AnalogFehler = " +  std::to_string(AnalogFehler));
+    result = ((int) floor(number) + 10) % 10;
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalAnalogNew - number unambiguous, no correction necessary - result = " + std::to_string(result) +
+                                                " number: " + std::to_string(number) + " numeral_preceder = " + std::to_string(numeral_preceder) + " Analog_error = " +  std::to_string(Analog_error));
 
     return result;
-
 }
 
 
 bool ClassFlowCNNGeneral::ReadParameter(FILE* pfile, string& aktparamgraph)
 {
-    std::vector<string> zerlegt;
+    std::vector<string> splitted;
 
     aktparamgraph = trim(aktparamgraph);
 
@@ -317,71 +338,77 @@ bool ClassFlowCNNGeneral::ReadParameter(FILE* pfile, string& aktparamgraph)
 
     while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
     {
-        zerlegt = ZerlegeZeile(aktparamgraph);
-        if ((toUpper(zerlegt[0]) == "LOGIMAGELOCATION") && (zerlegt.size() > 1))
+        splitted = ZerlegeZeile(aktparamgraph);
+        if ((toUpper(splitted[0]) == "ROIIMAGESLOCATION") && (splitted.size() > 1))
         {
-            this->LogImageLocation = "/sdcard" + zerlegt[1];
+            this->imagesLocation = "/sdcard" + splitted[1];
             this->isLogImage = true;
         }
-        if ((toUpper(zerlegt[0]) == "LOGIMAGESELECT") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "LOGIMAGESELECT") && (splitted.size() > 1))
         {
-            LogImageSelect = zerlegt[1];
+            LogImageSelect = splitted[1];
             isLogImageSelect = true;            
         }
 
-        if ((toUpper(zerlegt[0]) == "LOGFILERETENTIONINDAYS") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "ROIIMAGESRETENTION") && (splitted.size() > 1))
         {
-            this->logfileRetentionInDays = std::stoi(zerlegt[1]);
+            this->imagesRetention = std::stoi(splitted[1]);
         }
 
-        if ((toUpper(zerlegt[0]) == "MODEL") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "MODEL") && (splitted.size() > 1))
         {
-            this->cnnmodelfile = zerlegt[1];
+            this->cnnmodelfile = splitted[1];
         }
         
-        if ((toUpper(zerlegt[0]) == "CNNGOODTHRESHOLD") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "CNNGOODTHRESHOLD") && (splitted.size() > 1))
         {
-            CNNGoodThreshold = std::stof(zerlegt[1]);
+            CNNGoodThreshold = std::stof(splitted[1]);
         }
-        if (zerlegt.size() >= 5)
+        if (splitted.size() >= 5)
         {
-            general* _analog = GetGENERAL(zerlegt[0], true);
+            general* _analog = GetGENERAL(splitted[0], true);
             roi* neuroi = _analog->ROI[_analog->ROI.size()-1];
-            neuroi->posx = std::stoi(zerlegt[1]);
-            neuroi->posy = std::stoi(zerlegt[2]);
-            neuroi->deltax = std::stoi(zerlegt[3]);
-            neuroi->deltay = std::stoi(zerlegt[4]);
+            neuroi->posx = std::stoi(splitted[1]);
+            neuroi->posy = std::stoi(splitted[2]);
+            neuroi->deltax = std::stoi(splitted[3]);
+            neuroi->deltay = std::stoi(splitted[4]);
             neuroi->CCW = false;
-            if (zerlegt.size() >= 6)
+            if (splitted.size() >= 6)
             {
-                neuroi->CCW = toUpper(zerlegt[5]) == "TRUE";
+                neuroi->CCW = toUpper(splitted[5]) == "TRUE";
             }
             neuroi->result_float = -1;
             neuroi->image = NULL;
             neuroi->image_org = NULL;
         }
 
-        if ((toUpper(zerlegt[0]) == "SAVEALLFILES") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "SAVEALLFILES") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 SaveAllFiles = true;
         }
     }
 
-    if (!getNetworkParameter())
+    if (!getNetworkParameter()) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "An error occured on setting up the Network -> Disabling it!");
+        disabled = true; // An error occured, disable this CNN!
         return false;
+    }
 
 
     for (int _ana = 0; _ana < GENERAL.size(); ++_ana)
         for (int i = 0; i < GENERAL[_ana]->ROI.size(); ++i)
         {
-            GENERAL[_ana]->ROI[i]->image = new CImageBasis(modelxsize, modelysize, modelchannel);
-            GENERAL[_ana]->ROI[i]->image_org = new CImageBasis(GENERAL[_ana]->ROI[i]->deltax, GENERAL[_ana]->ROI[i]->deltay, 3);
+            GENERAL[_ana]->ROI[i]->image = new CImageBasis("ROI " + GENERAL[_ana]->ROI[i]->name, 
+                    modelxsize, modelysize, modelchannel);
+            GENERAL[_ana]->ROI[i]->image_org = new CImageBasis("ROI " + GENERAL[_ana]->ROI[i]->name + " original",
+                    GENERAL[_ana]->ROI[i]->deltax, GENERAL[_ana]->ROI[i]->deltay, 3);
         }
 
     return true;
 }
 
+
 general* ClassFlowCNNGeneral::FindGENERAL(string _name_number)
 {
     for (int i = 0; i < GENERAL.size(); ++i)
@@ -413,7 +440,7 @@ general* ClassFlowCNNGeneral::GetGENERAL(string _name, bool _create = true)
         if (GENERAL[i]->name == _analog)
             _ret = GENERAL[i];
 
-    if (!_create)         // nicht gefunden und soll auch nicht erzeugt werden
+    if (!_create)         // not found and should not be created
         return _ret;
 
     if (_ret == NULL)
@@ -434,7 +461,6 @@ general* ClassFlowCNNGeneral::GetGENERAL(string _name, bool _create = true)
 }
 
 
-
 string ClassFlowCNNGeneral::getHTMLSingleStep(string host)
 {
     string result, zw;
@@ -459,24 +485,38 @@ string ClassFlowCNNGeneral::getHTMLSingleStep(string host)
 }
 
 
-
 bool ClassFlowCNNGeneral::doFlow(string time)
 {
+
+#ifdef HEAP_TRACING_CLASS_FLOW_CNN_GENERAL_DO_ALING_AND_CUT
+    //register a buffer to record the memory trace
+    ESP_ERROR_CHECK( heap_trace_init_standalone(trace_record, NUM_RECORDS) );
+    // start tracing
+    ESP_ERROR_CHECK( heap_trace_start(HEAP_TRACE_LEAKS) );
+#endif
+
     if (disabled)
       return true;
 
     if (!doAlignAndCut(time)){
         return false;
-    };
+    }
 
-    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "doFlow nach Alignment");
+    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "doFlow after alignment");
 
     doNeuralNetwork(time);
 
     RemoveOldLogs();
+
+#ifdef HEAP_TRACING_CLASS_FLOW_CNN_GENERAL_DO_ALING_AND_CUT
+    ESP_ERROR_CHECK( heap_trace_stop() );
+    heap_trace_dump(); 
+#endif   
+
     return true;
 }
 
+
 bool ClassFlowCNNGeneral::doAlignAndCut(string time)
 {
     if (disabled)
@@ -502,40 +542,45 @@ bool ClassFlowCNNGeneral::doAlignAndCut(string time)
             if (SaveAllFiles)
             {
                 if (GENERAL[_ana]->name == "default")
-                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->ROI[i]->name + ".bmp"));
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
                 else
-                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".bmp"));
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
             } 
         }
 
     return true;
 } 
 
+
 void ClassFlowCNNGeneral::DrawROI(CImageBasis *_zw)
 {
-    if (CNNType == Analogue || CNNType == Analogue100)
-    {
-        int r = 0;
-        int g = 255;
-        int b = 0;
+    if (_zw->ImageOkay()) 
+    { 
+        if (CNNType == Analogue || CNNType == Analogue100)
+        {
+            int r = 0;
+            int g = 255;
+            int b = 0;
 
-        for (int _ana = 0; _ana < GENERAL.size(); ++_ana)
-            for (int i = 0; i < GENERAL[_ana]->ROI.size(); ++i)
-            {
-                _zw->drawRect(GENERAL[_ana]->ROI[i]->posx, GENERAL[_ana]->ROI[i]->posy, GENERAL[_ana]->ROI[i]->deltax, GENERAL[_ana]->ROI[i]->deltay, r, g, b, 1);
-                _zw->drawEllipse( (int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int)  (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), (int) (GENERAL[_ana]->ROI[i]->deltax/2), (int) (GENERAL[_ana]->ROI[i]->deltay/2), r, g, b, 2);
-                _zw->drawLine((int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int) GENERAL[_ana]->ROI[i]->posy, (int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay), r, g, b, 2);
-                _zw->drawLine((int) GENERAL[_ana]->ROI[i]->posx, (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), (int) GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax, (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), r, g, b, 2);
-            }
-    }
-    else
-    {
-        for (int _dig = 0; _dig < GENERAL.size(); ++_dig)
-            for (int i = 0; i < GENERAL[_dig]->ROI.size(); ++i)
-                _zw->drawRect(GENERAL[_dig]->ROI[i]->posx, GENERAL[_dig]->ROI[i]->posy, GENERAL[_dig]->ROI[i]->deltax, GENERAL[_dig]->ROI[i]->deltay, 0, 0, (255 - _dig*100), 2);
+            for (int _ana = 0; _ana < GENERAL.size(); ++_ana)
+                for (int i = 0; i < GENERAL[_ana]->ROI.size(); ++i)
+                {
+                    _zw->drawRect(GENERAL[_ana]->ROI[i]->posx, GENERAL[_ana]->ROI[i]->posy, GENERAL[_ana]->ROI[i]->deltax, GENERAL[_ana]->ROI[i]->deltay, r, g, b, 1);
+                    _zw->drawEllipse( (int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int)  (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), (int) (GENERAL[_ana]->ROI[i]->deltax/2), (int) (GENERAL[_ana]->ROI[i]->deltay/2), r, g, b, 2);
+                    _zw->drawLine((int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int) GENERAL[_ana]->ROI[i]->posy, (int) (GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax/2), (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay), r, g, b, 2);
+                    _zw->drawLine((int) GENERAL[_ana]->ROI[i]->posx, (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), (int) GENERAL[_ana]->ROI[i]->posx + GENERAL[_ana]->ROI[i]->deltax, (int) (GENERAL[_ana]->ROI[i]->posy + GENERAL[_ana]->ROI[i]->deltay/2), r, g, b, 2);
+                }
+        }
+        else
+        {
+            for (int _dig = 0; _dig < GENERAL.size(); ++_dig)
+                for (int i = 0; i < GENERAL[_dig]->ROI.size(); ++i)
+                    _zw->drawRect(GENERAL[_dig]->ROI[i]->posx, GENERAL[_dig]->ROI[i]->posy, GENERAL[_dig]->ROI[i]->deltax, GENERAL[_dig]->ROI[i]->deltay, 0, 0, (255 - _dig*100), 2);
+        }
     }
 } 
 
+
 bool ClassFlowCNNGeneral::getNetworkParameter()
 {
     if (disabled)
@@ -546,11 +591,18 @@ bool ClassFlowCNNGeneral::getNetworkParameter()
     zwcnn = FormatFileName(zwcnn);
     ESP_LOGD(TAG, "%s", zwcnn.c_str());
     if (!tflite->LoadModel(zwcnn)) {
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't read model file " + cnnmodelfile);
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't load tflite model " + cnnmodelfile + " -> Init aborted!");
+        LogFile.WriteHeapInfo("getNetworkParameter-LoadModel");
         delete tflite;
         return false;
     } 
-    tflite->MakeAllocate();
+
+    if (!tflite->MakeAllocate()) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate tflite model -> Init aborted!");
+        LogFile.WriteHeapInfo("getNetworkParameter-MakeAllocate");
+        delete tflite;
+        return false;
+    }
 
     if (CNNType == AutoDetect)
     {
@@ -593,7 +645,7 @@ bool ClassFlowCNNGeneral::getNetworkParameter()
                 }
                 break;
             default:
-                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "tflite passt nicht zur Firmware (outout_dimension=" + std::to_string(_anzoutputdimensions) + ")");
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "tflite does not fit the firmware (outout_dimension=" + std::to_string(_anzoutputdimensions) + ")");
         }
     }
 
@@ -601,6 +653,7 @@ bool ClassFlowCNNGeneral::getNetworkParameter()
     return true;
 }
 
+
 bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
 {
     if (disabled)
@@ -612,13 +665,20 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
     string zwcnn = "/sdcard" + cnnmodelfile;
     zwcnn = FormatFileName(zwcnn);
     ESP_LOGD(TAG, "%s", zwcnn.c_str());
-    if (!tflite->LoadModel(zwcnn)) {
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't read model file " + cnnmodelfile);
 
+    if (!tflite->LoadModel(zwcnn)) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't load tflite model " + cnnmodelfile + " -> Exec aborted this round!");
+        LogFile.WriteHeapInfo("doNeuralNetwork-LoadModel");
         delete tflite;
         return false;
-    } 
-    tflite->MakeAllocate();
+    }
+
+    if (!tflite->MakeAllocate()) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate tfilte model -> Exec aborted this round!");
+        LogFile.WriteHeapInfo("doNeuralNetwork-MakeAllocate");
+        delete tflite;
+        return false;
+    }
 
     for (int n = 0; n < GENERAL.size(); ++n) // For each NUMBER
     {
@@ -637,7 +697,7 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
 
                         tflite->LoadInputImageBasis(GENERAL[n]->ROI[roi]->image);        
                         tflite->Invoke();
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Nach Invoke");
+                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "After Invoke");
 
                         f1 = tflite->GetOutputValue(0);
                         f2 = tflite->GetOutputValue(1);
@@ -648,7 +708,7 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
                         else
                             GENERAL[n]->ROI[roi]->result_float = result * 10;
                               
-                        ESP_LOGD(TAG, "Result General(Analog)%i - CCW: %d -  %f", roi, GENERAL[n]->ROI[roi]->CCW, GENERAL[n]->ROI[roi]->result_float);
+                        ESP_LOGD(TAG, "General result (Analog)%i - CCW: %d -  %f", roi, GENERAL[n]->ROI[roi]->CCW, GENERAL[n]->ROI[roi]->result_float);
                         if (isLogImage)
                             LogImage(logPath, GENERAL[n]->ROI[roi]->name, &GENERAL[n]->ROI[roi]->result_float, NULL, time, GENERAL[n]->ROI[roi]->image_org);
                     } break;
@@ -658,7 +718,7 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
                     {
                         GENERAL[n]->ROI[roi]->result_klasse = 0;
                         GENERAL[n]->ROI[roi]->result_klasse = tflite->GetClassFromImageBasis(GENERAL[n]->ROI[roi]->image);
-                        ESP_LOGD(TAG, "Result General(Digit)%i: %d", roi, GENERAL[n]->ROI[roi]->result_klasse);
+                        ESP_LOGD(TAG, "General result (Digit)%i: %d", roi, GENERAL[n]->ROI[roi]->result_klasse);
 
                         if (isLogImage)
                         {
@@ -674,85 +734,7 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
                             }
                         }
                     } break;
-/*
-                case DigitalHyprid:
-                    {
-                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "CNN Type: DigitalHyprid");
-                        int _num, _nachkomma;
 
-                        tflite->LoadInputImageBasis(GENERAL[_ana]->ROI[i]->image);        
-                        tflite->Invoke();
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Nach Invoke");
-
-                        _num = tflite->GetOutClassification(0, 10);
-                        _nachkomma = tflite->GetOutClassification(11, 21);
-
-
-                        string _zwres = "Nach Invoke - Nummer: " + to_string(_num) + " Nachkomma: " + to_string(_nachkomma);
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, _zwres);
-
-                        if ((_num == 10) || (_nachkomma == 10))                      // NaN detektiert
-                            GENERAL[_ana]->ROI[i]->result_float = -1;
-                        else
-                            GENERAL[_ana]->ROI[i]->result_float = fmod((double) _num + (((double)_nachkomma)-5)/10 + (double) 10, 10);
-
-                        ESP_LOGD(TAG, "Result General(DigitalHyprid)%i: %f\n", i, GENERAL[_ana]->ROI[i]->result_float);
-                        _zwres = "Result General(DigitalHyprid)" + to_string(i) + ": " + to_string(GENERAL[_ana]->ROI[i]->result_float);
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, _zwres);
-
-                        if (isLogImage)
-                        {
-                            string _imagename = GENERAL[_ana]->name +  "_" + GENERAL[_ana]->ROI[i]->name;
-                            if (isLogImageSelect)
-                            {
-                                if (LogImageSelect.find(GENERAL[_ana]->ROI[i]->name) != std::string::npos)
-                                    LogImage(logPath, _imagename, NULL, &GENERAL[_ana]->ROI[i]->result_klasse, time, GENERAL[_ana]->ROI[i]->image_org);
-                            }
-                            else
-                            {
-                                LogImage(logPath, _imagename, NULL, &GENERAL[_ana]->ROI[i]->result_klasse, time, GENERAL[_ana]->ROI[i]->image_org);
-                            }
-                        }
-                    } break;
-*/
-/*
-                case DigitalHyprid10:
-                    {
-                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "CNN Type: DigitalHyprid10");
-                        int _num, _nachkomma;
-
-                        tflite->LoadInputImageBasis(GENERAL[_ana]->ROI[i]->image);        
-                        tflite->Invoke();
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Nach Invoke");
-
-                        _num = tflite->GetOutClassification(0, 9);
-                        _nachkomma = tflite->GetOutClassification(10, 19);
-
-
-                        string _zwres = "Nach Invoke - Nummer: " + to_string(_num) + " Nachkomma: " + to_string(_nachkomma);
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, _zwres);
-
-                        GENERAL[_ana]->ROI[i]->result_float = fmod((double) _num + (((double)_nachkomma)-5)/10 + (double) 10, 10);
-
-                        ESP_LOGD(TAG, "Result General(DigitalHyprid)%i: %f\n", i, GENERAL[_ana]->ROI[i]->result_float);
-                        _zwres = "Result General(DigitalHyprid)" + to_string(i) + ": " + to_string(GENERAL[_ana]->ROI[i]->result_float);
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, _zwres);
-
-                        if (isLogImage)
-                        {
-                            string _imagename = GENERAL[_ana]->name +  "_" + GENERAL[_ana]->ROI[i]->name;
-                            if (isLogImageSelect)
-                            {
-                                if (LogImageSelect.find(GENERAL[_ana]->ROI[i]->name) != std::string::npos)
-                                    LogImage(logPath, _imagename, NULL, &GENERAL[_ana]->ROI[i]->result_klasse, time, GENERAL[_ana]->ROI[i]->image_org);
-                            }
-                            else
-                            {
-                                LogImage(logPath, _imagename, NULL, &GENERAL[_ana]->ROI[i]->result_klasse, time, GENERAL[_ana]->ROI[i]->image_org);
-                            }
-                        }
-                    } break;
-*/
 
                 case DoubleHyprid10:
                     {
@@ -764,7 +746,7 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
 
                         tflite->LoadInputImageBasis(GENERAL[n]->ROI[roi]->image);        
                         tflite->Invoke();
-                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Nach Invoke");
+                        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "After Invoke");
 
                         _num = tflite->GetOutClassification(0, 9);
                         _numplus = (_num + 1) % 10;
@@ -804,8 +786,8 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
                         {
                             GENERAL[n]->ROI[roi]->isReject = true;
                             result = -1;
-                            _result_save_file+= 100;     // Für den Fall, dass fit nicht ausreichend, soll trotzdem das Ergebnis mit "-10x.y" abgespeichert werden.
-                            string zw = "Value Rejected due to Threshold (Fit: " + to_string(_fit) + "Threshold: " + to_string(CNNGoodThreshold) + ")";
+                            _result_save_file+= 100;     // In case fit is not sufficient, the result should still be saved with "-10x.y".
+                            string zw = "Value Rejected due to Threshold (Fit: " + to_string(_fit) + ", Threshold: " + to_string(CNNGoodThreshold) + ")";
                             LogFile.WriteToFile(ESP_LOG_WARN, TAG, zw);
                         }
                         else
@@ -883,16 +865,15 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
     return true;
 }
 
+
 bool ClassFlowCNNGeneral::isExtendedResolution(int _number)
 {
-    if (!(CNNType == Digital))
-        return true;
-
-    return false;
+    if (CNNType == Digital)
+        return false;
+    return true;
 }
 
 
-
 std::vector<HTMLInfo*> ClassFlowCNNGeneral::GetHTMLInfo()
 {
     std::vector<HTMLInfo*> result;
@@ -904,20 +885,20 @@ std::vector<HTMLInfo*> ClassFlowCNNGeneral::GetHTMLInfo()
             if (GENERAL[_ana]->ROI[i]->image)
             {
                 if (GENERAL[_ana]->name == "default")
-                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->ROI[i]->name + ".bmp"));
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
                 else
-                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".bmp"));
+                    GENERAL[_ana]->ROI[i]->image->SaveToFile(FormatFileName("/sdcard/img_tmp/" + GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg"));
             }
 
             HTMLInfo *zw = new HTMLInfo;
             if (GENERAL[_ana]->name == "default")
             {
-                zw->filename = GENERAL[_ana]->ROI[i]->name + ".bmp";
+                zw->filename = GENERAL[_ana]->ROI[i]->name + ".jpg";
                 zw->filename_org = GENERAL[_ana]->ROI[i]->name + ".jpg";
             }
             else
             {
-                zw->filename = GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".bmp";
+                zw->filename = GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg";
                 zw->filename_org = GENERAL[_ana]->name + "_" + GENERAL[_ana]->ROI[i]->name + ".jpg";
             }
 
@@ -934,11 +915,13 @@ std::vector<HTMLInfo*> ClassFlowCNNGeneral::GetHTMLInfo()
     return result;
 }
 
-int ClassFlowCNNGeneral::getAnzahlGENERAL()
+
+int ClassFlowCNNGeneral::getNumberGENERAL()
 {
     return GENERAL.size();
 }
 
+
 string ClassFlowCNNGeneral::getNameGENERAL(int _analog)
 {
     if (_analog < GENERAL.size())
@@ -947,6 +930,7 @@ string ClassFlowCNNGeneral::getNameGENERAL(int _analog)
     return "GENERAL DOES NOT EXIST";
 }
 
+
 general* ClassFlowCNNGeneral::GetGENERAL(int _analog)
 {
     if (_analog < GENERAL.size())
@@ -956,7 +940,6 @@ general* ClassFlowCNNGeneral::GetGENERAL(int _analog)
 }
 
 
-
 void ClassFlowCNNGeneral::UpdateNameNumbers(std::vector<std::string> *_name_numbers)
 {
     for (int _dig = 0; _dig < GENERAL.size(); _dig++)
@@ -973,6 +956,7 @@ void ClassFlowCNNGeneral::UpdateNameNumbers(std::vector<std::string> *_name_numb
     }
 }
 
+
 string ClassFlowCNNGeneral::getReadoutRawString(int _analog) 
 {
     string rt = "";

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"
@@ -23,13 +25,15 @@ 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 DigitalUebergangsbereichVorgaenger = 0.7; // 9.3 - 0.7
-    float DigitalUebergangsbereichVorlauf = 9.7; // Vorlauf-Nulldurchgang passiert erst ab ca. 9.7
+
+	//moved to define.h
+    //float Analog_error = 3.0;
+    //float AnalogToDigtalFehler = 0.8;
+    //float Digital_Uncertainty = 0.2;
+    //int DigitalBand = 3;
+    //float Digital_Transition_Range_Predecessor = 2;
+    //float Digital_Transition_Area_Predecessor = 0.7; // 9.3 - 0.7
+    //float Digital_Transition_Area_Forward = 9.7; // Pre-run zero crossing only happens from approx. 9.7 onwards
 
     string cnnmodelfile;
     int modelxsize, modelysize, modelchannel;
@@ -39,9 +43,9 @@ protected:
 
     bool SaveAllFiles;   
 
-    int ZeigerEvalAnalogNeu(float zahl, int ziffer_vorgaenger);
-    int ZeigerEvalAnalogToDigitNeu(float zahl, float ziffer_vorgaenger,  int eval_vorgaenger, float analogDigitalTransitionStart);
-    int ZeigerEvalHybridNeu(float zahl, float zahl_vorgaenger, int eval_vorgaenger, bool AnalogerVorgaenger = false, float analogDigitalTransitionStart=9.2);
+    int PointerEvalAnalogNew(float zahl, int numeral_preceder);
+    int PointerEvalAnalogToDigitNew(float zahl, float numeral_preceder,  int eval_predecessors, float analogDigitalTransitionStart);
+    int PointerEvalHybridNew(float zahl, float number_of_predecessors, int eval_predecessors, bool Analog_Predecessors = false, float analogDigitalTransitionStart=9.2);
 
 
 
@@ -57,7 +61,7 @@ public:
     bool doFlow(string time);
 
     string getHTMLSingleStep(string host);
-    string getReadout(int _analog, bool _extendedResolution = false, int prev = -1, float _vorgaengerAnalog = -1, float analogDigitalTransitionStart=9.2); 
+    string getReadout(int _analog, bool _extendedResolution = false, int prev = -1, float _before_narrow_Analog = -1, float analogDigitalTransitionStart=9.2); 
 
     string getReadoutRawString(int _analog);  
 
@@ -65,7 +69,7 @@ public:
 
    	std::vector<HTMLInfo*> GetHTMLInfo();   
 
-    int getAnzahlGENERAL();
+    int getNumberGENERAL();
     general* GetGENERAL(int _analog);
     general* GetGENERAL(string _name, bool _create);
     general* FindGENERAL(string _name_number);    

code/components/jomjol_flowcontroll/ClassFlowControll.cpp

@@ -24,13 +24,13 @@ extern "C" {
     #include "server_mqtt.h"
 #endif //ENABLE_MQTT
 
-//#include "CImg.h"
-
 #include "server_help.h"
+#include "MainFlowControl.h"
+#include "../../include/defines.h"
 
-//#define DEBUG_DETAIL_ON  
+static const char* TAG = "FLOWCTRL";
 
-static const char* TAG = "CTRL";
+//#define DEBUG_DETAIL_ON
 
 
 std::string ClassFlowControll::doSingleStep(std::string _stepname, std::string _host){
@@ -39,8 +39,8 @@ std::string ClassFlowControll::doSingleStep(std::string _stepname, std::string _
 
     ESP_LOGD(TAG, "Step %s start", _stepname.c_str());
 
-    if ((_stepname.compare("[MakeImage]") == 0) || (_stepname.compare(";[MakeImage]") == 0)){
-        _classname = "ClassFlowMakeImage";
+    if ((_stepname.compare("[TakeImage]") == 0) || (_stepname.compare(";[TakeImage]") == 0)){
+        _classname = "ClassFlowTakeImage";
     }
     if ((_stepname.compare("[Alignment]") == 0) || (_stepname.compare(";[Alignment]") == 0)){
         _classname = "ClassFlowAlignment";
@@ -51,21 +51,24 @@ std::string ClassFlowControll::doSingleStep(std::string _stepname, std::string _
     if ((_stepname.compare("[Analog]") == 0) || (_stepname.compare(";[Analog]") == 0)){
         _classname = "ClassFlowCNNGeneral";
     }
-#ifdef ENABLE_MQTT
+    #ifdef ENABLE_MQTT
     if ((_stepname.compare("[MQTT]") == 0) || (_stepname.compare(";[MQTT]") == 0)){
         _classname = "ClassFlowMQTT";
     }
-#endif //ENABLE_MQTT
+    #endif //ENABLE_MQTT
 
-#ifdef ENABLE_INFLUXDB
+    #ifdef ENABLE_INFLUXDB
     if ((_stepname.compare("[InfluxDB]") == 0) || (_stepname.compare(";[InfluxDB]") == 0)){
         _classname = "ClassFlowInfluxDB";
     }
-#endif //ENABLE_INFLUXDB
+    if ((_stepname.compare("[InfluxDBv2]") == 0) || (_stepname.compare(";[InfluxDBv2]") == 0)){
+        _classname = "ClassFlowInfluxDBv2";
+    }
+    #endif //ENABLE_INFLUXDB
 
     for (int i = 0; i < FlowControll.size(); ++i)
         if (FlowControll[i]->name().compare(_classname) == 0){
-            if (!(FlowControll[i]->name().compare("ClassFlowMakeImage") == 0))      // falls es ein MakeImage ist, braucht das Bild nicht extra aufgenommen zu werden, dass passiert bei html-Abfrage automatisch
+            if (!(FlowControll[i]->name().compare("ClassFlowTakeImage") == 0))      // if it is a TakeImage, the image does not need to be included, this happens automatically with the html query.
                 FlowControll[i]->doFlow("");
             result = FlowControll[i]->getHTMLSingleStep(_host);
         }
@@ -78,24 +81,24 @@ std::string ClassFlowControll::doSingleStep(std::string _stepname, std::string _
 
 std::string ClassFlowControll::TranslateAktstatus(std::string _input)
 {
-    if (_input.compare("ClassFlowMakeImage") == 0)
+    if (_input.compare("ClassFlowTakeImage") == 0)
         return ("Take Image");
     if (_input.compare("ClassFlowAlignment") == 0)
         return ("Aligning");
     if (_input.compare("ClassFlowCNNGeneral") == 0)
         return ("Digitalization of ROIs");
-#ifdef ENABLE_MQTT
-    if (_input.compare("ClassFlowMQTT") == 0)
-        return ("Sending MQTT");
-#endif //ENABLE_MQTT
-#ifdef ENABLE_INFLUXDB
-    if (_input.compare("ClassFlowInfluxDB") == 0)
-        return ("Sending InfluxDB");
-#endif //ENABLE_INFLUXDB
+    #ifdef ENABLE_MQTT
+        if (_input.compare("ClassFlowMQTT") == 0)
+            return ("Sending MQTT");
+    #endif //ENABLE_MQTT
+    #ifdef ENABLE_INFLUXDB
+        if (_input.compare("ClassFlowInfluxDB") == 0)
+            return ("Sending InfluxDB");
+        if (_input.compare("ClassFlowInfluxDBv2") == 0)
+            return ("Sending InfluxDBv2");
+    #endif //ENABLE_INFLUXDB
     if (_input.compare("ClassFlowPostProcessing") == 0)
         return ("Post-Processing");
-    if (_input.compare("ClassFlowWriteList") == 0)
-        return ("Writing List");
 
     return "Unkown Status";
 }
@@ -113,6 +116,7 @@ std::vector<HTMLInfo*> ClassFlowControll::GetAllDigital()
     return empty;
 }
 
+
 std::vector<HTMLInfo*> ClassFlowControll::GetAllAnalog()
 {
     if (flowanalog)
@@ -122,6 +126,7 @@ std::vector<HTMLInfo*> ClassFlowControll::GetAllAnalog()
     return empty;
 }
 
+
 t_CNNType ClassFlowControll::GetTypeDigital()
 {
     if (flowdigit)
@@ -130,6 +135,7 @@ t_CNNType ClassFlowControll::GetTypeDigital()
     return t_CNNType::None;
 }
 
+
 t_CNNType ClassFlowControll::GetTypeAnalog()
 {
     if (flowanalog)
@@ -139,57 +145,73 @@ t_CNNType ClassFlowControll::GetTypeAnalog()
 }
 
 
-
-#ifdef ENABLE_MQTT
-string ClassFlowControll::GetMQTTMainTopic()
+#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+void ClassFlowControll::DigitalDrawROI(CImageBasis *_zw)
 {
-    for (int i = 0; i < FlowControll.size(); ++i)
-        if (FlowControll[i]->name().compare("ClassFlowMQTT") == 0)
-            return ((ClassFlowMQTT*) (FlowControll[i]))->GetMQTTMainTopic();
-
-    return "";
+    if (flowdigit)
+        flowdigit->DrawROI(_zw);
 }
 
-bool ClassFlowControll::StartMQTTService() {
+
+void ClassFlowControll::AnalogDrawROI(CImageBasis *_zw)
+{
+    if (flowanalog)
+        flowanalog->DrawROI(_zw);
+}
+#endif
+
+
+#ifdef ENABLE_MQTT
+bool ClassFlowControll::StartMQTTService() 
+{
     /* Start the MQTT service */
         for (int i = 0; i < FlowControll.size(); ++i) {
             if (FlowControll[i]->name().compare("ClassFlowMQTT") == 0) {
-                return ((ClassFlowMQTT*) (FlowControll[i]))->Start(AutoIntervall);
+                return ((ClassFlowMQTT*) (FlowControll[i]))->Start(AutoInterval);
             }  
         } 
     return false;
 }
 #endif //ENABLE_MQTT
 
+
 void ClassFlowControll::SetInitialParameter(void)
 {
     AutoStart = false;
     SetupModeActive = false;
-    AutoIntervall = 10; // Minutes
+    AutoInterval = 10; // Minutes
     flowdigit = NULL;
     flowanalog = NULL;
     flowpostprocessing = NULL;
     disabled = false;
     aktRunNr = 0;
-    aktstatus = "Booting ...";
+    aktstatus = "Flow task not yet created";
+    aktstatusWithTime = aktstatus;
 }
 
-bool ClassFlowControll::isAutoStart(long &_intervall)
+
+bool ClassFlowControll::getIsAutoStart(void)
 {
-    _intervall = AutoIntervall * 60 * 1000; // AutoIntervall: Minuten -> ms
     return AutoStart;
 }
 
+
+void ClassFlowControll::setAutoStartInterval(long &_interval)
+{
+    _interval = AutoInterval * 60 * 1000; // AutoInterval: minutes -> ms
+}
+
+
 ClassFlow* ClassFlowControll::CreateClassFlow(std::string _type)
 {
     ClassFlow* cfc = NULL;
 
     _type = trim(_type);
 
-    if (toUpper(_type).compare("[MAKEIMAGE]") == 0)
+    if (toUpper(_type).compare("[TAKEIMAGE]") == 0)
     {
-        cfc = new ClassFlowMakeImage(&FlowControll);
-        flowmakeimage = (ClassFlowMakeImage*) cfc;
+        cfc = new ClassFlowTakeImage(&FlowControll);
+        flowtakeimage = (ClassFlowTakeImage*) cfc;
     }
     if (toUpper(_type).compare("[ALIGNMENT]") == 0)
     {
@@ -206,16 +228,16 @@ ClassFlow* ClassFlowControll::CreateClassFlow(std::string _type)
         cfc = new ClassFlowCNNGeneral(flowalignment);
         flowdigit = (ClassFlowCNNGeneral*) cfc;
     }
-#ifdef ENABLE_MQTT
+    #ifdef ENABLE_MQTT
     if (toUpper(_type).compare("[MQTT]") == 0)
         cfc = new ClassFlowMQTT(&FlowControll);
-#endif //ENABLE_MQTT
-#ifdef ENABLE_INFLUXDB
+    #endif //ENABLE_MQTT
+    #ifdef ENABLE_INFLUXDB
     if (toUpper(_type).compare("[INFLUXDB]") == 0)
         cfc = new ClassFlowInfluxDB(&FlowControll);
-#endif //ENABLE_INFLUXDB        
-    if (toUpper(_type).compare("[WRITELIST]") == 0)
-        cfc = new ClassFlowWriteList(&FlowControll);
+    if (toUpper(_type).compare("[INFLUXDBV2]") == 0)
+        cfc = new ClassFlowInfluxDBv2(&FlowControll);
+    #endif //ENABLE_INFLUXDB  
 
     if (toUpper(_type).compare("[POSTPROCESSING]") == 0)
     {
@@ -223,7 +245,7 @@ ClassFlow* ClassFlowControll::CreateClassFlow(std::string _type)
         flowpostprocessing = (ClassFlowPostProcessing*) cfc;
     }
 
-    if (cfc)                            // Wird nur angehangen, falls es nicht [AutoTimer] ist, denn dieses ist für FlowControll
+    if (cfc)                            // Attached only if it is not [AutoTimer], because this is for FlowControll
         FlowControll.push_back(cfc);
 
     if (toUpper(_type).compare("[AUTOTIMER]") == 0)
@@ -241,16 +263,23 @@ ClassFlow* ClassFlowControll::CreateClassFlow(std::string _type)
     return cfc;
 }
 
+
 void ClassFlowControll::InitFlow(std::string config)
 {
-    string line;
+    aktstatus = "Initialization";
+    aktstatusWithTime = aktstatus;
 
+    //#ifdef ENABLE_MQTT
+        //MQTTPublish(mqttServer_getMainTopic() + "/" + "status", "Initialization", 1, false); // Right now, not possible -> MQTT Service is going to be started later
+    //#endif //ENABLE_MQTT
+    
+    string line;
     flowpostprocessing = NULL;
 
     ClassFlow* cfc;
     FILE* pFile;
     config = FormatFileName(config);
-    pFile = OpenFileAndWait(config.c_str(), "r");
+    pFile = fopen(config.c_str(), "r");
 
     line = "";
 
@@ -265,6 +294,7 @@ void ClassFlowControll::InitFlow(std::string config)
     while ((line.size() > 0) && !(feof(pFile)))
     {
         cfc = CreateClassFlow(line);
+//        printf("Name: %s\n", cfc->name().c_str());
         if (cfc)
         {
             ESP_LOGD(TAG, "Start ReadParameter (%s)", line.c_str());
@@ -282,73 +312,91 @@ void ClassFlowControll::InitFlow(std::string config)
     }
 
     fclose(pFile);
-
 }
 
-std::string* ClassFlowControll::getActStatus(){
+
+std::string* ClassFlowControll::getActStatusWithTime()
+{
+    return &aktstatusWithTime;
+}
+
+
+std::string* ClassFlowControll::getActStatus()
+{
     return &aktstatus;
 }
 
-void ClassFlowControll::doFlowMakeImageOnly(string time){
+
+void ClassFlowControll::setActStatus(std::string _aktstatus)
+{
+    aktstatus = _aktstatus;
+    aktstatusWithTime = aktstatus;
+}
+
+
+void ClassFlowControll::doFlowTakeImageOnly(string time)
+{
     std::string zw_time;
 
     for (int i = 0; i < FlowControll.size(); ++i)
     {
-        if (FlowControll[i]->name() == "ClassFlowMakeImage") {
-//            zw_time = gettimestring("%Y%m%d-%H%M%S");
-            zw_time = gettimestring("%H:%M:%S");
-            std::string flowStatus = TranslateAktstatus(FlowControll[i]->name());
-            aktstatus = flowStatus + " (" + zw_time + ")";
-#ifdef ENABLE_MQTT
-            MQTTPublish(mqttServer_getMainTopic() + "/" + "status", flowStatus, false);
-#endif //ENABLE_MQTT
+        if (FlowControll[i]->name() == "ClassFlowTakeImage") {
+            zw_time = getCurrentTimeString("%H:%M:%S");
+            aktstatus = TranslateAktstatus(FlowControll[i]->name());
+            aktstatusWithTime = aktstatus + " (" + zw_time + ")";
+            #ifdef ENABLE_MQTT
+                MQTTPublish(mqttServer_getMainTopic() + "/" + "status", aktstatus, 1, false);
+            #endif //ENABLE_MQTT
 
             FlowControll[i]->doFlow(time);
         }
     }
 }
 
+
 bool ClassFlowControll::doFlow(string time)
 {
-//    CleanTempFolder();            // dazu muss man noch eine Rolling einführen
-
     bool result = true;
     std::string zw_time;
     int repeat = 0;
+    int qos = 1;
 
-#ifdef DEBUG_DETAIL_ON 
-    LogFile.WriteHeapInfo("ClassFlowControll::doFlow - Start");
-#endif
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::doFlow - Start");
+    #endif
 
     /* Check if we have a valid date/time and if not restart the NTP client */
-    if (! getTimeIsSet()) {
+   /* if (! getTimeIsSet()) {
         LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Time not set, restarting NTP Client!");
         restartNtpClient();
-    }
+    }*/
+
+    //checkNtpStatus(0);
 
     for (int i = 0; i < FlowControll.size(); ++i)
     {
-        zw_time = gettimestring("%H:%M:%S");
-        std::string flowStatus = TranslateAktstatus(FlowControll[i]->name());
-        aktstatus = flowStatus + " (" + zw_time + ")";
-#ifdef ENABLE_MQTT
-        MQTTPublish(mqttServer_getMainTopic() + "/" + "status", flowStatus, false);
-#endif //ENABLE_MQTT
+        zw_time = getCurrentTimeString("%H:%M:%S");
+        aktstatus = TranslateAktstatus(FlowControll[i]->name());
+        aktstatusWithTime = aktstatus + " (" + zw_time + ")";
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Status: " + aktstatusWithTime);
+        #ifdef ENABLE_MQTT
+            MQTTPublish(mqttServer_getMainTopic() + "/" + "status", aktstatus, qos, false);
+        #endif //ENABLE_MQTT
 
-        string zw = "FlowControll.doFlow - " + FlowControll[i]->name();
-        #ifdef DEBUG_DETAIL_ON 
+        #ifdef DEBUG_DETAIL_ON
+            string zw = "FlowControll.doFlow - " + FlowControll[i]->name();
             LogFile.WriteHeapInfo(zw);
         #endif
 
         if (!FlowControll[i]->doFlow(time)){
             repeat++;
             LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Fehler im vorheriger Schritt - wird zum " + to_string(repeat) + ". Mal wiederholt");
-            if (i) i -= 1;    // vorheriger Schritt muss wiederholt werden (vermutlich Bilder aufnehmen)
+            if (i) i -= 1;    // vPrevious step must be repeated (probably take pictures)
             result = false;
             if (repeat > 5) {
                 LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Wiederholung 5x nicht erfolgreich --> reboot");
                 doReboot();
-                // Schritt wurde 5x wiederholt --> reboot
+                //Step was repeated 5x --> reboot
             }
         }
         else
@@ -356,17 +404,19 @@ bool ClassFlowControll::doFlow(string time)
             result = true;
         }
         
-#ifdef DEBUG_DETAIL_ON  
-        LogFile.WriteHeapInfo("ClassFlowControll::doFlow");
-#endif
-
+        #ifdef DEBUG_DETAIL_ON  
+            LogFile.WriteHeapInfo("ClassFlowControll::doFlow");
+        #endif
     }
-    zw_time = gettimestring("%H:%M:%S");
-    std::string flowStatus = "Flow finished";
-    aktstatus = flowStatus + " (" + zw_time + ")";
-#ifdef ENABLE_MQTT
-    MQTTPublish(mqttServer_getMainTopic() + "/" + "status", flowStatus, false);
-#endif //ENABLE_MQTT
+
+    zw_time = getCurrentTimeString("%H:%M:%S");
+    aktstatus = "Flow finished";
+    aktstatusWithTime = aktstatus + " (" + zw_time + ")";
+    //LogFile.WriteToFile(ESP_LOG_INFO, TAG, aktstatusWithTime);
+    #ifdef ENABLE_MQTT
+        MQTTPublish(mqttServer_getMainTopic() + "/" + "status", aktstatus, qos, false);
+    #endif //ENABLE_MQTT
+
     return result;
 }
 
@@ -413,10 +463,10 @@ string ClassFlowControll::getReadoutAll(int _type)
 }	
 
 
-string ClassFlowControll::getReadout(bool _rawvalue = false, bool _noerror = false)
+string ClassFlowControll::getReadout(bool _rawvalue = false, bool _noerror = false, int _number = 0)
 {
     if (flowpostprocessing)
-        return flowpostprocessing->getReadoutParam(_rawvalue, _noerror);
+        return flowpostprocessing->getReadoutParam(_rawvalue, _noerror, _number);
 
     string zw = "";
     string result = "";
@@ -436,6 +486,7 @@ string ClassFlowControll::getReadout(bool _rawvalue = false, bool _noerror = fal
     return result;
 }
 
+
 string ClassFlowControll::GetPrevalue(std::string _number)	
 {
     if (flowpostprocessing)
@@ -443,41 +494,46 @@ string ClassFlowControll::GetPrevalue(std::string _number)
         return flowpostprocessing->GetPreValue(_number);   
     }
 
+
     return std::string("");    
 }
 
-std::string ClassFlowControll::UpdatePrevalue(std::string _newvalue, std::string _numbers, bool _extern)
+
+bool ClassFlowControll::UpdatePrevalue(std::string _newvalue, std::string _numbers, bool _extern)
 {
-    float zw;
+    double newvalueAsDouble;
     char* p;
 
     _newvalue = trim(_newvalue);
-//    ESP_LOGD(TAG, "Input UpdatePreValue: %s", _newvalue.c_str());
+    //ESP_LOGD(TAG, "Input UpdatePreValue: %s", _newvalue.c_str());
 
-    if (_newvalue.compare("0.0") == 0)
-    {
-        zw = 0;
+    if (_newvalue.substr(0,8).compare("0.000000") == 0 || _newvalue.compare("0.0") == 0 || _newvalue.compare("0") == 0) {
+        newvalueAsDouble = 0;   // preset to value = 0
     }
-    else
-    {
-        zw = strtof(_newvalue.c_str(), &p);
-        if (zw == 0)
-            return "- Error in String to Value Conversion!!! Must be of format value=123.456";
+    else {
+        newvalueAsDouble = strtod(_newvalue.c_str(), &p);
+        if (newvalueAsDouble == 0) {
+            LogFile.WriteToFile(ESP_LOG_WARN, TAG, "UpdatePrevalue: No valid value for processing: " + _newvalue);
+            return false;
+        }
     }
     
-
-    if (flowpostprocessing)
-    {
-        flowpostprocessing->SetPreValue(zw, _numbers, _extern);
-        return _newvalue;    
+    if (flowpostprocessing) {
+        if (flowpostprocessing->SetPreValue(newvalueAsDouble, _numbers, _extern))
+            return true;
+        else
+            return false;
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "UpdatePrevalue: ERROR - Class Post-Processing not initialized");
+        return false;
     }
-
-    return std::string();
 }
 
+
 bool ClassFlowControll::ReadParameter(FILE* pfile, string& aktparamgraph)
 {
-    std::vector<string> zerlegt;
+    std::vector<string> splitted;
 
     aktparamgraph = trim(aktparamgraph);
 
@@ -487,28 +543,28 @@ bool ClassFlowControll::ReadParameter(FILE* pfile, string& aktparamgraph)
 
 
     if ((toUpper(aktparamgraph).compare("[AUTOTIMER]") != 0) && (toUpper(aktparamgraph).compare("[DEBUG]") != 0) &&
-        (toUpper(aktparamgraph).compare("[SYSTEM]") != 0 && (toUpper(aktparamgraph).compare("[DATALOGGING]") != 0)))      // Paragraph passt nicht zu MakeImage
+        (toUpper(aktparamgraph).compare("[SYSTEM]") != 0 && (toUpper(aktparamgraph).compare("[DATALOGGING]") != 0)))      // Paragraph passt nicht zu Debug oder DataLogging
         return false;
 
     while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
     {
-        zerlegt = ZerlegeZeile(aktparamgraph, " =");
-        if ((toUpper(zerlegt[0]) == "AUTOSTART") && (zerlegt.size() > 1))
+        splitted = ZerlegeZeile(aktparamgraph, " =");
+        if ((toUpper(splitted[0]) == "AUTOSTART") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
             {
                 AutoStart = true;
             }
         }
 
-        if ((toUpper(zerlegt[0]) == "INTERVALL") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "INTERVAL") && (splitted.size() > 1))
         {
-            AutoIntervall = std::stof(zerlegt[1]);
+            AutoInterval = std::stof(splitted[1]);
         }
 
-        if ((toUpper(zerlegt[0]) == "DATALOGACTIVE") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "DATALOGACTIVE") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
             {
                 LogFile.SetDataLogToSD(true);
             }
@@ -517,64 +573,72 @@ bool ClassFlowControll::ReadParameter(FILE* pfile, string& aktparamgraph)
             }
         }
 
-        if ((toUpper(zerlegt[0]) == "DATALOGRETENTIONINDAYS") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "DATAFILESRETENTION") && (splitted.size() > 1))
         {
-            LogFile.SetDataLogRetention(std::stoi(zerlegt[1]));
+            LogFile.SetDataLogRetention(std::stoi(splitted[1]));
         }
 
-        if ((toUpper(zerlegt[0]) == "LOGFILE") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "LOGLEVEL") && (splitted.size() > 1))
         {
             /* matches esp_log_level_t */
-            if ((toUpper(zerlegt[1]) == "TRUE") || (toUpper(zerlegt[1]) == "2"))
+            if ((toUpper(splitted[1]) == "TRUE") || (toUpper(splitted[1]) == "2"))
             {
                 LogFile.setLogLevel(ESP_LOG_WARN);
             }
-            else if ((toUpper(zerlegt[1]) == "FALSE") || (toUpper(zerlegt[1]) == "0") || (toUpper(zerlegt[1]) == "1"))
+            else if ((toUpper(splitted[1]) == "FALSE") || (toUpper(splitted[1]) == "0") || (toUpper(splitted[1]) == "1"))
             {
                 LogFile.setLogLevel(ESP_LOG_ERROR);
             }
-            else if (toUpper(zerlegt[1]) == "3")
+            else if (toUpper(splitted[1]) == "3")
             {
                 LogFile.setLogLevel(ESP_LOG_INFO);
             }
-            else if (toUpper(zerlegt[1]) == "4")
+            else if (toUpper(splitted[1]) == "4")
             {
                 LogFile.setLogLevel(ESP_LOG_DEBUG);
             }
+
+            /* If system reboot was not triggered by user and reboot was caused by execption -> keep log level to DEBUG */
+            if (!getIsPlannedReboot() && (esp_reset_reason() == ESP_RST_PANIC))
+                LogFile.setLogLevel(ESP_LOG_DEBUG);
         }
-        if ((toUpper(zerlegt[0]) == "LOGFILERETENTIONINDAYS") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "LOGFILESRETENTION") && (splitted.size() > 1))
         {
-            LogFile.SetLogFileRetention(std::stoi(zerlegt[1]));
+            LogFile.SetLogFileRetention(std::stoi(splitted[1]));
         }
 
-        if ((toUpper(zerlegt[0]) == "TIMEZONE") && (zerlegt.size() > 1))
+        /* TimeServer and TimeZone got already read from the config, see setupTime () */
+        
+        #if (defined WLAN_USE_ROAMING_BY_SCANNING || (defined WLAN_USE_MESH_ROAMING && defined WLAN_USE_MESH_ROAMING_ACTIVATE_CLIENT_TRIGGERED_QUERIES))
+        if ((toUpper(splitted[0]) == "RSSITHRESHOLD") && (splitted.size() > 1))
         {
-            string zw = "Set TimeZone: " + zerlegt[1];
-            setTimeZone(zerlegt[1]);
-        }      
-
-        if ((toUpper(zerlegt[0]) == "TIMESERVER") && (zerlegt.size() > 1))
-        {
-            string zw = "Set TimeZone: " + zerlegt[1];
-            reset_servername(zerlegt[1]);
-        }  
-
-        if ((toUpper(zerlegt[0]) == "HOSTNAME") && (zerlegt.size() > 1))
-        {
-            if (ChangeHostName("/sdcard/wlan.ini", zerlegt[1]))
+            int RSSIThresholdTMP = atoi(splitted[1].c_str());
+            RSSIThresholdTMP = min(0, max(-100, RSSIThresholdTMP)); // Verify input limits (-100 - 0)
+            
+            if (ChangeRSSIThreshold(WLAN_CONFIG_FILE, RSSIThresholdTMP))
             {
-                // reboot notwendig damit die neue wlan.ini auch benutzt wird !!!
+                // reboot necessary so that the new wlan.ini is also used !!!
                 fclose(pfile);
-                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Rebooting to activate new HOSTNAME...");
-                esp_restart();
-                hard_restart();                   
+                LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Rebooting to activate new RSSITHRESHOLD ...");
+                doReboot();
+            }
+        }
+        #endif
+
+        if ((toUpper(splitted[0]) == "HOSTNAME") && (splitted.size() > 1))
+        {
+            if (ChangeHostName(WLAN_CONFIG_FILE, splitted[1]))
+            {
+                // reboot necessary so that the new wlan.ini is also used !!!
+                fclose(pfile);
+                LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Rebooting to activate new HOSTNAME...");             
                 doReboot();
             }
         }
 
-        if ((toUpper(zerlegt[0]) == "SETUPMODE") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "SETUPMODE") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
             {
                 SetupModeActive = true;
             }        
@@ -617,7 +681,7 @@ int ClassFlowControll::CleanTempFolder() {
 
 esp_err_t ClassFlowControll::SendRawJPG(httpd_req_t *req)
 {
-    return flowmakeimage != NULL ? flowmakeimage->SendRawJPG(req) : ESP_FAIL;
+    return flowtakeimage != NULL ? flowtakeimage->SendRawJPG(req) : ESP_FAIL;
 }
 
 
@@ -625,90 +689,229 @@ esp_err_t ClassFlowControll::GetJPGStream(std::string _fn, httpd_req_t *req)
 {
     ESP_LOGD(TAG, "ClassFlowControll::GetJPGStream %s", _fn.c_str());
 
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::GetJPGStream - Start");
+    #endif
+
     CImageBasis *_send = NULL;
     esp_err_t result = ESP_FAIL;
-    bool Dodelete = false;    
+    bool _sendDelete = false;
 
-    if (flowalignment == NULL)
-    {
-        ESP_LOGD(TAG, "Can't continue, flowalignment is NULL");
-        return ESP_FAIL;
-    }
-
-    if (_fn == "alg.jpg")
-    {
-        _send = flowalignment->ImageBasis;  
-    }
-    else
-    {
-        if (_fn == "alg_roi.jpg")
-        {
-            CImageBasis* _imgzw = new CImageBasis(flowalignment->ImageBasis);
-            flowalignment->DrawRef(_imgzw);
-            if (flowdigit) flowdigit->DrawROI(_imgzw);
-            if (flowanalog) flowanalog->DrawROI(_imgzw);
-            _send = _imgzw;
-            Dodelete = true;
+    if (_fn == "alg.jpg") {
+        if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+            _send = flowalignment->ImageBasis;
         }
-        else
-        {
-            std::vector<HTMLInfo*> htmlinfo;
-            htmlinfo = GetAllDigital();
-            ESP_LOGD(TAG, "After getClassFlowControll::GetAllDigital");
-
-            for (int i = 0; i < htmlinfo.size(); ++i)
-            {
-                if (_fn == htmlinfo[i]->filename)
-                {
-                    if (htmlinfo[i]->image)
-                        _send = htmlinfo[i]->image;
-                }
-                if (_fn == htmlinfo[i]->filename_org)
-                {
-                    if (htmlinfo[i]->image_org)
-                        _send = htmlinfo[i]->image_org;        
-                }
-                delete htmlinfo[i];
-            }
-            htmlinfo.clear();
-
-            if (!_send)
-            {
-                htmlinfo = GetAllAnalog();
-                for (int i = 0; i < htmlinfo.size(); ++i)
-                {
-                    if (_fn == htmlinfo[i]->filename)
-                    {
-                        if (htmlinfo[i]->image)
-                            _send = htmlinfo[i]->image;
-                    }
-                    if (_fn == htmlinfo[i]->filename_org)
-                    {
-                        if (htmlinfo[i]->image_org)
-                            _send = htmlinfo[i]->image_org;        
-                    }
-                    delete htmlinfo[i];
-                }
-                htmlinfo.clear();
-
-            }
+        else {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: alg.jpg cannot be served");
+            return ESP_FAIL;
         }
     }
+    else if (_fn == "alg_roi.jpg") {
+        #ifdef ALGROI_LOAD_FROM_MEM_AS_JPG      // no CImageBasis needed to create alg_roi.jpg (ca. 790kB less RAM)
+            if (aktstatus.find("Initialization (delayed)") != -1) {
+                FILE* file = fopen("/sdcard/html/Flowstate_initialization_delayed.jpg", "rb"); 
+
+                if (!file) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_initialization_delayed.jpg not found");
+                    return ESP_FAIL;
+                }
+
+                fseek(file, 0, SEEK_END);
+                long fileSize = ftell(file); /* how long is the file ? */
+                fseek(file, 0, SEEK_SET); /* reset */
+
+                unsigned char* fileBuffer = (unsigned char*) malloc(fileSize);
+
+                if (!fileBuffer) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: Not enough memory to create fileBuffer: " + std::to_string(fileSize));
+                    fclose(file);  
+                    return ESP_FAIL;
+                }
+
+                fread(fileBuffer, fileSize, 1, file);
+                fclose(file);
+
+                httpd_resp_set_type(req, "image/jpeg");
+                result = httpd_resp_send(req, (const char *)fileBuffer, fileSize); 
+                free(fileBuffer);
+            }
+            else if (aktstatus.find("Initialization") != -1) {
+                FILE* file = fopen("/sdcard/html/Flowstate_initialization.jpg", "rb"); 
+
+                if (!file) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_initialization.jpg not found");
+                    return ESP_FAIL;
+                }
+
+                fseek(file, 0, SEEK_END);
+                long fileSize = ftell(file); /* how long is the file ? */
+                fseek(file, 0, SEEK_SET); /* reset */
+
+                unsigned char* fileBuffer = (unsigned char*) malloc(fileSize);
+
+                if (!fileBuffer) {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: Not enough memory to create fileBuffer: " + std::to_string(fileSize));
+                    fclose(file);  
+                    return ESP_FAIL;
+                }
+
+                fread(fileBuffer, fileSize, 1, file);
+                fclose(file);
+
+                httpd_resp_set_type(req, "image/jpeg");
+                result = httpd_resp_send(req, (const char *)fileBuffer, fileSize); 
+                free(fileBuffer);
+            }
+            else if (aktstatus.find("Take Image") != -1) {
+                if (flowalignment && flowalignment->AlgROI) {
+                    FILE* file = fopen("/sdcard/html/Flowstate_take_image.jpg", "rb");    
+
+                    if (!file) {
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_take_image.jpg not found");
+                        return ESP_FAIL;
+                    }
+
+                    fseek(file, 0, SEEK_END);
+                    flowalignment->AlgROI->size = ftell(file); /* how long is the file ? */
+                    fseek(file, 0, SEEK_SET); /* reset */
+                    
+                    if (flowalignment->AlgROI->size > MAX_JPG_SIZE) {
+                        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File /sdcard/html/Flowstate_take_image.jpg (" + std::to_string(flowalignment->AlgROI->size) +
+                                                                ") > allocated buffer (" + std::to_string(MAX_JPG_SIZE) + ")");
+                        fclose(file);
+                        return ESP_FAIL;
+                    }
+
+                    fread(flowalignment->AlgROI->data, flowalignment->AlgROI->size, 1, file);
+                    fclose(file);
+
+                    httpd_resp_set_type(req, "image/jpeg");
+                    result = httpd_resp_send(req, (const char *)flowalignment->AlgROI->data, flowalignment->AlgROI->size);
+                }
+                else {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: alg_roi.jpg cannot be served -> alg.jpg is going to be served!");
+                    if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+                        _send = flowalignment->ImageBasis;
+                    }
+                    else {
+                        httpd_resp_send(req, NULL, 0);
+                        return ESP_OK;
+                    }
+                }
+            }
+            else {
+                if (flowalignment && flowalignment->AlgROI) {
+                    httpd_resp_set_type(req, "image/jpeg");
+                    result = httpd_resp_send(req, (const char *)flowalignment->AlgROI->data, flowalignment->AlgROI->size);
+                }
+                else {
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ClassFlowControll::GetJPGStream: alg_roi.jpg cannot be served -> alg.jpg is going to be served!");
+                    if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+                        _send = flowalignment->ImageBasis;
+                    }
+                    else {
+                        httpd_resp_send(req, NULL, 0);
+                        return ESP_OK;
+                    }
+                }
+            }
+        #else
+            if (!flowalignment) {
+                ESP_LOGD(TAG, "ClassFloDControll::GetJPGStream: FlowAlignment is not (yet) initialized. Interrupt serving!");
+                httpd_resp_send(req, NULL, 0);
+                return ESP_FAIL;
+            }
+
+            _send = new CImageBasis("alg_roi", flowalignment->ImageBasis);
+			
+            if (_send->ImageOkay()) {
+                if (flowalignment) flowalignment->DrawRef(_send);
+                if (flowdigit) flowdigit->DrawROI(_send);
+                if (flowanalog) flowanalog->DrawROI(_send);
+                _sendDelete = true; // delete temporary _send element after sending
+            }
+            else {
+                LogFile.WriteToFile(ESP_LOG_WARN, TAG, "ClassFlowControll::GetJPGStream: Not enough memory to create alg_roi.jpg -> alg.jpg is going to be served!");
+                
+                if (flowalignment && flowalignment->ImageBasis->ImageOkay()) {
+                    _send = flowalignment->ImageBasis;
+                }
+                else {
+                    httpd_resp_send(req, NULL, 0);
+                    return ESP_OK;
+                }
+            }
+        #endif
+    }
+    else {
+        std::vector<HTMLInfo*> htmlinfo;
+    
+        htmlinfo = GetAllDigital();
+        ESP_LOGD(TAG, "After getClassFlowControll::GetAllDigital");
+
+        for (int i = 0; i < htmlinfo.size(); ++i)
+        {
+            if (_fn == htmlinfo[i]->filename)
+            {
+                if (htmlinfo[i]->image)
+                    _send = htmlinfo[i]->image;
+            }
+
+            if (_fn == htmlinfo[i]->filename_org)
+            {
+                if (htmlinfo[i]->image_org)
+                    _send = htmlinfo[i]->image_org;
+            }
+            delete htmlinfo[i];
+        }
+        htmlinfo.clear();
+
+        if (!_send)
+        {
+	        htmlinfo = GetAllAnalog();
+	        ESP_LOGD(TAG, "After getClassFlowControll::GetAllAnalog");
+	        
+	        for (int i = 0; i < htmlinfo.size(); ++i)
+	        {
+	            if (_fn == htmlinfo[i]->filename)
+	            {
+	                if (htmlinfo[i]->image)
+	                    _send = htmlinfo[i]->image;
+	            }
+
+	            if (_fn == htmlinfo[i]->filename_org)
+	            {
+	                if (htmlinfo[i]->image_org)
+	                    _send = htmlinfo[i]->image_org;
+	            }
+	            delete htmlinfo[i];
+	        }
+	        htmlinfo.clear();
+    	}
+    }
+
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::GetJPGStream - before send");
+    #endif
 
     if (_send)
     {
         ESP_LOGD(TAG, "Sending file: %s ...", _fn.c_str());
         set_content_type_from_file(req, _fn.c_str());
         result = _send->SendJPGtoHTTP(req);
-        ESP_LOGD(TAG, "File sending complete");    
         /* Respond with an empty chunk to signal HTTP response completion */
         httpd_resp_send_chunk(req, NULL, 0);
+        ESP_LOGD(TAG, "File sending complete");
+
+        if (_sendDelete)
+            delete _send;
+            
+        _send = NULL;  
     }
 
-    if (Dodelete) 
-    {
-        delete _send;
-    }
+    #ifdef DEBUG_DETAIL_ON 
+        LogFile.WriteHeapInfo("ClassFlowControll::GetJPGStream - done");
+    #endif
 
     return result;
 }
@@ -719,6 +922,7 @@ string ClassFlowControll::getNumbersName()
     return flowpostprocessing->getNumbersName();
 }
 
+
 string ClassFlowControll::getJSON()
 {
     return flowpostprocessing->GetJSON();

code/components/jomjol_flowcontroll/ClassFlowControll.h

@@ -1,12 +1,12 @@
+#pragma once
 
-
-#ifndef __FLOWCONTROLL__
-#define __FLOWCONTROLL__
+#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"
@@ -15,16 +15,9 @@
 #endif //ENABLE_MQTT
 #ifdef ENABLE_INFLUXDB
 	#include "ClassFlowInfluxDB.h"
+	#include "ClassFlowInfluxDBv2.h"
 #endif //ENABLE_INFLUXDB
 #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
@@ -36,51 +29,59 @@ 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();
 	string getNumbersName();
 
 	string TranslateAktstatus(std::string _input);
-#ifdef ENABLE_MQTT
-	string GetMQTTMainTopic();
-#endif //ENABLE_MQTT
+
+	#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
+	void DigitalDrawROI(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*> GetAllAnalog();	
 
 	t_CNNType GetTypeDigital();
 	t_CNNType GetTypeAnalog();
-#ifdef ENABLE_MQTT
+	
+	#ifdef ENABLE_MQTT
 	bool StartMQTTService();
-#endif //ENABLE_MQTT
+	#endif //ENABLE_MQTT
 
 	int CleanTempFolder();
 

code/components/jomjol_flowcontroll/ClassFlowDefineTypes.h

@@ -1,5 +1,7 @@
-#ifndef __CLASSFLOWIMAGE_CLASS__
-#define __CLASSFLOWIMAGE_CLASS__
+#pragma once
+
+#ifndef CLASSFLOWDEFINETYPES_H
+#define CLASSFLOWDEFINETYPES_H
 
 #include "ClassFlowImage.h"
 
@@ -32,23 +34,30 @@ struct NumberPost {
     bool AllowNegativeRates;
     bool checkDigitIncreaseConsistency;
     time_t lastvalue;
+    time_t timeStampTimeUTC;
     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
+    double FlowRateAct; // m3 / min
+    double PreValue; // last value that was read out well
+    double Value; // last value read out, incl. corrections
+    string ReturnRateValue; // return value rate
+    string ReturnChangeAbsolute; // return value rate
+    string ReturnRawValue; // Raw value (with N & leading 0)    
+    string ReturnValue; // corrected return value, if necessary with error message
+    string ReturnPreValue; // corrected return value without error message
+    string ErrorMessageText; // Error message for consistency check
     int AnzahlAnalog;
     int AnzahlDigital;
     int DecimalShift;
     int DecimalShiftInitial;
-    float AnalogDigitalTransitionStart; // Wann ist das digit > x.1, also wann fängt es an zu kippen
+    float AnalogDigitalTransitionStart; // When is the digit > x.1, i.e. when does it start to tilt?
     int Nachkomma;
 
+    string FieldV1; // Fieldname in InfluxDBv1  
+    string MeasurementV1;   // Measurement in InfluxDBv1
+
+    string FieldV2;         // Fieldname in InfluxDBv2  
+    string MeasurementV2;   // Measurement in InfluxDBv2
+
     bool isExtendedResolution;
 
     general *digit_roi;

code/components/jomjol_flowcontroll/ClassFlowImage.cpp

@@ -15,15 +15,17 @@ extern "C" {
 #include "ClassLogFile.h"
 #include "CImageBasis.h"
 #include "esp_log.h"
+#include "../../include/defines.h"
+
+static const char* TAG = "FLOWIMAGE";
 
-static const char* TAG = "IMG";
 
 ClassFlowImage::ClassFlowImage(const char* logTag)
 {
 	this->logTag = logTag;
 	isLogImage = false;
     disabled = false;
-    this->logfileRetentionInDays = 5;
+    this->imagesRetention = 5;
 }
 
 ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, const char* logTag) : ClassFlow(lfc)
@@ -31,7 +33,7 @@ ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, const char* logTag
 	this->logTag = logTag;
 	isLogImage = false;
     disabled = false;
-    this->logfileRetentionInDays = 5;
+    this->imagesRetention = 5;
 }
 
 ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, ClassFlow *_prev, const char* logTag) :  ClassFlow(lfc, _prev)
@@ -39,7 +41,7 @@ ClassFlowImage::ClassFlowImage(std::vector<ClassFlow*> * lfc, ClassFlow *_prev,
 	this->logTag = logTag;
 	isLogImage = false;
     disabled = false;
-    this->logfileRetentionInDays = 5;
+    this->imagesRetention = 5;
 }
 
 
@@ -47,7 +49,7 @@ 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) {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't create log folder for analog images. Path " + logPath);
@@ -94,7 +96,7 @@ void ClassFlowImage::RemoveOldLogs()
 		return;
 	
 	ESP_LOGD(TAG, "remove old images");
-    if (logfileRetentionInDays == 0) {
+    if (imagesRetention == 0) {
         return;
     }
 
@@ -103,17 +105,17 @@ void ClassFlowImage::RemoveOldLogs()
     char cmpfilename[30];
 
     time(&rawtime);
-    rawtime = addDays(rawtime, -logfileRetentionInDays + 1);
+    rawtime = addDays(rawtime, -1 * imagesRetention + 1);
     timeinfo = localtime(&rawtime);
-    //ESP_LOGD(TAG, "ImagefileRetentionInDays: %d", logfileRetentionInDays);
+    //ESP_LOGD(TAG, "ImagefileRetentionInDays: %d", imagesRetention);
     
     strftime(cmpfilename, 30, LOGFILE_TIME_FORMAT, timeinfo);
     //ESP_LOGD(TAG, "file name to compare: %s", cmpfilename);
 	string folderName = string(cmpfilename).LOGFILE_TIME_FORMAT_DATE_EXTR;
 
-    DIR *dir = opendir(LogImageLocation.c_str());
+    DIR *dir = opendir(imagesLocation.c_str());
     if (!dir) {
-        ESP_LOGE(TAG, "Failed to stat dir: %s", LogImageLocation.c_str());
+        ESP_LOGE(TAG, "Failed to stat dir: %s", imagesLocation.c_str());
         return;
     }
 
@@ -121,7 +123,7 @@ 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_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)) {

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

code/components/jomjol_flowcontroll/ClassFlowInfluxDB.cpp

@@ -9,16 +9,18 @@
 
 #include "ClassFlowPostProcessing.h"
 #include "esp_log.h"
+#include "../../include/defines.h"
+
+#include "ClassLogFile.h"
 
 #include <time.h>
 
-static const char* TAG = "class_flow_influxDb";
+static const char* TAG = "INFLUXDB";
 
 void ClassFlowInfluxDB::SetInitialParameter(void)
 {
     uri = "";
     database = "";
-    measurement = "";
 
     OldValue = "";
     flowpostprocessing = NULL;  
@@ -68,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);
 
@@ -82,58 +84,60 @@ bool ClassFlowInfluxDB::ReadParameter(FILE* pfile, string& aktparamgraph)
     while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
     {
         ESP_LOGD(TAG, "while loop reading line: %s", aktparamgraph.c_str());
-        zerlegt = ZerlegeZeile(aktparamgraph);
-        if ((toUpper(zerlegt[0]) == "USER") && (zerlegt.size() > 1))
+        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)) 
     { 
-        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());
-        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 {
-        ESP_LOGD(TAG, "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 = "";
 
@@ -143,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);
         }
     }
    
@@ -165,4 +178,50 @@ 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

code/components/jomjol_flowcontroll/ClassFlowInfluxDB.h

@@ -1,5 +1,10 @@
 #ifdef ENABLE_INFLUXDB
+
 #pragma once
+
+#ifndef CLASSFINFLUXDB_H
+#define CLASSFINFLUXDB_H
+
 #include "ClassFlow.h"
 
 #include "ClassFlowPostProcessing.h"
@@ -16,18 +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

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

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

code/components/jomjol_flowcontroll/ClassFlowMQTT.cpp

@@ -5,6 +5,7 @@
 #include "ClassFlowMQTT.h"
 #include "Helper.h"
 #include "connect_wlan.h"
+#include "read_wlanini.h"
 #include "ClassLogFile.h"
 
 #include "time_sntp.h"
@@ -15,14 +16,9 @@
 #include "server_mqtt.h"
 
 #include <time.h>
-
-
-#define __HIDE_PASSWORD
+#include "../../include/defines.h"
 
 static const char *TAG = "MQTT";
-#define LWT_TOPIC        "connection"
-#define LWT_CONNECTED    "connected"
-#define LWT_DISCONNECTED "connection lost"
 
 extern const char* libfive_git_version(void);
 extern const char* libfive_git_revision(void);
@@ -36,18 +32,21 @@ void ClassFlowMQTT::SetInitialParameter(void)
     topicError = "";
     topicRate = "";
     topicTimeStamp = "";
-    maintopic = hostname;
+    maintopic = wlan_config.hostname;
 
     topicUptime = "";
     topicFreeMem = "";
 
-    clientname = "AIOTED-" + getMac();
+    caCertFilename = "";
+    clientCertFilename = "";
+    clientKeyFilename = "";
+    clientname = wlan_config.hostname;
 
     OldValue = "";
     flowpostprocessing = NULL;  
     user = "";
     password = ""; 
-    SetRetainFlag = 0;
+    SetRetainFlag = false;
     previousElement = NULL;
     ListFlowControll = NULL; 
     disabled = false;
@@ -92,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);
 
@@ -100,77 +99,91 @@ 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 = 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(zerlegt[0]) == "HOMEASSISTANTDISCOVERY") && (zerlegt.size() > 1))
+        if ((toUpper(splitted[0]) == "HOMEASSISTANTDISCOVERY") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 SetHomeassistantDiscoveryEnabled(true);  
         }
-        if ((toUpper(zerlegt[0]) == "METERTYPE") && (zerlegt.size() > 1)) {
+        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(zerlegt[1]) == "WATER_M3") {
+            if (toUpper(splitted[1]) == "WATER_M3") {
                 mqttServer_setMeterType("water", "m³", "h", "m³/h");
             }
-            else if (toUpper(zerlegt[1]) == "WATER_L") {
+            else if (toUpper(splitted[1]) == "WATER_L") {
                 mqttServer_setMeterType("water", "L", "h", "L/h");
             }
-            else if (toUpper(zerlegt[1]) == "WATER_FT3") {
+            else if (toUpper(splitted[1]) == "WATER_FT3") {
                 mqttServer_setMeterType("water", "ft³", "m", "ft³/m"); // Minutes
             }
-            else if (toUpper(zerlegt[1]) == "WATER_GAL") {
+            else if (toUpper(splitted[1]) == "WATER_GAL") {
                 mqttServer_setMeterType("water", "gal", "h", "gal/h");
             }
-            else if (toUpper(zerlegt[1]) == "GAS_M3") {
+            else if (toUpper(splitted[1]) == "GAS_M3") {
                 mqttServer_setMeterType("gas", "m³", "h", "m³/h");
             }
-            else if (toUpper(zerlegt[1]) == "GAS_FT3") {
+            else if (toUpper(splitted[1]) == "GAS_FT3") {
                 mqttServer_setMeterType("gas", "ft³", "m", "ft³/m"); // Minutes
             }
-            else if (toUpper(zerlegt[1]) == "ENERGY_WH") {
+            else if (toUpper(splitted[1]) == "ENERGY_WH") {
                 mqttServer_setMeterType("energy", "Wh", "h", "W");
             }
-            else if (toUpper(zerlegt[1]) == "ENERGY_KWH") {
+            else if (toUpper(splitted[1]) == "ENERGY_KWH") {
                 mqttServer_setMeterType("energy", "kWh", "h", "kW");
             }
-            else if (toUpper(zerlegt[1]) == "ENERGY_MWH") {
+            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];
-            mqttServer_setMainTopic(maintopic);
+            maintopic = splitted[1];
         }
     }
 
@@ -179,19 +192,15 @@ bool ClassFlowMQTT::ReadParameter(FILE* pfile, string& aktparamgraph)
      * How ever we need the interval parameter from the ClassFlowControll, but that only gets started later.
      * To work around this, we delay the start and trigger it from ClassFlowControll::ReadParameter() */
 
+    mqttServer_setMainTopic(maintopic);
+
     return true;
 }
 
 
-string ClassFlowMQTT::GetMQTTMainTopic()
+bool ClassFlowMQTT::Start(float AutoInterval) 
 {
-    return maintopic;
-}
-
-
-bool ClassFlowMQTT::Start(float AutoIntervall) 
-{
-    roundInterval = AutoIntervall; // Minutes
+    roundInterval = AutoInterval; // Minutes
     keepAlive = roundInterval * 60 * 2.5; // Seconds, make sure it is greater thatn 2 rounds!
 
     std::stringstream stream;
@@ -202,7 +211,8 @@ bool ClassFlowMQTT::Start(float AutoIntervall)
     mqttServer_setParameter(flowpostprocessing->GetNumbers(), keepAlive, roundInterval);
 
     bool MQTTConfigCheck = MQTT_Configure(uri, clientname, user, password, maintopic, LWT_TOPIC, LWT_CONNECTED,
-                                     LWT_DISCONNECTED, keepAlive, SetRetainFlag, (void *)&GotConnected);
+                                     LWT_DISCONNECTED, caCertFilename, clientCertFilename, clientKeyFilename,
+                                     keepAlive, SetRetainFlag, (void *)&GotConnected);
 
     if (!MQTTConfigCheck) {
         return false;
@@ -214,6 +224,7 @@ bool ClassFlowMQTT::Start(float AutoIntervall)
 
 bool ClassFlowMQTT::doFlow(string zwtime)
 {
+    bool success;
     std::string result;
     std::string resulterror = "";
     std::string resultraw = "";
@@ -224,8 +235,12 @@ bool ClassFlowMQTT::doFlow(string zwtime)
     std::string resultchangabs = "";
     string zw = "";
     string namenumber = "";
+    int qos = 1;
 
-    publishSystemData();
+    /* Send the the Homeassistant Discovery and the Static Topics in case they where scheduled */
+    sendDiscovery_and_static_Topics();
+
+    success = publishSystemData(qos);
 
     if (flowpostprocessing && getMQTTisConnected())
     {
@@ -251,13 +266,13 @@ bool ClassFlowMQTT::doFlow(string zwtime)
 
 
             if (result.length() > 0)   
-                MQTTPublish(namenumber + "value", result, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "value", result, qos, SetRetainFlag);
 
             if (resulterror.length() > 0)  
-                MQTTPublish(namenumber + "error", resulterror, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "error", resulterror, qos, SetRetainFlag);
 
             if (resultrate.length() > 0) {
-                MQTTPublish(namenumber + "rate", resultrate, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "rate", resultrate, qos, SetRetainFlag);
                 
                 std::string resultRatePerTimeUnit;
                 if (getTimeUnit() == "h") { // Need conversion to be per hour
@@ -266,22 +281,22 @@ bool ClassFlowMQTT::doFlow(string zwtime)
                 else { // Keep per minute
                     resultRatePerTimeUnit = resultrate;
                 }
-                MQTTPublish(namenumber + "rate_per_time_unit", resultRatePerTimeUnit, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "rate_per_time_unit", resultRatePerTimeUnit, qos, SetRetainFlag);
             }
 
             if (resultchangabs.length() > 0) {
-                MQTTPublish(namenumber + "changeabsolut", resultchangabs, SetRetainFlag); // Legacy API
-                MQTTPublish(namenumber + "rate_per_digitalization_round", resultchangabs, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "changeabsolut", resultchangabs, qos, SetRetainFlag); // Legacy API
+                success |= MQTTPublish(namenumber + "rate_per_digitalization_round", resultchangabs, qos, SetRetainFlag);
             }
 
             if (resultraw.length() > 0)   
-                MQTTPublish(namenumber + "raw", resultraw, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "raw", resultraw, qos, SetRetainFlag);
 
             if (resulttimestamp.length() > 0)
-                MQTTPublish(namenumber + "timestamp", resulttimestamp, SetRetainFlag);
+                success |= MQTTPublish(namenumber + "timestamp", resulttimestamp, qos, SetRetainFlag);
 
             std::string json = flowpostprocessing->getJsonFromNumber(i, "\n");
-            MQTTPublish(namenumber + "json", json, SetRetainFlag);
+            success |= MQTTPublish(namenumber + "json", json, qos, SetRetainFlag);
         }
     }
     
@@ -299,10 +314,14 @@ bool ClassFlowMQTT::doFlow(string zwtime)
     //                 result = result + "\t" + zw;
     //         }
     //     }
-    //     MQTTPublish(topic, result, SetRetainFlag);
+    //     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;
 }

code/components/jomjol_flowcontroll/ClassFlowMQTT.h

@@ -1,5 +1,10 @@
 #ifdef ENABLE_MQTT
+
 #pragma once
+
+#ifndef CLASSFFLOWMQTT_H
+#define CLASSFFLOWMQTT_H
+
 #include "ClassFlow.h"
 
 #include "ClassFlowPostProcessing.h"
@@ -14,7 +19,8 @@ protected:
     std::string OldValue;
 	ClassFlowPostProcessing* flowpostprocessing;  
     std::string user, password; 
-    int SetRetainFlag;
+    std::string caCertFilename, clientCertFilename, clientKeyFilename; 
+    bool SetRetainFlag;
     int keepAlive; // Seconds
     float roundInterval; // Minutes
 
@@ -26,12 +32,11 @@ public:
     ClassFlowMQTT(std::vector<ClassFlow*>* lfc);
     ClassFlowMQTT(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
 
-    string GetMQTTMainTopic();
-    bool Start(float AutoIntervall);
+    bool Start(float AutoInterval);
 
     bool ReadParameter(FILE* pfile, string& aktparamgraph);
     bool doFlow(string time);
     string name(){return "ClassFlowMQTT";};
 };
-
+#endif //CLASSFFLOWMQTT_H
 #endif //ENABLE_MQTT

code/components/jomjol_flowcontroll/ClassFlowMakeImage.cpp

@@ -1,244 +0,0 @@
-#include "ClassFlowMakeImage.h"
-#include "Helper.h"
-#include "ClassLogFile.h"
-
-#include "CImageBasis.h"
-#include "ClassControllCamera.h"
-
-#include "esp_wifi.h"
-#include "esp_log.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;
-    /////////////////////////////////////////////////////////////////////////////////////
-    ESP_LOGD(TAG, "Flashdauer: %d", 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)
-{
-    LogImageLocation = "/log/source";
-    logfileRetentionInDays = 5;
-    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 = 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]) == "LOGFILERETENTIONINDAYS") && (zerlegt.size() > 1))
-        {
-            this->logfileRetentionInDays = std::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))
-    {
-//        ESP_LOGD(TAG, "Fixed Exposure enabled!");
-        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;
-}
-

code/components/jomjol_flowcontroll/ClassFlowPostProcessing.cpp

@@ -1,26 +1,21 @@
 #include "ClassFlowPostProcessing.h"
 #include "Helper.h"
-#include "ClassFlowMakeImage.h"
+#include "ClassFlowTakeImage.h"
 #include "ClassLogFile.h"
 
 #include <iomanip>
 #include <sstream>
+#include <cassert>
 
 #include <time.h>
 
 #include "time_sntp.h"
 
 #include "esp_log.h"
+#include "../../include/defines.h"
 
 static const char* TAG = "POSTPROC";
 
-//#define SERIAL_DEBUG // testing debug on serial enabled
-
-
-#define PREVALUE_TIME_FORMAT_OUTPUT "%Y-%m-%dT%H:%M:%S%z"
-#define PREVALUE_TIME_FORMAT_INPUT "%d-%d-%dT%d:%d:%d"
-
-
 std::string ClassFlowPostProcessing::getNumbersName()
 {
     std::string ret="";
@@ -102,39 +97,61 @@ string ClassFlowPostProcessing::GetPreValue(std::string _number)
     return result;
 }
 
-void ClassFlowPostProcessing::SetPreValue(double zw, string _numbers, bool _extern)
+
+bool ClassFlowPostProcessing::SetPreValue(double _newvalue, string _numbers, bool _extern)
 {
-    ESP_LOGD(TAG, "SetPrevalue: %f, %s", zw, _numbers.c_str());
-    for (int j = 0; j < NUMBERS.size(); ++j)
-    {
-//        ESP_LOGD(TAG, "Number %d, %s", j, NUMBERS[j]->name.c_str());
-        if (NUMBERS[j]->name == _numbers)
-        {
-            NUMBERS[j]->PreValue = zw;
-            NUMBERS[j]->ReturnPreValue = std::to_string(zw);
+    //ESP_LOGD(TAG, "SetPrevalue: %f, %s", zw, _numbers.c_str());
+
+    for (int j = 0; j < NUMBERS.size(); ++j) {
+        //ESP_LOGD(TAG, "Number %d, %s", j, NUMBERS[j]->name.c_str());
+        if (NUMBERS[j]->name == _numbers) {
+            if (_newvalue >= 0) {  // if new value posivive, use provided value to preset PreValue
+                NUMBERS[j]->PreValue = _newvalue;
+            }
+            else {          // if new value negative, use last raw value to preset PreValue
+                char* p;
+                double ReturnRawValueAsDouble = strtod(NUMBERS[j]->ReturnRawValue.c_str(), &p);
+                if (ReturnRawValueAsDouble == 0) {
+                    LogFile.WriteToFile(ESP_LOG_WARN, TAG, "SetPreValue: RawValue not a valid value for further processing: "
+                                                            + NUMBERS[j]->ReturnRawValue);
+                    return false;
+                }
+                NUMBERS[j]->PreValue = ReturnRawValueAsDouble;
+            }
+
+            NUMBERS[j]->ReturnPreValue = std::to_string(NUMBERS[j]->PreValue);
             NUMBERS[j]->PreValueOkay = true;
+
             if (_extern)
             {
                 time(&(NUMBERS[j]->lastvalue));
                 localtime(&(NUMBERS[j]->lastvalue));
             }
-//            ESP_LOGD(TAG, "Found %d! - set to %f", j,  NUMBERS[j]->PreValue);
+            //ESP_LOGD(TAG, "Found %d! - set to %.8f", j,  NUMBERS[j]->PreValue);
+            
+            UpdatePreValueINI = true;   // Only update prevalue file if a new value is set
+            SavePreValue();
+
+            LogFile.WriteToFile(ESP_LOG_INFO, TAG, "SetPreValue: PreValue for " + NUMBERS[j]->name + " set to " + 
+                                                     std::to_string(NUMBERS[j]->PreValue));
+            return true;
         }
     }
-    UpdatePreValueINI = true;
-    SavePreValue();
+    
+    LogFile.WriteToFile(ESP_LOG_WARN, TAG, "SetPreValue: Numbersname not found or not valid");
+    return false;   // No new value was set (e.g. wrong numbersname, no numbers at all)
 }
 
 
 bool ClassFlowPostProcessing::LoadPreValue(void)
 {
-    std::vector<string> zerlegt;
+    std::vector<string> splitted;
     FILE* pFile;
     char zw[1024];
     string zwtime, zwvalue, name;
     bool _done = false;
 
-    UpdatePreValueINI = false;       // Konvertierung ins neue Format
+    UpdatePreValueINI = false;       // Conversion to the new format
 
 
     pFile = fopen(FilePreValue.c_str(), "r");
@@ -147,21 +164,21 @@ bool ClassFlowPostProcessing::LoadPreValue(void)
     if (zwtime.length() == 0)
         return false;
 
-    zerlegt = HelperZerlegeZeile(zwtime, "\t");
-    if (zerlegt.size() > 1)     // neues Format
+    splitted = HelperZerlegeZeile(zwtime, "\t");
+    if (splitted.size() > 1)     //  Conversion to the new format
     {
-        while ((zerlegt.size() > 1) && !_done)
+        while ((splitted.size() > 1) && !_done)
         {
-            name = trim(zerlegt[0]);
-            zwtime = trim(zerlegt[1]);
-            zwvalue = trim(zerlegt[2]);
+            name = trim(splitted[0]);
+            zwtime = trim(splitted[1]);
+            zwvalue = trim(splitted[2]);
 
             for (int j = 0; j < NUMBERS.size(); ++j)
             {
                 if (NUMBERS[j]->name == name)
                 {
                     NUMBERS[j]->PreValue = stod(zwvalue.c_str());
-                    NUMBERS[j]->ReturnPreValue = RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma + 1);      // SIcherheitshalber 1 Stelle mehr, da ggf. Exgtended Resolution an ist (wird erst beim ersten Durchlauf gesetzt)
+                    NUMBERS[j]->ReturnPreValue = RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma + 1);      // To be on the safe side, 1 digit more, as Exgtended Resolution may be on (will only be set during the first run).
 
                     time_t tStart;
                     int yy, month, dd, hh, mm, ss;
@@ -194,18 +211,18 @@ bool ClassFlowPostProcessing::LoadPreValue(void)
             else
             {
                 ESP_LOGD(TAG, "Read line Prevalue.ini: %s", zw);
-                zerlegt = HelperZerlegeZeile(trim(std::string(zw)), "\t");
-                if (zerlegt.size() > 1)
+                splitted = HelperZerlegeZeile(trim(std::string(zw)), "\t");
+                if (splitted.size() > 1)
                 {
-                    name = trim(zerlegt[0]);
-                    zwtime = trim(zerlegt[1]);
-                    zwvalue = trim(zerlegt[2]);
+                    name = trim(splitted[0]);
+                    zwtime = trim(splitted[1]);
+                    zwvalue = trim(splitted[2]);
                 }
             }
         }
         fclose(pFile);
     }   
-    else        // altes Format
+    else        // Old Format
     {
         fgets(zw, 1024, pFile);
         fclose(pFile);
@@ -245,7 +262,7 @@ bool ClassFlowPostProcessing::LoadPreValue(void)
             NUMBERS[0]->ReturnValue = RundeOutput(NUMBERS[0]->Value, NUMBERS[0]->Nachkomma);
         }
 
-        UpdatePreValueINI = true;       // Konvertierung ins neue Format
+        UpdatePreValueINI = true;       // Conversion to the new format
         SavePreValue();
     } 
 
@@ -257,7 +274,7 @@ void ClassFlowPostProcessing::SavePreValue()
     FILE* pFile;
     string _zw;
 
-    if (!UpdatePreValueINI)         // PreValues unverändert --> File muss nicht neu geschrieben werden
+    if (!UpdatePreValueINI)         // PreValues unchanged --> File does not have to be rewritten
         return;
 
     pFile = fopen(FilePreValue.c_str(), "w");
@@ -268,10 +285,11 @@ void ClassFlowPostProcessing::SavePreValue()
         struct tm* timeinfo = localtime(&NUMBERS[j]->lastvalue);
         strftime(buffer, 80, PREVALUE_TIME_FORMAT_OUTPUT, timeinfo);
         NUMBERS[j]->timeStamp = std::string(buffer);
+        NUMBERS[j]->timeStampTimeUTC = NUMBERS[j]->lastvalue;
 //        ESP_LOGD(TAG, "SaverPreValue %d, Value: %f, Nachkomma %d", j, NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma);
 
         _zw = NUMBERS[j]->name + "\t" + NUMBERS[j]->timeStamp + "\t" + RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma) + "\n";
-        ESP_LOGD(TAG, "Write PreValue Zeile: %s", _zw.c_str());
+        ESP_LOGD(TAG, "Write PreValue line: %s", _zw.c_str());
         if (pFile) {
             fputs(_zw.c_str(), pFile);
         }
@@ -291,7 +309,7 @@ ClassFlowPostProcessing::ClassFlowPostProcessing(std::vector<ClassFlow*>* lfc, C
     ListFlowControll = NULL;
     FilePreValue = FormatFileName("/sdcard/config/prevalue.ini");
     ListFlowControll = lfc;
-    flowMakeImage = NULL;
+    flowTakeImage = NULL;
     UpdatePreValueINI = false;
     IgnoreLeadingNaN = false;
     flowAnalog = _analog;
@@ -299,9 +317,9 @@ ClassFlowPostProcessing::ClassFlowPostProcessing(std::vector<ClassFlow*>* lfc, C
 
     for (int i = 0; i < ListFlowControll->size(); ++i)
     {
-        if (((*ListFlowControll)[i])->name().compare("ClassFlowMakeImage") == 0)
+        if (((*ListFlowControll)[i])->name().compare("ClassFlowTakeImage") == 0)
         {
-            flowMakeImage = (ClassFlowMakeImage*) (*ListFlowControll)[i];
+            flowTakeImage = (ClassFlowTakeImage*) (*ListFlowControll)[i];
         }
     }
 }
@@ -323,7 +341,7 @@ void ClassFlowPostProcessing::handleDecimalExtendedResolution(string _decsep, st
         if (toUpper(_value) == "TRUE")
             _zwdc = true;
      
-        if (_digit == "default")                        // erstmal auf default setzen (falls sonst nichts gesetzt)
+        if (_digit == "default")                        // Set to default first (if nothing else is set)
         {
             NUMBERS[j]->isExtendedResolution = _zwdc;
         }
@@ -359,7 +377,7 @@ void ClassFlowPostProcessing::handleDecimalSeparator(string _decsep, string _val
             ESP_LOGD(TAG, "ERROR - Decimalshift is not a number: %s", _value.c_str());
         }
 */        
-        if (_digit == "default")                        // erstmal auf default setzen (falls sonst nichts gesetzt)
+        if (_digit == "default")                        //  Set to default first (if nothing else is set)
         {
             NUMBERS[j]->DecimalShift = _zwdc;
             NUMBERS[j]->DecimalShiftInitial = _zwdc;
@@ -391,7 +409,7 @@ void ClassFlowPostProcessing::handleAnalogDigitalTransitionStart(string _decsep,
         {
             _zwdc = stof(_value);
         }
-        if (_digit == "default" || NUMBERS[j]->name == _digit)  // erstmal auf default setzen (falls sonst nichts gesetzt)
+        if (_digit == "default" || NUMBERS[j]->name == _digit)  // Set to default first (if nothing else is set)
         {
             NUMBERS[j]->AnalogDigitalTransitionStart = _zwdc;
 
@@ -399,6 +417,36 @@ void ClassFlowPostProcessing::handleAnalogDigitalTransitionStart(string _decsep,
     }
 }
 
+void ClassFlowPostProcessing::handleAllowNegativeRate(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 < NUMBERS.size(); ++j)
+    {
+        bool _rt = false;
+
+        if (toUpper(_value) == "TRUE")
+            _rt = true;
+
+        if (_digit == "default")                        // Set to default first (if nothing else is set)
+        {
+            NUMBERS[j]->AllowNegativeRates = _rt;
+        }
+
+        if (NUMBERS[j]->name == _digit)
+        {
+            NUMBERS[j]->AllowNegativeRates = _rt;
+        }
+    }
+}
+
+
 
 void ClassFlowPostProcessing::handleMaxRateType(string _decsep, string _value)
 {
@@ -417,7 +465,7 @@ void ClassFlowPostProcessing::handleMaxRateType(string _decsep, string _value)
         if (toUpper(_value) == "RATECHANGE")
             _rt = RateChange;
 
-        if (_digit == "default")                        // erstmal auf default setzen (falls sonst nichts gesetzt)
+        if (_digit == "default")                        // Set to default first (if nothing else is set)
         {
             NUMBERS[j]->RateType = _rt;
         }
@@ -453,7 +501,7 @@ void ClassFlowPostProcessing::handleMaxRateValue(string _decsep, string _value)
             ESP_LOGD(TAG, "ERROR - MaxRateValue is not a number: %s", _value.c_str());
         }
 */
-        if (_digit == "default")                        // erstmal auf default setzen (falls sonst nichts gesetzt)
+        if (_digit == "default")                        //  Set to default first (if nothing else is set)
         {
             NUMBERS[j]->useMaxRateValue = true;
             NUMBERS[j]->MaxRateValue = _zwdc;
@@ -469,7 +517,7 @@ void ClassFlowPostProcessing::handleMaxRateValue(string _decsep, string _value)
 
 bool ClassFlowPostProcessing::ReadParameter(FILE* pfile, string& aktparamgraph)
 {
-    std::vector<string> zerlegt;
+    std::vector<string> splitted;
     int _n;
 
     aktparamgraph = trim(aktparamgraph);
@@ -479,7 +527,7 @@ bool ClassFlowPostProcessing::ReadParameter(FILE* pfile, string& aktparamgraph)
             return false;
 
 
-    if (aktparamgraph.compare("[PostProcessing]") != 0)       // Paragraph passt nich zu MakeImage
+    if (aktparamgraph.compare("[PostProcessing]") != 0)       // Paragraph does not fit PostProcessing
         return false;
 
     InitNUMBERS();
@@ -487,65 +535,68 @@ bool ClassFlowPostProcessing::ReadParameter(FILE* pfile, string& aktparamgraph)
 
     while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
     {
-        zerlegt = ZerlegeZeile(aktparamgraph);
-        std::string _param = GetParameterName(zerlegt[0]);
+        splitted = ZerlegeZeile(aktparamgraph);
+        std::string _param = GetParameterName(splitted[0]);
 
-        if ((toUpper(_param) == "EXTENDEDRESOLUTION") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "EXTENDEDRESOLUTION") && (splitted.size() > 1))
         {
-            handleDecimalExtendedResolution(zerlegt[0], zerlegt[1]);
+            handleDecimalExtendedResolution(splitted[0], splitted[1]);
         }
 
-        if ((toUpper(_param) == "DECIMALSHIFT") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "DECIMALSHIFT") && (splitted.size() > 1))
         {
-            handleDecimalSeparator(zerlegt[0], zerlegt[1]);
+            handleDecimalSeparator(splitted[0], splitted[1]);
         }
-        if ((toUpper(_param) == "ANALOGDIGITALTRANSITIONSTART") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "ANALOGDIGITALTRANSITIONSTART") && (splitted.size() > 1))
         {
-            handleAnalogDigitalTransitionStart(zerlegt[0], zerlegt[1]);
+            handleAnalogDigitalTransitionStart(splitted[0], splitted[1]);
         }
-        if ((toUpper(_param) == "MAXRATEVALUE") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "MAXRATEVALUE") && (splitted.size() > 1))
         {
-            handleMaxRateValue(zerlegt[0], zerlegt[1]);
+            handleMaxRateValue(splitted[0], splitted[1]);
         }
-        if ((toUpper(_param) == "MAXRATETYPE") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "MAXRATETYPE") && (splitted.size() > 1))
         {
-            handleMaxRateType(zerlegt[0], zerlegt[1]);
+            handleMaxRateType(splitted[0], splitted[1]);
         }
 
-        if ((toUpper(_param) == "PREVALUEUSE") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "PREVALUEUSE") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
             {
                 PreValueUse = true;
             }
         }
-        if ((toUpper(_param) == "CHECKDIGITINCREASECONSISTENCY") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "CHECKDIGITINCREASECONSISTENCY") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 for (_n = 0; _n < NUMBERS.size(); ++_n)
                     NUMBERS[_n]->checkDigitIncreaseConsistency = true;
         }        
-        if ((toUpper(_param) == "ALLOWNEGATIVERATES") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "ALLOWNEGATIVERATES") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            handleAllowNegativeRate(splitted[0], splitted[1]);
+/*          Updated to allow individual Settings
+            if (toUpper(splitted[1]) == "TRUE")
                 for (_n = 0; _n < NUMBERS.size(); ++_n)
                     NUMBERS[_n]->AllowNegativeRates = true;
+*/
         }
-        if ((toUpper(_param) == "ERRORMESSAGE") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "ERRORMESSAGE") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 ErrorMessage = true;
         }
-        if ((toUpper(_param) == "IGNORELEADINGNAN") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "IGNORELEADINGNAN") && (splitted.size() > 1))
         {
-            if (toUpper(zerlegt[1]) == "TRUE")
+            if (toUpper(splitted[1]) == "TRUE")
                 IgnoreLeadingNaN = true;
         }
 
         
-        if ((toUpper(_param) == "PREVALUEAGESTARTUP") && (zerlegt.size() > 1))
+        if ((toUpper(_param) == "PREVALUEAGESTARTUP") && (splitted.size() > 1))
         {
-            PreValueAgeStartup = std::stoi(zerlegt[1]);
+            PreValueAgeStartup = std::stoi(splitted[1]);
         }
     }
 
@@ -564,12 +615,12 @@ void ClassFlowPostProcessing::InitNUMBERS()
 
     if (flowDigit)
     {
-        anzDIGIT = flowDigit->getAnzahlGENERAL();
+        anzDIGIT = flowDigit->getNumberGENERAL();
         flowDigit->UpdateNameNumbers(&name_numbers);
     }
     if (flowAnalog)
     {
-        anzANALOG = flowAnalog->getAnzahlGENERAL();
+        anzANALOG = flowAnalog->getNumberGENERAL();
         flowAnalog->UpdateNameNumbers(&name_numbers);
     }
 
@@ -600,9 +651,9 @@ void ClassFlowPostProcessing::InitNUMBERS()
         else
             _number->AnzahlAnalog = 0;
 
-        _number->ReturnRawValue = "";      // Rohwert (mit N & führenden 0)    
-        _number->ReturnValue = "";         // korrigierter Rückgabewert, ggf. mit Fehlermeldung
-        _number->ErrorMessageText = "";        // Fehlermeldung bei Consistency Check
+        _number->ReturnRawValue = ""; // Raw value (with N & leading 0).    
+        _number->ReturnValue = ""; // corrected return value, possibly with error message
+        _number->ErrorMessageText = ""; // Error message for consistency check
         _number->ReturnPreValue = "";
         _number->PreValueOkay = false;
         _number->AllowNegativeRates = false;
@@ -616,12 +667,12 @@ void ClassFlowPostProcessing::InitNUMBERS()
         _number->AnalogDigitalTransitionStart=9.2;
 
 
-        _number->FlowRateAct = 0;          // m3 / min
-        _number->PreValue = 0;             // letzter Wert, der gut ausgelesen wurde
-        _number->Value = 0;                // letzer ausgelesener Wert, inkl. Korrekturen
-        _number->ReturnRawValue = "";      // Rohwert (mit N & führenden 0)    
-        _number->ReturnValue = "";         // korrigierter Rückgabewert, ggf. mit Fehlermeldung
-        _number->ErrorMessageText = "";        // Fehlermeldung bei Consistency Check
+        _number->FlowRateAct = 0; // m3 / min
+        _number->PreValue = 0; // last value read out well
+        _number->Value = 0; // last value read out, incl. corrections
+        _number->ReturnRawValue = ""; // raw value (with N & leading 0)    
+        _number->ReturnValue = ""; // corrected return value, possibly with error message
+        _number->ErrorMessageText = ""; // Error message for consistency check
 
         _number->Nachkomma = _number->AnzahlAnalog;
 
@@ -653,7 +704,7 @@ string ClassFlowPostProcessing::ShiftDecimal(string in, int _decShift){
     
     _pos_dec_neu = _pos_dec_org + _decShift;
 
-    if (_pos_dec_neu <= 0) {        // Komma ist vor der ersten Ziffer
+    if (_pos_dec_neu <= 0) {        // comma is before the first digit
         for (int i = 0; i > _pos_dec_neu; --i){
             in = in.insert(0, "0");
         }
@@ -661,7 +712,7 @@ string ClassFlowPostProcessing::ShiftDecimal(string in, int _decShift){
         return in;
     }
 
-    if (_pos_dec_neu > in.length()){    // Komma soll hinter String (123 --> 1230)
+    if (_pos_dec_neu > in.length()){    // Comma should be after string (123 --> 1230)
         for (int i = in.length(); i < _pos_dec_neu; ++i){
             in = in.insert(in.length(), "0");
         }  
@@ -676,6 +727,130 @@ string ClassFlowPostProcessing::ShiftDecimal(string in, int _decShift){
     return zw;
 }
 
+
+float wrapAround(float val)
+{
+    return fmod(val, 10.);
+}
+
+/**
+ * @brief Checks whether val is in the range [min, max]
+ *
+ * Note, this function also handles the wrap around case,
+ * in which min could be larger than max in case of
+ * a circular range
+ *
+ * @param val The value to be checked
+ * @param min Minimal bound of the range
+ * @param max Maximum bound of the range
+ * @return True, if val is in the range
+ */
+bool inRange(float val, float min, float max)
+{
+    assert(min >= 0. && min < 10.0);
+    assert(max >= 0. && max <= 10.0);
+    assert(val >= 0. && val < 10.0);
+
+    if (min <= max)
+    {
+        return min <= val && val <= max;
+    }
+    else
+    {
+        // e.g. between 8 and 2 (of the next round)
+        return (min <= val && val < 10.) || (0. <= val && val <= max);
+    }
+}
+
+/**
+ * @brief Synchronizes a potential misalignment between analog and digital part
+ *
+ * @param The current value assembled from digits (pre comma) and analogs (post comma)
+ * @param digitalPrecision   The post-comma value of the last digit ([0...9])
+ * @param analogDigitalShift The value of the 0.1 analog, when the digital precision == 5 in [0, 9.9]
+ *
+ * We define 3 phases:
+ *   - Pre transition: analog post comma < analogDigitalShift && not in transition
+ *   - Transition: Digital Precision in range 1...9
+ *   - Post transition: analog post comma > analogDigitalShift && not in transition
+ *
+ * @return The synchronized values as a string
+ */
+std::string syncDigitalAnalog(const std::string& value, const std::string& digitalPrecision,
+                              double analogDigitalShift)
+{
+    if (digitalPrecision.empty())
+    {
+        return value;
+    }
+
+    const auto pos = value.find('.');
+    if (pos == std::string::npos)
+    {
+        return value;
+    }
+
+    // disassemble value into pre and post comma part
+    const auto preComma = value.substr(0, pos);
+
+    // memorize, to be able to assemble right numbers of leading zeros
+    const size_t nPreComma = preComma.size();
+    const auto postComma = value.substr(pos+1);
+
+    const float digitalPostComma = std::atof(digitalPrecision.c_str());
+    int         digitalPreComma = std::atoi(preComma.c_str());
+    const float analogPostComma = std::atof(("0." + postComma).c_str());
+
+    // Determine phase
+    const bool inTransition = digitalPostComma > 0. && digitalPostComma < 10.;
+    const bool postTransition = !inTransition && inRange(analogPostComma*10., analogDigitalShift, wrapAround(analogDigitalShift + 5.));
+    const bool preTransition = !inTransition && inRange(analogPostComma*10., 0, analogDigitalShift);
+
+
+    if (inRange(analogDigitalShift, 0.5, 5.))
+    {
+        // late transition, last digit starts transition, when analog is between [0.5, 5)
+        if (inTransition || preTransition)
+        {
+            ESP_LOGD("syncDigitalAnalog", "Late digital transition. Increase digital value by 1.");
+            digitalPreComma += 1;
+        }
+    }
+    else if (inRange(analogDigitalShift, 5., 9.5))
+    {
+        // early transition
+        if (postTransition && analogPostComma*10 > analogDigitalShift)
+        {
+            ESP_LOGD("syncDigitalAnalog", "Early digital transition. Decrease digital value by 1.");
+            digitalPreComma -= 1;
+        }
+
+        // transition has not finished, but we are already at the new cycle
+        // this also should handle hanging digits
+        if (inTransition && analogPostComma < 0.5) {
+            digitalPreComma += 1;
+        }
+    }
+    else
+    {
+        return value;
+    }
+
+    // assemble result into string again, pad with zeros
+    auto preCommaNew = std::to_string(digitalPreComma);
+    for (size_t i = preCommaNew.size(); i < nPreComma; ++i)
+        preCommaNew = "0" + preCommaNew;
+
+    const std::string result = preCommaNew + "." + postComma;
+
+#if debugSync
+    ESP_LOGD("syncDigitalAnalog", "result: %s", result.c_str());
+#endif
+
+    return result;
+
+}
+
 bool ClassFlowPostProcessing::doFlow(string zwtime)
 {
     string result = "";
@@ -686,9 +861,9 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
     time_t imagetime = 0;
     string rohwert;
 
-    // Update Nachkomma, da sich beim Wechsel von CNNType Auto --> xyz auch die Nachkommastellen ändern können:
+    // Update decimal point, as the decimal places can also change when changing from CNNType Auto --> xyz:
 
-    imagetime = flowMakeImage->getTimeImageTaken();
+    imagetime = flowTakeImage->getTimeImageTaken();
     if (imagetime == 0)
         time(&imagetime);
 
@@ -698,7 +873,7 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
     strftime(strftime_buf, sizeof(strftime_buf), "%Y-%m-%dT%H:%M:%S", timeinfo);
     zwtime = std::string(strftime_buf);
 
-    ESP_LOGD(TAG, "Anzahl NUMBERS: %d", NUMBERS.size());
+    ESP_LOGD(TAG, "Quantity NUMBERS: %d", NUMBERS.size());
 
     for (int j = 0; j < NUMBERS.size(); ++j)
     {
@@ -707,13 +882,20 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
         NUMBERS[j]->ReturnValue = "";
         NUMBERS[j]->ErrorMessageText = "";
         NUMBERS[j]->Value = -1;
-        /* TODO to be discussed, see https://github.com/jomjol/AI-on-the-edge-device/issues/1617 */
-//        NUMBERS[j]->lastvalue = imagetime;    // must only be set in case of good value !!! --> move to the end
+
+        /* calculate time difference BEFORE we overwrite the 'lastvalue' */
+        double difference = difftime(imagetime, NUMBERS[j]->lastvalue);      // in seconds
+
+        /* TODO:
+         * We could call `NUMBERS[j]->lastvalue = imagetime;` here and remove all other such calls further down.
+         * But we should check nothing breaks! */
 
         UpdateNachkommaDecimalShift();
 
         int previous_value = -1;
 
+        // ------------------- start processing analog values --------------------------//
+
         if (NUMBERS[j]->analog_roi)
         {
             NUMBERS[j]->ReturnRawValue = flowAnalog->getReadout(j, NUMBERS[j]->isExtendedResolution); 
@@ -727,19 +909,38 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
         #ifdef SERIAL_DEBUG
             ESP_LOGD(TAG, "After analog->getReadout: ReturnRaw %s", NUMBERS[j]->ReturnRawValue.c_str());
         #endif
-        if (NUMBERS[j]->digit_roi && NUMBERS[j]->analog_roi)
-            NUMBERS[j]->ReturnRawValue = "." + NUMBERS[j]->ReturnRawValue;
 
-        if (NUMBERS[j]->digit_roi)
+        // ----------------- start processing digital values --------------------------//
+
+        // we need the precision of the digital values to determine transition phase
+        std::string digitalPrecision = {"0"};
+        if (NUMBERS[j]->digit_roi && NUMBERS[j]->analog_roi) {
+            // we have nachkommad and vorkomman part!
+
+            std::string analogValues = NUMBERS[j]->ReturnRawValue;
+            std::string digitValues =  flowDigit->getReadout(j, true, previous_value, NUMBERS[j]->analog_roi->ROI[0]->result_float, 0.);
+
+            if (flowDigit->getCNNType() != Digital)
+            {
+                // The digital type does not provide an extended resolution, so we cannot extract it
+                digitalPrecision = digitValues.substr(digitValues.size() - 1);
+                digitValues = digitValues.substr(0, digitValues.size() - 1);
+            }
+
+            NUMBERS[j]->ReturnRawValue = digitValues + "." + analogValues;
+        }
+
+
+        if (NUMBERS[j]->digit_roi && !NUMBERS[j]->analog_roi)
         {
-            if (NUMBERS[j]->analog_roi) 
-                NUMBERS[j]->ReturnRawValue = flowDigit->getReadout(j, false, previous_value, NUMBERS[j]->analog_roi->ROI[0]->result_float, NUMBERS[j]->AnalogDigitalTransitionStart) + NUMBERS[j]->ReturnRawValue;
-            else
-                NUMBERS[j]->ReturnRawValue = flowDigit->getReadout(j, NUMBERS[j]->isExtendedResolution, previous_value);        // Extended Resolution nur falls es keine analogen Ziffern gibt
+            NUMBERS[j]->ReturnRawValue = flowDigit->getReadout(j, NUMBERS[j]->isExtendedResolution, previous_value);        // Extended Resolution only if there are no analogue digits
         }
         #ifdef SERIAL_DEBUG
             ESP_LOGD(TAG, "After digital->getReadout: ReturnRaw %s", NUMBERS[j]->ReturnRawValue.c_str());
         #endif
+
+        //  ------------------ start corrections --------------------------//
+
         NUMBERS[j]->ReturnRawValue = ShiftDecimal(NUMBERS[j]->ReturnRawValue, NUMBERS[j]->DecimalShift);
 
         #ifdef SERIAL_DEBUG
@@ -759,7 +960,7 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
         {
             if (PreValueUse && NUMBERS[j]->PreValueOkay)
             {
-                NUMBERS[j]->ReturnValue = ErsetzteN(NUMBERS[j]->ReturnValue, NUMBERS[j]->PreValue); 
+                NUMBERS[j]->ReturnValue = ErsetzteN(NUMBERS[j]->ReturnValue, NUMBERS[j]->PreValue);
             }
             else
             {
@@ -769,13 +970,20 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
                 NUMBERS[j]->lastvalue = imagetime;
 
                 WriteDataLog(j);
-                continue; // es gibt keinen Zahl, da noch ein N vorhanden ist.
+                continue; // there is no number because there is still an N.
             }
         }
+
+        if (NUMBERS[j]->digit_roi && NUMBERS[j]->analog_roi)
+        {
+            // Synchronize potential misalignment between analog and digital part
+            NUMBERS[j]->ReturnValue = syncDigitalAnalog(NUMBERS[j]->ReturnValue, digitalPrecision, NUMBERS[j]->AnalogDigitalTransitionStart);
+        }
+
         #ifdef SERIAL_DEBUG
             ESP_LOGD(TAG, "After findDelimiterPos: ReturnValue %s", NUMBERS[j]->ReturnRawValue.c_str());
         #endif
-        // Lösche führende Nullen (außer es ist nur noch einen 0)
+        // Delete leading zeros (unless there is only one 0 left)
         while ((NUMBERS[j]->ReturnValue.length() > 1) && (NUMBERS[j]->ReturnValue[0] == '0'))
             NUMBERS[j]->ReturnValue.erase(0, 1);
         #ifdef SERIAL_DEBUG
@@ -806,38 +1014,45 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
         #ifdef SERIAL_DEBUG
             ESP_LOGD(TAG, "After checkDigitIncreaseConsistency: Value %f", NUMBERS[j]->Value);
         #endif
-               
 
         if (!NUMBERS[j]->AllowNegativeRates)
         {
+            LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "handleAllowNegativeRate for device: " + NUMBERS[j]->name);
             if ((NUMBERS[j]->Value < NUMBERS[j]->PreValue))
             {
-                #ifdef SERIAL_DEBUG
-                    ESP_LOGD(TAG, "Neg: value=%f, preValue=%f, preToll%f", NUMBERS[j]->Value, NUMBERS[j]->PreValue,
-                     NUMBERS[j]->PreValue-(2/pow(10, NUMBERS[j]->Nachkomma))
-                      ) ;
-                #endif
-                // Bei isExtendedResolution Ungenauigkeit von 0.2 mit einrechnen.
-                if (NUMBERS[j]->Value >= (NUMBERS[j]->PreValue-(2/pow(10, NUMBERS[j]->Nachkomma))) && NUMBERS[j]->isExtendedResolution) {
-                    NUMBERS[j]->Value = NUMBERS[j]->PreValue;
-                    NUMBERS[j]->ReturnValue = to_string(NUMBERS[j]->PreValue);
-                } else {
+                // more debug if extended resolution is on, see #2447
+                if (NUMBERS[j]->isExtendedResolution) {
+                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Neg: value=" + std::to_string(NUMBERS[j]->Value) 
+                                                    + ", preValue=" + std::to_string(NUMBERS[j]->PreValue) 
+                                                    + ", preToll=" + std::to_string(NUMBERS[j]->PreValue-(2/pow(10, NUMBERS[j]->Nachkomma))));
+                } 
+
+                    // Include inaccuracy of 0.2 for isExtendedResolution.
+                if ((NUMBERS[j]->Value >= (NUMBERS[j]->PreValue-(2/pow(10, NUMBERS[j]->Nachkomma))) && NUMBERS[j]->isExtendedResolution)
+                    // not extended resolution allows -1 on the lowest digit  
+                   || (NUMBERS[j]->Value >= (NUMBERS[j]->PreValue-(1/pow(10, NUMBERS[j]->Nachkomma))) && !NUMBERS[j]->isExtendedResolution)) {
+                        NUMBERS[j]->Value = NUMBERS[j]->PreValue;
+                        NUMBERS[j]->ReturnValue = to_string(NUMBERS[j]->PreValue);
+                } 
+                else {
                     NUMBERS[j]->ErrorMessageText = NUMBERS[j]->ErrorMessageText + "Neg. Rate - Read: " + zwvalue + " - Raw: " + NUMBERS[j]->ReturnRawValue + " - Pre: " + RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma) + " "; 
                     NUMBERS[j]->Value = NUMBERS[j]->PreValue;
                     NUMBERS[j]->ReturnValue = "";
+                    NUMBERS[j]->lastvalue = imagetime;
 
                     string _zw = NUMBERS[j]->name + ": Raw: " + NUMBERS[j]->ReturnRawValue + ", Value: " + NUMBERS[j]->ReturnValue + ", Status: " + NUMBERS[j]->ErrorMessageText;
-                    LogFile.WriteToFile(ESP_LOG_INFO, TAG, _zw);
+                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, _zw);
                     WriteDataLog(j);
                     continue;
                 }
                 
             }
         }
+
         #ifdef SERIAL_DEBUG
             ESP_LOGD(TAG, "After AllowNegativeRates: Value %f", NUMBERS[j]->Value);
         #endif
-        double difference = difftime(imagetime, NUMBERS[j]->lastvalue);      // in Sekunden
+
         difference /= 60;  
         NUMBERS[j]->FlowRateAct = (NUMBERS[j]->Value - NUMBERS[j]->PreValue) / difference;
         NUMBERS[j]->ReturnRateValue =  to_string(NUMBERS[j]->FlowRateAct);
@@ -852,29 +1067,28 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
 
             if (abs(_ratedifference) > abs(NUMBERS[j]->MaxRateValue))
             {
-                WriteDataLog(j);
-
                 NUMBERS[j]->ErrorMessageText = NUMBERS[j]->ErrorMessageText + "Rate too high - Read: " + RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->Nachkomma) + " - Pre: " + RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma) + " - Rate: " + RundeOutput(_ratedifference, NUMBERS[j]->Nachkomma);
                 NUMBERS[j]->Value = NUMBERS[j]->PreValue;
                 NUMBERS[j]->ReturnValue = "";
                 NUMBERS[j]->ReturnRateValue = "";
+                NUMBERS[j]->lastvalue = imagetime;
 
                 string _zw = NUMBERS[j]->name + ": Raw: " + NUMBERS[j]->ReturnRawValue + ", Value: " + NUMBERS[j]->ReturnValue + ", Status: " + NUMBERS[j]->ErrorMessageText;
-                LogFile.WriteToFile(ESP_LOG_INFO, TAG, _zw);
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, _zw);
                 WriteDataLog(j);
                 continue;
             }
         }
+
         #ifdef SERIAL_DEBUG
            ESP_LOGD(TAG, "After MaxRateCheck: Value %f", NUMBERS[j]->Value);
         #endif
+        
         NUMBERS[j]->ReturnChangeAbsolute = RundeOutput(NUMBERS[j]->Value - NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma);
         NUMBERS[j]->PreValue = NUMBERS[j]->Value;
         NUMBERS[j]->PreValueOkay = true;
         NUMBERS[j]->lastvalue = imagetime;
 
-
-
         NUMBERS[j]->ReturnValue = RundeOutput(NUMBERS[j]->Value, NUMBERS[j]->Nachkomma);
         NUMBERS[j]->ReturnPreValue = RundeOutput(NUMBERS[j]->PreValue, NUMBERS[j]->Nachkomma);
 
@@ -882,7 +1096,6 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
         UpdatePreValueINI = true;
 
         string _zw = NUMBERS[j]->name + ": Raw: " + NUMBERS[j]->ReturnRawValue + ", Value: " + NUMBERS[j]->ReturnValue + ", Status: " + NUMBERS[j]->ErrorMessageText;
-        ESP_LOGD(TAG, "%s", zw.c_str());
         LogFile.WriteToFile(ESP_LOG_INFO, TAG, _zw);
         WriteDataLog(j);
     }
@@ -922,22 +1135,22 @@ void ClassFlowPostProcessing::UpdateNachkommaDecimalShift()
 {
     for (int j = 0; j < NUMBERS.size(); ++j)
     {
-        if (NUMBERS[j]->digit_roi && !NUMBERS[j]->analog_roi)            // es gibt nur digitale ziffern
+        if (NUMBERS[j]->digit_roi && !NUMBERS[j]->analog_roi)            // There are only digital digits
         {
 //            ESP_LOGD(TAG, "Nurdigital");
             NUMBERS[j]->DecimalShift = NUMBERS[j]->DecimalShiftInitial;
 
-            if (NUMBERS[j]->isExtendedResolution && flowDigit->isExtendedResolution())  // extended resolution ist an und soll auch bei dieser Ziffer verwendet werden
+            if (NUMBERS[j]->isExtendedResolution && flowDigit->isExtendedResolution())  // Extended resolution is on and should also be used for this digit.
                 NUMBERS[j]->DecimalShift = NUMBERS[j]->DecimalShift-1;
 
             NUMBERS[j]->Nachkomma = -NUMBERS[j]->DecimalShift;
         }
 
-        if (!NUMBERS[j]->digit_roi && NUMBERS[j]->analog_roi)            // es gibt nur analoge ziffern
+        if (!NUMBERS[j]->digit_roi && NUMBERS[j]->analog_roi)
         {
 //            ESP_LOGD(TAG, "Nur analog");
             NUMBERS[j]->DecimalShift = NUMBERS[j]->DecimalShiftInitial;
-            if (NUMBERS[j]->isExtendedResolution && flowAnalog->isExtendedResolution())  // extended resolution ist an und soll auch bei dieser Ziffer verwendet werden
+            if (NUMBERS[j]->isExtendedResolution && flowAnalog->isExtendedResolution()) 
                 NUMBERS[j]->DecimalShift = NUMBERS[j]->DecimalShift-1;
 
             NUMBERS[j]->Nachkomma = -NUMBERS[j]->DecimalShift;
@@ -950,7 +1163,7 @@ void ClassFlowPostProcessing::UpdateNachkommaDecimalShift()
             NUMBERS[j]->DecimalShift = NUMBERS[j]->DecimalShiftInitial;
             NUMBERS[j]->Nachkomma = NUMBERS[j]->analog_roi->ROI.size() - NUMBERS[j]->DecimalShift;
 
-            if (NUMBERS[j]->isExtendedResolution && flowAnalog->isExtendedResolution())  // extended resolution ist an und soll auch bei dieser Ziffer verwendet werden
+            if (NUMBERS[j]->isExtendedResolution && flowAnalog->isExtendedResolution())  // Extended resolution is on and should also be used for this digit.
                 NUMBERS[j]->Nachkomma = NUMBERS[j]->Nachkomma+1;
 
         }
@@ -1014,7 +1227,7 @@ float ClassFlowPostProcessing::checkDigitConsistency(double input, int _decilams
     bool no_nulldurchgang = false;
 
     pot = _decilamshift;
-    if (!_isanalog)             // falls es keine analogwerte gibt, kann die letzte nicht bewertet werden
+    if (!_isanalog)             // if there are no analogue values, the last one cannot be evaluated
     {
         pot++;
     }
@@ -1040,14 +1253,14 @@ float ClassFlowPostProcessing::checkDigitConsistency(double input, int _decilams
         {
             if (aktdigit != olddigit) 
             {
-                input = input + ((float) (olddigit - aktdigit)) * pow(10, pot);     // Neue Digit wird durch alte Digit ersetzt;
+                input = input + ((float) (olddigit - aktdigit)) * pow(10, pot);     // New Digit is replaced by old Digit;
             }
         }
         else
         {
-            if (aktdigit == olddigit)                   // trotz Nulldurchgang wurde Stelle nicht hochgezählt --> addiere 1
+            if (aktdigit == olddigit)                   // despite zero crossing, digit was not incremented --> add 1
             {
-                input = input + ((float) (1)) * pow(10, pot);   // addiere 1 an der Stelle
+                input = input + ((float) (1)) * pow(10, pot);   // add 1 at the point
             }
         }
         #ifdef SERIAL_DEBUG

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,12 +15,11 @@ 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;
@@ -27,7 +28,7 @@ protected:
 
     string FilePreValue;
 
-    ClassFlowMakeImage *flowMakeImage;
+    ClassFlowTakeImage *flowTakeImage;
 
     bool LoadPreValue(void);
     string ShiftDecimal(string in, int _decShift);
@@ -41,6 +42,8 @@ protected:
     void handleDecimalExtendedResolution(string _decsep, string _value); 
     void handleMaxRateType(string _decsep, string _value);
     void handleAnalogDigitalTransitionStart(string _decsep, string _value);
+    void handleAllowNegativeRate(string _decsep, string _value);
+    
     std::string GetStringReadouts(general);
 
     void WriteDataLog(int _index);
@@ -50,6 +53,8 @@ protected:
 
 public:
     bool PreValueUse;
+    std::vector<NumberPost*> NUMBERS;
+
 
     ClassFlowPostProcessing(std::vector<ClassFlow*>* lfc, ClassFlowCNNGeneral *_analog, ClassFlowCNNGeneral *_digit);
     virtual ~ClassFlowPostProcessing(){};
@@ -63,7 +68,7 @@ public:
     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 _lineend = "\n");
     std::string getNumbersName();
@@ -76,4 +81,4 @@ public:
 };
 
 
-#endif
+#endif //CLASSFFLOWPOSTPROCESSING_H

code/components/jomjol_flowcontroll/ClassFlowTakeImage.cpp

@@ -0,0 +1,260 @@
+#include "ClassFlowTakeImage.h"
+#include "Helper.h"
+#include "ClassLogFile.h"
+
+#include "CImageBasis.h"
+#include "ClassControllCamera.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(){
+    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 = image_width;          
+    rawImage->height = image_height;
+    /////////////////////////////////////////////////////////////////////////////////////
+    ESP_LOGD(TAG, "flash_duration: %d", flash_duration);
+    Camera.CaptureToBasisImage(rawImage, flash_duration);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    if (SaveAllFiles) rawImage->SaveToFile(namerawimage);
+}
+
+void ClassFlowTakeImage::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";
+}     
+
+
+ClassFlowTakeImage::ClassFlowTakeImage(std::vector<ClassFlow*>* lfc) : ClassFlowImage(lfc, TAG)
+{
+    imagesLocation = "/log/source";
+    imagesRetention = 5;
+    SetInitialParameter();
+}
+
+
+bool ClassFlowTakeImage::ReadParameter(FILE* pfile, string& aktparamgraph)
+{
+    std::vector<string> splitted;
+
+    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("[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;
+        }
+        if ((toUpper(splitted[0]) == "IMAGEQUALITY") && (splitted.size() > 1))
+            ImageQuality = std::stod(splitted[1]);
+
+        if ((toUpper(splitted[0]) == "IMAGESIZE") && (splitted.size() > 1))
+        {
+            ImageSize = Camera.TextToFramesize(splitted[1].c_str());
+            isImageSize = true;
+        }
+
+        if ((toUpper(splitted[0]) == "SAVEALLFILES") && (splitted.size() > 1))
+        {
+            if (toUpper(splitted[1]) == "TRUE")
+                SaveAllFiles = true;
+        }
+        
+        if ((toUpper(splitted[0]) == "WAITBEFORETAKINGPICTURE") && (splitted.size() > 1))
+        {
+            waitbeforepicture = stoi(splitted[1]);
+        }
+
+        if ((toUpper(splitted[0]) == "RAWIMAGESRETENTION") && (splitted.size() > 1))
+        {
+            this->imagesRetention = std::stoi(splitted[1]);
+        }
+
+        if ((toUpper(splitted[0]) == "BRIGHTNESS") && (splitted.size() > 1))
+        {
+            _brightness = stoi(splitted[1]);
+        }
+
+        if ((toUpper(splitted[0]) == "CONTRAST") && (splitted.size() > 1))
+        {
+            _contrast = stoi(splitted[1]);
+        }
+
+        if ((toUpper(splitted[0]) == "SATURATION") && (splitted.size() > 1))
+        {
+            _saturation = stoi(splitted[1]);
+        }
+
+        if ((toUpper(splitted[0]) == "FIXEDEXPOSURE") && (splitted.size() > 1))
+        {
+            if (toUpper(splitted[1]) == "TRUE")
+                FixedExposure = true;  
+        }
+
+        if ((toUpper(splitted[0]) == "LEDINTENSITY") && (splitted.size() > 1))
+        {
+            float ledintensity = stof(splitted[1]);
+            ledintensity = min((float) 100, ledintensity);
+            ledintensity = max((float) 0, ledintensity);
+            Camera.SetLEDIntensity(ledintensity);
+        }
+
+        if ((toUpper(splitted[0]) == "DEMO") && (splitted.size() > 1))
+        {
+            if (toUpper(splitted[1]) == "TRUE")
+                Camera.useDemoMode();
+        }
+    }
+
+    Camera.SetBrightnessContrastSaturation(_brightness, _contrast, _saturation);
+    Camera.SetQualitySize(ImageQuality, ImageSize);
+
+    image_width = Camera.image_width;
+    image_height = Camera.image_height;
+    rawImage = new CImageBasis("rawImage");
+    rawImage->CreateEmptyImage(image_width, image_height, 3);
+
+    waitbeforepicture_store = waitbeforepicture;
+    if (FixedExposure && (waitbeforepicture > 0))
+    {
+//        ESP_LOGD(TAG, "Fixed Exposure enabled!");
+        int flash_duration = (int) (waitbeforepicture * 1000);
+        Camera.EnableAutoExposure(flash_duration);
+        waitbeforepicture = 0.2;
+//        flash_duration = (int) (waitbeforepicture * 1000);
+//        takePictureWithFlash(flash_duration);
+//        rawImage->SaveToFile("/sdcard/init2.jpg");
+    }
+
+    return true;
+}
+
+
+string ClassFlowTakeImage::getHTMLSingleStep(string host)
+{
+    string result;
+    result = "Raw Image: <br>\n<img src=\"" + host + "/img_tmp/raw.jpg\">\n";
+    return result;
+}
+
+
+bool ClassFlowTakeImage::doFlow(string zwtime)
+{
+    psram_init_shared_memory_for_take_image_step();
+
+    string logPath = CreateLogFolder(zwtime);
+
+    int flash_duration = (int) (waitbeforepicture * 1000);
+ 
+    #ifdef DEBUG_DETAIL_ON  
+        LogFile.WriteHeapInfo("ClassFlowTakeImage::doFlow - Before takePictureWithFlash");
+    #endif
+
+
+    #ifdef WIFITURNOFF
+        esp_wifi_stop();        // to save power usage and 
+    #endif
+
+    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) (waitbeforepicture * 1000);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    return Camera.CaptureToHTTP(req, flash_duration);
+}
+
+
+ImageData* ClassFlowTakeImage::SendRawImage()
+{
+    CImageBasis *zw = new CImageBasis("SendRawImage", rawImage);
+    ImageData *id;
+    int flash_duration = (int) (waitbeforepicture * 1000);
+    Camera.CaptureToBasisImage(zw, flash_duration);
+    time(&TimeImageTaken);
+    localtime(&TimeImageTaken);
+
+    id = zw->writeToMemoryAsJPG();    
+    delete zw;
+    return id;  
+}
+
+time_t ClassFlowTakeImage::getTimeImageTaken()
+{
+    return TimeImageTaken;
+}
+
+ClassFlowTakeImage::~ClassFlowTakeImage(void)
+{
+    delete rawImage;
+}
+

code/components/jomjol_flowcontroll/ClassFlowTakeImage.h

@@ -1,16 +1,15 @@
 #pragma once
+
+#ifndef CLASSFFLOWTAKEIMAGE_H
+#define CLASSFFLOWTAKEIMAGE_H
+
 #include "ClassFlowImage.h"
 #include "ClassControllCamera.h"
+#include "../../include/defines.h"
 
 #include <string>
 
-#define BLINK_GPIO GPIO_NUM_4
-
-#define CAMERA_MODEL_AI_THINKER
-
-
-
-class ClassFlowMakeImage :
+class ClassFlowTakeImage :
     public ClassFlowImage
 {
 protected:
@@ -30,7 +29,7 @@ protected:
     void CopyFile(string input, string output);
 
     esp_err_t camera_capture();
-    void takePictureWithFlash(int flashdauer);
+    void takePictureWithFlash(int flash_duration);
 
 
     void SetInitialParameter(void);       
@@ -38,18 +37,19 @@ protected:
 public:
     CImageBasis *rawImage;
 
-    ClassFlowMakeImage(std::vector<ClassFlow*>* lfc);
+    ClassFlowTakeImage(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";};
+    string name(){return "ClassFlowTakeImage";};
 
     ImageData* SendRawImage();
     esp_err_t SendRawJPG(httpd_req_t *req);
 
-    ~ClassFlowMakeImage(void);
+    ~ClassFlowTakeImage(void);
 };
 
 
+#endif //CLASSFFLOWTAKEIMAGE_H

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 = 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;
-}

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";};
-};
-

code/components/jomjol_flowcontroll/MainFlowControl.h

@@ -0,0 +1,34 @@
+#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"
+
+extern ClassFlowControll flowctrl;
+
+
+void register_server_main_flow_task_uri(httpd_handle_t server);
+
+void CheckIsPlannedReboot();
+bool getIsPlannedReboot();
+
+void InitializeFlowTask();
+void DeleteMainFlowTask();
+bool isSetupModusActive();
+
+int getCountFlowRounds();
+
+#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

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

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 fatfs sdmmc)
+                    REQUIRES esp_timer esp-tflite-micro jomjol_logfile fatfs sdmmc vfs)
 
 

code/components/jomjol_helper/Helper.cpp

@@ -23,70 +23,77 @@ extern "C" {
 
 #include <string.h>
 #include <esp_log.h>
-
+#include <esp_mac.h>
+#include <esp_timer.h>
+#include "../../include/defines.h"
 
 #include "ClassLogFile.h"
 
 #include "esp_vfs_fat.h"
+#include "../sdmmc_common.h"
 
 static const char* TAG = "HELPER";
 
-//#define ISWINDOWS_TRUE
-#define PATH_MAX_STRING_SIZE 256
-
 using namespace std;
 
 unsigned int systemStatus = 0;
 
 sdmmc_cid_t SDCardCid;
 sdmmc_csd_t SDCardCsd;
+bool SDCardIsMMC;
+
+// #define DEBUG_DETAIL_ON 
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 string getESPHeapInfo(){
 	string espInfoResultStr = "";
 	char aMsgBuf[80];
-    
-	multi_heap_info_t aMultiHead_info ;
-	heap_caps_get_info (&aMultiHead_info,MALLOC_CAP_8BIT);
-	size_t aFreeHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT);
-	size_t aMinFreeHeadSize =  heap_caps_get_minimum_free_size(MALLOC_CAP_8BIT);
-	size_t aMinFreeHeapSize =  heap_caps_get_minimum_free_size(MALLOC_CAP_8BIT);
-	size_t aHeapLargestFreeBlockSize = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
-	sprintf(aMsgBuf," Free Heap Size: %ld", (long) aFreeHeapSize);
-	size_t aFreeSPIHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT| MALLOC_CAP_SPIRAM);
- 	size_t aFreeInternalHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT| MALLOC_CAP_INTERNAL);
-	 size_t aMinFreeInternalHeapSize =  heap_caps_get_minimum_free_size(MALLOC_CAP_8BIT| MALLOC_CAP_INTERNAL);
 
-	sprintf(aMsgBuf," Heap: %ld", (long) aFreeHeapSize);
+	size_t aFreeHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT);
+
+	size_t aFreeSPIHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
+	size_t aFreeInternalHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
+
+	size_t aHeapLargestFreeBlockSize = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
+	size_t aHeapIntLargestFreeBlockSize = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
+
+	size_t aMinFreeHeapSize =  heap_caps_get_minimum_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
+	size_t aMinFreeInternalHeapSize =  heap_caps_get_minimum_free_size(MALLOC_CAP_8BIT | MALLOC_CAP_INTERNAL);
+
+
+	sprintf(aMsgBuf,"Heap Total: %ld", (long) aFreeHeapSize);
 	espInfoResultStr += string(aMsgBuf);
-	sprintf(aMsgBuf," Min Free: %ld", (long) aMinFreeHeapSize);
+
+	sprintf(aMsgBuf," | SPI Free: %ld", (long) aFreeSPIHeapSize);
 	espInfoResultStr += string(aMsgBuf);
-	sprintf(aMsgBuf," larg. Block:  %ld", (long) aHeapLargestFreeBlockSize);
+	sprintf(aMsgBuf," | SPI Large Block:  %ld", (long) aHeapLargestFreeBlockSize);
 	espInfoResultStr += string(aMsgBuf);
-	sprintf(aMsgBuf," SPI Heap: %ld", (long) aFreeSPIHeapSize);
+	sprintf(aMsgBuf," | SPI Min Free: %ld", (long) aMinFreeHeapSize);
 	espInfoResultStr += string(aMsgBuf);
-	sprintf(aMsgBuf," Min Free Heap Size: %ld", (long) aMinFreeHeadSize);
-	sprintf(aMsgBuf," NOT_SPI Heap: %ld", (long) (aFreeHeapSize - aFreeSPIHeapSize));
+
+	sprintf(aMsgBuf," | Int Free: %ld", (long) (aFreeInternalHeapSize));
 	espInfoResultStr += string(aMsgBuf);
-	sprintf(aMsgBuf," largest Block Size:  %ld", (long) aHeapLargestFreeBlockSize);
-	sprintf(aMsgBuf," Internal Heap: %ld", (long) (aFreeInternalHeapSize));
+	sprintf(aMsgBuf," | Int Large Block:  %ld", (long) aHeapIntLargestFreeBlockSize);
 	espInfoResultStr += string(aMsgBuf);
-	sprintf(aMsgBuf," Internal Min Heap free: %ld", (long) (aMinFreeInternalHeapSize));
+	sprintf(aMsgBuf," | Int Min Free: %ld", (long) (aMinFreeInternalHeapSize));
 	espInfoResultStr += string(aMsgBuf);
+	
 	return 	espInfoResultStr;
 }
 
 
-size_t getESPHeapSize(){
-   size_t aFreeHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT);
-   return aFreeHeapSize;
+size_t getESPHeapSize()
+{
+   return heap_caps_get_free_size(MALLOC_CAP_8BIT);
 }
 
-size_t getInternalESPHeapSize() {
-	size_t aFreeInternalHeapSize  = heap_caps_get_free_size(MALLOC_CAP_8BIT| MALLOC_CAP_INTERNAL);
-	return aFreeInternalHeapSize;
+
+size_t getInternalESPHeapSize() 
+{
+	return heap_caps_get_free_size(MALLOC_CAP_8BIT| MALLOC_CAP_INTERNAL);
 }
 
+
 string getSDCardPartitionSize(){
 	FATFS *fs;
     uint32_t fre_clust, tot_sect;
@@ -100,6 +107,7 @@ string getSDCardPartitionSize(){
 	return std::to_string(tot_sect);
 }
 
+
 string getSDCardFreePartitionSpace(){
 	FATFS *fs;
     uint32_t fre_clust, fre_sect;
@@ -113,6 +121,7 @@ string getSDCardFreePartitionSpace(){
 	return std::to_string(fre_sect);
 }
 
+
 string getSDCardPartitionAllocationSize(){
 	FATFS *fs;
     uint32_t fre_clust, allocation_size;
@@ -130,8 +139,10 @@ string getSDCardPartitionAllocationSize(){
 void SaveSDCardInfo(sdmmc_card_t* card) {
 	SDCardCid = card->cid;
     SDCardCsd = card->csd;
+	SDCardIsMMC = card->is_mmc;
 }
 
+
 string getSDCardManufacturer(){
 	string SDCardManufacturer = SDCardParseManufacturerIDs(SDCardCid.mfg_id);
 	//ESP_LOGD(TAG, "SD Card Manufacturer: %s", SDCardManufacturer.c_str());
@@ -139,6 +150,7 @@ string getSDCardManufacturer(){
 	return (SDCardManufacturer + " (ID: " + std::to_string(SDCardCid.mfg_id) + ")");
 }
 
+
 string getSDCardName(){
 	char *SDCardName = SDCardCid.name;
 	//ESP_LOGD(TAG, "SD Card Name: %s", SDCardName); 
@@ -146,6 +158,7 @@ string getSDCardName(){
 	return std::string(SDCardName);
 }
 
+
 string getSDCardCapacity(){
 	int SDCardCapacity = SDCardCsd.capacity / (1024/SDCardCsd.sector_size) / 1024;  // total sectors * sector size  --> Byte to MB (1024*1024)
 	//ESP_LOGD(TAG, "SD Card Capacity: %s", std::to_string(SDCardCapacity).c_str()); 
@@ -153,6 +166,7 @@ string getSDCardCapacity(){
 	return std::to_string(SDCardCapacity);
 }
 
+
 string getSDCardSectorSize(){
 	int SDCardSectorSize = SDCardCsd.sector_size;
 	//ESP_LOGD(TAG, "SD Card Sector Size: %s bytes", std::to_string(SDCardSectorSize).c_str()); 
@@ -169,24 +183,6 @@ void memCopyGen(uint8_t* _source, uint8_t* _target, int _size)
 }
 
 
-
-FILE* OpenFileAndWait(const char* nm, const char* _mode, int _waitsec, bool silent)
-{
-	FILE *pfile;
-
-	ESP_LOGD(TAG, "open file %s in mode %s", nm, _mode);
-
-	if ((pfile = fopen(nm, _mode)) != NULL) {
-		if (!silent) ESP_LOGE(TAG, "File %s successfully opened", nm);
-	}
-	else {
-		if (!silent) ESP_LOGE(TAG, "Error: file %s does not exist!", nm);
-		return NULL;
-	}
-
-	return pfile;
-}
-
 std::string FormatFileName(std::string input)
 {
 #ifdef ISWINDOWS_TRUE
@@ -230,17 +226,52 @@ void FindReplace(std::string& line, std::string& oldString, std::string& newStri
     }
 }
 
-bool MakeDir(std::string _what)
-{
-	int mk_ret = mkdir(_what.c_str(), 0775);
-	if (mk_ret)
-	{
-		ESP_LOGD(TAG, "error with mkdir %s ret %d", _what.c_str(), mk_ret);
-		return false;
-	}
-	return true;
-}
 
+/**
+ * Create a folder and its parent folders as needed
+ */
+bool MakeDir(std::string path)
+{
+	std::string parent;
+
+	LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Creating folder " + path + "...");
+
+	bool bSuccess = false;
+    int nRC = ::mkdir( path.c_str(), 0775 );
+    if( nRC == -1 )
+    {
+        switch( errno ) {
+            case ENOENT:
+                //parent didn't exist, try to create it
+				parent = path.substr(0, path.find_last_of('/'));
+        		LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Need to create parent folder first: " + parent);
+                if(MakeDir(parent)) {
+                    //Now, try to create again.
+                    bSuccess = 0 == ::mkdir( path.c_str(), 0775 );
+				}
+                else {
+        			LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to create parent folder: " + parent);
+                    bSuccess = false;
+				}
+                break;
+
+            case EEXIST:
+                //Done!
+                bSuccess = true;
+                break;
+				
+            default:
+				LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to create folder: " + path + " (errno: " + std::to_string(errno) + ")");
+                bSuccess = false;
+                break;
+        }
+    }
+    else {
+        bSuccess = true;
+	}
+
+    return bSuccess;
+}
 
 
 bool ctype_space(const char c, string adddelimiter)
@@ -255,6 +286,7 @@ bool ctype_space(const char c, string adddelimiter)
 	return false;
 }
 
+
 string trim(string istring, string adddelimiter)
 {
 	bool trimmed = false;
@@ -281,6 +313,7 @@ string trim(string istring, string adddelimiter)
 	}
 }
 
+
 size_t findDelimiterPos(string input, string delimiter)
 {
 	size_t pos = std::string::npos;
@@ -309,7 +342,7 @@ bool RenameFile(string from, string to)
 {
 //	ESP_LOGI(logTag, "Deleting file: %s", fn.c_str());
 	/* Delete file */
-	FILE* fpSourceFile = OpenFileAndWait(from.c_str(), "rb");
+	FILE* fpSourceFile = fopen(from.c_str(), "rb");
 	if (!fpSourceFile)	// Sourcefile existiert nicht sonst gibt es einen Fehler beim Kopierversuch!
 	{
 		ESP_LOGE(TAG, "DeleteFile: File %s existiert nicht!", from.c_str());
@@ -322,11 +355,23 @@ bool RenameFile(string from, string to)
 }
 
 
+bool FileExists(string filename)
+{
+	FILE* fpSourceFile = fopen(filename.c_str(), "rb");
+	if (!fpSourceFile)	// Sourcefile existiert nicht sonst gibt es einen Fehler beim Kopierversuch!
+	{
+		return false;
+	}
+	fclose(fpSourceFile);
+	return true;    
+}
+
+
 bool DeleteFile(string fn)
 {
 //	ESP_LOGI(logTag, "Deleting file: %s", fn.c_str());
 	/* Delete file */
-	FILE* fpSourceFile = OpenFileAndWait(fn.c_str(), "rb");
+	FILE* fpSourceFile = fopen(fn.c_str(), "rb");
 	if (!fpSourceFile)	// Sourcefile existiert nicht sonst gibt es einen Fehler beim Kopierversuch!
 	{
 		ESP_LOGD(TAG, "DeleteFile: File %s existiert nicht!", fn.c_str());
@@ -344,21 +389,21 @@ bool CopyFile(string input, string output)
 	input = FormatFileName(input);
 	output = FormatFileName(output);
 
-	if (toUpper(input).compare("/SDCARD/WLAN.INI") == 0)
+	if (toUpper(input).compare(WLAN_CONFIG_FILE) == 0)
 	{
 		ESP_LOGD(TAG, "wlan.ini kann nicht kopiert werden!");
 		return false;
 	}
 
 	char cTemp;
-	FILE* fpSourceFile = OpenFileAndWait(input.c_str(), "rb");
+	FILE* fpSourceFile = fopen(input.c_str(), "rb");
 	if (!fpSourceFile)	// Sourcefile existiert nicht sonst gibt es einen Fehler beim Kopierversuch!
 	{
 		ESP_LOGD(TAG, "File %s existiert nicht!", input.c_str());
 		return false;
 	}
 
-	FILE* fpTargetFile = OpenFileAndWait(output.c_str(), "wb");
+	FILE* fpTargetFile = fopen(output.c_str(), "wb");
 
 	// Code Section
 
@@ -376,6 +421,7 @@ bool CopyFile(string input, string output)
 	return true;
 }
 
+
 string getFileFullFileName(string filename)
 {
 	size_t lastpos = filename.find_last_of('/');
@@ -390,6 +436,7 @@ string getFileFullFileName(string filename)
 	return zw;
 }
 
+
 string getDirectory(string filename)
 {
 	size_t lastpos = filename.find('/');
@@ -406,6 +453,7 @@ string getDirectory(string filename)
 	return zw;
 }
 
+
 string getFileType(string filename)
 {
 	size_t lastpos = filename.rfind(".", filename.length());
@@ -424,16 +472,17 @@ string getFileType(string filename)
 	return zw;
 }
 
+
 /* recursive mkdir */
 int mkdir_r(const char *dir, const mode_t mode) {
-    char tmp[PATH_MAX_STRING_SIZE];
+    char tmp[FILE_PATH_MAX];
     char *p = NULL;
     struct stat sb;
     size_t len;
     
     /* copy path */
-    len = strnlen (dir, PATH_MAX_STRING_SIZE);
-    if (len == 0 || len == PATH_MAX_STRING_SIZE) {
+    len = strnlen (dir, FILE_PATH_MAX);
+    if (len == 0 || len == FILE_PATH_MAX) {
         return -1;
     }
     memcpy (tmp, dir, len);
@@ -481,6 +530,7 @@ int mkdir_r(const char *dir, const mode_t mode) {
     return 0;
 }
 
+
 string toUpper(string in)
 {
 	for (int i = 0; i < in.length(); ++i)
@@ -489,6 +539,7 @@ string toUpper(string in)
 	return in;
 }
 
+
 string toLower(string in)
 {
 	for (int i = 0; i < in.length(); ++i)
@@ -497,6 +548,7 @@ string toLower(string in)
 	return in;
 }
 
+
 // CPU Temp
 extern "C" uint8_t temprature_sens_read();
 float temperatureRead()
@@ -504,12 +556,14 @@ float temperatureRead()
     return (temprature_sens_read() - 32) / 1.8;
 }
 
+
 time_t addDays(time_t startTime, int days) {
 	struct tm* tm = localtime(&startTime);
 	tm->tm_mday += days;
 	return mktime(tm);
 }
 
+
 int removeFolder(const char* folderPath, const char* logTag) {
 	//ESP_LOGD(logTag, "Delete content in path %s", folderPath);
 
@@ -557,13 +611,9 @@ std::vector<string> HelperZerlegeZeile(std::string input, std::string _delimiter
 }
 
 
-
 std::vector<string> ZerlegeZeile(std::string input, std::string delimiter)
 {
 	std::vector<string> Output;
-
-	input = trim(input, delimiter);
-
 	/* The input can have multiple formats: 
 	 *  - key = value
      *  - key = value1 value2 value3 ...
@@ -578,12 +628,13 @@ std::vector<string> ZerlegeZeile(std::string input, std::string delimiter)
 	 * As a workaround and to not break any legacy usage, we enforce to only use the
 	 * equal sign, if the key is "password"
 	*/
-	if (input.find("password") != string::npos) { // Line contains a password, use the equal sign as the only delimiter and only split on first occurrence
+	if ((input.find("password") != string::npos) || (input.find("Token") != string::npos)) { // Line contains a password, use the equal sign as the only delimiter and only split on first occurrence
 		size_t pos = input.find("=");
 		Output.push_back(trim(input.substr(0, pos), ""));
 		Output.push_back(trim(input.substr(pos +1, string::npos), ""));
 	}
 	else { // Legacy Mode
+		input = trim(input, delimiter);							// sonst werden delimiter am Ende (z.B. == im Token) gelöscht)
 		size_t pos = findDelimiterPos(input, delimiter);
 		std::string token;
 		while (pos != std::string::npos) {
@@ -602,6 +653,17 @@ std::vector<string> ZerlegeZeile(std::string input, std::string delimiter)
 }
 
 
+std::string ReplaceString(std::string subject, const std::string& search,
+                          const std::string& replace) {
+    size_t pos = 0;
+    while ((pos = subject.find(search, pos)) != std::string::npos) {
+         subject.replace(pos, search.length(), replace);
+         pos += replace.length();
+    }
+    return subject;
+}
+
+
 /* Source: https://git.kernel.org/pub/scm/utils/mmc/mmc-utils.git/tree/lsmmc.c */
 /* SD Card Manufacturer Database */
 struct SDCard_Manufacturer_database {
@@ -610,9 +672,10 @@ struct SDCard_Manufacturer_database {
 	string manufacturer;
 };
 
+
 /* Source: https://git.kernel.org/pub/scm/utils/mmc/mmc-utils.git/tree/lsmmc.c */
 /* SD Card Manufacturer Database */
-struct SDCard_Manufacturer_database database[] = {
+struct SDCard_Manufacturer_database sd_database[] = {
 	{
 		.type = "sd",
 		.id = 0x01,
@@ -717,24 +780,124 @@ struct SDCard_Manufacturer_database database[] = {
 		.type = "sd",
 		.id = 0x89,
 		.manufacturer = "Unknown",
-	}
+	},
+};
+
+struct SDCard_Manufacturer_database mmc_database[] = {
+	{
+		.type = "mmc",
+		.id = 0x00,
+		.manufacturer = "SanDisk",
+	},
+	{
+		.type = "mmc",
+		.id = 0x02,
+		.manufacturer = "Kingston/SanDisk",
+	},
+	{
+		.type = "mmc",
+		.id = 0x03,
+		.manufacturer = "Toshiba",
+	},
+	{
+		.type = "mmc",
+		.id = 0x05,
+		.manufacturer = "Unknown",
+	},
+	{
+		.type = "mmc",
+		.id = 0x06,
+		.manufacturer = "Unknown",
+	},
+	{
+		.type = "mmc",
+		.id = 0x11,
+		.manufacturer = "Toshiba",
+	},
+	{
+		.type = "mmc",
+		.id = 0x13,
+		.manufacturer = "Micron",
+	},
+	{
+		.type = "mmc",
+		.id = 0x15,
+		.manufacturer = "Samsung/SanDisk/LG",
+	},
+	{
+		.type = "mmc",
+		.id = 0x37,
+		.manufacturer = "KingMax",
+	},
+	{
+		.type = "mmc",
+		.id = 0x44,
+		.manufacturer = "ATP",
+	},
+	{
+		.type = "mmc",
+		.id = 0x45,
+		.manufacturer = "SanDisk Corporation",
+	},
+	{
+		.type = "mmc",
+		.id = 0x2c,
+		.manufacturer = "Kingston",
+	},
+	{
+		.type = "mmc",
+		.id = 0x70,
+		.manufacturer = "Kingston",
+	},
+	{
+		.type = "mmc",
+		.id = 0xfe,
+		.manufacturer = "Micron",
+	},
 };
 
 /* Parse SD Card Manufacturer Database */
 string SDCardParseManufacturerIDs(int id) 
 {
-	unsigned int id_cnt = sizeof(database) / sizeof(struct SDCard_Manufacturer_database);
+    if (SDCardIsMMC)
+    {
+        unsigned int id_cnt = sizeof(mmc_database) / sizeof(struct SDCard_Manufacturer_database);
+        string ret_val = "";
+
+        for (int i = 0; i < id_cnt; i++)
+	{
+	    if (mmc_database[i].id == id)
+	    {
+		return mmc_database[i].manufacturer;
+	    }
+	    else
+	    {
+		ret_val = "ID unknown (not in DB)";
+	    }
+	}
+
+	return ret_val;
+    }
+
+    else
+    {
+	unsigned int id_cnt = sizeof(sd_database) / sizeof(struct SDCard_Manufacturer_database);
 	string ret_val = "";
 
-	for (int i = 0; i < id_cnt; i++) {
-		if (database[i].id == id) {
-			return database[i].manufacturer;
-		}
-		else {
-			ret_val = "ID unknown (not in DB)";
-		}
+	for (int i = 0; i < id_cnt; i++)
+	{
+	    if (sd_database[i].id == id)
+	    {
+		return sd_database[i].manufacturer;
+	    }
+	    else
+	    {
+		ret_val = "ID unknown (not in DB)";
+	    }
 	}
+
 	return ret_val;
+    }
 }
 
 
@@ -782,6 +945,7 @@ void setSystemStatusFlag(SystemStatusFlag_t flag) {
     LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "New System Status: " + std::string(buf));
 }
 
+
 void clearSystemStatusFlag(SystemStatusFlag_t flag) {
 	systemStatus = systemStatus | ~flag; // clear bit
 
@@ -790,10 +954,12 @@ void clearSystemStatusFlag(SystemStatusFlag_t flag) {
     LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "New System Status: " + std::string(buf));
 }
 
+
 int getSystemStatus(void) {
     return systemStatus;
 }
 
+
 bool isSetSystemStatusFlag(SystemStatusFlag_t flag) {
 	//ESP_LOGE(TAG, "Flag (0x%08X) is set (0x%08X): %d", flag, systemStatus , ((systemStatus & flag) == flag));
 
@@ -805,11 +971,17 @@ bool isSetSystemStatusFlag(SystemStatusFlag_t flag) {
 	}
 }
 
+
+time_t getUpTime(void) {
+    return (uint32_t)(esp_timer_get_time()/1000/1000); // in seconds
+}
+
+
 string getResetReason(void) {
 	std::string reasonText;
 
 	switch(esp_reset_reason()) {
-		case ESP_RST_POWERON: reasonText = "Power-on event"; break;    //!< Reset due to power-on event
+		case ESP_RST_POWERON: reasonText = "Power-on event (or reset button)"; break;    //!< Reset due to power-on event
 		case ESP_RST_EXT: reasonText = "External pin"; break;        //!< Reset by external pin (not applicable for ESP32)
 		case ESP_RST_SW: reasonText = "Via esp_restart"; break;         //!< Software reset via esp_restart
 		case ESP_RST_PANIC: reasonText = "Exception/panic"; break;      //!< Software reset due to exception/panic
@@ -827,6 +999,7 @@ string getResetReason(void) {
     return reasonText;
 }
 
+
 /**
  * Returns the current uptime  formated ad xxf xxh xxm [xxs]
  */
@@ -834,7 +1007,7 @@ std::string getFormatedUptime(bool compact) {
 	char buf[20];
 	#pragma GCC diagnostic ignored "-Wformat-truncation"
 
-    int uptime = (uint32_t)(esp_timer_get_time()/1000/1000); // in seconds
+    int uptime = getUpTime(); // in seconds
 
     int days = int(floor(uptime / (3600*24)));
     int hours = int(floor((uptime - days * 3600*24) / (3600)));
@@ -851,6 +1024,7 @@ std::string getFormatedUptime(bool compact) {
 	return std::string(buf);
 }
 
+
 const char* get404(void) {
     return 
 "<pre>\n\n\n\n"
@@ -861,3 +1035,64 @@ const char* get404(void) {
 "                You could try your <a href=index.html target=_parent>luck</a> here!</pre>\n"
 "<script>document.cookie = \"page=overview.html\"</script>"; // Make sure we load the overview page
 }
+
+
+std::string UrlDecode(const std::string& value)
+{
+    std::string result;
+    result.reserve(value.size());
+
+    for (std::size_t i = 0; i < value.size(); ++i)
+    {
+        auto ch = value[i];
+
+        if (ch == '%' && (i + 2) < value.size())
+        {
+            auto hex = value.substr(i + 1, 2);
+            auto dec = static_cast<char>(std::strtol(hex.c_str(), nullptr, 16));
+            result.push_back(dec);
+            i += 2;
+        }
+        else if (ch == '+')
+        {
+            result.push_back(' ');
+        }
+        else
+        {
+            result.push_back(ch);
+        }
+    }
+
+    return result;
+}
+
+
+bool replaceString(std::string& s, std::string const& toReplace, std::string const& replaceWith) {
+    return replaceString(s, toReplace, replaceWith, true);
+}
+
+
+bool replaceString(std::string& s, std::string const& toReplace, std::string const& replaceWith, bool logIt) {
+    std::size_t pos = s.find(toReplace);
+
+    if (pos == std::string::npos) { // Not found
+        return false;
+    }
+
+    std::string old = s;
+    s.replace(pos, toReplace.length(), replaceWith);
+    if (logIt) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Migrated Configfile line '" + old + "' to '" + s + "'");
+    }
+    return true;
+}
+
+
+bool isInString(std::string& s, std::string const& toFind) {
+    std::size_t pos = s.find(toFind);
+
+    if (pos == std::string::npos) { // Not found
+        return false;
+    }
+    return true;
+}

code/components/jomjol_helper/Helper.h

@@ -1,7 +1,12 @@
 #pragma once
+
+#ifndef HELPER_H
+#define HELPER_H
+
 #include <string>
 #include <fstream>
 #include <vector>
+
 #include "sdmmc_cmd.h"
 
 using namespace std;
@@ -14,13 +19,11 @@ bool CopyFile(string input, string output);
 bool DeleteFile(string fn);
 bool RenameFile(string from, string to);
 bool MakeDir(std::string _what);
+bool FileExists(string filename);
 
 
 string RundeOutput(double _in, int _anzNachkomma);
 
-
-FILE* OpenFileAndWait(const char* nm, const char* _mode, int _waitsec = 1, bool silent = true);
-
 size_t findDelimiterPos(string input, string delimiter);
 //string trim(string istring);
 string trim(string istring, string adddelimiter = "");
@@ -30,6 +33,7 @@ string getFileType(string filename);
 string getFileFullFileName(string filename);
 string getDirectory(string filename);
 
+
 int mkdir_r(const char *dir, const mode_t mode);
 int removeFolder(const char* folderPath, const char* logTag);
 
@@ -67,12 +71,14 @@ string getMac(void);
 
 /* Error bit fields
    One bit per error
-   Make sure it matches https://github.com/jomjol/AI-on-the-edge-device/wiki/Error-Codes */
+   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
@@ -84,7 +90,16 @@ 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);
+
+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);
+
+#endif //HELPER_H

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

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

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

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

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

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 

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 Digitalization 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 == "Digitalization_Model")) {
+        sharedMemoryInUseFor = "Digitalization_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 == "Digitalization_Tensor")) {
+        sharedMemoryInUseFor = "Digitalization_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);
+}

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 Digitalization 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

code/components/jomjol_helper/sdcard_check.cpp

@@ -0,0 +1,161 @@
+#include "sdcard_check.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <sys/stat.h>
+
+#include "esp_rom_crc.h" 
+#include "ClassLogFile.h"
+
+static const char *TAG = "SDCARD";
+
+int SDCardCheckRW(void)
+{
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Basic R/W check started...");
+    FILE* pFile = NULL;
+    int iCRCMessage = 0;
+   
+    pFile = fopen("/sdcard/sdcheck.txt","w");
+    if (pFile == NULL) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E1) No able to open file to write");
+        return -1;
+    } 
+    else {
+        std::string sMessage = "This message is used for a SD-Card basic check!";
+        iCRCMessage = esp_rom_crc16_le(0, (uint8_t*)sMessage.c_str(), sMessage.length());
+        if (fwrite(sMessage.c_str(), sMessage.length(), 1, pFile) == 0 ) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E2) Not able to write file");
+            fclose(pFile);
+            unlink("/sdcard/sdcheck.txt");
+            return -2;
+        }
+        fclose(pFile); 
+    }
+
+    pFile = fopen("/sdcard/sdcheck.txt","r");
+    if (pFile == NULL) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E3) Not able to open file to read back");
+        unlink("/sdcard/sdcheck.txt");
+        return -3;
+    } 
+    else {
+        char cReadBuf[50];
+        if (fgets(cReadBuf, sizeof(cReadBuf), pFile) == 0) {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E4) Not able to read file back");
+            fclose(pFile);
+            unlink("/sdcard/sdcheck.txt");
+            return -4;
+        }
+        else {
+            if (esp_rom_crc16_le(0, (uint8_t*)cReadBuf, strlen(cReadBuf)) != iCRCMessage) {                 
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E5) Read back, but wrong CRC");
+                fclose(pFile);
+                unlink("/sdcard/sdcheck.txt");
+                return -5;
+            }
+        }      
+        fclose(pFile);
+    }
+
+    if (unlink("/sdcard/sdcheck.txt") != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Basic R/W check: (E6) Unable to delete the file");
+        return -6;
+    }
+
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Basic R/W check successful");
+    return 0;
+}
+
+
+bool SDCardCheckFolderFilePresence()
+{
+    struct stat sb;
+    bool bRetval = true;
+
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Folder/file presence check started...");
+    /* check if folder exists: config */
+    if (stat("/sdcard/config", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /config not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: html */
+    if (stat("/sdcard/html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /html not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: firmware */
+    if (stat("/sdcard/firmware", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /firmware not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: img_tmp */
+    if (stat("/sdcard/img_tmp", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /img_tmp not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: log */
+    if (stat("/sdcard/log", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /log not found");
+        bRetval = false;
+    }
+
+    /* check if folder exists: demo */
+    if (stat("/sdcard/demo", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: Folder /demo not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: wlan.ini */
+    if (stat("/sdcard/wlan.ini", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /wlan.ini not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: config.ini */
+    if (stat("/sdcard/config/config.ini", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /config/config.ini not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: index.html */
+    if (stat("/sdcard/html/index.html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/index.html not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: ota.html */
+    if (stat("/sdcard/html/ota_page.html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/ota.html not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: log.html */
+    if (stat("/sdcard/html/log.html", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/log.html not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: common.js */
+    if (stat("/sdcard/html/common.js", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/common.js not found");
+        bRetval = false;
+    }
+
+    /* check if file exists: version.txt */
+    if (stat("/sdcard/html/version.txt", &sb) != 0) {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/version.txt not found");
+        bRetval = false;
+    }
+
+    if (bRetval)
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Folder/file presence check successful");
+    
+    return bRetval;
+}

code/components/jomjol_helper/sdcard_check.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#ifndef COMPONENTS_HELPER_SDCARD_CHECK_H
+#define COMPONENTS_HELPER_SDCARD_CHECK_H
+
+#include "../../include/defines.h"
+
+int SDCardCheckRW(void);
+bool SDCardCheckFolderFilePresence(void);
+
+#endif /* COMPONENTS_HELPER_SDCARD_CHECK_H */

code/components/jomjol_helper/sdcard_init.c

@@ -0,0 +1,651 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "sdcard_init.h"
+
+#include "esp_log.h"
+#include "ffconf.h"
+#include "esp_compiler.h"
+#include "esp_vfs.h"
+#include "vfs_fat_internal.h"
+#include "diskio_impl.h"
+#include "diskio_sdmmc.h"
+#include "soc/soc_caps.h"
+#include "driver/sdmmc_defs.h"
+
+#if SOC_SDMMC_HOST_SUPPORTED
+	#include "driver/sdmmc_host.h"
+#endif
+
+static sdmmc_card_t* s_cards[FF_VOLUMES] = { NULL };
+static bool s_disk_status_check_en[FF_VOLUMES] = { };
+
+static const char* TAG = "sdcard_init";
+
+#define CHECK_EXECUTE_RESULT(err, str) do { \
+    if ((err) !=ESP_OK) { \
+        ESP_LOGE(TAG, str" (0x%x).", err); \
+        goto cleanup; \
+    } \
+    } while(0)
+
+typedef struct vfs_fat_sd_ctx_t {
+    BYTE pdrv;                                  //Drive number that is mounted
+    esp_vfs_fat_mount_config_t mount_config;    //Mount configuration
+    FATFS *fs;                                  //FAT structure pointer that is registered
+    sdmmc_card_t *card;                         //Card info
+    char *base_path;                            //Path where partition is registered
+} vfs_fat_sd_ctx_t;
+
+static vfs_fat_sd_ctx_t *s_ctx[FF_VOLUMES] = {};
+
+/**
+ * This `s_saved_ctx_id` is only used by `esp_vfs_fat_sdmmc_unmount`, which is deprecated.
+ * This variable together with `esp_vfs_fat_sdmmc_unmount` should be removed in next major version
+ */
+static uint32_t s_saved_ctx_id = FF_VOLUMES;
+
+
+static void call_host_deinit_mh(const sdmmc_host_t *host_config);
+static esp_err_t partition_card_mh(const esp_vfs_fat_mount_config_t *mount_config, const char *drv, sdmmc_card_t *card, BYTE pdrv);
+
+
+//Check if SD/MMC card is present
+static DSTATUS ff_sdmmc_card_available_mh(BYTE pdrv)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    esp_err_t err = sdmmc_get_status(card);
+	
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "Check status failed (0x%x)", err);
+        return STA_NOINIT;
+    }
+    return 0;
+}
+
+/**
+*   ff_sdmmc_status() and ff_sdmmc_initialize() return STA_NOINIT when sdmmc_get_status()
+*   fails. This error value is checked throughout the FATFS code.
+*   Both functions return 0 on success.
+*/
+DSTATUS ff_sdmmc_initialize_mh (BYTE pdrv)
+{
+    return ff_sdmmc_card_available_mh(pdrv);
+}
+
+DSTATUS ff_sdmmc_status_mh(BYTE pdrv)
+{
+    if (s_disk_status_check_en[pdrv]) {
+        return ff_sdmmc_card_available_mh(pdrv);
+    }
+    return 0;
+}
+
+DRESULT ff_sdmmc_read_mh (BYTE pdrv, BYTE* buff, DWORD sector, UINT count)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    esp_err_t err = sdmmc_read_sectors(card, buff, sector, count);
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "sdmmc_read_blocks failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+
+DRESULT ff_sdmmc_write_mh (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    esp_err_t err = sdmmc_write_sectors(card, buff, sector, count);
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "sdmmc_write_blocks failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+
+#if FF_USE_TRIM
+DRESULT ff_sdmmc_trim_mh (BYTE pdrv, DWORD start_sector, DWORD sector_count)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    sdmmc_erase_arg_t arg;
+
+    arg = sdmmc_can_discard(card) == ESP_OK ? SDMMC_DISCARD_ARG : SDMMC_ERASE_ARG;
+    esp_err_t err = sdmmc_erase_sectors(card, start_sector, sector_count, arg);
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "sdmmc_erase_sectors failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+#endif //FF_USE_TRIM
+
+DRESULT ff_sdmmc_ioctl_mh (BYTE pdrv, BYTE cmd, void* buff)
+{
+    sdmmc_card_t* card = s_cards[pdrv];
+    assert(card);
+    switch(cmd) {
+        case CTRL_SYNC:
+            return RES_OK;
+        case GET_SECTOR_COUNT:
+            *((DWORD*) buff) = card->csd.capacity;
+            return RES_OK;
+        case GET_SECTOR_SIZE:
+            *((WORD*) buff) = card->csd.sector_size;
+            return RES_OK;
+        case GET_BLOCK_SIZE:
+            return RES_ERROR;
+#if FF_USE_TRIM
+        case CTRL_TRIM:
+            if (sdmmc_can_trim(card) != ESP_OK) {
+                return RES_PARERR;
+            }
+            return ff_sdmmc_trim_mh (pdrv, *((DWORD*)buff), //start_sector
+                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
+#endif //FF_USE_TRIM
+    }
+    return RES_ERROR;
+}
+
+void ff_sdmmc_set_disk_status_check_mh(BYTE pdrv, bool enable)
+{
+    s_disk_status_check_en[pdrv] = enable;
+}
+
+void ff_diskio_register_sdmmc_mh(BYTE pdrv, sdmmc_card_t* card)
+{
+    static const ff_diskio_impl_t sdmmc_impl = {
+        .init = &ff_sdmmc_initialize_mh,
+        .status = &ff_sdmmc_status_mh,
+        .read = &ff_sdmmc_read_mh,
+        .write = &ff_sdmmc_write_mh,
+        .ioctl = &ff_sdmmc_ioctl_mh
+    };
+    s_cards[pdrv] = card;
+    s_disk_status_check_en[pdrv] = false;
+    ff_diskio_register(pdrv, &sdmmc_impl);
+}
+
+BYTE ff_diskio_get_pdrv_card_mh(const sdmmc_card_t* card)
+{
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        if (card == s_cards[i]) {
+            return i;
+        }
+    }
+    return 0xff;
+}
+
+
+
+
+
+
+static bool s_get_context_id_by_card_mh(const sdmmc_card_t *card, uint32_t *out_id)
+{
+    vfs_fat_sd_ctx_t *p_ctx = NULL;
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        p_ctx = s_ctx[i];
+        if (p_ctx) {
+            if (p_ctx->card == card) {
+                *out_id = i;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+static uint32_t s_get_unused_context_id_mh(void)
+{
+    for (uint32_t i = 0; i < FF_VOLUMES; i++) {
+        if (!s_ctx[i]) {
+            return i;
+        }
+    }
+    return FF_VOLUMES;
+}
+
+static esp_err_t mount_prepare_mem_mh(const char *base_path, BYTE *out_pdrv, char **out_dup_path, sdmmc_card_t** out_card)
+{
+    esp_err_t err = ESP_OK;
+    char* dup_path = NULL;
+    sdmmc_card_t* card = NULL;
+
+    // connect SDMMC driver to FATFS
+    BYTE pdrv = FF_DRV_NOT_USED;
+
+    if (ff_diskio_get_drive(&pdrv) != ESP_OK || pdrv == FF_DRV_NOT_USED) {
+        ESP_LOGD(TAG, "the maximum count of volumes is already mounted");
+        return ESP_ERR_NO_MEM;
+    }
+
+    // not using ff_memalloc here, as allocation in internal RAM is preferred
+    card = (sdmmc_card_t*)malloc(sizeof(sdmmc_card_t));
+
+    if (card == NULL) {
+        ESP_LOGD(TAG, "could not locate new sdmmc_card_t");
+        err = ESP_ERR_NO_MEM;
+        goto cleanup;
+    }
+
+    dup_path = strdup(base_path);
+
+    if(!dup_path){
+        ESP_LOGD(TAG, "could not copy base_path");
+        err = ESP_ERR_NO_MEM;
+        goto cleanup;
+    }
+
+    *out_card = card;
+    *out_pdrv = pdrv;
+    *out_dup_path = dup_path;
+    return ESP_OK;
+cleanup:
+    free(card);
+    free(dup_path);
+    return err;
+}
+
+static esp_err_t s_f_mount_mh(sdmmc_card_t *card, FATFS *fs, const char *drv, uint8_t pdrv, const esp_vfs_fat_mount_config_t *mount_config)
+{
+    esp_err_t err = ESP_OK;
+    FRESULT res = f_mount(fs, drv, 1);
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGW(TAG, "failed to mount card (%d)", res);
+
+        bool need_mount_again = (res == FR_NO_FILESYSTEM || res == FR_INT_ERR) && mount_config->format_if_mount_failed;
+
+        if (!need_mount_again) {
+            return ESP_FAIL;
+        }
+
+        err = partition_card_mh(mount_config, drv, card, pdrv);
+
+        if (err != ESP_OK) {
+            return err;
+        }
+
+        ESP_LOGW(TAG, "mounting again");
+        res = f_mount(fs, drv, 0);
+
+        if (res != FR_OK) {
+            err = ESP_FAIL;
+            ESP_LOGD(TAG, "f_mount failed after formatting (%d)", res);
+            return err;
+        }
+    }
+
+    return ESP_OK;
+}
+
+static esp_err_t mount_to_vfs_fat_mh(const esp_vfs_fat_mount_config_t *mount_config, sdmmc_card_t *card, uint8_t pdrv, const char *base_path, FATFS **out_fs)
+{
+    FATFS *fs = NULL;
+    esp_err_t err;
+    ff_diskio_register_sdmmc_mh(pdrv, card);
+    ff_sdmmc_set_disk_status_check_mh(pdrv, mount_config->disk_status_check_enable);
+    ESP_LOGD(TAG, "using pdrv=%i", pdrv);
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+    // connect FATFS to VFS
+    err = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs);
+    *out_fs = fs;
+
+    if (err == ESP_ERR_INVALID_STATE) {
+        // it's okay, already registered with VFS
+    } else if (err != ESP_OK) {
+        ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", err);
+        goto fail;
+    }
+
+    // Try to mount partition
+    err = s_f_mount_mh(card, fs, drv, pdrv, mount_config);
+
+    if (err != ESP_OK) {
+        goto fail;
+    }
+    return ESP_OK;
+
+fail:
+    if (fs) {
+        f_mount(NULL, drv, 0);
+    }
+    esp_vfs_fat_unregister_path(base_path);
+    ff_diskio_unregister(pdrv);
+    return err;
+}
+
+static esp_err_t partition_card_mh(const esp_vfs_fat_mount_config_t *mount_config, const char *drv, sdmmc_card_t *card, BYTE pdrv)
+{
+    FRESULT res = FR_OK;
+    esp_err_t err;
+    const size_t workbuf_size = 4096;
+    void* workbuf = NULL;
+    ESP_LOGW(TAG, "partitioning card");
+
+    workbuf = ff_memalloc(workbuf_size);
+
+    if (workbuf == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    LBA_t plist[] = {100, 0, 0, 0};
+    res = f_fdisk(pdrv, plist, workbuf);
+
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGD(TAG, "f_fdisk failed (%d)", res);
+        goto fail;
+    }
+
+    size_t alloc_unit_size = esp_vfs_fat_get_allocation_unit_size(card->csd.sector_size, mount_config->allocation_unit_size);
+
+    ESP_LOGW(TAG, "formatting card, allocation unit size=%d", alloc_unit_size);
+    const MKFS_PARM opt = {(BYTE)FM_ANY, 0, 0, 0, alloc_unit_size};
+    res = f_mkfs(drv, &opt, workbuf, workbuf_size);
+
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGD(TAG, "f_mkfs failed (%d)", res);
+        goto fail;
+    }
+
+    free(workbuf);
+    return ESP_OK;
+fail:
+    free(workbuf);
+    return err;
+}
+
+#if SOC_SDMMC_HOST_SUPPORTED
+static esp_err_t init_sdmmc_host_mh(int slot, const void *slot_config, int *out_slot)
+{
+    *out_slot = slot;
+    return sdmmc_host_init_slot(slot, (const sdmmc_slot_config_t*) slot_config);
+}
+
+esp_err_t esp_vfs_fat_sdmmc_mount_mh(const char* base_path, const sdmmc_host_t* host_config, const void* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card)
+{
+    esp_err_t err;
+    vfs_fat_sd_ctx_t *ctx = NULL;
+    uint32_t ctx_id = FF_VOLUMES;
+    FATFS *fs = NULL;
+    int card_handle = -1;   //uninitialized
+    sdmmc_card_t* card = NULL;
+    BYTE pdrv = FF_DRV_NOT_USED;
+    char* dup_path = NULL;
+    bool host_inited = false;
+
+    err = mount_prepare_mem_mh(base_path, &pdrv, &dup_path, &card);
+
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "mount_prepare failed");
+        return err;
+    }
+
+    err = (*host_config->init)();
+    CHECK_EXECUTE_RESULT(err, "host init failed");
+    //deinit() needs to be called to revert the init
+    host_inited = true;
+    //If this failed (indicated by card_handle != -1), slot deinit needs to called()
+    //leave card_handle as is to indicate that (though slot deinit not implemented yet.
+    err = init_sdmmc_host_mh(host_config->slot, slot_config, &card_handle);
+    CHECK_EXECUTE_RESULT(err, "slot init failed");
+
+    // probe and initialize card
+    err = sdmmc_card_init(host_config, card);
+    CHECK_EXECUTE_RESULT(err, "sdmmc_card_init failed");
+
+    err = mount_to_vfs_fat_mh(mount_config, card, pdrv, dup_path, &fs);
+    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
+
+    if (out_card != NULL) {
+        *out_card = card;
+    }
+
+    //For deprecation backward compatibility
+    if (s_saved_ctx_id == FF_VOLUMES) {
+        s_saved_ctx_id = 0;
+    }
+
+    ctx = calloc(sizeof(vfs_fat_sd_ctx_t), 1);
+
+    if (!ctx) {
+        CHECK_EXECUTE_RESULT(ESP_ERR_NO_MEM, "no mem");
+    }
+
+    ctx->pdrv = pdrv;
+    memcpy(&ctx->mount_config, mount_config, sizeof(esp_vfs_fat_mount_config_t));
+    ctx->card = card;
+    ctx->base_path = dup_path;
+    ctx->fs = fs;
+    ctx_id = s_get_unused_context_id_mh();
+    assert(ctx_id != FF_VOLUMES);
+    s_ctx[ctx_id] = ctx;
+
+    return ESP_OK;
+cleanup:
+    if (host_inited) {
+        call_host_deinit_mh(host_config);
+    }
+
+    free(card);
+    free(dup_path);
+    return err;
+}
+#endif
+
+static esp_err_t init_sdspi_host_mh(int slot, const void *slot_config, int *out_slot)
+{
+    esp_err_t err = sdspi_host_init_device((const sdspi_device_config_t*)slot_config, out_slot);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG,
+"Failed to attach sdspi device onto an SPI bus (rc=0x%x), please initialize the \
+bus first and check the device parameters."
+            , err);
+    }
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdspi_mount_mh(const char* base_path, const sdmmc_host_t* host_config_input, const sdspi_device_config_t* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card)
+{
+    const sdmmc_host_t* host_config = host_config_input;
+    esp_err_t err;
+    vfs_fat_sd_ctx_t *ctx = NULL;
+    uint32_t ctx_id = FF_VOLUMES;
+    FATFS *fs = NULL;
+    int card_handle = -1;   //uninitialized
+    bool host_inited = false;
+    BYTE pdrv = FF_DRV_NOT_USED;
+    sdmmc_card_t* card = NULL;
+    char* dup_path = NULL;
+
+    err = mount_prepare_mem_mh(base_path, &pdrv, &dup_path, &card);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "mount_prepare failed");
+        return err;
+    }
+
+    //the init() function is usually empty, doesn't require any deinit to revert it
+    err = (*host_config->init)();
+    CHECK_EXECUTE_RESULT(err, "host init failed");
+
+    err = init_sdspi_host_mh(host_config->slot, slot_config, &card_handle);
+    CHECK_EXECUTE_RESULT(err, "slot init failed");
+    //Set `host_inited` to true to indicate that host_config->deinit() needs
+    //to be called to revert `init_sdspi_host`
+    host_inited = true;
+
+    //The `slot` argument inside host_config should be replaced by the SD SPI handled returned
+    //above. But the input pointer is const, so create a new variable.
+
+    sdmmc_host_t new_config;
+
+    if (card_handle != host_config->slot) {
+        new_config = *host_config_input;
+        host_config = &new_config;
+        new_config.slot = card_handle;
+    }
+
+    // probe and initialize card
+    err = sdmmc_card_init(host_config, card);
+    CHECK_EXECUTE_RESULT(err, "sdmmc_card_init failed");
+
+    err = mount_to_vfs_fat_mh(mount_config, card, pdrv, dup_path, &fs);
+    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
+
+    if (out_card != NULL) {
+        *out_card = card;
+    }
+
+    //For deprecation backward compatibility
+    if (s_saved_ctx_id == FF_VOLUMES) {
+        s_saved_ctx_id = 0;
+    }
+
+    ctx = calloc(sizeof(vfs_fat_sd_ctx_t), 1);
+
+    if (!ctx) {
+        CHECK_EXECUTE_RESULT(ESP_ERR_NO_MEM, "no mem");
+    }
+
+    ctx->pdrv = pdrv;
+    memcpy(&ctx->mount_config, mount_config, sizeof(esp_vfs_fat_mount_config_t));
+    ctx->card = card;
+    ctx->base_path = dup_path;
+    ctx->fs = fs;
+    ctx_id = s_get_unused_context_id_mh();
+    assert(ctx_id != FF_VOLUMES);
+    s_ctx[ctx_id] = ctx;
+
+    return ESP_OK;
+
+cleanup:
+    if (host_inited) {
+        call_host_deinit_mh(host_config);
+    }
+
+    free(card);
+    free(dup_path);
+    return err;
+}
+
+static void call_host_deinit_mh(const sdmmc_host_t *host_config)
+{
+    if (host_config->flags & SDMMC_HOST_FLAG_DEINIT_ARG) {
+        host_config->deinit_p(host_config->slot);
+    } else {
+        host_config->deinit();
+    }
+}
+
+static esp_err_t unmount_card_core_mh(const char *base_path, sdmmc_card_t *card)
+{
+    BYTE pdrv = ff_diskio_get_pdrv_card_mh(card);
+
+    if (pdrv == 0xff) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    // unmount
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+    f_mount(0, drv, 0);
+    // release SD driver
+    ff_diskio_unregister(pdrv);
+
+    call_host_deinit_mh(&card->host);
+    free(card);
+
+    esp_err_t err = esp_vfs_fat_unregister_path(base_path);
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdmmc_unmount_mh(void)
+{
+    esp_err_t err = unmount_card_core_mh(s_ctx[s_saved_ctx_id]->base_path, s_ctx[s_saved_ctx_id]->card);
+    free(s_ctx[s_saved_ctx_id]);
+    s_ctx[s_saved_ctx_id] = NULL;
+    s_saved_ctx_id = FF_VOLUMES;
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdcard_unmount_mh(const char *base_path, sdmmc_card_t *card)
+{
+    uint32_t id = FF_VOLUMES;
+    bool found = s_get_context_id_by_card_mh(card, &id);
+
+    if (!found) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    free(s_ctx[id]);
+    s_ctx[id] = NULL;
+
+    esp_err_t err = unmount_card_core_mh(base_path, card);
+
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdcard_format_mh(const char *base_path, sdmmc_card_t *card)
+{
+    esp_err_t ret = ESP_OK;
+
+    if (!card) {
+        ESP_LOGE(TAG, "card not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    BYTE pdrv = ff_diskio_get_pdrv_card_mh(card);
+
+    if (pdrv == 0xff) {
+        ESP_LOGE(TAG, "card driver not registered");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    const size_t workbuf_size = 4096;
+    void *workbuf = ff_memalloc(workbuf_size);
+
+    if (workbuf == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    //unmount
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+    f_mount(0, drv, 0);
+
+    //format
+    uint32_t id = FF_VOLUMES;
+    bool found = s_get_context_id_by_card_mh(card, &id);
+    assert(found);
+    size_t alloc_unit_size = esp_vfs_fat_get_allocation_unit_size(card->csd.sector_size, s_ctx[id]->mount_config.allocation_unit_size);
+    ESP_LOGI(TAG, "Formatting card, allocation unit size=%d", alloc_unit_size);
+    const MKFS_PARM opt = {(BYTE)FM_ANY, 0, 0, 0, alloc_unit_size};
+    FRESULT res = f_mkfs(drv, &opt, workbuf, workbuf_size);
+    free(workbuf);
+
+    if (res != FR_OK) {
+        ret = ESP_FAIL;
+        ESP_LOGD(TAG, "f_mkfs failed (%d)", res);
+    }
+
+    //mount back
+    esp_err_t err = s_f_mount_mh(card, s_ctx[id]->fs, drv, pdrv, &s_ctx[id]->mount_config);
+
+    if (err != ESP_OK) {
+        unmount_card_core_mh(base_path, card);
+        ESP_LOGE(TAG, "failed to format, resources recycled, please mount again");
+    }
+
+    return ret;
+}

code/components/jomjol_helper/sdcard_init.h

@@ -0,0 +1,111 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stddef.h>
+#include "esp_err.h"
+#include "driver/gpio.h"
+#include "sdmmc_cmd.h"
+#include "driver/sdmmc_types.h"
+#include "driver/sdspi_host.h"
+#include "ff.h"
+#include "esp_vfs_fat.h"
+#include "wear_levelling.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Convenience function to get FAT filesystem on SD card registered in VFS
+ *
+ * This is an all-in-one function which does the following:
+ * - initializes SDMMC driver or SPI driver with configuration in host_config
+ * - initializes SD card with configuration in slot_config
+ * - mounts FAT partition on SD card using FATFS library, with configuration in mount_config
+ * - registers FATFS library with VFS, with prefix given by base_prefix variable
+ *
+ * This function is intended to make example code more compact.
+ * For real world applications, developers should implement the logic of
+ * probing SD card, locating and mounting partition, and registering FATFS in VFS,
+ * with proper error checking and handling of exceptional conditions.
+ *
+ * @note Use this API to mount a card through SDSPI is deprecated. Please call
+ *       `esp_vfs_fat_sdspi_mount()` instead for that case.
+ *
+ * @param base_path     path where partition should be registered (e.g. "/sdcard")
+ * @param host_config   Pointer to structure describing SDMMC host. When using
+ *                      SDMMC peripheral, this structure can be initialized using
+ *                      SDMMC_HOST_DEFAULT() macro. When using SPI peripheral,
+ *                      this structure can be initialized using SDSPI_HOST_DEFAULT()
+ *                      macro.
+ * @param slot_config   Pointer to structure with slot configuration.
+ *                      For SDMMC peripheral, pass a pointer to sdmmc_slot_config_t
+ *                      structure initialized using SDMMC_SLOT_CONFIG_DEFAULT.
+ * @param mount_config  pointer to structure with extra parameters for mounting FATFS
+ * @param[out] out_card  if not NULL, pointer to the card information structure will be returned via this argument
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount was already called
+ *      - ESP_ERR_NO_MEM if memory can not be allocated
+ *      - ESP_FAIL if partition can not be mounted
+ *      - other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
+ */
+esp_err_t esp_vfs_fat_sdmmc_mount_mh(const char* base_path, const sdmmc_host_t* host_config, const void* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card);
+
+/**
+ * @brief Convenience function to get FAT filesystem on SD card registered in VFS
+ *
+ * This is an all-in-one function which does the following:
+ * - initializes an SPI Master device based on the SPI Master driver with configuration in
+ *   slot_config, and attach it to an initialized SPI bus.
+ * - initializes SD card with configuration in host_config_input
+ * - mounts FAT partition on SD card using FATFS library, with configuration in mount_config
+ * - registers FATFS library with VFS, with prefix given by base_prefix variable
+ *
+ * This function is intended to make example code more compact.
+ * For real world applications, developers should implement the logic of
+ * probing SD card, locating and mounting partition, and registering FATFS in VFS,
+ * with proper error checking and handling of exceptional conditions.
+ *
+ * @note This function try to attach the new SD SPI device to the bus specified in host_config.
+ *       Make sure the SPI bus specified in `host_config->slot` have been initialized by
+ *       `spi_bus_initialize()` before.
+ *
+ * @param base_path     path where partition should be registered (e.g. "/sdcard")
+ * @param host_config_input Pointer to structure describing SDMMC host. This structure can be
+ *                          initialized using SDSPI_HOST_DEFAULT() macro.
+ * @param slot_config   Pointer to structure with slot configuration.
+ *                      For SPI peripheral, pass a pointer to sdspi_device_config_t
+ *                      structure initialized using SDSPI_DEVICE_CONFIG_DEFAULT().
+ * @param mount_config  pointer to structure with extra parameters for mounting FATFS
+ * @param[out] out_card If not NULL, pointer to the card information structure will be returned via
+ *                      this argument. It is suggested to hold this handle and use it to unmount the card later if
+ *                      needed. Otherwise it's not suggested to use more than one card at the same time and unmount one
+ *                      of them in your application.
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount was already called
+ *      - ESP_ERR_NO_MEM if memory can not be allocated
+ *      - ESP_FAIL if partition can not be mounted
+ *      - other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
+ */
+esp_err_t esp_vfs_fat_sdspi_mount_mh(const char* base_path, const sdmmc_host_t* host_config_input, const sdspi_device_config_t* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+
+
+
+
+
+
+

code/components/jomjol_helper/statusled.cpp

@@ -0,0 +1,153 @@
+#include "statusled.h"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include "driver/gpio.h"
+
+#include "ClassLogFile.h"
+#include "../../include/defines.h"
+
+// define `gpio_pad_select_gpip` for newer versions of IDF
+#if (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 0))
+#include "esp_rom_gpio.h"
+#define gpio_pad_select_gpio esp_rom_gpio_pad_select_gpio
+#endif
+
+static const char* TAG = "STATUSLED";
+
+TaskHandle_t xHandle_task_StatusLED = NULL;
+struct StatusLEDData StatusLEDData = {};
+
+
+void task_StatusLED(void *pvParameter)
+{
+    //ESP_LOGD(TAG, "task_StatusLED - create");
+	while (StatusLEDData.bProcessingRequest) 
+	{
+		//ESP_LOGD(TAG, "task_StatusLED - start");
+		struct StatusLEDData StatusLEDDataInt = StatusLEDData;
+
+		gpio_pad_select_gpio(BLINK_GPIO); // Init the GPIO
+		gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT); // Set the GPIO as a push/pull output
+		gpio_set_level(BLINK_GPIO, 1);// LED off
+
+		for (int i=0; i<2; ) // Default: repeat 2 times
+		{
+			if (!StatusLEDDataInt.bInfinite)
+				++i;
+
+			for (int j = 0; j < StatusLEDDataInt.iSourceBlinkCnt; ++j)
+			{
+				gpio_set_level(BLINK_GPIO, 0);
+				vTaskDelay(StatusLEDDataInt.iBlinkTime / portTICK_PERIOD_MS);
+				gpio_set_level(BLINK_GPIO, 1);      
+				vTaskDelay(StatusLEDDataInt.iBlinkTime / portTICK_PERIOD_MS);
+			}
+
+			vTaskDelay(500 / portTICK_PERIOD_MS);	// Delay between module code and error code
+
+			for (int j = 0; j < StatusLEDDataInt.iCodeBlinkCnt; ++j)
+			{
+				gpio_set_level(BLINK_GPIO, 0);      
+				vTaskDelay(StatusLEDDataInt.iBlinkTime / portTICK_PERIOD_MS);
+				gpio_set_level(BLINK_GPIO, 1);
+				vTaskDelay(StatusLEDDataInt.iBlinkTime / portTICK_PERIOD_MS);
+			}
+			vTaskDelay(1500 / portTICK_PERIOD_MS);	// Delay to signal new round
+		}
+
+		StatusLEDData.bProcessingRequest = false;
+		//ESP_LOGD(TAG, "task_StatusLED - done/wait");
+		vTaskDelay(10000 / portTICK_PERIOD_MS);	// Wait for an upcoming request otherwise continue and delete task to save memory
+	}
+	//ESP_LOGD(TAG, "task_StatusLED - delete");
+	xHandle_task_StatusLED = NULL;
+    vTaskDelete(NULL); // Delete this task due to no request
+}
+
+
+void StatusLED(StatusLedSource _eSource, int _iCode, bool _bInfinite)
+{
+	//ESP_LOGD(TAG, "StatusLED - start");
+
+    if (_eSource == WLAN_CONN) {
+		StatusLEDData.iSourceBlinkCnt = WLAN_CONN;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 250;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+	else if (_eSource == WLAN_INIT) {
+		StatusLEDData.iSourceBlinkCnt = WLAN_INIT;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 250;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+	else if (_eSource == SDCARD_INIT) {
+		StatusLEDData.iSourceBlinkCnt = SDCARD_INIT;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 250;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+	else if (_eSource == SDCARD_CHECK) {
+		StatusLEDData.iSourceBlinkCnt = SDCARD_CHECK;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 250;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+    else if (_eSource == CAM_INIT) {
+		StatusLEDData.iSourceBlinkCnt = CAM_INIT;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 250;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+    else if (_eSource == PSRAM_INIT) {
+		StatusLEDData.iSourceBlinkCnt = PSRAM_INIT;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 250;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+	else if (_eSource == TIME_CHECK) {
+		StatusLEDData.iSourceBlinkCnt = TIME_CHECK;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 250;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+	else if (_eSource == AP_OR_OTA) {
+		StatusLEDData.iSourceBlinkCnt = AP_OR_OTA;
+		StatusLEDData.iCodeBlinkCnt = _iCode;
+		StatusLEDData.iBlinkTime = 350;
+		StatusLEDData.bInfinite = _bInfinite;
+	}
+
+	if (xHandle_task_StatusLED && !StatusLEDData.bProcessingRequest) {
+		StatusLEDData.bProcessingRequest = true;
+		BaseType_t xReturned = xTaskAbortDelay(xHandle_task_StatusLED);	// Reuse still running status LED task
+		/*if (xReturned == pdPASS)
+			ESP_LOGD(TAG, "task_StatusLED - abort waiting delay");*/
+	}
+	else if (xHandle_task_StatusLED == NULL) {
+		StatusLEDData.bProcessingRequest = true;
+		BaseType_t xReturned = xTaskCreate(&task_StatusLED, "task_StatusLED", 1280, NULL, tskIDLE_PRIORITY+1, &xHandle_task_StatusLED);
+		if(xReturned != pdPASS)
+		{
+			xHandle_task_StatusLED = NULL;
+			LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "task_StatusLED failed to create");
+        	LogFile.WriteHeapInfo("task_StatusLED failed");
+		}
+	}
+	else {
+		ESP_LOGD(TAG, "task_StatusLED still processing, request skipped");	// Requests with high frequency could be skipped, but LED is only helpful for static states 
+	}
+	//ESP_LOGD(TAG, "StatusLED - done");
+}
+
+
+void StatusLEDOff(void)
+{
+	if (xHandle_task_StatusLED)
+		vTaskDelete(xHandle_task_StatusLED); // Delete task for StatusLED to force stop of blinking
+	
+	gpio_pad_select_gpio(BLINK_GPIO); // Init the GPIO
+	gpio_set_direction(BLINK_GPIO, GPIO_MODE_OUTPUT); // Set the GPIO as a push/pull output
+	gpio_set_level(BLINK_GPIO, 1);// LED off
+}

code/components/jomjol_helper/statusled.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#ifndef STATUSLED_H
+#define STATUSLED_H
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+
+
+extern TaskHandle_t xHandle_task_StatusLED;
+
+enum StatusLedSource {
+	WLAN_CONN = 1,
+    WLAN_INIT = 2,
+    SDCARD_INIT = 3,
+	SDCARD_CHECK = 4,
+    CAM_INIT = 5,
+    PSRAM_INIT = 6,
+    TIME_CHECK = 7,
+    AP_OR_OTA = 8
+};
+
+struct StatusLEDData {
+    int iSourceBlinkCnt = 1;
+    int iCodeBlinkCnt = 1;
+    int iBlinkTime = 250;
+    bool bInfinite = false;
+    bool bProcessingRequest = false;
+};
+
+void StatusLED(StatusLedSource _eSource, int _iCode, bool _bInfinite);
+void StatusLEDOff(void);
+
+#endif //STATUSLED_H

code/components/jomjol_image_proc/CAlignAndCutImage.cpp

@@ -2,21 +2,17 @@
 #include "CRotateImage.h"
 #include "ClassLogFile.h"
 
-#define _USE_MATH_DEFINES
 #include <math.h>
 #include <algorithm>
 #include <esp_log.h>
+#include "psram.h"
+#include "../../include/defines.h"
 
 static const char* TAG = "c_align_and_cut_image";
 
-//#define GET_MEMORY malloc
-#define GET_MEMORY(X) heap_caps_malloc(X, MALLOC_CAP_SPIRAM)
-
-// #define DEBUG_DETAIL_ON 
-
-
-CAlignAndCutImage::CAlignAndCutImage(CImageBasis *_org, CImageBasis *_temp)
+CAlignAndCutImage::CAlignAndCutImage(std::string _name, CImageBasis *_org, CImageBasis *_temp) : CImageBasis(_name)
 {
+    name = _name;
     rgb_image = _org->rgb_image;
     channels = _org->channels;
     width = _org->width;
@@ -43,18 +39,18 @@ bool CAlignAndCutImage::Align(RefInfo *_temp1, RefInfo *_temp2)
     int r0_x, r0_y, r1_x, r1_y;
     bool isSimilar1, isSimilar2;
 
-    CFindTemplate* ft = new CFindTemplate(rgb_image, channels, width, height, bpp);
+    CFindTemplate* ft = new CFindTemplate("align", rgb_image, channels, width, height, bpp);
 
     r0_x = _temp1->target_x;
     r0_y = _temp1->target_y;
-    ESP_LOGD(TAG, "Vor ft->FindTemplate(_temp1); %s", _temp1->image_file.c_str());
+    ESP_LOGD(TAG, "Before ft->FindTemplate(_temp1); %s", _temp1->image_file.c_str());
     isSimilar1 = ft->FindTemplate(_temp1);
     _temp1->width = ft->tpl_width;
     _temp1->height = ft->tpl_height; 
 
     r1_x = _temp2->target_x;
     r1_y = _temp2->target_y;
-    ESP_LOGD(TAG, "Vor ft->FindTemplate(_temp2); %s", _temp2->image_file.c_str());
+    ESP_LOGD(TAG, "Before ft->FindTemplate(_temp2); %s", _temp2->image_file.c_str());
     isSimilar2 = ft->FindTemplate(_temp2);
     _temp2->width = ft->tpl_width;
     _temp2->height = ft->tpl_height; 
@@ -78,16 +74,16 @@ bool CAlignAndCutImage::Align(RefInfo *_temp1, RefInfo *_temp2)
 
     d_winkel = (w_ist - w_org) * 180 / M_PI;
 
-#ifdef DEBUG_DETAIL_ON
+/*#ifdef DEBUG_DETAIL_ON
     std::string zw = "\tdx:\t" + std::to_string(dx) + "\tdy:\t" + std::to_string(dy) + "\td_winkel:\t" + std::to_string(d_winkel);
     zw = zw + "\tt1_x_y:\t" + std::to_string(_temp1->found_x) + "\t" + std::to_string(_temp1->found_y);
     zw = zw + "\tpara1_found_min_avg_max_SAD:\t" + std::to_string(_temp1->fastalg_min) + "\t" + std::to_string(_temp1->fastalg_avg) + "\t" + std::to_string(_temp1->fastalg_max) + "\t"+ std::to_string(_temp1->fastalg_SAD);
     zw = zw + "\tt2_x_y:\t" + std::to_string(_temp2->found_x) + "\t" + std::to_string(_temp2->found_y);
     zw = zw + "\tpara2_found_min_avg_max:\t" + std::to_string(_temp2->fastalg_min) + "\t" + std::to_string(_temp2->fastalg_avg) + "\t" + std::to_string(_temp2->fastalg_max) + "\t"+ std::to_string(_temp2->fastalg_SAD);
     LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", zw);
-#endif
+#endif*/
 
-    CRotateImage rt(this, ImageTMP);
+    CRotateImage rt("Align", this, ImageTMP);
     rt.Translate(dx, dy);
     rt.Rotate(d_winkel, _temp1->target_x, _temp1->target_y);
     ESP_LOGD(TAG, "Alignment: dx %d - dy %d - rot %f", dx, dy, d_winkel);
@@ -113,7 +109,7 @@ void CAlignAndCutImage::CutAndSave(std::string _template1, int x1, int y1, int d
     dy = y2 - y1;
 
     int memsize = dx * dy * channels;
-    uint8_t* odata = (unsigned char*) GET_MEMORY(memsize);
+    uint8_t* odata = (unsigned char*) malloc_psram_heap(std::string(TAG) + "->odata", memsize, MALLOC_CAP_SPIRAM);
 
     stbi_uc* p_target;
     stbi_uc* p_source;
@@ -129,8 +125,12 @@ void CAlignAndCutImage::CutAndSave(std::string _template1, int x1, int y1, int d
                 p_target[_channels] = p_source[_channels];
         }
 
-    //    stbi_write_jpg(_template1.c_str(), dx, dy, channels, odata, 0);
+#ifdef STBI_ONLY_JPEG
+    stbi_write_jpg(_template1.c_str(), dx, dy, channels, odata, 100);
+#else
     stbi_write_bmp(_template1.c_str(), dx, dy, channels, odata);
+#endif
+    
 
     RGBImageRelease();
 
@@ -188,7 +188,7 @@ CImageBasis* CAlignAndCutImage::CutAndSave(int x1, int y1, int dx, int dy)
     dy = y2 - y1;
 
     int memsize = dx * dy * channels;
-    uint8_t* odata = (unsigned char*)GET_MEMORY(memsize);
+    uint8_t* odata = (unsigned char*)malloc_psram_heap(std::string(TAG) + "->odata", memsize, MALLOC_CAP_SPIRAM);
 
     stbi_uc* p_target;
     stbi_uc* p_source;
@@ -204,7 +204,7 @@ CImageBasis* CAlignAndCutImage::CutAndSave(int x1, int y1, int dx, int dy)
                 p_target[_channels] = p_source[_channels];
         }
 
-    CImageBasis* rs = new CImageBasis(odata, channels, dx, dy, bpp);
+    CImageBasis* rs = new CImageBasis("CutAndSave", odata, channels, dx, dy, bpp);
     RGBImageRelease();
     rs->SetIndepended();
     return rs;

code/components/jomjol_image_proc/CAlignAndCutImage.h

@@ -1,3 +1,8 @@
+#pragma once
+
+#ifndef CALIGNANDCUTIMAGE_H
+#define CALIGNANDCUTIMAGE_H
+
 #include "CImageBasis.h"
 #include "CFindTemplate.h"
 
@@ -7,9 +12,9 @@ class CAlignAndCutImage : public CImageBasis
     public:
         int t0_dx, t0_dy, t1_dx, t1_dy;
         CImageBasis *ImageTMP;
-        CAlignAndCutImage(std::string _image) : CImageBasis(_image) {ImageTMP = NULL;};
-        CAlignAndCutImage(uint8_t* _rgb_image, int _channels, int _width, int _height, int _bpp) : CImageBasis(_rgb_image, _channels, _width, _height, _bpp) {ImageTMP = NULL;};
-        CAlignAndCutImage(CImageBasis *_org, CImageBasis *_temp);
+        CAlignAndCutImage(std::string name, std::string _image) : CImageBasis(name, _image) {ImageTMP = NULL;};
+        CAlignAndCutImage(std::string name, uint8_t* _rgb_image, int _channels, int _width, int _height, int _bpp) : CImageBasis(name, _rgb_image, _channels, _width, _height, _bpp) {ImageTMP = NULL;};
+        CAlignAndCutImage(std::string name, CImageBasis *_org, CImageBasis *_temp);
 
         bool Align(RefInfo *_temp1, RefInfo *_temp2);
 //        void Align(std::string _template1, int x1, int y1, std::string _template2, int x2, int y2, int deltax = 40, int deltay = 40, std::string imageROI = "");
@@ -19,3 +24,4 @@ class CAlignAndCutImage : public CImageBasis
         void GetRefSize(int *ref_dx, int *ref_dy);
 };
 
+#endif //CALIGNANDCUTIMAGE_H

code/components/jomjol_image_proc/CFindTemplate.cpp

@@ -2,6 +2,7 @@
 
 #include "ClassLogFile.h"
 #include "Helper.h"
+#include "../../include/defines.h"
 
 #include <esp_log.h>
 
@@ -67,11 +68,11 @@ bool CFindTemplate::FindTemplate(RefInfo *_ref)
     if ((_ref->alignment_algo == 2) && (_ref->fastalg_x > -1) && (_ref->fastalg_y > -1))     // für Testzwecke immer Berechnen
     {
         isSimilar = CalculateSimularities(rgb_template, _ref->fastalg_x, _ref->fastalg_y, ow, oh, min, avg, max, SAD, _ref->fastalg_SAD, _ref->fastalg_SAD_criteria);
-#ifdef DEBUG_DETAIL_ON  
+/*#ifdef DEBUG_DETAIL_ON
         std::string zw = "\t" + _ref->image_file + "\tt1_x_y:\t" + std::to_string(_ref->fastalg_x) + "\t" + std::to_string(_ref->fastalg_y);
         zw = zw + "\tpara1_found_min_avg_max_SAD:\t" + std::to_string(min) + "\t" + std::to_string(avg) + "\t" + std::to_string(max) + "\t"+ std::to_string(SAD);
         LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", zw);
-#endif
+#endif*/
     }
 
 //    ESP_LOGD(TAG, "FindTemplate 03");
@@ -143,11 +144,11 @@ bool CFindTemplate::FindTemplate(RefInfo *_ref)
     _ref->fastalg_SAD = SAD;
 
     
-#ifdef DEBUG_DETAIL_ON  
+/*#ifdef DEBUG_DETAIL_ON
     std::string zw = "\t" + _ref->image_file + "\tt1_x_y:\t" + std::to_string(_ref->fastalg_x) + "\t" + std::to_string(_ref->fastalg_y);
     zw = zw + "\tpara1_found_min_avg_max_SAD:\t" + std::to_string(min) + "\t" + std::to_string(avg) + "\t" + std::to_string(max) + "\t"+ std::to_string(SAD);
     LogFile.WriteToDedicatedFile("/sdcard/alignment.txt", zw);
-#endif
+#endif*/
 
     RGBImageRelease();
     stbi_image_free(rgb_template);

code/components/jomjol_image_proc/CFindTemplate.h

@@ -1,5 +1,7 @@
-#ifndef __CFINDTEMPLATE_CLASS
-#define __CFINDTEMPLATE_CLASS
+#pragma once
+
+#ifndef CFINDTEMPLATE_H
+#define CFINDTEMPLATE_H
 
 #include "CImageBasis.h"
 
@@ -30,11 +32,11 @@ class CFindTemplate : public CImageBasis
 {
     public:
         int tpl_width, tpl_height, tpl_bpp;    
-        CFindTemplate(uint8_t* _rgb_image, int _channels, int _width, int _height, int _bpp) : CImageBasis(_rgb_image, _channels, _width, _height, _bpp) {};
+        CFindTemplate(std::string name, uint8_t* _rgb_image, int _channels, int _width, int _height, int _bpp) : CImageBasis(name, _rgb_image, _channels, _width, _height, _bpp) {};
 
         bool FindTemplate(RefInfo *_ref);
 
         bool CalculateSimularities(uint8_t* _rgb_tmpl, int _startx, int _starty, int _sizex, int _sizey, int &min, float &avg, int &max, float &SAD, float _SADold, float _SADcrit);
 };
 
-#endif
+#endif //CFINDTEMPLATE_H