v15.5.0 (#2850) (#2851)

* update

* Revert "v15.4.0"

This reverts commit 74d4f20858.

* Revert "prepare v15.4.0 versuch 2"

This reverts commit e790a14caa.

* revert submnodules (#2768)



* Update submodules (#2769)

- Update `esp-nn` to v1.0.2
- Update `esp32-camera` to v2.0.6
- Updated `tflite-micro-esp-examples` (The repo got renamed to `esp-tflite-micro ` and the folder structure got cleaned up).

* fix(unity-test): Run unity tests in dedicated task
Avoid running out of heap

* Add delay

* Update

* Update

* Enhance busy notification (#2774)

* on marker updating, show message and retry until round got completed

* same for contrast enhancement

---------



* Fix negatives on extended resolution false #2744 (#2772)

* not extended resolution allows -1 on the lowest digit

* not extended resolution allows -1 on the lowest number

* negatives on last value digit with -1 will set to prevalue and is not an error  #2744

---------



* Implemented late analog / digital transition (#2778)

* Implemented late transition

Complete rewrite of analog / digital transition

Two tests is still failing, which need to be discussed.

* Allow wider range of transition values to support late transition

* Added documentation

* Fix testings (#2783)

* fix all tests and more description

* The decimal point offset. -3 corresponds to x.yyy

---------



* Bugfix InfluxDB shifting times (#2785)

* Modify time_sntp

* Update time_sntp.cpp

* Update time_sntp.cpp

* update

* Update interface_influxdb.cpp

* Update interface_influxdb.cpp

* Update time_sntp.cpp

* Upload

* Update interface_influxdb.cpp

* Update interface_influxdb.cpp

* Update interface_influxdb.cpp

* Remove Time Convert vom influx Interface

* Update platform-espressif32 to 6.5.0 (#2770)

* Update ESP IDF to 6.5.0

* Migration to new IDF

* Correct smtp vor v5.1

---------




* ATA-Trim support (#2781)

* Add files via upload

* Update main.cpp

* Update main.cpp

* Update main.cpp

* Update Helper.cpp

* Update Helper.h

* Update CMakeLists.txt

* Update CMakeLists.txt

* Update diskio_sdmmc_mh.c

* Update diskio_sdmmc_mh.h

* Update ff_mh.c

* Update vfs_fat_sdmmc_mh.c

* Update sdmmc_common_mh.h

* Update sdmmc_common_mh.c

* Update Helper.cpp

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update ff_mh.c

---------



* Update Changelog.md

* Add device info info page (#2789)



* fix chip information REST API

* Update pipelines to fix warnings (#2841)

Update actions

* Move param doc (#2843)

moved param doc from docs repo to here

* fix(tflite): Fix memory leaks in tflite integration (#2842)

* Update Changelog.md (#2849)

---------

Signed-off-by: Florian Grabmeier <flo.grabmeier@gmail.com>
Co-authored-by: jomjol <30766535+jomjol@users.noreply.github.com>
Co-authored-by: CaCO3 <caco@ruinelli.ch>
Co-authored-by: Slider0007 <jobbelle@gmx.net>
Co-authored-by: Frank Haverland <fspapaping@googlemail.com>
Co-authored-by: Martin Siggel <martin.siggel@dlr.de>
Co-authored-by: michael <Heinrich-Tuning@web.de>
Co-authored-by: flox_x <93255373+flooxo@users.noreply.github.com>
Co-authored-by: Slider0007 <115730895+Slider0007@users.noreply.github.com>

.github/label-commenter-config.yml

@@ -3,7 +3,32 @@
 # 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:     
+ 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
   #######################################################################

.github/workflows/build.yml

@@ -15,7 +15,7 @@ jobs:
       with:
         concurrent_skipping: same_content_newer
     
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         submodules: recursive
 
@@ -25,28 +25,28 @@ jobs:
         echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
 
     - name: Update PIP cache on every commit
-      uses: actions/cache@v3.2.3
+      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@v3.2.3
+      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@v3.2.3
+      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@v3.2.3
+      uses: actions/cache@v4
       with:
         path: |
           ./code/.pio/build/esp32cam/firmware.bin
@@ -57,7 +57,7 @@ jobs:
         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@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.10'
 
@@ -70,7 +70,7 @@ jobs:
       #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 (copy data from repo, generate tooltip pages and update hashes in all files)
+    - name: Prepare Web UI (generate tooltip pages and update hashes in all files)
       run: |
         rm -rf ./html
         mkdir html
@@ -79,7 +79,7 @@ jobs:
         python -m pip install markdown
         mkdir html/param-tooltips
         cd tools/parameter-tooltip-generator
-        bash generate-param-doc-tooltips.sh
+        python generate-param-doc-tooltips.py
         cd ../..
 
         cp -r ./sd-card/html/* ./html/
@@ -101,10 +101,10 @@ jobs:
     needs: build
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Update generated-files cache on every commit
-      uses: actions/cache@v3.2.3
+      uses: actions/cache@v4
       with:
         path: |
           ./code/.pio/build/esp32cam/firmware.bin
@@ -115,7 +115,7 @@ jobs:
         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@v3.2.3
+      uses: actions/cache@v4
       with:
         path: update
         key: update-${{ github.run_id }}
@@ -144,7 +144,7 @@ jobs:
         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@v3
+      uses: actions/upload-artifact@v4
       with:
         name: "AI-on-the-edge-device__update__${{ steps.vars.outputs.branch }}_(${{ steps.vars.outputs.sha_short }})"
         path: ./update/*
@@ -164,10 +164,10 @@ jobs:
     needs: build
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Update generated-files cache on every commit
-      uses: actions/cache@v3.2.3
+      uses: actions/cache@v4
       with:
         path: |
           ./code/.pio/build/esp32cam/firmware.bin
@@ -178,7 +178,7 @@ jobs:
         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@v3.2.3
+      uses: actions/cache@v4
       with:
         path: remote_setup
         key: remote_setup-${{ github.run_id }}
@@ -205,7 +205,7 @@ jobs:
         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@v3
+      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/*
@@ -220,10 +220,10 @@ jobs:
     needs: build
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
 
     - name: Update generated-files cache on every commit
-      uses: actions/cache@v3.2.3
+      uses: actions/cache@v4
       with:
         path: |
           ./code/.pio/build/esp32cam/firmware.bin
@@ -234,7 +234,7 @@ jobs:
         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@v3.2.3
+      uses: actions/cache@v4
       with:
         path: manual_setup
         key: manual_setup-${{ github.run_id }}
@@ -263,7 +263,7 @@ jobs:
         cd ./manual_setup
   
     - name: Upload manual_setup.zip artifact (Firmware + Bootloader + Partitions + Web UI)
-      uses: actions/upload-artifact@v3
+      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
@@ -284,24 +284,24 @@ jobs:
       id-token: write
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     
     - name: Update update cache on every commit
-      uses: actions/cache@v3.2.3
+      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@v3.2.3
+      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@v3.2.3
+      uses: actions/cache@v4
       with:
         path: manual_setup
         key: manual_setup-${{ github.run_id }}
@@ -380,7 +380,7 @@ jobs:
 #########################################################################################
 ## Update the Web Installer on a release
 #########################################################################################
-# This is the same as in the update-webinstaller.yml
+# Make sure to also update update-webinstaller.yml!
   update-web-installer:    
     needs: [release]
     environment:
@@ -396,7 +396,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
       
     - name: Get version of last release
       id: last_release
@@ -408,20 +408,22 @@ jobs:
       
     - 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
-        cp -f docs/manifest_template.json docs/manifest.json
-        sed -i 's/VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/manifest.json
+        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
+      uses: actions/configure-pages@v4
 
     - name: Upload artifact
-      uses: actions/upload-pages-artifact@v1
+      uses: actions/upload-pages-artifact@v2
       with:
         path: 'docs'
 
     - name: Deploy to GitHub Pages
       id: deployment
-      uses: actions/deploy-pages@v1   
+      uses: actions/deploy-pages@v4

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

@@ -1,7 +1,7 @@
 # This updates the Web Installer with the files from the docs folder and the binary of the latest release
 # it only gets run on:
-#  - Changes to the docs folder in the `rolling` branch
-#  - On a release
+#  - Manually triggered
+# Make sure to also update the lower part of build.yml!
 
 name: Manual Web Installer Update
 
@@ -40,12 +40,14 @@ jobs:
       
     - 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
-        cp -f docs/manifest_template.json docs/manifest.json
-        sed -i 's/VERSION/${{ steps.last_release.outputs.tag_name }}/g' docs/manifest.json
+        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

.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,9 +1,129 @@
+## [15.5.0] - 2024-02-02
+
+### Changes
+
+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
+
+### Changes
+
+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
+
+### Changes
+
+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
+
+### Changes
+
+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
+
+### Changes
+
+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
 
-### 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/v15.1.0...v15.1.1)
@@ -933,6 +1053,9 @@ External Illumination
 -   Initial Version
 
 
+[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

FeatureRequest.md

@@ -2,15 +2,41 @@
 
 **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
@@ -51,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
 
@@ -89,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,31 +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://jomjol.github.io/AI-on-the-edge-device-docs/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
-- Tensorflow Lite (TFlite) integration - including easy to use wrapper
-- Inline Image processing (feature detection, alignment, ROI extraction)
-- **Small** and **cheap** device (3x4.5x2 cm³, < 10 EUR)
-- camera and illumination integrated
-- Web surface to administrate and control
-- OTA-Interface to update directly through the web interface
+- 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
+- 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"> 
 
@@ -41,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 [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 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 [Docu](https://jomjol.github.io/AI-on-the-edge-device-docs/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 [Docu](https://jomjol.github.io/AI-on-the-edge-device-docs/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 [Docu](https://jomjol.github.io/AI-on-the-edge-device-docs/outdated--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,4 +1,5 @@
 .pio
+.idea
 .vscode/.browse.c_cpp.db*
 .vscode/c_cpp_properties.json
 .vscode/launch.json

code/CMakeLists.txt

@@ -1,6 +1,6 @@
 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

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/esp-fatfs/CMakeLists.txt

@@ -0,0 +1,18 @@
+set(srcs "diskio/diskio_mh.c"
+         "diskio/diskio_rawflash_mh.c"
+         "diskio/diskio_sdmmc_mh.c"
+         "diskio/diskio_wl_mh.c"
+         "src/ff_mh.c"
+         "port/freertos/ffsystem_mh.c"
+         "src/ffunicode_mh.c"
+         "vfs/vfs_fat_mh.c"
+         "vfs/vfs_fat_sdmmc_mh.c"
+         "vfs/vfs_fat_spiflash_mh.c")
+
+idf_component_register(SRCS ${srcs}
+                       INCLUDE_DIRS "." diskio vfs src
+                       REQUIRES wear_levelling esp-sdmmc
+                       PRIV_REQUIRES vfs spi_flash
+                      )
+
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

code/components/esp-fatfs/README.md

@@ -0,0 +1,278 @@
+# AIOTED related changes, see https://github.com/jomjol/AI-on-the-edge-device/pull/2781
+These files/folders were copied from `framework-espidf@3.50002.230601/components/` and adapted to our own needs.
+Since not every SD/MMC was recognized and this was due to the implementation of ATA trim support, this was revised.
+Furthermore, files that we don't need were deleted from it.
+
+## The most relevant changes are:
+### fatfs/diskio/diskio_sdmmc.c
+DRESULT ff_sdmmc_ioctl (BYTE pdrv, BYTE cmd, void* buff), at lines 106 to 110 changed from:
+```c
+#if FF_USE_TRIM
+        case CTRL_TRIM:
+            return ff_sdmmc_trim (pdrv, *((DWORD*)buff), //start_sector
+                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
+#endif //FF_USE_TRIM
+```
+to:
+```c
+#if (FF_USE_TRIM)
+        case CTRL_TRIM:
+            if(FF_CAN_TRIM){
+                return ff_sdmmc_trim (pdrv, *((DWORD*)buff), //start_sector
+                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
+            }
+            else{
+                return RES_ERROR;
+            }
+#endif //FF_USE_TRIM
+```
+
+### fatfs/src/ff.c
+added:
+```c
+#include "sdmmc_cmd.h"
+```
+
+static FRESULT remove_chain(FFOBJID* obj, DWORD clst, DWORD pclst), at lines 1437 to 1454 changed from:
+```c
+#if FF_FS_EXFAT || FF_USE_TRIM
+		if (ecl + 1 == nxt) {	/* Is next cluster contiguous? */
+			ecl = nxt;
+		} else {				/* End of contiguous cluster block */
+#if FF_FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				res = change_bitmap(fs, scl, ecl - scl + 1, 0);	/* Mark the cluster block 'free' on the bitmap */
+				if (res != FR_OK) return res;
+			}
+#endif
+#if FF_USE_TRIM
+			rt[0] = clst2sect(fs, scl);					/* Start of data area to be freed */
+			rt[1] = clst2sect(fs, ecl) + fs->csize - 1;	/* End of data area to be freed */
+			disk_ioctl(fs->pdrv, CTRL_TRIM, rt);		/* Inform storage device that the data in the block may be erased */
+#endif
+			scl = ecl = nxt;
+		}
+#endif
+```
+
+to:
+```c
+#if FF_FS_EXFAT || FF_USE_TRIM
+		if(FF_FS_EXFAT || FF_CAN_TRIM){
+			if (ecl + 1 == nxt) {	/* Is next cluster contiguous? */
+				ecl = nxt;
+			} 
+			else {				/* End of contiguous cluster block */
+#if FF_FS_EXFAT
+				if (fs->fs_type == FS_EXFAT) {
+					res = change_bitmap(fs, scl, ecl - scl + 1, 0);	/* Mark the cluster block 'free' on the bitmap */
+					if (res != FR_OK) return res;
+				}
+#endif
+#if FF_USE_TRIM
+				if(FF_CAN_TRIM){
+					rt[0] = clst2sect(fs, scl);					/* Start of data area to be freed */
+					rt[1] = clst2sect(fs, ecl) + fs->csize - 1;	/* End of data area to be freed */
+					disk_ioctl(fs->pdrv, CTRL_TRIM, rt);		/* Inform storage device that the data in the block may be erased */
+				}
+#endif
+				scl = ecl = nxt;
+			}
+		}
+#endif
+```
+
+FRESULT f_mkfs(const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len), at lines 5946 to 5949 changed from:
+```c
+#if FF_USE_TRIM
+		lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+		disk_ioctl(pdrv, CTRL_TRIM, lba);
+#endif
+```
+to:
+```c
+#if FF_USE_TRIM
+		if(FF_CAN_TRIM){
+			lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+			disk_ioctl(pdrv, CTRL_TRIM, lba);
+		}
+#endif
+```
+
+FRESULT f_mkfs(const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len), at lines 6175 to 6178 changed from:
+```c
+#if FF_USE_TRIM
+		lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+		disk_ioctl(pdrv, CTRL_TRIM, lba);
+#endif
+```
+to:
+```c
+#if FF_USE_TRIM
+		if(FF_CAN_TRIM){
+			lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+			disk_ioctl(pdrv, CTRL_TRIM, lba);
+		}
+#endif
+```
+
+### sdmmc/sdmmc_cmd.c
+added:
+```c
+int FF_CAN_TRIM = 0;
+```
+
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card), at lines 630 to 636 changed from:
+```c
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card)
+{
+    if ((card->is_mmc) && (card->ext_csd.sec_feature & EXT_CSD_SEC_GB_CL_EN)) {
+        return ESP_OK;
+    }
+    return ESP_FAIL;
+}
+```
+to:
+```c
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card)
+{
+    if ((card->is_mmc) && (card->ext_csd.sec_feature & EXT_CSD_SEC_GB_CL_EN)) {
+        FF_CAN_TRIM = 1;
+        return ESP_OK;
+    }
+    FF_CAN_TRIM = 0;
+    return ESP_FAIL;
+}
+```
+
+### sdmmc/include/sdmmc_cmd.h
+
+added:
+```c
+extern int FF_CAN_TRIM;
+```
+
+# Espressif IoT Development Framework
+
+* [中文版](./README_CN.md)
+
+ESP-IDF is the development framework for Espressif SoCs supported on Windows, Linux and macOS.
+
+# ESP-IDF Release Support Schedule
+
+![Support Schedule](https://dl.espressif.com/dl/esp-idf/support-periods.svg)
+
+- Please read [the support policy](SUPPORT_POLICY.md) and [the documentation](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/versions.html) for more information about ESP-IDF versions.
+- Please see the [End-of-Life Advisories](https://www.espressif.com/en/support/documents/advisories?keys=&field_type_of_advisory_tid%5B%5D=817) for information about ESP-IDF releases with discontinued support.
+
+# ESP-IDF Release and SoC Compatibility
+
+The following table shows ESP-IDF support of Espressif SoCs where ![alt text][preview] and ![alt text][supported] denote preview status and support, respectively. The preview support is usually limited in time and intended for beta versions of chips. Please use an ESP-IDF release where the desired SoC is already supported.
+
+|Chip         |          v4.1         |          v4.2          |         v4.3           |          v4.4          |          v5.0          |                                                                                      |
+|:----------- |:---------------------:| :---------------------:| :---------------------:| :---------------------:| :---------------------:|:------------------------------------------------------------------------------------ |
+|ESP32        |![alt text][supported] | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] |                                                                                      |
+|ESP32-S2     |                       | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] |                                                                                      |
+|ESP32-C3     |                       |                        | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] |                                                                                      |
+|ESP32-S3     |                       |                        |                        | ![alt text][supported] | ![alt text][supported] | [Announcement](https://www.espressif.com/en/news/ESP32_S3)                           |
+|ESP32-C2     |                       |                        |                        |                        | ![alt text][supported] | [Announcement](https://blog.espressif.com/esp32-c2-and-why-it-matter-s-bcf4d7d0b2c6) |
+|ESP32-H2     |                       |                        |                        | ![alt text][preview]   | ![alt text][preview]   | [Announcement](https://www.espressif.com/en/news/ESP32_H2)                           |
+
+[supported]: https://img.shields.io/badge/-supported-green "supported"
+[preview]: https://img.shields.io/badge/-preview-orange "preview"
+
+Espressif SoCs released before 2016 (ESP8266 and ESP8285) are supported by [RTOS SDK](https://github.com/espressif/ESP8266_RTOS_SDK) instead.
+
+# Developing With ESP-IDF
+
+## Setting Up ESP-IDF
+
+See https://idf.espressif.com/ for links to detailed instructions on how to set up the ESP-IDF depending on chip you use.
+
+**Note:** Each SoC series and each ESP-IDF release has its own documentation. Please see Section [Versions](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/versions.html) on how to find documentation and how to checkout specific release of ESP-IDF.
+
+### Non-GitHub forks
+
+ESP-IDF uses relative locations as its submodules URLs ([.gitmodules](.gitmodules)). So they link to GitHub. If ESP-IDF is forked to a Git repository which is not on GitHub, you will need to run the script [tools/set-submodules-to-github.sh](tools/set-submodules-to-github.sh) after git clone.
+
+The script sets absolute URLs for all submodules, allowing `git submodule update --init --recursive` to complete. If cloning ESP-IDF from GitHub, this step is not needed.
+
+## Finding a Project
+
+As well as the [esp-idf-template](https://github.com/espressif/esp-idf-template) project mentioned in Getting Started, ESP-IDF comes with some example projects in the [examples](examples) directory.
+
+Once you've found the project you want to work with, change to its directory and you can configure and build it.
+
+To start your own project based on an example, copy the example project directory outside of the ESP-IDF directory.
+
+# Quick Reference
+
+See the Getting Started guide links above for a detailed setup guide. This is a quick reference for common commands when working with ESP-IDF projects:
+
+## Setup Build Environment
+
+(See the Getting Started guide listed above for a full list of required steps with more details.)
+
+* Install host build dependencies mentioned in the Getting Started guide.
+* Run the install script to set up the build environment. The options include `install.bat` or `install.ps1` for Windows, and `install.sh` or `install.fish` for Unix shells.
+* Run the export script on Windows (`export.bat`) or source it on Unix (`source export.sh`) in every shell environment before using ESP-IDF.
+
+## Configuring the Project
+
+* `idf.py set-target <chip_name>` sets the target of the project to `<chip_name>`. Run `idf.py set-target` without any arguments to see a list of supported targets.
+* `idf.py menuconfig` opens a text-based configuration menu where you can configure the project.
+
+## Compiling the Project
+
+`idf.py build`
+
+... will compile app, bootloader and generate a partition table based on the config.
+
+## Flashing the Project
+
+When the build finishes, it will print a command line to use esptool.py to flash the chip. However you can also do this automatically by running:
+
+`idf.py -p PORT flash`
+
+Replace PORT with the name of your serial port (like `COM3` on Windows, `/dev/ttyUSB0` on Linux, or `/dev/cu.usbserial-X` on MacOS. If the `-p` option is left out, `idf.py flash` will try to flash the first available serial port.
+
+This will flash the entire project (app, bootloader and partition table) to a new chip. The settings for serial port flashing can be configured with `idf.py menuconfig`.
+
+You don't need to run `idf.py build` before running `idf.py flash`, `idf.py flash` will automatically rebuild anything which needs it.
+
+## Viewing Serial Output
+
+The `idf.py monitor` target uses the [idf_monitor tool](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/idf-monitor.html) to display serial output from Espressif SoCs. idf_monitor also has a range of features to decode crash output and interact with the device. [Check the documentation page for details](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/idf-monitor.html).
+
+Exit the monitor by typing Ctrl-].
+
+To build, flash and monitor output in one pass, you can run:
+
+`idf.py flash monitor`
+
+## Compiling & Flashing Only the App
+
+After the initial flash, you may just want to build and flash just your app, not the bootloader and partition table:
+
+* `idf.py app` - build just the app.
+* `idf.py app-flash` - flash just the app.
+
+`idf.py app-flash` will automatically rebuild the app if any source files have changed.
+
+(In normal development there's no downside to reflashing the bootloader and partition table each time, if they haven't changed.)
+
+## Erasing Flash
+
+The `idf.py flash` target does not erase the entire flash contents. However it is sometimes useful to set the device back to a totally erased state, particularly when making partition table changes or OTA app updates. To erase the entire flash, run `idf.py erase-flash`.
+
+This can be combined with other targets, ie `idf.py -p PORT erase-flash flash` will erase everything and then re-flash the new app, bootloader and partition table.
+
+# Resources
+
+* Documentation for the latest version: https://docs.espressif.com/projects/esp-idf/. This documentation is built from the [docs directory](docs) of this repository.
+
+* The [esp32.com forum](https://esp32.com/) is a place to ask questions and find community resources.
+
+* [Check the Issues section on github](https://github.com/espressif/esp-idf/issues) if you find a bug or have a feature request. Please check existing Issues before opening a new one.
+
+* If you're interested in contributing to ESP-IDF, please check the [Contributions Guide](https://docs.espressif.com/projects/esp-idf/en/latest/contribute/index.html).

code/components/esp-fatfs/diskio/diskio_impl_mh.h

@@ -0,0 +1,72 @@
+// Copyright 2017-2019 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.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+typedef unsigned int UINT;
+typedef unsigned char BYTE;
+typedef uint32_t DWORD;
+
+#define FF_DRV_NOT_USED 0xFF
+
+#include "diskio_mh.h"
+#include "esp_err.h"
+
+/**
+ * Structure of pointers to disk IO driver functions.
+ *
+ * See FatFs documentation for details about these functions
+ */
+typedef struct {
+    DSTATUS (*init) (unsigned char pdrv);    /*!< disk initialization function */
+    DSTATUS (*status) (unsigned char pdrv);  /*!< disk status check function */
+    DRESULT (*read) (unsigned char pdrv, unsigned char* buff, uint32_t sector, unsigned count);  /*!< sector read function */
+    DRESULT (*write) (unsigned char pdrv, const unsigned char* buff, uint32_t sector, unsigned count);   /*!< sector write function */
+    DRESULT (*ioctl) (unsigned char pdrv, unsigned char cmd, void* buff); /*!< function to get info about disk and do some misc operations */
+} ff_diskio_impl_t;
+
+/**
+ * Register or unregister diskio driver for given drive number.
+ *
+ * When FATFS library calls one of disk_xxx functions for driver number pdrv,
+ * corresponding function in discio_impl for given pdrv will be called.
+ *
+ * @param pdrv drive number
+ * @param discio_impl   pointer to ff_diskio_impl_t structure with diskio functions
+ *                      or NULL to unregister and free previously registered drive
+ */
+void ff_diskio_register(BYTE pdrv, const ff_diskio_impl_t* discio_impl);
+
+#define ff_diskio_unregister(pdrv_) ff_diskio_register(pdrv_, NULL)
+
+
+/**
+ * Get next available drive number
+ *
+ * @param   out_pdrv            pointer to the byte to set if successful
+ *
+ * @return  ESP_OK              on success
+ *          ESP_ERR_NOT_FOUND   if all drives are attached
+ */
+esp_err_t ff_diskio_get_drive(BYTE* out_pdrv);
+
+
+#ifdef __cplusplus
+}
+#endif

code/components/esp-fatfs/diskio/diskio_mh.c

@@ -0,0 +1,117 @@
+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module skeleton for FatFs     (C)ChaN, 2016        */
+/* ESP-IDF port Copyright 2016 Espressif Systems (Shanghai) PTE LTD      */
+/*-----------------------------------------------------------------------*/
+/* If a working storage control module is available, it should be        */
+/* attached to the FatFs via a glue function rather than modifying it.   */
+/* This is an example of glue functions to attach various exsisting      */
+/* storage control modules to the FatFs module with a defined API.       */
+/*-----------------------------------------------------------------------*/
+
+#include <string.h>
+#include <time.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include "diskio_impl_mh.h"
+#include "ffconf_mh.h"
+#include "ff_mh.h"
+
+static ff_diskio_impl_t * s_impls[FF_VOLUMES] = { NULL };
+
+#if FF_MULTI_PARTITION		/* Multiple partition configuration */
+const PARTITION VolToPart[FF_VOLUMES] = {
+    {0, 0},    /* Logical drive 0 ==> Physical drive 0, auto detection */
+    {1, 0},    /* Logical drive 1 ==> Physical drive 1, auto detection */
+#if FF_VOLUMES > 2
+    {2, 0},     /* Logical drive 2 ==> Physical drive 2, auto detection */
+#endif
+#if FF_VOLUMES > 3
+    {3, 0},     /* Logical drive 3 ==> Physical drive 3, auto detection */
+#endif
+#if FF_VOLUMES > 4
+    {4, 0},     /* Logical drive 4 ==> Physical drive 4, auto detection */
+#endif
+#if FF_VOLUMES > 5
+    {5, 0},     /* Logical drive 5 ==> Physical drive 5, auto detection */
+#endif
+#if FF_VOLUMES > 6
+    {6, 0},     /* Logical drive 6 ==> Physical drive 6, auto detection */
+#endif
+#if FF_VOLUMES > 7
+    {7, 0},     /* Logical drive 7 ==> Physical drive 7, auto detection */
+#endif
+#if FF_VOLUMES > 8
+    {8, 0},     /* Logical drive 8 ==> Physical drive 8, auto detection */
+#endif
+#if FF_VOLUMES > 9
+    {9, 0},     /* Logical drive 9 ==> Physical drive 9, auto detection */
+#endif
+};
+#endif
+
+esp_err_t ff_diskio_get_drive(BYTE* out_pdrv)
+{
+    BYTE i;
+    for(i=0; i<FF_VOLUMES; i++) {
+        if (!s_impls[i]) {
+            *out_pdrv = i;
+            return ESP_OK;
+        }
+    }
+    return ESP_ERR_NOT_FOUND;
+}
+
+void ff_diskio_register(BYTE pdrv, const ff_diskio_impl_t* discio_impl)
+{
+    assert(pdrv < FF_VOLUMES);
+
+    if (s_impls[pdrv]) {
+        ff_diskio_impl_t* im = s_impls[pdrv];
+        s_impls[pdrv] = NULL;
+        free(im);
+    }
+
+    if (!discio_impl) {
+        return;
+    }
+
+    ff_diskio_impl_t * impl = (ff_diskio_impl_t *)malloc(sizeof(ff_diskio_impl_t));
+    assert(impl != NULL);
+    memcpy(impl, discio_impl, sizeof(ff_diskio_impl_t));
+    s_impls[pdrv] = impl;
+}
+
+DSTATUS ff_disk_initialize (BYTE pdrv)
+{
+    return s_impls[pdrv]->init(pdrv);
+}
+DSTATUS ff_disk_status (BYTE pdrv)
+{
+    return s_impls[pdrv]->status(pdrv);
+}
+DRESULT ff_disk_read (BYTE pdrv, BYTE* buff, LBA_t sector, UINT count)
+{
+    return s_impls[pdrv]->read(pdrv, buff, sector, count);
+}
+DRESULT ff_disk_write (BYTE pdrv, const BYTE* buff, LBA_t sector, UINT count)
+{
+    return s_impls[pdrv]->write(pdrv, buff, sector, count);
+}
+DRESULT ff_disk_ioctl (BYTE pdrv, BYTE cmd, void* buff)
+{
+    return s_impls[pdrv]->ioctl(pdrv, cmd, buff);
+}
+
+DWORD get_fattime(void)
+{
+    time_t t = time(NULL);
+    struct tm tmr;
+    localtime_r(&t, &tmr);
+    int year = tmr.tm_year < 80 ? 0 : tmr.tm_year - 80;
+    return    ((DWORD)(year) << 25)
+            | ((DWORD)(tmr.tm_mon + 1) << 21)
+            | ((DWORD)tmr.tm_mday << 16)
+            | (WORD)(tmr.tm_hour << 11)
+            | (WORD)(tmr.tm_min << 5)
+            | (WORD)(tmr.tm_sec >> 1);
+}

code/components/esp-fatfs/diskio/diskio_rawflash_mh.c

@@ -0,0 +1,99 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <string.h>
+#include "diskio_impl_mh.h"
+#include "ffconf_mh.h"
+#include "ff_mh.h"
+#include "esp_log.h"
+#include "diskio_rawflash_mh.h"
+#include "esp_compiler.h"
+#include "spi_flash_mmap.h"
+
+
+static const char* TAG = "diskio_rawflash";
+
+const esp_partition_t* ff_raw_handles[FF_VOLUMES];
+
+
+DSTATUS ff_raw_initialize (BYTE pdrv)
+{
+    return 0;
+}
+
+DSTATUS ff_raw_status (BYTE pdrv)
+{
+    return 0;
+}
+
+DRESULT ff_raw_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
+{
+    ESP_LOGV(TAG, "ff_raw_read - pdrv=%i, sector=%i, count=%in", (unsigned int)pdrv, (unsigned int)sector, (unsigned int)count);
+    const esp_partition_t* part = ff_raw_handles[pdrv];
+    assert(part);
+    esp_err_t err = esp_partition_read(part, sector * SPI_FLASH_SEC_SIZE, buff, count * SPI_FLASH_SEC_SIZE);
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "esp_partition_read failed (0x%x)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+
+
+DRESULT ff_raw_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
+{
+    return RES_ERROR;
+}
+
+DRESULT ff_raw_ioctl (BYTE pdrv, BYTE cmd, void *buff)
+{
+    const esp_partition_t* part = ff_raw_handles[pdrv];
+    ESP_LOGV(TAG, "ff_raw_ioctl: cmd=%in", cmd);
+    assert(part);
+    switch (cmd) {
+        case CTRL_SYNC:
+            return RES_OK;
+        case GET_SECTOR_COUNT:
+            *((DWORD *) buff) = part->size / SPI_FLASH_SEC_SIZE;
+            return RES_OK;
+        case GET_SECTOR_SIZE:
+            *((WORD *) buff) = SPI_FLASH_SEC_SIZE;
+            return RES_OK;
+        case GET_BLOCK_SIZE:
+            return RES_ERROR;
+    }
+    return RES_ERROR;
+}
+
+
+esp_err_t ff_diskio_register_raw_partition(BYTE pdrv, const esp_partition_t* part_handle)
+{
+    if (pdrv >= FF_VOLUMES) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    static const ff_diskio_impl_t raw_impl = {
+        .init = &ff_raw_initialize,
+        .status = &ff_raw_status,
+        .read = &ff_raw_read,
+        .write = &ff_raw_write,
+        .ioctl = &ff_raw_ioctl
+    };
+    ff_diskio_register(pdrv, &raw_impl);
+    ff_raw_handles[pdrv] = part_handle;
+    return ESP_OK;
+
+}
+
+
+BYTE ff_diskio_get_pdrv_raw(const esp_partition_t* part_handle)
+{
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        if (part_handle == ff_raw_handles[i]) {
+            return i;
+        }
+    }
+    return 0xff;
+}

code/components/esp-fatfs/diskio/diskio_rawflash_mh.h

@@ -0,0 +1,37 @@
+// Copyright 2015-2018 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 _DISKIO_RAWFLASH_DEFINED
+#define _DISKIO_RAWFLASH_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "esp_partition.h"
+
+/**
+ * Register spi flash partition
+ *
+ * @param pdrv  drive number
+ * @param part_handle  pointer to raw flash partition.
+ */
+esp_err_t ff_diskio_register_raw_partition(unsigned char pdrv, const esp_partition_t* part_handle);
+unsigned char ff_diskio_get_pdrv_raw(const esp_partition_t* part_handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DISKIO_RAWFLASH_DEFINED

code/components/esp-fatfs/diskio/diskio_sdmmc_mh.c

@@ -0,0 +1,147 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "diskio_impl_mh.h"
+#include "ffconf_mh.h"
+#include "ff_mh.h"
+#include "sdmmc_cmd_mh.h"
+#include "esp_log.h"
+#include "esp_compiler.h"
+
+static sdmmc_card_t* s_cards[FF_VOLUMES] = { NULL };
+static bool s_disk_status_check_en[FF_VOLUMES] = { };
+
+static const char* TAG = "diskio_sdmmc";
+
+//Check if SD/MMC card is present
+static DSTATUS ff_sdmmc_card_available(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 (BYTE pdrv)
+{
+    return ff_sdmmc_card_available(pdrv);
+}
+
+DSTATUS ff_sdmmc_status(BYTE pdrv)
+{
+    if (s_disk_status_check_en[pdrv]) {
+        return ff_sdmmc_card_available(pdrv);
+    }
+    return 0;
+}
+
+DRESULT ff_sdmmc_read (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 (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 (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 (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(FF_CAN_TRIM){
+                return ff_sdmmc_trim (pdrv, *((DWORD*)buff), //start_sector
+                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
+            }
+            else{
+                return RES_ERROR;
+            }
+#endif //FF_USE_TRIM
+    }
+    return RES_ERROR;
+}
+
+void ff_sdmmc_set_disk_status_check(BYTE pdrv, bool enable)
+{
+    s_disk_status_check_en[pdrv] = enable;
+}
+
+void ff_diskio_register_sdmmc(BYTE pdrv, sdmmc_card_t* card)
+{
+    static const ff_diskio_impl_t sdmmc_impl = {
+        .init = &ff_sdmmc_initialize,
+        .status = &ff_sdmmc_status,
+        .read = &ff_sdmmc_read,
+        .write = &ff_sdmmc_write,
+        .ioctl = &ff_sdmmc_ioctl
+    };
+    s_cards[pdrv] = card;
+    s_disk_status_check_en[pdrv] = false;
+    ff_diskio_register(pdrv, &sdmmc_impl);
+}
+
+BYTE ff_diskio_get_pdrv_card(const sdmmc_card_t* card)
+{
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        if (card == s_cards[i]) {
+            return i;
+        }
+    }
+    return 0xff;
+}

code/components/esp-fatfs/diskio/diskio_sdmmc_mh.h

@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2017-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include "sdmmc_cmd_mh.h"
+
+#include "driver/sdmmc_defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Enable/disable SD card status checking
+ *
+ * @param pdrv   drive number
+ * @param enable mock ff_sdmmc_status function (return 0)
+ */
+void ff_sdmmc_set_disk_status_check(BYTE pdrv, bool enable);
+
+/**
+ * Register SD/MMC diskio driver
+ *
+ * @param pdrv  drive number
+ * @param card  pointer to sdmmc_card_t structure describing a card; card should be initialized before calling f_mount.
+ */
+void ff_diskio_register_sdmmc(unsigned char pdrv, sdmmc_card_t* card);
+
+/**
+ * @brief Get the driver number corresponding to a card
+ *
+ * @param card The card to get its driver
+ * @return Driver number to the card
+ */
+BYTE ff_diskio_get_pdrv_card(const sdmmc_card_t* card);
+
+#ifdef __cplusplus
+}
+#endif

code/components/esp-fatfs/diskio/diskio_wl_mh.c

@@ -0,0 +1,118 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <string.h>
+#include "diskio_impl_mh.h"
+#include "ffconf_mh.h"
+#include "ff_mh.h"
+#include "esp_log.h"
+#include "diskio_wl_mh.h"
+#include "wear_levelling.h"
+#include "esp_compiler.h"
+
+static const char* TAG = "ff_diskio_spiflash";
+
+wl_handle_t ff_wl_handles[FF_VOLUMES] = {
+        [0 ... FF_VOLUMES - 1] = WL_INVALID_HANDLE
+};
+
+DSTATUS ff_wl_initialize (BYTE pdrv)
+{
+    return 0;
+}
+
+DSTATUS ff_wl_status (BYTE pdrv)
+{
+    return 0;
+}
+
+DRESULT ff_wl_read (BYTE pdrv, BYTE *buff, DWORD sector, UINT count)
+{
+    ESP_LOGV(TAG, "ff_wl_read - pdrv=%i, sector=%i, count=%i\n", (unsigned int)pdrv, (unsigned int)sector, (unsigned int)count);
+    wl_handle_t wl_handle = ff_wl_handles[pdrv];
+    assert(wl_handle + 1);
+    esp_err_t err = wl_read(wl_handle, sector * wl_sector_size(wl_handle), buff, count * wl_sector_size(wl_handle));
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "wl_read failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+
+DRESULT ff_wl_write (BYTE pdrv, const BYTE *buff, DWORD sector, UINT count)
+{
+    ESP_LOGV(TAG, "ff_wl_write - pdrv=%i, sector=%i, count=%i\n", (unsigned int)pdrv, (unsigned int)sector, (unsigned int)count);
+    wl_handle_t wl_handle = ff_wl_handles[pdrv];
+    assert(wl_handle + 1);
+    esp_err_t err = wl_erase_range(wl_handle, sector * wl_sector_size(wl_handle), count * wl_sector_size(wl_handle));
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "wl_erase_range failed (%d)", err);
+        return RES_ERROR;
+    }
+    err = wl_write(wl_handle, sector * wl_sector_size(wl_handle), buff, count * wl_sector_size(wl_handle));
+    if (unlikely(err != ESP_OK)) {
+        ESP_LOGE(TAG, "wl_write failed (%d)", err);
+        return RES_ERROR;
+    }
+    return RES_OK;
+}
+
+DRESULT ff_wl_ioctl (BYTE pdrv, BYTE cmd, void *buff)
+{
+    wl_handle_t wl_handle = ff_wl_handles[pdrv];
+    ESP_LOGV(TAG, "ff_wl_ioctl: cmd=%i\n", cmd);
+    assert(wl_handle + 1);
+    switch (cmd) {
+    case CTRL_SYNC:
+        return RES_OK;
+    case GET_SECTOR_COUNT:
+        *((DWORD *) buff) = wl_size(wl_handle) / wl_sector_size(wl_handle);
+        return RES_OK;
+    case GET_SECTOR_SIZE:
+        *((WORD *) buff) = wl_sector_size(wl_handle);
+        return RES_OK;
+    case GET_BLOCK_SIZE:
+        return RES_ERROR;
+    }
+    return RES_ERROR;
+}
+
+
+esp_err_t ff_diskio_register_wl_partition(BYTE pdrv, wl_handle_t flash_handle)
+{
+    if (pdrv >= FF_VOLUMES) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    static const ff_diskio_impl_t wl_impl = {
+        .init = &ff_wl_initialize,
+        .status = &ff_wl_status,
+        .read = &ff_wl_read,
+        .write = &ff_wl_write,
+        .ioctl = &ff_wl_ioctl
+    };
+    ff_wl_handles[pdrv] = flash_handle;
+    ff_diskio_register(pdrv, &wl_impl);
+    return ESP_OK;
+}
+
+BYTE ff_diskio_get_pdrv_wl(wl_handle_t flash_handle)
+{
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        if (flash_handle == ff_wl_handles[i]) {
+            return i;
+        }
+    }
+    return 0xff;
+}
+
+void ff_diskio_clear_pdrv_wl(wl_handle_t flash_handle)
+{
+    for (int i = 0; i < FF_VOLUMES; i++) {
+        if (flash_handle == ff_wl_handles[i]) {
+            ff_wl_handles[i] = WL_INVALID_HANDLE;
+        }
+    }
+}

code/components/esp-fatfs/diskio/diskio_wl_mh.h

@@ -0,0 +1,39 @@
+// Copyright 2015-2017 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 _DISKIO_WL_DEFINED
+#define _DISKIO_WL_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "wear_levelling.h"
+
+
+/**
+ * Register spi flash partition
+ *
+ * @param pdrv  drive number
+ * @param flash_handle  handle of the wear levelling partition.
+ */
+esp_err_t ff_diskio_register_wl_partition(unsigned char pdrv, wl_handle_t flash_handle);
+unsigned char ff_diskio_get_pdrv_wl(wl_handle_t flash_handle);
+void ff_diskio_clear_pdrv_wl(wl_handle_t flash_handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _DISKIO_WL_DEFINED

code/components/esp-fatfs/port/freertos/ffsystem_mh.c

@@ -0,0 +1,108 @@
+/*------------------------------------------------------------------------*/
+/* Sample Code of OS Dependent Functions for FatFs                        */
+/* (C)ChaN, 2017                                                          */
+/*------------------------------------------------------------------------*/
+
+
+#include <string.h>
+#include <stdlib.h>
+#include "ff_mh.h"
+#include "sdkconfig.h"
+#ifdef CONFIG_FATFS_ALLOC_PREFER_EXTRAM
+#include "esp_heap_caps.h"
+#endif
+
+void* ff_memalloc (    /* Returns pointer to the allocated memory block (null on not enough core) */
+    unsigned msize     /* Number of bytes to allocate */
+)
+{
+#ifdef CONFIG_FATFS_ALLOC_PREFER_EXTRAM
+    return heap_caps_malloc_prefer(msize, 2, MALLOC_CAP_DEFAULT | MALLOC_CAP_SPIRAM,
+                                            MALLOC_CAP_DEFAULT | MALLOC_CAP_INTERNAL);
+#else
+    return malloc(msize);
+#endif
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+
+void ff_memfree (
+    void* mblock    /* Pointer to the memory block to free (nothing to do for null) */
+)
+{
+    free(mblock);   /* Free the memory block with POSIX API */
+}
+
+
+
+
+#if FF_FS_REENTRANT    /* Mutal exclusion */
+
+/*------------------------------------------------------------------------*/
+/* Create a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to create a new
+/  synchronization object for the volume, such as semaphore and mutex.
+/  When a 0 is returned, the f_mount() function fails with FR_INT_ERR.
+*/
+
+
+int ff_cre_syncobj (    /* 1:Function succeeded, 0:Could not create the sync object */
+    BYTE vol,           /* Corresponding volume (logical drive number) */
+    FF_SYNC_t *sobj     /* Pointer to return the created sync object */
+)
+{
+    *sobj = xSemaphoreCreateMutex();
+    return (*sobj != NULL) ? 1 : 0;
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Delete a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to delete a synchronization
+/  object that created with ff_cre_syncobj() function. When a 0 is returned,
+/  the f_mount() function fails with FR_INT_ERR.
+*/
+
+int ff_del_syncobj (    /* 1:Function succeeded, 0:Could not delete due to an error */
+    FF_SYNC_t sobj      /* Sync object tied to the logical drive to be deleted */
+)
+{
+    vSemaphoreDelete(sobj);
+    return 1;
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Request Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on entering file functions to lock the volume.
+/  When a 0 is returned, the file function fails with FR_TIMEOUT.
+*/
+
+int ff_req_grant (    /* 1:Got a grant to access the volume, 0:Could not get a grant */
+    FF_SYNC_t sobj    /* Sync object to wait */
+)
+{
+    return (xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE) ? 1 : 0;
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Release Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on leaving file functions to unlock the volume.
+*/
+
+void ff_rel_grant (
+    FF_SYNC_t sobj    /* Sync object to be signaled */
+)
+{
+    xSemaphoreGive(sobj);
+}
+
+#endif // FF_FS_REENTRANT

code/components/esp-fatfs/src/00history.txt

@@ -0,0 +1,329 @@
+----------------------------------------------------------------------------
+  Revision history of FatFs module
+----------------------------------------------------------------------------
+
+R0.00 (February 26, 2006)
+
+  Prototype.
+
+
+
+R0.01 (April 29, 2006)
+
+  The first release.
+
+
+
+R0.02 (June 01, 2006)
+
+  Added FAT12 support.
+  Removed unbuffered mode.
+  Fixed a problem on small (<32M) partition.
+
+
+
+R0.02a (June 10, 2006)
+
+  Added a configuration option (_FS_MINIMUM).
+
+
+
+R0.03 (September 22, 2006)
+
+  Added f_rename().
+  Changed option _FS_MINIMUM to _FS_MINIMIZE.
+
+
+
+R0.03a (December 11, 2006)
+
+  Improved cluster scan algorithm to write files fast.
+  Fixed f_mkdir() creates incorrect directory on FAT32.
+
+
+
+R0.04 (February 04, 2007)
+
+  Added f_mkfs().
+  Supported multiple drive system.
+  Changed some interfaces for multiple drive system.
+  Changed f_mountdrv() to f_mount().
+
+
+
+R0.04a (April 01, 2007)
+
+  Supported multiple partitions on a physical drive.
+  Added a capability of extending file size to f_lseek().
+  Added minimization level 3.
+  Fixed an endian sensitive code in f_mkfs().
+
+
+
+R0.04b (May 05, 2007)
+
+  Added a configuration option _USE_NTFLAG.
+  Added FSINFO support.
+  Fixed DBCS name can result FR_INVALID_NAME.
+  Fixed short seek (<= csize) collapses the file object.
+
+
+
+R0.05 (August 25, 2007)
+
+  Changed arguments of f_read(), f_write() and f_mkfs().
+  Fixed f_mkfs() on FAT32 creates incorrect FSINFO.
+  Fixed f_mkdir() on FAT32 creates incorrect directory.
+
+
+
+R0.05a (February 03, 2008)
+
+  Added f_truncate() and f_utime().
+  Fixed off by one error at FAT sub-type determination.
+  Fixed btr in f_read() can be mistruncated.
+  Fixed cached sector is not flushed when create and close without write.
+
+
+
+R0.06 (April 01, 2008)
+
+  Added fputc(), fputs(), fprintf() and fgets().
+  Improved performance of f_lseek() on moving to the same or following cluster.
+
+
+
+R0.07 (April 01, 2009)
+
+  Merged Tiny-FatFs as a configuration option. (_FS_TINY)
+  Added long file name feature. (_USE_LFN)
+  Added multiple code page feature. (_CODE_PAGE)
+  Added re-entrancy for multitask operation. (_FS_REENTRANT)
+  Added auto cluster size selection to f_mkfs().
+  Added rewind option to f_readdir().
+  Changed result code of critical errors.
+  Renamed string functions to avoid name collision.
+
+
+
+R0.07a (April 14, 2009)
+
+  Septemberarated out OS dependent code on reentrant cfg.
+  Added multiple sector size feature.
+
+
+
+R0.07c (June 21, 2009)
+
+  Fixed f_unlink() can return FR_OK on error.
+  Fixed wrong cache control in f_lseek().
+  Added relative path feature.
+  Added f_chdir() and f_chdrive().
+  Added proper case conversion to extended character.
+
+
+
+R0.07e (November 03, 2009)
+
+  Septemberarated out configuration options from ff.h to ffconf.h.
+  Fixed f_unlink() fails to remove a sub-directory on _FS_RPATH.
+  Fixed name matching error on the 13 character boundary.
+  Added a configuration option, _LFN_UNICODE.
+  Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
+
+
+
+R0.08 (May 15, 2010)
+
+  Added a memory configuration option. (_USE_LFN = 3)
+  Added file lock feature. (_FS_SHARE)
+  Added fast seek feature. (_USE_FASTSEEK)
+  Changed some types on the API, XCHAR->TCHAR.
+  Changed .fname in the FILINFO structure on Unicode cfg.
+  String functions support UTF-8 encoding files on Unicode cfg.
+
+
+
+R0.08a (August 16, 2010)
+
+  Added f_getcwd(). (_FS_RPATH = 2)
+  Added sector erase feature. (_USE_ERASE)
+  Moved file lock semaphore table from fs object to the bss.
+  Fixed f_mkfs() creates wrong FAT32 volume.
+
+
+
+R0.08b (January 15, 2011)
+
+  Fast seek feature is also applied to f_read() and f_write().
+  f_lseek() reports required table size on creating CLMP.
+  Extended format syntax of f_printf().
+  Ignores duplicated directory separators in given path name.
+
+
+
+R0.09 (September 06, 2011)
+
+  f_mkfs() supports multiple partition to complete the multiple partition feature.
+  Added f_fdisk().
+
+
+
+R0.09a (August 27, 2012)
+
+  Changed f_open() and f_opendir() reject null object pointer to avoid crash.
+  Changed option name _FS_SHARE to _FS_LOCK.
+  Fixed assertion failure due to OS/2 EA on FAT12/16 volume.
+
+
+
+R0.09b (January 24, 2013)
+
+  Added f_setlabel() and f_getlabel().
+
+
+
+R0.10 (October 02, 2013)
+
+  Added selection of character encoding on the file. (_STRF_ENCODE)
+  Added f_closedir().
+  Added forced full FAT scan for f_getfree(). (_FS_NOFSINFO)
+  Added forced mount feature with changes of f_mount().
+  Improved behavior of volume auto detection.
+  Improved write throughput of f_puts() and f_printf().
+  Changed argument of f_chdrive(), f_mkfs(), disk_read() and disk_write().
+  Fixed f_write() can be truncated when the file size is close to 4GB.
+  Fixed f_open(), f_mkdir() and f_setlabel() can return incorrect value on error.
+
+
+
+R0.10a (January 15, 2014)
+
+  Added arbitrary strings as drive number in the path name. (_STR_VOLUME_ID)
+  Added a configuration option of minimum sector size. (_MIN_SS)
+  2nd argument of f_rename() can have a drive number and it will be ignored.
+  Fixed f_mount() with forced mount fails when drive number is >= 1. (appeared at R0.10)
+  Fixed f_close() invalidates the file object without volume lock.
+  Fixed f_closedir() returns but the volume lock is left acquired. (appeared at R0.10)
+  Fixed creation of an entry with LFN fails on too many SFN collisions. (appeared at R0.07)
+
+
+
+R0.10b (May 19, 2014)
+
+  Fixed a hard error in the disk I/O layer can collapse the directory entry.
+  Fixed LFN entry is not deleted when delete/rename an object with lossy converted SFN. (appeared at R0.07)
+
+
+
+R0.10c (November 09, 2014)
+
+  Added a configuration option for the platforms without RTC. (_FS_NORTC)
+  Changed option name _USE_ERASE to _USE_TRIM.
+  Fixed volume label created by Mac OS X cannot be retrieved with f_getlabel(). (appeared at R0.09b)
+  Fixed a potential problem of FAT access that can appear on disk error.
+  Fixed null pointer dereference on attempting to delete the root direcotry. (appeared at R0.08)
+
+
+
+R0.11 (February 09, 2015)
+
+  Added f_findfirst(), f_findnext() and f_findclose(). (_USE_FIND)
+  Fixed f_unlink() does not remove cluster chain of the file. (appeared at R0.10c)
+  Fixed _FS_NORTC option does not work properly. (appeared at R0.10c)
+
+
+
+R0.11a (September 05, 2015)
+
+  Fixed wrong media change can lead a deadlock at thread-safe configuration.
+  Added code page 771, 860, 861, 863, 864, 865 and 869. (_CODE_PAGE)
+  Removed some code pages actually not exist on the standard systems. (_CODE_PAGE)
+  Fixed errors in the case conversion teble of code page 437 and 850 (ff.c).
+  Fixed errors in the case conversion teble of Unicode (cc*.c).
+
+
+
+R0.12 (April 12, 2016)
+
+  Added support for exFAT file system. (_FS_EXFAT)
+  Added f_expand(). (_USE_EXPAND)
+  Changed some members in FINFO structure and behavior of f_readdir().
+  Added an option _USE_CHMOD.
+  Removed an option _WORD_ACCESS.
+  Fixed errors in the case conversion table of Unicode (cc*.c).
+
+
+
+R0.12a (July 10, 2016)
+
+  Added support for creating exFAT volume with some changes of f_mkfs().
+  Added a file open method FA_OPEN_APPEND. An f_lseek() following f_open() is no longer needed.
+  f_forward() is available regardless of _FS_TINY.
+  Fixed f_mkfs() creates wrong volume. (appeared at R0.12)
+  Fixed wrong memory read in create_name(). (appeared at R0.12)
+  Fixed compilation fails at some configurations, _USE_FASTSEEK and _USE_FORWARD.
+
+
+
+R0.12b (September 04, 2016)
+
+  Made f_rename() be able to rename objects with the same name but case.
+  Fixed an error in the case conversion teble of code page 866. (ff.c)
+  Fixed writing data is truncated at the file offset 4GiB on the exFAT volume. (appeared at R0.12)
+  Fixed creating a file in the root directory of exFAT volume can fail. (appeared at R0.12)
+  Fixed f_mkfs() creating exFAT volume with too small cluster size can collapse unallocated memory. (appeared at R0.12)
+  Fixed wrong object name can be returned when read directory at Unicode cfg. (appeared at R0.12)
+  Fixed large file allocation/removing on the exFAT volume collapses allocation bitmap. (appeared at R0.12)
+  Fixed some internal errors in f_expand() and f_lseek(). (appeared at R0.12)
+
+
+
+R0.12c (March 04, 2017)
+
+  Improved write throughput at the fragmented file on the exFAT volume.
+  Made memory usage for exFAT be able to be reduced as decreasing _MAX_LFN.
+  Fixed successive f_getfree() can return wrong count on the FAT12/16 volume. (appeared at R0.12)
+  Fixed configuration option _VOLUMES cannot be set 10. (appeared at R0.10c)
+
+
+
+R0.13 (May 21, 2017)
+
+  Changed heading character of configuration keywords "_" to "FF_".
+  Removed ASCII-only configuration, FF_CODE_PAGE = 1. Use FF_CODE_PAGE = 437 instead.
+  Added f_setcp(), run-time code page configuration. (FF_CODE_PAGE = 0)
+  Improved cluster allocation time on stretch a deep buried cluster chain.
+  Improved processing time of f_mkdir() with large cluster size by using FF_USE_LFN = 3.
+  Improved NoFatChain flag of the fragmented file to be set after it is truncated and got contiguous.
+  Fixed archive attribute is left not set when a file on the exFAT volume is renamed. (appeared at R0.12)
+  Fixed exFAT FAT entry can be collapsed when write or lseek operation to the existing file is done. (appeared at R0.12c)
+  Fixed creating a file can fail when a new cluster allocation to the exFAT directory occures. (appeared at R0.12c)
+
+
+
+R0.13a (October 14, 2017)
+
+  Added support for UTF-8 encoding on the API. (FF_LFN_UNICODE = 2)
+  Added options for file name output buffer. (FF_LFN_BUF, FF_SFN_BUF).
+  Added dynamic memory allocation option for working buffer of f_mkfs() and f_fdisk().
+  Fixed f_fdisk() and f_mkfs() create the partition table with wrong CHS parameters. (appeared at R0.09)
+  Fixed f_unlink() can cause lost clusters at fragmented file on the exFAT volume. (appeared at R0.12c)
+  Fixed f_setlabel() rejects some valid characters for exFAT volume. (appeared at R0.12)
+
+
+
+R0.13b (April 07, 2018)
+
+  Added support for UTF-32 encoding on the API. (FF_LFN_UNICODE = 3)
+  Added support for Unix style volume ID. (FF_STR_VOLUME_ID = 2)
+  Fixed accesing any object on the exFAT root directory beyond the cluster boundary can fail. (appeared at R0.12c)
+  Fixed f_setlabel() does not reject some invalid characters. (appeared at R0.09b)
+
+
+
+R0.13c (October 14, 2018)
+  Supported stdint.h for C99 and later. (integer.h was included in ff.h)
+  Fixed reading a directory gets infinite loop when the last directory entry is not empty. (appeared at R0.12)
+  Fixed creating a sub-directory in the fragmented sub-directory on the exFAT volume collapses FAT chain of the parent directory. (appeared at R0.12)
+  Fixed f_getcwd() cause output buffer overrun when the buffer has a valid drive number. (appeared at R0.13b)

code/components/esp-fatfs/src/00readme.txt

@@ -0,0 +1,20 @@
+FatFs Module Source Files R0.13c
+
+
+FILES
+
+  00readme.txt   This file.
+  00history.txt  Revision history.
+  ff.c           FatFs module.
+  ffconf.h       Configuration file of FatFs module.
+  ff.h           Common include file for FatFs and application module.
+  diskio.h       Common include file for FatFs and disk I/O module.
+  diskio.c       An example of glue function to attach existing disk I/O module to FatFs.
+  ffunicode.c    Optional Unicode utility functions.
+  ffsystem.c     An example of optional O/S related functions.
+
+
+  Low level disk I/O module is not included in this archive because the FatFs
+  module is only a generic file system layer and it does not depend on any specific
+  storage device. You need to provide a low level disk I/O module written to
+  control the storage device that attached to the target system.

code/components/esp-fatfs/src/diskio_mh.c

@@ -0,0 +1,228 @@
+/*-----------------------------------------------------------------------*/
+/* Low level disk I/O module SKELETON for FatFs     (C)ChaN, 2019        */
+/*-----------------------------------------------------------------------*/
+/* If a working storage control module is available, it should be        */
+/* attached to the FatFs via a glue function rather than modifying it.   */
+/* This is an example of glue functions to attach various exsisting      */
+/* storage control modules to the FatFs module with a defined API.       */
+/*-----------------------------------------------------------------------*/
+
+#include "ff_mh.h"			/* Obtains integer types */
+#include "diskio_mh.h"		/* Declarations of disk functions */
+
+/* Definitions of physical drive number for each drive */
+#define DEV_RAM		0	/* Example: Map Ramdisk to physical drive 0 */
+#define DEV_MMC		1	/* Example: Map MMC/SD card to physical drive 1 */
+#define DEV_USB		2	/* Example: Map USB MSD to physical drive 2 */
+
+
+/*-----------------------------------------------------------------------*/
+/* Get Drive Status                                                      */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_status (
+	BYTE pdrv		/* Physical drive nmuber to identify the drive */
+)
+{
+	DSTATUS stat;
+	int result;
+
+	switch (pdrv) {
+	case DEV_RAM :
+		result = RAM_disk_status();
+
+		// translate the reslut code here
+
+		return stat;
+
+	case DEV_MMC :
+		result = MMC_disk_status();
+
+		// translate the reslut code here
+
+		return stat;
+
+	case DEV_USB :
+		result = USB_disk_status();
+
+		// translate the reslut code here
+
+		return stat;
+	}
+	return STA_NOINIT;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Inidialize a Drive                                                    */
+/*-----------------------------------------------------------------------*/
+
+DSTATUS disk_initialize (
+	BYTE pdrv				/* Physical drive nmuber to identify the drive */
+)
+{
+	DSTATUS stat;
+	int result;
+
+	switch (pdrv) {
+	case DEV_RAM :
+		result = RAM_disk_initialize();
+
+		// translate the reslut code here
+
+		return stat;
+
+	case DEV_MMC :
+		result = MMC_disk_initialize();
+
+		// translate the reslut code here
+
+		return stat;
+
+	case DEV_USB :
+		result = USB_disk_initialize();
+
+		// translate the reslut code here
+
+		return stat;
+	}
+	return STA_NOINIT;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Read Sector(s)                                                        */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_read (
+	BYTE pdrv,		/* Physical drive nmuber to identify the drive */
+	BYTE *buff,		/* Data buffer to store read data */
+	LBA_t sector,	/* Start sector in LBA */
+	UINT count		/* Number of sectors to read */
+)
+{
+	DRESULT res;
+	int result;
+
+	switch (pdrv) {
+	case DEV_RAM :
+		// translate the arguments here
+
+		result = RAM_disk_read(buff, sector, count);
+
+		// translate the reslut code here
+
+		return res;
+
+	case DEV_MMC :
+		// translate the arguments here
+
+		result = MMC_disk_read(buff, sector, count);
+
+		// translate the reslut code here
+
+		return res;
+
+	case DEV_USB :
+		// translate the arguments here
+
+		result = USB_disk_read(buff, sector, count);
+
+		// translate the reslut code here
+
+		return res;
+	}
+
+	return RES_PARERR;
+}
+
+
+
+/*-----------------------------------------------------------------------*/
+/* Write Sector(s)                                                       */
+/*-----------------------------------------------------------------------*/
+
+#if FF_FS_READONLY == 0
+
+DRESULT disk_write (
+	BYTE pdrv,			/* Physical drive nmuber to identify the drive */
+	const BYTE *buff,	/* Data to be written */
+	LBA_t sector,		/* Start sector in LBA */
+	UINT count			/* Number of sectors to write */
+)
+{
+	DRESULT res;
+	int result;
+
+	switch (pdrv) {
+	case DEV_RAM :
+		// translate the arguments here
+
+		result = RAM_disk_write(buff, sector, count);
+
+		// translate the reslut code here
+
+		return res;
+
+	case DEV_MMC :
+		// translate the arguments here
+
+		result = MMC_disk_write(buff, sector, count);
+
+		// translate the reslut code here
+
+		return res;
+
+	case DEV_USB :
+		// translate the arguments here
+
+		result = USB_disk_write(buff, sector, count);
+
+		// translate the reslut code here
+
+		return res;
+	}
+
+	return RES_PARERR;
+}
+
+#endif
+
+
+/*-----------------------------------------------------------------------*/
+/* Miscellaneous Functions                                               */
+/*-----------------------------------------------------------------------*/
+
+DRESULT disk_ioctl (
+	BYTE pdrv,		/* Physical drive nmuber (0..) */
+	BYTE cmd,		/* Control code */
+	void *buff		/* Buffer to send/receive control data */
+)
+{
+	DRESULT res;
+	int result;
+
+	switch (pdrv) {
+	case DEV_RAM :
+
+		// Process of the command for the RAM drive
+
+		return res;
+
+	case DEV_MMC :
+
+		// Process of the command for the MMC/SD card
+
+		return res;
+
+	case DEV_USB :
+
+		// Process of the command the USB drive
+
+		return res;
+	}
+
+	return RES_PARERR;
+}

code/components/esp-fatfs/src/diskio_mh.h

@@ -0,0 +1,79 @@
+/*-----------------------------------------------------------------------/
+/  Low level disk interface modlue include file   (C)ChaN, 2019          /
+/-----------------------------------------------------------------------*/
+
+#ifndef _DISKIO_DEFINED
+#define _DISKIO_DEFINED
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ff_mh.h"
+
+/* Status of Disk Functions */
+typedef BYTE	DSTATUS;
+
+/* Results of Disk Functions */
+typedef enum {
+	RES_OK = 0,		/* 0: Successful */
+	RES_ERROR,		/* 1: R/W Error */
+	RES_WRPRT,		/* 2: Write Protected */
+	RES_NOTRDY,		/* 3: Not Ready */
+	RES_PARERR		/* 4: Invalid Parameter */
+} DRESULT;
+
+
+/*---------------------------------------*/
+/* Prototypes for disk control functions */
+
+
+DSTATUS disk_initialize (BYTE pdrv);
+DSTATUS disk_status (BYTE pdrv);
+DRESULT disk_read (BYTE pdrv, BYTE* buff, LBA_t sector, UINT count);
+DRESULT disk_write (BYTE pdrv, const BYTE* buff, LBA_t sector, UINT count);
+DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
+
+
+/* Disk Status Bits (DSTATUS) */
+
+#define STA_NOINIT		0x01	/* Drive not initialized */
+#define STA_NODISK		0x02	/* No medium in the drive */
+#define STA_PROTECT		0x04	/* Write protected */
+
+
+/* Command code for disk_ioctrl fucntion */
+
+/* Generic command (Used by FatFs) */
+#define CTRL_SYNC			0	/* Complete pending write process (needed at FF_FS_READONLY == 0) */
+#define GET_SECTOR_COUNT	1	/* Get media size (needed at FF_USE_MKFS == 1) */
+#define GET_SECTOR_SIZE		2	/* Get sector size (needed at FF_MAX_SS != FF_MIN_SS) */
+#define GET_BLOCK_SIZE		3	/* Get erase block size (needed at FF_USE_MKFS == 1) */
+#define CTRL_TRIM			4	/* Inform device that the data on the block of sectors is no longer used (needed at FF_USE_TRIM == 1) */
+
+/* Generic command (Not used by FatFs) */
+#define CTRL_POWER			5	/* Get/Set power status */
+#define CTRL_LOCK			6	/* Lock/Unlock media removal */
+#define CTRL_EJECT			7	/* Eject media */
+#define CTRL_FORMAT			8	/* Create physical format on the media */
+
+/* MMC/SDC specific ioctl command */
+#define MMC_GET_TYPE		10	/* Get card type */
+#define MMC_GET_CSD			11	/* Get CSD */
+#define MMC_GET_CID			12	/* Get CID */
+#define MMC_GET_OCR			13	/* Get OCR */
+#define MMC_GET_SDSTAT		14	/* Get SD status */
+#define ISDIO_READ			55	/* Read data form SD iSDIO register */
+#define ISDIO_WRITE			56	/* Write data to SD iSDIO register */
+#define ISDIO_MRITE			57	/* Masked write data to SD iSDIO register */
+
+/* ATA/CF specific ioctl command */
+#define ATA_GET_REV			20	/* Get F/W revision */
+#define ATA_GET_MODEL		21	/* Get model name */
+#define ATA_GET_SN			22	/* Get serial number */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

code/components/esp-fatfs/src/ff_mh.h

@@ -0,0 +1,422 @@
+/*----------------------------------------------------------------------------/
+/  FatFs - Generic FAT Filesystem module  R0.14b                              /
+/-----------------------------------------------------------------------------/
+/
+/ Copyright (C) 2021, ChaN, all right reserved.
+/
+/ FatFs module is an open source software. Redistribution and use of FatFs in
+/ source and binary forms, with or without modification, are permitted provided
+/ that the following condition is met:
+
+/ 1. Redistributions of source code must retain the above copyright notice,
+/    this condition and the following disclaimer.
+/
+/ This software is provided by the copyright holder and contributors "AS IS"
+/ and any warranties related to this software are DISCLAIMED.
+/ The copyright owner or contributors be NOT LIABLE for any damages caused
+/ by use of this software.
+/
+/----------------------------------------------------------------------------*/
+
+
+#ifndef FF_DEFINED
+#define FF_DEFINED	86631	/* Revision ID */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "ffconf_mh.h"		/* FatFs configuration options */
+
+#if FF_DEFINED != FFCONF_DEF
+#error Wrong configuration file (ffconf.h).
+#endif
+
+
+/* Integer types used for FatFs API */
+
+#if defined(_WIN32)		/* Windows VC++ (for development only) */
+#define FF_INTDEF 2
+#include <windows.h>
+typedef unsigned __int64 QWORD;
+#include <float.h>
+#define isnan(v) _isnan(v)
+#define isinf(v) (!_finite(v))
+
+#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus)	/* C99 or later */
+#define FF_INTDEF 2
+#include <stdint.h>
+typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
+typedef unsigned char	BYTE;	/* char must be 8-bit */
+typedef uint16_t		WORD;	/* 16-bit unsigned integer */
+typedef uint32_t		DWORD;	/* 32-bit unsigned integer */
+typedef uint64_t		QWORD;	/* 64-bit unsigned integer */
+typedef WORD			WCHAR;	/* UTF-16 character type */
+
+#else  	/* Earlier than C99 */
+#define FF_INTDEF 1
+typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
+typedef unsigned char	BYTE;	/* char must be 8-bit */
+typedef unsigned short	WORD;	/* 16-bit unsigned integer */
+typedef unsigned long	DWORD;	/* 32-bit unsigned integer */
+typedef WORD			WCHAR;	/* UTF-16 character type */
+#endif
+
+
+/* Type of file size and LBA variables */
+
+#if FF_FS_EXFAT
+#if FF_INTDEF != 2
+#error exFAT feature wants C99 or later
+#endif
+typedef QWORD FSIZE_t;
+#if FF_LBA64
+typedef QWORD LBA_t;
+#else
+typedef DWORD LBA_t;
+#endif
+#else
+#if FF_LBA64
+#error exFAT needs to be enabled when enable 64-bit LBA
+#endif
+typedef DWORD FSIZE_t;
+typedef DWORD LBA_t;
+#endif
+
+
+
+/* Type of path name strings on FatFs API (TCHAR) */
+
+#if FF_USE_LFN && FF_LFN_UNICODE == 1 	/* Unicode in UTF-16 encoding */
+typedef WCHAR TCHAR;
+#define _T(x) L ## x
+#define _TEXT(x) L ## x
+#elif FF_USE_LFN && FF_LFN_UNICODE == 2	/* Unicode in UTF-8 encoding */
+typedef char TCHAR;
+#define _T(x) u8 ## x
+#define _TEXT(x) u8 ## x
+#elif FF_USE_LFN && FF_LFN_UNICODE == 3	/* Unicode in UTF-32 encoding */
+typedef DWORD TCHAR;
+#define _T(x) U ## x
+#define _TEXT(x) U ## x
+#elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3)
+#error Wrong FF_LFN_UNICODE setting
+#else									/* ANSI/OEM code in SBCS/DBCS */
+typedef char TCHAR;
+#define _T(x) x
+#define _TEXT(x) x
+#endif
+
+
+
+/* Definitions of volume management */
+
+#if FF_MULTI_PARTITION		/* Multiple partition configuration */
+typedef struct {
+	BYTE pd;	/* Physical drive number */
+	BYTE pt;	/* Partition: 0:Auto detect, 1-4:Forced partition) */
+} PARTITION;
+extern const PARTITION VolToPart[];	/* Volume - Partition mapping table */
+#endif
+
+#if FF_STR_VOLUME_ID
+#ifndef FF_VOLUME_STRS
+extern const char* VolumeStr[FF_VOLUMES];	/* User defied volume ID */
+#endif
+#endif
+
+
+
+/* Filesystem object structure (FATFS) */
+
+typedef struct {
+	BYTE	fs_type;		/* Filesystem type (0:not mounted) */
+	BYTE	pdrv;			/* Associated physical drive */
+	BYTE	n_fats;			/* Number of FATs (1 or 2) */
+	BYTE	wflag;			/* win[] flag (b0:dirty) */
+	BYTE	fsi_flag;		/* FSINFO flags (b7:disabled, b0:dirty) */
+	WORD	id;				/* Volume mount ID */
+	WORD	n_rootdir;		/* Number of root directory entries (FAT12/16) */
+	WORD	csize;			/* Cluster size [sectors] */
+#if FF_MAX_SS != FF_MIN_SS
+	WORD	ssize;			/* Sector size (512, 1024, 2048 or 4096) */
+#endif
+#if FF_USE_LFN
+	WCHAR*	lfnbuf;			/* LFN working buffer */
+#endif
+#if FF_FS_EXFAT
+	BYTE*	dirbuf;			/* Directory entry block scratchpad buffer for exFAT */
+#endif
+#if FF_FS_REENTRANT
+	FF_SYNC_t	sobj;		/* Identifier of sync object */
+#endif
+#if !FF_FS_READONLY
+	DWORD	last_clst;		/* Last allocated cluster */
+	DWORD	free_clst;		/* Number of free clusters */
+#endif
+#if FF_FS_RPATH
+	DWORD	cdir;			/* Current directory start cluster (0:root) */
+#if FF_FS_EXFAT
+	DWORD	cdc_scl;		/* Containing directory start cluster (invalid when cdir is 0) */
+	DWORD	cdc_size;		/* b31-b8:Size of containing directory, b7-b0: Chain status */
+	DWORD	cdc_ofs;		/* Offset in the containing directory (invalid when cdir is 0) */
+#endif
+#endif
+	DWORD	n_fatent;		/* Number of FAT entries (number of clusters + 2) */
+	DWORD	fsize;			/* Size of an FAT [sectors] */
+	LBA_t	volbase;		/* Volume base sector */
+	LBA_t	fatbase;		/* FAT base sector */
+	LBA_t	dirbase;		/* Root directory base sector/cluster */
+	LBA_t	database;		/* Data base sector */
+#if FF_FS_EXFAT
+	LBA_t	bitbase;		/* Allocation bitmap base sector */
+#endif
+	LBA_t	winsect;		/* Current sector appearing in the win[] */
+	BYTE	win[FF_MAX_SS];	/* Disk access window for Directory, FAT (and file data at tiny cfg) */
+} FATFS;
+
+
+
+/* Object ID and allocation information (FFOBJID) */
+
+typedef struct {
+	FATFS*	fs;				/* Pointer to the hosting volume of this object */
+	WORD	id;				/* Hosting volume mount ID */
+	BYTE	attr;			/* Object attribute */
+	BYTE	stat;			/* Object chain status (b1-0: =0:not contiguous, =2:contiguous, =3:fragmented in this session, b2:sub-directory stretched) */
+	DWORD	sclust;			/* Object data start cluster (0:no cluster or root directory) */
+	FSIZE_t	objsize;		/* Object size (valid when sclust != 0) */
+#if FF_FS_EXFAT
+	DWORD	n_cont;			/* Size of first fragment - 1 (valid when stat == 3) */
+	DWORD	n_frag;			/* Size of last fragment needs to be written to FAT (valid when not zero) */
+	DWORD	c_scl;			/* Containing directory start cluster (valid when sclust != 0) */
+	DWORD	c_size;			/* b31-b8:Size of containing directory, b7-b0: Chain status (valid when c_scl != 0) */
+	DWORD	c_ofs;			/* Offset in the containing directory (valid when file object and sclust != 0) */
+#endif
+#if FF_FS_LOCK
+	UINT	lockid;			/* File lock ID origin from 1 (index of file semaphore table Files[]) */
+#endif
+} FFOBJID;
+
+
+
+/* File object structure (FIL) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier (must be the 1st member to detect invalid object pointer) */
+	BYTE	flag;			/* File status flags */
+	BYTE	err;			/* Abort flag (error code) */
+	FSIZE_t	fptr;			/* File read/write pointer (Zeroed on file open) */
+	DWORD	clust;			/* Current cluster of fpter (invalid when fptr is 0) */
+	LBA_t	sect;			/* Sector number appearing in buf[] (0:invalid) */
+#if !FF_FS_READONLY
+	LBA_t	dir_sect;		/* Sector number containing the directory entry (not used at exFAT) */
+	BYTE*	dir_ptr;		/* Pointer to the directory entry in the win[] (not used at exFAT) */
+#endif
+#if FF_USE_FASTSEEK
+	DWORD*	cltbl;			/* Pointer to the cluster link map table (nulled on open, set by application) */
+#endif
+#if !FF_FS_TINY
+	BYTE	buf[FF_MAX_SS];	/* File private data read/write window */
+#endif
+} FIL;
+
+
+
+/* Directory object structure (FF_DIR) */
+
+typedef struct {
+	FFOBJID	obj;			/* Object identifier */
+	DWORD	dptr;			/* Current read/write offset */
+	DWORD	clust;			/* Current cluster */
+	LBA_t	sect;			/* Current sector (0:Read operation has terminated) */
+	BYTE*	dir;			/* Pointer to the directory item in the win[] */
+	BYTE	fn[12];			/* SFN (in/out) {body[8],ext[3],status[1]} */
+#if FF_USE_LFN
+	DWORD	blk_ofs;		/* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */
+#endif
+#if FF_USE_FIND
+	const TCHAR* pat;		/* Pointer to the name matching pattern */
+#endif
+} FF_DIR;
+
+
+
+/* File information structure (FILINFO) */
+
+typedef struct {
+	FSIZE_t	fsize;			/* File size */
+	WORD	fdate;			/* Modified date */
+	WORD	ftime;			/* Modified time */
+	BYTE	fattrib;		/* File attribute */
+#if FF_USE_LFN
+	TCHAR	altname[FF_SFN_BUF + 1];/* Altenative file name */
+	TCHAR	fname[FF_LFN_BUF + 1];	/* Primary file name */
+#else
+	TCHAR	fname[12 + 1];	/* File name */
+#endif
+} FILINFO;
+
+
+
+/* Format parameter structure (MKFS_PARM) */
+
+typedef struct {
+	BYTE fmt;			/* Format option (FM_FAT, FM_FAT32, FM_EXFAT and FM_SFD) */
+	BYTE n_fat;			/* Number of FATs */
+	UINT align;			/* Data area alignment (sector) */
+	UINT n_root;		/* Number of root directory entries */
+	DWORD au_size;		/* Cluster size (byte) */
+} MKFS_PARM;
+
+
+
+/* File function return code (FRESULT) */
+
+typedef enum {
+	FR_OK = 0,				/* (0) Succeeded */
+	FR_DISK_ERR,			/* (1) A hard error occurred in the low level disk I/O layer */
+	FR_INT_ERR,				/* (2) Assertion failed */
+	FR_NOT_READY,			/* (3) The physical drive cannot work */
+	FR_NO_FILE,				/* (4) Could not find the file */
+	FR_NO_PATH,				/* (5) Could not find the path */
+	FR_INVALID_NAME,		/* (6) The path name format is invalid */
+	FR_DENIED,				/* (7) Access denied due to prohibited access or directory full */
+	FR_EXIST,				/* (8) Access denied due to prohibited access */
+	FR_INVALID_OBJECT,		/* (9) The file/directory object is invalid */
+	FR_WRITE_PROTECTED,		/* (10) The physical drive is write protected */
+	FR_INVALID_DRIVE,		/* (11) The logical drive number is invalid */
+	FR_NOT_ENABLED,			/* (12) The volume has no work area */
+	FR_NO_FILESYSTEM,		/* (13) There is no valid FAT volume */
+	FR_MKFS_ABORTED,		/* (14) The f_mkfs() aborted due to any problem */
+	FR_TIMEOUT,				/* (15) Could not get a grant to access the volume within defined period */
+	FR_LOCKED,				/* (16) The operation is rejected according to the file sharing policy */
+	FR_NOT_ENOUGH_CORE,		/* (17) LFN working buffer could not be allocated */
+	FR_TOO_MANY_OPEN_FILES,	/* (18) Number of open files > FF_FS_LOCK */
+	FR_INVALID_PARAMETER	/* (19) Given parameter is invalid */
+} FRESULT;
+
+
+
+/*--------------------------------------------------------------*/
+/* FatFs module application interface                           */
+
+FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode);				/* Open or create a file */
+FRESULT f_close (FIL* fp);											/* Close an open file object */
+FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br);			/* Read data from the file */
+FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw);	/* Write data to the file */
+FRESULT f_lseek (FIL* fp, FSIZE_t ofs);								/* Move file pointer of the file object */
+FRESULT f_truncate (FIL* fp);										/* Truncate the file */
+FRESULT f_sync (FIL* fp);											/* Flush cached data of the writing file */
+FRESULT f_opendir (FF_DIR* dp, const TCHAR* path);						/* Open a directory */
+FRESULT f_closedir (FF_DIR* dp);										/* Close an open directory */
+FRESULT f_readdir (FF_DIR* dp, FILINFO* fno);							/* Read a directory item */
+FRESULT f_findfirst (FF_DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern);	/* Find first file */
+FRESULT f_findnext (FF_DIR* dp, FILINFO* fno);							/* Find next file */
+FRESULT f_mkdir (const TCHAR* path);								/* Create a sub directory */
+FRESULT f_unlink (const TCHAR* path);								/* Delete an existing file or directory */
+FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new);	/* Rename/Move a file or directory */
+FRESULT f_stat (const TCHAR* path, FILINFO* fno);					/* Get file status */
+FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask);			/* Change attribute of a file/dir */
+FRESULT f_utime (const TCHAR* path, const FILINFO* fno);			/* Change timestamp of a file/dir */
+FRESULT f_chdir (const TCHAR* path);								/* Change current directory */
+FRESULT f_chdrive (const TCHAR* path);								/* Change current drive */
+FRESULT f_getcwd (TCHAR* buff, UINT len);							/* Get current directory */
+FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs);	/* Get number of free clusters on the drive */
+FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn);	/* Get volume label */
+FRESULT f_setlabel (const TCHAR* label);							/* Set volume label */
+FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf);	/* Forward data to the stream */
+FRESULT f_expand (FIL* fp, FSIZE_t fsz, BYTE opt);					/* Allocate a contiguous block to the file */
+FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt);			/* Mount/Unmount a logical drive */
+FRESULT f_mkfs (const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len);	/* Create a FAT volume */
+FRESULT f_fdisk (BYTE pdrv, const LBA_t ptbl[], void* work);		/* Divide a physical drive into some partitions */
+FRESULT f_setcp (WORD cp);											/* Set current code page */
+int f_putc (TCHAR c, FIL* fp);										/* Put a character to the file */
+int f_puts (const TCHAR* str, FIL* cp);								/* Put a string to the file */
+int f_printf (FIL* fp, const TCHAR* str, ...);						/* Put a formatted string to the file */
+TCHAR* f_gets (TCHAR* buff, int len, FIL* fp);						/* Get a string from the file */
+
+#define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
+#define f_error(fp) ((fp)->err)
+#define f_tell(fp) ((fp)->fptr)
+#define f_size(fp) ((fp)->obj.objsize)
+#define f_rewind(fp) f_lseek((fp), 0)
+#define f_rewinddir(dp) f_readdir((dp), 0)
+#define f_rmdir(path) f_unlink(path)
+#define f_unmount(path) f_mount(0, path, 0)
+
+
+
+
+/*--------------------------------------------------------------*/
+/* Additional user defined functions                            */
+
+/* RTC function */
+#if !FF_FS_READONLY && !FF_FS_NORTC
+DWORD get_fattime (void);
+#endif
+
+/* LFN support functions */
+#if FF_USE_LFN >= 1						/* Code conversion (defined in unicode.c) */
+WCHAR ff_oem2uni (WCHAR oem, WORD cp);	/* OEM code to Unicode conversion */
+WCHAR ff_uni2oem (DWORD uni, WORD cp);	/* Unicode to OEM code conversion */
+DWORD ff_wtoupper (DWORD uni);			/* Unicode upper-case conversion */
+#endif
+#if FF_USE_LFN == 3						/* Dynamic memory allocation */
+void* ff_memalloc (UINT msize);			/* Allocate memory block */
+void ff_memfree (void* mblock);			/* Free memory block */
+#endif
+
+/* Sync functions */
+#if FF_FS_REENTRANT
+int ff_cre_syncobj (BYTE vol, FF_SYNC_t* sobj);	/* Create a sync object */
+int ff_req_grant (FF_SYNC_t sobj);		/* Lock sync object */
+void ff_rel_grant (FF_SYNC_t sobj);		/* Unlock sync object */
+int ff_del_syncobj (FF_SYNC_t sobj);	/* Delete a sync object */
+#endif
+
+
+
+
+/*--------------------------------------------------------------*/
+/* Flags and offset address                                     */
+
+
+/* File access mode and open method flags (3rd argument of f_open) */
+#define	FA_READ				0x01
+#define	FA_WRITE			0x02
+#define	FA_OPEN_EXISTING	0x00
+#define	FA_CREATE_NEW		0x04
+#define	FA_CREATE_ALWAYS	0x08
+#define	FA_OPEN_ALWAYS		0x10
+#define	FA_OPEN_APPEND		0x30
+
+/* Fast seek controls (2nd argument of f_lseek) */
+#define CREATE_LINKMAP	((FSIZE_t)0 - 1)
+
+/* Format options (2nd argument of f_mkfs) */
+#define FM_FAT		0x01
+#define FM_FAT32	0x02
+#define FM_EXFAT	0x04
+#define FM_ANY		0x07
+#define FM_SFD		0x08
+
+/* Filesystem type (FATFS.fs_type) */
+#define FS_FAT12	1
+#define FS_FAT16	2
+#define FS_FAT32	3
+#define FS_EXFAT	4
+
+/* File attribute bits for directory entry (FILINFO.fattrib) */
+#define	AM_RDO	0x01	/* Read only */
+#define	AM_HID	0x02	/* Hidden */
+#define	AM_SYS	0x04	/* System */
+#define AM_DIR	0x10	/* Directory */
+#define AM_ARC	0x20	/* Archive */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FF_DEFINED */

code/components/esp-fatfs/src/ffconf_mh.h

@@ -0,0 +1,309 @@
+#include "sdkconfig.h"
+
+/*---------------------------------------------------------------------------/
+/  FatFs Functional Configurations
+/---------------------------------------------------------------------------*/
+
+#define FFCONF_DEF 86631 /* Revision ID */
+
+/*---------------------------------------------------------------------------/
+/ Function Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_READONLY 0
+/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
+/  Read-only configuration removes writing API functions, f_write(), f_sync(),
+/  f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
+/  and optional writing functions as well. */
+
+#define FF_FS_MINIMIZE 0
+/* This option defines minimization level to remove some basic API functions.
+/
+/   0: Basic functions are fully enabled.
+/   1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
+/      are removed.
+/   2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
+/   3: f_lseek() function is removed in addition to 2. */
+
+#define FF_USE_FIND 0
+/* This option switches filtered directory read functions, f_findfirst() and
+/  f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
+
+#define FF_USE_MKFS 1
+/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
+
+#define FF_USE_FASTSEEK CONFIG_FATFS_USE_FASTSEEK
+/* This option switches fast seek function. (0:Disable or 1:Enable) */
+
+#define FF_USE_EXPAND 0
+/* This option switches f_expand function. (0:Disable or 1:Enable) */
+
+#define FF_USE_CHMOD 1
+/* This option switches attribute manipulation functions, f_chmod() and f_utime().
+/  (0:Disable or 1:Enable) Also FF_FS_READONLY needs to be 0 to enable this option. */
+
+#define FF_USE_LABEL 0
+/* This option switches volume label functions, f_getlabel() and f_setlabel().
+/  (0:Disable or 1:Enable) */
+
+#define FF_USE_FORWARD 0
+/* This option switches f_forward() function. (0:Disable or 1:Enable) */
+
+#define FF_USE_STRFUNC 0
+#define FF_PRINT_LLI 0
+#define FF_PRINT_FLOAT 0
+#define FF_STRF_ENCODE 3
+/* FF_USE_STRFUNC switches string functions, f_gets(), f_putc(), f_puts() and
+/  f_printf().
+/
+/   0: Disable. FF_PRINT_LLI, FF_PRINT_FLOAT and FF_STRF_ENCODE have no effect.
+/   1: Enable without LF-CRLF conversion.
+/   2: Enable with LF-CRLF conversion.
+/
+/  FF_PRINT_LLI = 1 makes f_printf() support long long argument and FF_PRINT_FLOAT = 1/2
+   makes f_printf() support floating point argument. These features want C99 or later.
+/  When FF_LFN_UNICODE >= 1 with LFN enabled, string functions convert the character
+/  encoding in it. FF_STRF_ENCODE selects assumption of character encoding ON THE FILE
+/  to be read/written via those functions.
+/
+/   0: ANSI/OEM in current CP
+/   1: Unicode in UTF-16LE
+/   2: Unicode in UTF-16BE
+/   3: Unicode in UTF-8
+*/
+
+/*---------------------------------------------------------------------------/
+/ Locale and Namespace Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_CODE_PAGE CONFIG_FATFS_CODEPAGE
+/* This option specifies the OEM code page to be used on the target system.
+/  Incorrect code page setting can cause a file open failure.
+/
+/   437 - U.S.
+/   720 - Arabic
+/   737 - Greek
+/   771 - KBL
+/   775 - Baltic
+/   850 - Latin 1
+/   852 - Latin 2
+/   855 - Cyrillic
+/   857 - Turkish
+/   860 - Portuguese
+/   861 - Icelandic
+/   862 - Hebrew
+/   863 - Canadian French
+/   864 - Arabic
+/   865 - Nordic
+/   866 - Russian
+/   869 - Greek 2
+/   932 - Japanese (DBCS)
+/   936 - Simplified Chinese (DBCS)
+/   949 - Korean (DBCS)
+/   950 - Traditional Chinese (DBCS)
+/     0 - Include all code pages above and configured by f_setcp()
+*/
+
+#if defined(CONFIG_FATFS_LFN_STACK)
+#define FF_USE_LFN 2
+#elif defined(CONFIG_FATFS_LFN_HEAP)
+#define FF_USE_LFN 3
+#else /* CONFIG_FATFS_LFN_NONE */
+#define FF_USE_LFN 0
+#endif
+
+#ifdef CONFIG_FATFS_MAX_LFN
+#define FF_MAX_LFN CONFIG_FATFS_MAX_LFN
+#endif
+
+/* The FF_USE_LFN switches the support for LFN (long file name).
+/
+/   0: Disable LFN. FF_MAX_LFN has no effect.
+/   1: Enable LFN with static  working buffer on the BSS. Always NOT thread-safe.
+/   2: Enable LFN with dynamic working buffer on the STACK.
+/   3: Enable LFN with dynamic working buffer on the HEAP.
+/
+/  To enable the LFN, ffunicode.c needs to be added to the project. The LFN function
+/  requiers certain internal working buffer occupies (FF_MAX_LFN + 1) * 2 bytes and
+/  additional (FF_MAX_LFN + 44) / 15 * 32 bytes when exFAT is enabled.
+/  The FF_MAX_LFN defines size of the working buffer in UTF-16 code unit and it can
+/  be in range of 12 to 255. It is recommended to be set it 255 to fully support LFN
+/  specification.
+/  When use stack for the working buffer, take care on stack overflow. When use heap
+/  memory for the working buffer, memory management functions, ff_memalloc() and
+/  ff_memfree() exemplified in ffsystem.c, need to be added to the project. */
+
+#ifdef CONFIG_FATFS_API_ENCODING_UTF_8
+#define FF_LFN_UNICODE 2
+#else /* CONFIG_FATFS_API_ENCODING_ANSI_OEM */
+#define FF_LFN_UNICODE 0
+#endif
+/* This option switches the character encoding on the API when LFN is enabled.
+/
+/   0: ANSI/OEM in current CP (TCHAR = char)
+/   1: Unicode in UTF-16 (TCHAR = WCHAR)
+/   2: Unicode in UTF-8 (TCHAR = char)
+/   3: Unicode in UTF-32 (TCHAR = DWORD)
+/
+/  Also behavior of string I/O functions will be affected by this option.
+/  When LFN is not enabled, this option has no effect. */
+
+#define FF_LFN_BUF 255
+#define FF_SFN_BUF 12
+/* This set of options defines size of file name members in the FILINFO structure
+/  which is used to read out directory items. These values should be suffcient for
+/  the file names to read. The maximum possible length of the read file name depends
+/  on character encoding. When LFN is not enabled, these options have no effect. */
+
+#define FF_FS_RPATH 0
+/* This option configures support for relative path.
+/
+/   0: Disable relative path and remove related functions.
+/   1: Enable relative path. f_chdir() and f_chdrive() are available.
+/   2: f_getcwd() function is available in addition to 1.
+*/
+
+/*---------------------------------------------------------------------------/
+/ Drive/Volume Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_VOLUMES CONFIG_FATFS_VOLUME_COUNT
+/* Number of volumes (logical drives) to be used. (1-10) */
+
+#define FF_STR_VOLUME_ID 0
+#define FF_VOLUME_STRS "RAM", "NAND", "CF", "SD", "SD2", "USB", "USB2", "USB3"
+/* FF_STR_VOLUME_ID switches support for volume ID in arbitrary strings.
+/  When FF_STR_VOLUME_ID is set to 1 or 2, arbitrary strings can be used as drive
+/  number in the path name. FF_VOLUME_STRS defines the volume ID strings for each
+/  logical drives. Number of items must not be less than FF_VOLUMES. Valid
+/  characters for the volume ID strings are A-Z, a-z and 0-9, however, they are
+/  compared in case-insensitive. If FF_STR_VOLUME_ID >= 1 and FF_VOLUME_STRS is
+/  not defined, a user defined volume string table needs to be defined as:
+/
+/  const char* VolumeStr[FF_VOLUMES] = {"ram","flash","sd","usb",...
+*/
+
+#define FF_MULTI_PARTITION 1
+/* This option switches support for multiple volumes on the physical drive.
+/  By default (0), each logical drive number is bound to the same physical drive
+/  number and only an FAT volume found on the physical drive will be mounted.
+/  When this function is enabled (1), each logical drive number can be bound to
+/  arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
+/  funciton will be available. */
+
+/* SD card sector size */
+#define FF_SS_SDCARD 512
+/* wear_levelling library sector size */
+#define FF_SS_WL CONFIG_WL_SECTOR_SIZE
+
+#define FF_MIN_SS MIN(FF_SS_SDCARD, FF_SS_WL)
+#define FF_MAX_SS MAX(FF_SS_SDCARD, FF_SS_WL)
+/* This set of options configures the range of sector size to be supported. (512,
+/  1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
+/  harddisk, but a larger value may be required for on-board flash memory and some
+/  type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
+/  for variable sector size mode and disk_ioctl() function needs to implement
+/  GET_SECTOR_SIZE command. */
+
+#define FF_LBA64 0
+/* This option switches support for 64-bit LBA. (0:Disable or 1:Enable)
+/  To enable the 64-bit LBA, also exFAT needs to be enabled. (FF_FS_EXFAT == 1) */
+
+#define FF_MIN_GPT 0x10000000
+/* Minimum number of sectors to switch GPT as partitioning format in f_mkfs and
+/  f_fdisk function. 0x100000000 max. This option has no effect when FF_LBA64 == 0. */
+
+#define FF_USE_TRIM 1
+/* This option switches support for ATA-TRIM. (0:Disable or 1:Enable)
+/  To enable Trim function, also CTRL_TRIM command should be implemented to the
+/  disk_ioctl() function. */
+
+/*---------------------------------------------------------------------------/
+/ System Configurations
+/---------------------------------------------------------------------------*/
+
+#define FF_FS_TINY (!CONFIG_FATFS_PER_FILE_CACHE)
+/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
+/  At the tiny configuration, size of file object (FIL) is shrinked FF_MAX_SS bytes.
+/  Instead of private sector buffer eliminated from the file object, common sector
+/  buffer in the filesystem object (FATFS) is used for the file data transfer. */
+
+#define FF_FS_EXFAT 0
+/* This option switches support for exFAT filesystem. (0:Disable or 1:Enable)
+/  To enable exFAT, also LFN needs to be enabled. (FF_USE_LFN >= 1)
+/  Note that enabling exFAT discards ANSI C (C89) compatibility. */
+
+#define FF_FS_NORTC 0
+#define FF_NORTC_MON 1
+#define FF_NORTC_MDAY 1
+#define FF_NORTC_YEAR 2020
+/* The option FF_FS_NORTC switches timestamp functiton. If the system does not have
+/  any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
+/  the timestamp function. Every object modified by FatFs will have a fixed timestamp
+/  defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.
+/  To enable timestamp function (FF_FS_NORTC = 0), get_fattime() function need to be
+/  added to the project to read current time form real-time clock. FF_NORTC_MON,
+/  FF_NORTC_MDAY and FF_NORTC_YEAR have no effect.
+/  These options have no effect in read-only configuration (FF_FS_READONLY = 1). */
+
+#define FF_FS_NOFSINFO 0
+/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
+/  option, and f_getfree() function at first time after volume mount will force
+/  a full FAT scan. Bit 1 controls the use of last allocated cluster number.
+/
+/  bit0=0: Use free cluster count in the FSINFO if available.
+/  bit0=1: Do not trust free cluster count in the FSINFO.
+/  bit1=0: Use last allocated cluster number in the FSINFO if available.
+/  bit1=1: Do not trust last allocated cluster number in the FSINFO.
+*/
+
+#define FF_FS_LOCK CONFIG_FATFS_FS_LOCK
+/* The option FF_FS_LOCK switches file lock function to control duplicated file open
+/  and illegal operation to open objects. This option must be 0 when FF_FS_READONLY
+/  is 1.
+/
+/  0:  Disable file lock function. To avoid volume corruption, application program
+/      should avoid illegal open, remove and rename to the open objects.
+/  >0: Enable file lock function. The value defines how many files/sub-directories
+/      can be opened simultaneously under file lock control. Note that the file
+/      lock control is independent of re-entrancy. */
+
+/* #include <somertos.h>	// O/S definitions */
+#define FF_FS_REENTRANT 1
+#define FF_FS_TIMEOUT (CONFIG_FATFS_TIMEOUT_MS / portTICK_PERIOD_MS)
+#define FF_SYNC_t SemaphoreHandle_t
+/* The option FF_FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
+/  module itself. Note that regardless of this option, file access to different
+/  volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
+/  and f_fdisk() function, are always not re-entrant. Only file/directory access
+/  to the same volume is under control of this function.
+/
+/   0: Disable re-entrancy. FF_FS_TIMEOUT and FF_SYNC_t have no effect.
+/   1: Enable re-entrancy. Also user provided synchronization handlers,
+/      ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
+/      function, must be added to the project. Samples are available in
+/      option/syscall.c.
+/
+/  The FF_FS_TIMEOUT defines timeout period in unit of time tick.
+/  The FF_SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
+/  SemaphoreHandle_t and etc. A header file for O/S definitions needs to be
+/  included somewhere in the scope of ff.h. */
+
+#include <sys/param.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+
+/* Some memory allocation functions are declared here in addition to ff.h, so that
+   they can be used also by external code when LFN feature is disabled.
+ */
+void *ff_memalloc(unsigned msize);
+void ff_memfree(void *);
+
+/*--- End of configuration options ---*/
+
+/* Redefine names of disk IO functions to prevent name collisions */
+#define disk_initialize ff_disk_initialize
+#define disk_status ff_disk_status
+#define disk_read ff_disk_read
+#define disk_write ff_disk_write
+#define disk_ioctl ff_disk_ioctl

code/components/esp-fatfs/src/ffsystem_mh.c

@@ -0,0 +1,169 @@
+/*------------------------------------------------------------------------*/
+/* Sample Code of OS Dependent Functions for FatFs                        */
+/* (C)ChaN, 2018                                                          */
+/*------------------------------------------------------------------------*/
+
+
+#include "ff_mh.h"
+
+
+#if FF_USE_LFN == 3	/* Dynamic memory allocation */
+
+/*------------------------------------------------------------------------*/
+/* Allocate a memory block                                                */
+/*------------------------------------------------------------------------*/
+
+void* ff_memalloc (	/* Returns pointer to the allocated memory block (null if not enough core) */
+	UINT msize		/* Number of bytes to allocate */
+)
+{
+	return malloc(msize);	/* Allocate a new memory block with POSIX API */
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Free a memory block                                                    */
+/*------------------------------------------------------------------------*/
+
+void ff_memfree (
+	void* mblock	/* Pointer to the memory block to free (nothing to do if null) */
+)
+{
+	free(mblock);	/* Free the memory block with POSIX API */
+}
+
+#endif
+
+
+
+#if FF_FS_REENTRANT	/* Mutal exclusion */
+
+/*------------------------------------------------------------------------*/
+/* Create a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to create a new
+/  synchronization object for the volume, such as semaphore and mutex.
+/  When a 0 is returned, the f_mount() function fails with FR_INT_ERR.
+*/
+
+//const osMutexDef_t Mutex[FF_VOLUMES];	/* Table of CMSIS-RTOS mutex */
+
+
+int ff_cre_syncobj (	/* 1:Function succeeded, 0:Could not create the sync object */
+	BYTE vol,			/* Corresponding volume (logical drive number) */
+	FF_SYNC_t* sobj		/* Pointer to return the created sync object */
+)
+{
+	/* Win32 */
+	*sobj = CreateMutex(NULL, FALSE, NULL);
+	return (int)(*sobj != INVALID_HANDLE_VALUE);
+
+	/* uITRON */
+//	T_CSEM csem = {TA_TPRI,1,1};
+//	*sobj = acre_sem(&csem);
+//	return (int)(*sobj > 0);
+
+	/* uC/OS-II */
+//	OS_ERR err;
+//	*sobj = OSMutexCreate(0, &err);
+//	return (int)(err == OS_NO_ERR);
+
+	/* FreeRTOS */
+//	*sobj = xSemaphoreCreateMutex();
+//	return (int)(*sobj != NULL);
+
+	/* CMSIS-RTOS */
+//	*sobj = osMutexCreate(&Mutex[vol]);
+//	return (int)(*sobj != NULL);
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Delete a Synchronization Object                                        */
+/*------------------------------------------------------------------------*/
+/* This function is called in f_mount() function to delete a synchronization
+/  object that created with ff_cre_syncobj() function. When a 0 is returned,
+/  the f_mount() function fails with FR_INT_ERR.
+*/
+
+int ff_del_syncobj (	/* 1:Function succeeded, 0:Could not delete due to an error */
+	FF_SYNC_t sobj		/* Sync object tied to the logical drive to be deleted */
+)
+{
+	/* Win32 */
+	return (int)CloseHandle(sobj);
+
+	/* uITRON */
+//	return (int)(del_sem(sobj) == E_OK);
+
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexDel(sobj, OS_DEL_ALWAYS, &err);
+//	return (int)(err == OS_NO_ERR);
+
+	/* FreeRTOS */
+//  vSemaphoreDelete(sobj);
+//	return 1;
+
+	/* CMSIS-RTOS */
+//	return (int)(osMutexDelete(sobj) == osOK);
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Request Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on entering file functions to lock the volume.
+/  When a 0 is returned, the file function fails with FR_TIMEOUT.
+*/
+
+int ff_req_grant (	/* 1:Got a grant to access the volume, 0:Could not get a grant */
+	FF_SYNC_t sobj	/* Sync object to wait */
+)
+{
+	/* Win32 */
+	return (int)(WaitForSingleObject(sobj, FF_FS_TIMEOUT) == WAIT_OBJECT_0);
+
+	/* uITRON */
+//	return (int)(wai_sem(sobj) == E_OK);
+
+	/* uC/OS-II */
+//	OS_ERR err;
+//	OSMutexPend(sobj, FF_FS_TIMEOUT, &err));
+//	return (int)(err == OS_NO_ERR);
+
+	/* FreeRTOS */
+//	return (int)(xSemaphoreTake(sobj, FF_FS_TIMEOUT) == pdTRUE);
+
+	/* CMSIS-RTOS */
+//	return (int)(osMutexWait(sobj, FF_FS_TIMEOUT) == osOK);
+}
+
+
+/*------------------------------------------------------------------------*/
+/* Release Grant to Access the Volume                                     */
+/*------------------------------------------------------------------------*/
+/* This function is called on leaving file functions to unlock the volume.
+*/
+
+void ff_rel_grant (
+	FF_SYNC_t sobj	/* Sync object to be signaled */
+)
+{
+	/* Win32 */
+	ReleaseMutex(sobj);
+
+	/* uITRON */
+//	sig_sem(sobj);
+
+	/* uC/OS-II */
+//	OSMutexPost(sobj);
+
+	/* FreeRTOS */
+//	xSemaphoreGive(sobj);
+
+	/* CMSIS-RTOS */
+//	osMutexRelease(sobj);
+}
+
+#endif

code/components/esp-fatfs/vfs/esp_vfs_fat_mh.h

@@ -0,0 +1,321 @@
+/*
+ * 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 "driver/sdmmc_types.h"
+#include "driver/sdspi_host.h"
+#include "ff_mh.h"
+#include "wear_levelling.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Register FATFS with VFS component
+ *
+ * This function registers given FAT drive in VFS, at the specified base path.
+ * If only one drive is used, fat_drive argument can be an empty string.
+ * Refer to FATFS library documentation on how to specify FAT drive.
+ * This function also allocates FATFS structure which should be used for f_mount
+ * call.
+ *
+ * @note This function doesn't mount the drive into FATFS, it just connects
+ *       POSIX and C standard library IO function with FATFS. You need to mount
+ *       desired drive into FATFS separately.
+ *
+ * @param base_path  path prefix where FATFS should be registered
+ * @param fat_drive  FATFS drive specification; if only one drive is used, can be an empty string
+ * @param max_files  maximum number of files which can be open at the same time
+ * @param[out] out_fs  pointer to FATFS structure which can be used for FATFS f_mount call is returned via this argument.
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_register was already called
+ *      - ESP_ERR_NO_MEM if not enough memory or too many VFSes already registered
+ */
+esp_err_t esp_vfs_fat_register(const char* base_path, const char* fat_drive,
+        size_t max_files, FATFS** out_fs);
+
+/**
+ * @brief Un-register FATFS from VFS
+ *
+ * @note FATFS structure returned by esp_vfs_fat_register is destroyed after
+ *       this call. Make sure to call f_mount function to unmount it before
+ *       calling esp_vfs_fat_unregister_ctx.
+ *       Difference between this function and the one above is that this one
+ *       will release the correct drive, while the one above will release
+ *       the last registered one
+ *
+ * @param base_path     path prefix where FATFS is registered. This is the same
+ *                      used when esp_vfs_fat_register was called
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if FATFS is not registered in VFS
+ */
+esp_err_t esp_vfs_fat_unregister_path(const char* base_path);
+
+
+/**
+ * @brief Configuration arguments for esp_vfs_fat_sdmmc_mount and esp_vfs_fat_spiflash_mount_rw_wl functions
+ */
+typedef struct {
+    /**
+     * If FAT partition can not be mounted, and this parameter is true,
+     * create partition table and format the filesystem.
+     */
+    bool format_if_mount_failed;
+    int max_files;                  ///< Max number of open files
+    /**
+     * If format_if_mount_failed is set, and mount fails, format the card
+     * with given allocation unit size. Must be a power of 2, between sector
+     * size and 128 * sector size.
+     * For SD cards, sector size is always 512 bytes. For wear_levelling,
+     * sector size is determined by CONFIG_WL_SECTOR_SIZE option.
+     *
+     * Using larger allocation unit size will result in higher read/write
+     * performance and higher overhead when storing small files.
+     *
+     * Setting this field to 0 will result in allocation unit set to the
+     * sector size.
+     */
+    size_t allocation_unit_size;
+    /**
+     * Enables real ff_disk_status function implementation for SD cards
+     * (ff_sdmmc_status). Possibly slows down IO performance.
+     *
+     * Try to enable if you need to handle situations when SD cards
+     * are not unmounted properly before physical removal
+     * or you are experiencing issues with SD cards.
+     *
+     * Doesn't do anything for other memory storage media.
+     */
+    bool disk_status_check_enable;
+} esp_vfs_fat_mount_config_t;
+
+// Compatibility definition
+typedef esp_vfs_fat_mount_config_t esp_vfs_fat_sdmmc_mount_config_t;
+
+/**
+ * @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(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(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);
+
+/**
+ * @brief Unmount FAT filesystem and release resources acquired using esp_vfs_fat_sdmmc_mount
+ *
+ * @deprecated Use `esp_vfs_fat_sdcard_unmount()` instead.
+ *
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount hasn't been called
+ */
+esp_err_t esp_vfs_fat_sdmmc_unmount(void);
+
+/**
+ * @brief Unmount an SD card from the FAT filesystem and release resources acquired using
+ *        `esp_vfs_fat_sdmmc_mount()` or `esp_vfs_fat_sdspi_mount()`
+ *
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_ARG if the card argument is unregistered
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount hasn't been called
+ */
+esp_err_t esp_vfs_fat_sdcard_unmount(const char* base_path, sdmmc_card_t *card);
+
+/**
+ * @brief Convenience function to initialize FAT filesystem in SPI flash and register it in VFS
+ *
+ * This is an all-in-one function which does the following:
+ *
+ * - finds the partition with defined partition_label. Partition label should be
+ *   configured in the partition table.
+ * - initializes flash wear levelling library on top of the given partition
+ * - mounts FAT partition using FATFS library on top of flash wear levelling
+ *   library
+ * - registers FATFS library with VFS, with prefix given by base_prefix variable
+ *
+ * This function is intended to make example code more compact.
+ *
+ * @param base_path        path where FATFS partition should be mounted (e.g. "/spiflash")
+ * @param partition_label  label of the partition which should be used
+ * @param mount_config     pointer to structure with extra parameters for mounting FATFS
+ * @param[out] wl_handle   wear levelling driver handle
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_NOT_FOUND if the partition table does not contain FATFS partition with given label
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_spiflash_mount_rw_wl 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 wear levelling library, SPI flash driver, or FATFS drivers
+ */
+esp_err_t esp_vfs_fat_spiflash_mount_rw_wl(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config,
+    wl_handle_t* wl_handle);
+
+/**
+ * @brief Unmount FAT filesystem and release resources acquired using esp_vfs_fat_spiflash_mount_rw_wl
+ *
+ * @param base_path  path where partition should be registered (e.g. "/spiflash")
+ * @param wl_handle  wear levelling driver handle returned by esp_vfs_fat_spiflash_mount_rw_wl
+ *
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_spiflash_mount_rw_wl hasn't been called
+ */
+esp_err_t esp_vfs_fat_spiflash_unmount_rw_wl(const char* base_path, wl_handle_t wl_handle);
+
+/**
+ * @brief Convenience function to initialize read-only FAT filesystem and register it in VFS
+ *
+ * This is an all-in-one function which does the following:
+ *
+ * - finds the partition with defined partition_label. Partition label should be
+ *   configured in the partition table.
+ * - mounts FAT partition using FATFS library
+ * - registers FATFS library with VFS, with prefix given by base_prefix variable
+ *
+ * @note Wear levelling is not used when FAT is mounted in read-only mode using this function.
+ *
+ * @param base_path        path where FATFS partition should be mounted (e.g. "/spiflash")
+ * @param partition_label  label of the partition which should be used
+ * @param mount_config     pointer to structure with extra parameters for mounting FATFS
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_NOT_FOUND if the partition table does not contain FATFS partition with given label
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_spiflash_mount_ro was already called for the same partition
+ *      - ESP_ERR_NO_MEM if memory can not be allocated
+ *      - ESP_FAIL if partition can not be mounted
+ *      - other error codes from SPI flash driver, or FATFS drivers
+ */
+esp_err_t esp_vfs_fat_spiflash_mount_ro(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config);
+
+/**
+ * @brief Unmount FAT filesystem and release resources acquired using esp_vfs_fat_spiflash_mount_ro
+ *
+ * @param base_path  path where partition should be registered (e.g. "/spiflash")
+ * @param partition_label label of partition to be unmounted
+ *
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_spiflash_mount_rw_wl hasn't been called
+ */
+esp_err_t esp_vfs_fat_spiflash_unmount_ro(const char* base_path, const char* partition_label);
+
+esp_err_t esp_vfs_fat_spiflash_mount(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config,
+    wl_handle_t* wl_handle)
+    __attribute__((deprecated("esp_vfs_fat_spiflash_mount is deprecated, please use esp_vfs_fat_spiflash_mount_rw_wl instead")));
+esp_err_t esp_vfs_fat_spiflash_unmount(const char* base_path, wl_handle_t wl_handle)
+    __attribute__((deprecated("esp_vfs_fat_spiflash_unmount is deprecated, please use esp_vfs_fat_spiflash_unmount_rw_wl instead")));
+esp_err_t esp_vfs_fat_rawflash_mount(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config)
+    __attribute__((deprecated("esp_vfs_fat_rawflash_mount is deprecated, please use esp_vfs_fat_spiflash_mount_ro instead")));
+esp_err_t esp_vfs_fat_rawflash_unmount(const char* base_path, const char* partition_label)
+    __attribute__((deprecated("esp_vfs_fat_rawflash_unmount is deprecated, please use esp_vfs_fat_spiflash_unmount_ro instead")));
+
+/**
+ * @brief  Get information for FATFS partition
+ *
+ * @param base_path  Path where partition should be registered (e.g. "/spiflash")
+ * @param[out] out_total_bytes  Size of the file system
+ * @param[out] out_free_bytes   Current used bytes in the file system
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_STATE if partition not found
+ *      - ESP_FAIL if another FRESULT error (saved in errno)
+ */
+esp_err_t esp_vfs_fat_info(const char* base_path, uint64_t* out_total_bytes, uint64_t* out_free_bytes);
+
+#ifdef __cplusplus
+}
+#endif

code/components/esp-fatfs/vfs/vfs_fat_internal_mh.h

@@ -0,0 +1,30 @@
+// Copyright 2018 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.
+
+#pragma once
+
+#include "esp_vfs_fat_mh.h"
+#include <sys/param.h>
+#include <stddef.h>
+
+static inline size_t esp_vfs_fat_get_allocation_unit_size(
+        size_t sector_size, size_t requested_size)
+{
+    size_t alloc_unit_size = requested_size;
+    const size_t max_sectors_per_cylinder = 128;
+    const size_t max_size = sector_size * max_sectors_per_cylinder;
+    alloc_unit_size = MAX(alloc_unit_size, sector_size);
+    alloc_unit_size = MIN(alloc_unit_size, max_size);
+    return alloc_unit_size;
+}

code/components/esp-fatfs/vfs/vfs_fat_sdmmc_mh.c

@@ -0,0 +1,375 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "esp_log.h"
+#include "esp_vfs.h"
+#include "esp_vfs_fat_mh.h"
+#include "vfs_fat_internal_mh.h"
+#include "driver/sdspi_host.h"
+#include "sdmmc_cmd_mh.h"
+#include "diskio_impl_mh.h"
+#include "diskio_sdmmc_mh.h"
+#include "soc/soc_caps.h"
+#include "driver/sdmmc_defs.h"
+
+#if SOC_SDMMC_HOST_SUPPORTED
+#include "driver/sdmmc_host.h"
+#endif
+
+static const char* TAG = "vfs_fat_sdmmc";
+static sdmmc_card_t* s_card = NULL;
+static uint8_t s_pdrv = FF_DRV_NOT_USED;
+static char * s_base_path = NULL;
+
+#define CHECK_EXECUTE_RESULT(err, str) do { \
+    if ((err) !=ESP_OK) { \
+        ESP_LOGE(TAG, str" (0x%x).", err); \
+        goto cleanup; \
+    } \
+    } while(0)
+
+static void call_host_deinit(const sdmmc_host_t *host_config);
+static esp_err_t partition_card(const esp_vfs_fat_mount_config_t *mount_config,
+                                const char *drv, sdmmc_card_t *card, BYTE pdrv);
+
+static esp_err_t mount_prepare_mem(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 mount_to_vfs_fat(const esp_vfs_fat_mount_config_t *mount_config, sdmmc_card_t *card, uint8_t pdrv,
+                                  const char *base_path)
+{
+    FATFS* fs = NULL;
+    esp_err_t err;
+    ff_diskio_register_sdmmc(pdrv, card);
+    ff_sdmmc_set_disk_status_check(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);
+    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
+    FRESULT res = f_mount(fs, drv, 1);
+    if (res != FR_OK) {
+        err = ESP_FAIL;
+        ESP_LOGW(TAG, "failed to mount card (%d)", res);
+        if (!((res == FR_NO_FILESYSTEM || res == FR_INT_ERR)
+              && mount_config->format_if_mount_failed)) {
+            goto fail;
+        }
+
+        err = partition_card(mount_config, drv, card, pdrv);
+        if (err != ESP_OK) {
+            goto fail;
+        }
+
+        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);
+            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(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(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(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;
+    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(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(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(mount_config, card, pdrv, dup_path);
+    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
+
+    if (out_card != NULL) {
+        *out_card = card;
+    }
+    if (s_card == NULL) {
+        //store the ctx locally to be back-compatible
+        s_card = card;
+        s_pdrv = pdrv;
+        s_base_path = dup_path;
+    } else {
+        free(dup_path);
+    }
+    return ESP_OK;
+cleanup:
+    if (host_inited) {
+        call_host_deinit(host_config);
+    }
+    free(card);
+    free(dup_path);
+    return err;
+}
+#endif
+
+static esp_err_t init_sdspi_host(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(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;
+    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(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(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(mount_config, card, pdrv, dup_path);
+    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
+
+    if (out_card != NULL) {
+        *out_card = card;
+    }
+    if (s_card == NULL) {
+        //store the ctx locally to be back-compatible
+        s_card = card;
+        s_pdrv = pdrv;
+        s_base_path = dup_path;
+    } else {
+        free(dup_path);
+    }
+    return ESP_OK;
+
+cleanup:
+    if (host_inited) {
+        call_host_deinit(host_config);
+    }
+    free(card);
+    free(dup_path);
+    return err;
+
+}
+
+static void local_card_remove(void)
+{
+    s_card = NULL;
+    free(s_base_path);
+    s_base_path = NULL;
+    s_pdrv = FF_DRV_NOT_USED;
+}
+
+static void call_host_deinit(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(const char *base_path, sdmmc_card_t *card)
+{
+    BYTE pdrv = ff_diskio_get_pdrv_card(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(&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(void)
+{
+    sdmmc_card_t* card = s_card;
+    esp_err_t err = unmount_card_core(s_base_path, card);
+    local_card_remove();
+    return err;
+}
+
+esp_err_t esp_vfs_fat_sdcard_unmount(const char *base_path, sdmmc_card_t *card)
+{
+    esp_err_t err = unmount_card_core(base_path, card);
+    if (s_card == card) {
+        local_card_remove();
+    }
+    return err;
+}

code/components/esp-fatfs/vfs/vfs_fat_spiflash_mh.c

@@ -0,0 +1,218 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "esp_log.h"
+#include "esp_vfs.h"
+#include "esp_vfs_fat_mh.h"
+#include "vfs_fat_internal_mh.h"
+#include "diskio_impl_mh.h"
+
+#include "diskio_rawflash_mh.h"
+
+#include "wear_levelling.h"
+#include "diskio_wl_mh.h"
+
+static const char* TAG = "vfs_fat_spiflash";
+
+esp_err_t esp_vfs_fat_spiflash_mount_rw_wl(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config,
+    wl_handle_t* wl_handle)
+{
+    esp_err_t result = ESP_OK;
+    const size_t workbuf_size = 4096;
+    void *workbuf = NULL;
+
+    esp_partition_subtype_t subtype = partition_label ?
+            ESP_PARTITION_SUBTYPE_ANY : ESP_PARTITION_SUBTYPE_DATA_FAT;
+    const esp_partition_t *data_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
+                                                subtype, partition_label);
+    if (data_partition == NULL) {
+        ESP_LOGE(TAG, "Failed to find FATFS partition (type='data', subtype='fat', partition_label='%s'). Check the partition table.", partition_label);
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    result = wl_mount(data_partition, wl_handle);
+    if (result != ESP_OK) {
+        ESP_LOGE(TAG, "failed to mount wear levelling layer. result = %i", result);
+        return result;
+    }
+    // connect driver to FATFS
+    BYTE pdrv = 0xFF;
+    if (ff_diskio_get_drive(&pdrv) != ESP_OK) {
+        ESP_LOGD(TAG, "the maximum count of volumes is already mounted");
+        return ESP_ERR_NO_MEM;
+    }
+    ESP_LOGD(TAG, "using pdrv=%i", pdrv);
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+    result = ff_diskio_register_wl_partition(pdrv, *wl_handle);
+    if (result != ESP_OK) {
+        ESP_LOGE(TAG, "ff_diskio_register_wl_partition failed pdrv=%i, error - 0x(%x)", pdrv, result);
+        goto fail;
+    }
+    FATFS *fs;
+    result = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs);
+    if (result == ESP_ERR_INVALID_STATE) {
+        // it's okay, already registered with VFS
+    } else if (result != ESP_OK) {
+        ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", result);
+        goto fail;
+    }
+
+    // Try to mount partition
+    FRESULT fresult = f_mount(fs, drv, 1);
+    if (fresult != FR_OK) {
+        ESP_LOGW(TAG, "f_mount failed (%d)", fresult);
+        if (!((fresult == FR_NO_FILESYSTEM || fresult == FR_INT_ERR)
+              && mount_config->format_if_mount_failed)) {
+            result = ESP_FAIL;
+            goto fail;
+        }
+        workbuf = ff_memalloc(workbuf_size);
+        if (workbuf == NULL) {
+            result = ESP_ERR_NO_MEM;
+            goto fail;
+        }
+        size_t alloc_unit_size = esp_vfs_fat_get_allocation_unit_size(
+                CONFIG_WL_SECTOR_SIZE,
+                mount_config->allocation_unit_size);
+        ESP_LOGI(TAG, "Formatting FATFS partition, allocation unit size=%d", alloc_unit_size);
+        const MKFS_PARM opt = {(BYTE)(FM_ANY | FM_SFD), 0, 0, 0, alloc_unit_size};
+        fresult = f_mkfs(drv, &opt, workbuf, workbuf_size);
+        if (fresult != FR_OK) {
+            result = ESP_FAIL;
+            ESP_LOGE(TAG, "f_mkfs failed (%d)", fresult);
+            goto fail;
+        }
+        free(workbuf);
+        workbuf = NULL;
+        ESP_LOGI(TAG, "Mounting again");
+        fresult = f_mount(fs, drv, 0);
+        if (fresult != FR_OK) {
+            result = ESP_FAIL;
+            ESP_LOGE(TAG, "f_mount failed after formatting (%d)", fresult);
+            goto fail;
+        }
+    }
+    return ESP_OK;
+
+fail:
+    free(workbuf);
+    esp_vfs_fat_unregister_path(base_path);
+    ff_diskio_unregister(pdrv);
+    return result;
+}
+
+esp_err_t esp_vfs_fat_spiflash_unmount_rw_wl(const char* base_path, wl_handle_t wl_handle)
+{
+    BYTE pdrv = ff_diskio_get_pdrv_wl(wl_handle);
+    if (pdrv == 0xff) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+    f_mount(0, drv, 0);
+    ff_diskio_unregister(pdrv);
+    ff_diskio_clear_pdrv_wl(wl_handle);
+    // release partition driver
+    esp_err_t err_drv = wl_unmount(wl_handle);
+    esp_err_t err = esp_vfs_fat_unregister_path(base_path);
+    if (err == ESP_OK) err = err_drv;
+    return err;
+}
+
+
+esp_err_t esp_vfs_fat_spiflash_mount_ro(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config)
+{
+    esp_err_t result = ESP_OK;
+
+    const esp_partition_t *data_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
+            ESP_PARTITION_SUBTYPE_DATA_FAT, partition_label);
+    if (data_partition == NULL) {
+        ESP_LOGE(TAG, "Failed to find FATFS partition (type='data', subtype='fat', partition_label='%s'). Check the partition table.", partition_label);
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    // connect driver to FATFS
+    BYTE pdrv = 0xFF;
+    if (ff_diskio_get_drive(&pdrv) != ESP_OK) {
+        ESP_LOGD(TAG, "the maximum count of volumes is already mounted");
+        return ESP_ERR_NO_MEM;
+    }
+    ESP_LOGD(TAG, "using pdrv=%i", pdrv);
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+    result = ff_diskio_register_raw_partition(pdrv, data_partition);
+    if (result != ESP_OK) {
+        ESP_LOGE(TAG, "ff_diskio_register_raw_partition failed pdrv=%i, error - 0x(%x)", pdrv, result);
+        goto fail;
+    }
+
+    FATFS *fs;
+    result = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs);
+    if (result == ESP_ERR_INVALID_STATE) {
+        // it's okay, already registered with VFS
+    } else if (result != ESP_OK) {
+        ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", result);
+        goto fail;
+    }
+
+    // Try to mount partition
+    FRESULT fresult = f_mount(fs, drv, 1);
+    if (fresult != FR_OK) {
+        ESP_LOGW(TAG, "f_mount failed (%d)", fresult);
+        result = ESP_FAIL;
+        goto fail;
+    }
+    return ESP_OK;
+
+fail:
+    esp_vfs_fat_unregister_path(base_path);
+    ff_diskio_unregister(pdrv);
+    return result;
+}
+
+esp_err_t esp_vfs_fat_spiflash_unmount_ro(const char* base_path, const char* partition_label)
+{
+    const esp_partition_t *data_partition = esp_partition_find_first(ESP_PARTITION_TYPE_DATA,
+            ESP_PARTITION_SUBTYPE_DATA_FAT, partition_label);
+
+    if (data_partition == NULL) {
+        ESP_LOGE(TAG, "Failed to find FATFS partition (type='data', subtype='fat', partition_label='%s'). Check the partition table.", partition_label);
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    BYTE pdrv = ff_diskio_get_pdrv_raw(data_partition);
+    if (pdrv == 0xff) {
+        return ESP_ERR_INVALID_STATE;
+    }
+    char drv[3] = {(char)('0' + pdrv), ':', 0};
+
+    f_mount(0, drv, 0);
+    ff_diskio_unregister(pdrv);
+    esp_err_t err = esp_vfs_fat_unregister_path(base_path);
+    return err;
+}
+
+
+esp_err_t esp_vfs_fat_spiflash_mount(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config,
+    wl_handle_t* wl_handle)
+    __attribute__((alias("esp_vfs_fat_spiflash_mount_rw_wl")));
+esp_err_t esp_vfs_fat_spiflash_unmount(const char* base_path, wl_handle_t wl_handle)
+    __attribute__((alias("esp_vfs_fat_spiflash_unmount_rw_wl")));
+esp_err_t esp_vfs_fat_rawflash_mount(const char* base_path,
+    const char* partition_label,
+    const esp_vfs_fat_mount_config_t* mount_config)
+    __attribute__((alias("esp_vfs_fat_spiflash_mount_ro")));
+esp_err_t esp_vfs_fat_rawflash_unmount(const char* base_path, const char* partition_label)
+    __attribute__((alias("esp_vfs_fat_spiflash_unmount_ro")));

code/components/esp-sdmmc/CMakeLists.txt

@@ -0,0 +1,11 @@
+idf_component_register(SRCS "sdmmc_cmd_mh.c"
+                            "sdmmc_common_mh.c"
+                            "sdmmc_init_mh.c"
+                            "sdmmc_io_mh.c"
+                            "sdmmc_mmc_mh.c"
+                            "sdmmc_sd_mh.c"
+                    INCLUDE_DIRS "." "include"
+                    REQUIRES driver esp-fatfs
+                    PRIV_REQUIRES soc)
+
+target_compile_options(${COMPONENT_LIB} PRIVATE "-Wno-format")

code/components/esp-sdmmc/README.md

@@ -0,0 +1,279 @@
+# AIOTED related changes, see https://github.com/jomjol/AI-on-the-edge-device/pull/2781
+These files/folders were copied from `framework-espidf@3.50002.230601/components/` and adapted to our own needs.
+Since not every SD/MMC was recognized and this was due to the implementation of ATA trim support, this was revised.
+Furthermore, files that we don't need were deleted from it.
+
+## The most relevant changes are:
+### fatfs/diskio/diskio_sdmmc.c
+DRESULT ff_sdmmc_ioctl (BYTE pdrv, BYTE cmd, void* buff), at lines 106 to 110 changed from:
+```c
+#if FF_USE_TRIM
+        case CTRL_TRIM:
+            return ff_sdmmc_trim (pdrv, *((DWORD*)buff), //start_sector
+                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
+#endif //FF_USE_TRIM
+```
+to:
+```c
+#if (FF_USE_TRIM)
+        case CTRL_TRIM:
+            if(FF_CAN_TRIM){
+                return ff_sdmmc_trim (pdrv, *((DWORD*)buff), //start_sector
+                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
+            }
+            else{
+                return RES_ERROR;
+            }
+#endif //FF_USE_TRIM
+```
+
+### fatfs/src/ff.c
+added:
+```c
+#include "sdmmc_cmd.h"
+```
+
+static FRESULT remove_chain(FFOBJID* obj, DWORD clst, DWORD pclst), at lines 1437 to 1454 changed from:
+```c
+#if FF_FS_EXFAT || FF_USE_TRIM
+		if (ecl + 1 == nxt) {	/* Is next cluster contiguous? */
+			ecl = nxt;
+		} else {				/* End of contiguous cluster block */
+#if FF_FS_EXFAT
+			if (fs->fs_type == FS_EXFAT) {
+				res = change_bitmap(fs, scl, ecl - scl + 1, 0);	/* Mark the cluster block 'free' on the bitmap */
+				if (res != FR_OK) return res;
+			}
+#endif
+#if FF_USE_TRIM
+			rt[0] = clst2sect(fs, scl);					/* Start of data area to be freed */
+			rt[1] = clst2sect(fs, ecl) + fs->csize - 1;	/* End of data area to be freed */
+			disk_ioctl(fs->pdrv, CTRL_TRIM, rt);		/* Inform storage device that the data in the block may be erased */
+#endif
+			scl = ecl = nxt;
+		}
+#endif
+```
+
+to:
+```c
+#if FF_FS_EXFAT || FF_USE_TRIM
+		if(FF_FS_EXFAT || FF_CAN_TRIM){
+			if (ecl + 1 == nxt) {	/* Is next cluster contiguous? */
+				ecl = nxt;
+			} 
+			else {				/* End of contiguous cluster block */
+#if FF_FS_EXFAT
+				if (fs->fs_type == FS_EXFAT) {
+					res = change_bitmap(fs, scl, ecl - scl + 1, 0);	/* Mark the cluster block 'free' on the bitmap */
+					if (res != FR_OK) return res;
+				}
+#endif
+#if FF_USE_TRIM
+				if(FF_CAN_TRIM){
+					rt[0] = clst2sect(fs, scl);					/* Start of data area to be freed */
+					rt[1] = clst2sect(fs, ecl) + fs->csize - 1;	/* End of data area to be freed */
+					disk_ioctl(fs->pdrv, CTRL_TRIM, rt);		/* Inform storage device that the data in the block may be erased */
+				}
+#endif
+				scl = ecl = nxt;
+			}
+		}
+#endif
+```
+
+FRESULT f_mkfs(const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len), at lines 5946 to 5949 changed from:
+```c
+#if FF_USE_TRIM
+		lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+		disk_ioctl(pdrv, CTRL_TRIM, lba);
+#endif
+```
+to:
+```c
+#if FF_USE_TRIM
+		if(FF_CAN_TRIM){
+			lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+			disk_ioctl(pdrv, CTRL_TRIM, lba);
+		}
+#endif
+```
+
+FRESULT f_mkfs(const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len), at lines 6175 to 6178 changed from:
+```c
+#if FF_USE_TRIM
+		lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+		disk_ioctl(pdrv, CTRL_TRIM, lba);
+#endif
+```
+to:
+```c
+#if FF_USE_TRIM
+		if(FF_CAN_TRIM){
+			lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;	/* Inform storage device that the volume area may be erased */
+			disk_ioctl(pdrv, CTRL_TRIM, lba);
+		}
+#endif
+```
+
+### sdmmc/sdmmc_cmd.c
+added:
+```c
+int FF_CAN_TRIM = 0;
+```
+
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card), at lines 630 to 636 changed from:
+```c
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card)
+{
+    if ((card->is_mmc) && (card->ext_csd.sec_feature & EXT_CSD_SEC_GB_CL_EN)) {
+        return ESP_OK;
+    }
+    return ESP_FAIL;
+}
+```
+to:
+```c
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card)
+{
+    if ((card->is_mmc) && (card->ext_csd.sec_feature & EXT_CSD_SEC_GB_CL_EN)) {
+        FF_CAN_TRIM = 1;
+        return ESP_OK;
+    }
+    FF_CAN_TRIM = 0;
+    return ESP_FAIL;
+}
+```
+
+### sdmmc/include/sdmmc_cmd.h
+
+added:
+```c
+extern int FF_CAN_TRIM;
+```
+
+
+# Espressif IoT Development Framework
+
+* [中文版](./README_CN.md)
+
+ESP-IDF is the development framework for Espressif SoCs supported on Windows, Linux and macOS.
+
+# ESP-IDF Release Support Schedule
+
+![Support Schedule](https://dl.espressif.com/dl/esp-idf/support-periods.svg)
+
+- Please read [the support policy](SUPPORT_POLICY.md) and [the documentation](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/versions.html) for more information about ESP-IDF versions.
+- Please see the [End-of-Life Advisories](https://www.espressif.com/en/support/documents/advisories?keys=&field_type_of_advisory_tid%5B%5D=817) for information about ESP-IDF releases with discontinued support.
+
+# ESP-IDF Release and SoC Compatibility
+
+The following table shows ESP-IDF support of Espressif SoCs where ![alt text][preview] and ![alt text][supported] denote preview status and support, respectively. The preview support is usually limited in time and intended for beta versions of chips. Please use an ESP-IDF release where the desired SoC is already supported.
+
+|Chip         |          v4.1         |          v4.2          |         v4.3           |          v4.4          |          v5.0          |                                                                                      |
+|:----------- |:---------------------:| :---------------------:| :---------------------:| :---------------------:| :---------------------:|:------------------------------------------------------------------------------------ |
+|ESP32        |![alt text][supported] | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] |                                                                                      |
+|ESP32-S2     |                       | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] |                                                                                      |
+|ESP32-C3     |                       |                        | ![alt text][supported] | ![alt text][supported] | ![alt text][supported] |                                                                                      |
+|ESP32-S3     |                       |                        |                        | ![alt text][supported] | ![alt text][supported] | [Announcement](https://www.espressif.com/en/news/ESP32_S3)                           |
+|ESP32-C2     |                       |                        |                        |                        | ![alt text][supported] | [Announcement](https://blog.espressif.com/esp32-c2-and-why-it-matter-s-bcf4d7d0b2c6) |
+|ESP32-H2     |                       |                        |                        | ![alt text][preview]   | ![alt text][preview]   | [Announcement](https://www.espressif.com/en/news/ESP32_H2)                           |
+
+[supported]: https://img.shields.io/badge/-supported-green "supported"
+[preview]: https://img.shields.io/badge/-preview-orange "preview"
+
+Espressif SoCs released before 2016 (ESP8266 and ESP8285) are supported by [RTOS SDK](https://github.com/espressif/ESP8266_RTOS_SDK) instead.
+
+# Developing With ESP-IDF
+
+## Setting Up ESP-IDF
+
+See https://idf.espressif.com/ for links to detailed instructions on how to set up the ESP-IDF depending on chip you use.
+
+**Note:** Each SoC series and each ESP-IDF release has its own documentation. Please see Section [Versions](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/versions.html) on how to find documentation and how to checkout specific release of ESP-IDF.
+
+### Non-GitHub forks
+
+ESP-IDF uses relative locations as its submodules URLs ([.gitmodules](.gitmodules)). So they link to GitHub. If ESP-IDF is forked to a Git repository which is not on GitHub, you will need to run the script [tools/set-submodules-to-github.sh](tools/set-submodules-to-github.sh) after git clone.
+
+The script sets absolute URLs for all submodules, allowing `git submodule update --init --recursive` to complete. If cloning ESP-IDF from GitHub, this step is not needed.
+
+## Finding a Project
+
+As well as the [esp-idf-template](https://github.com/espressif/esp-idf-template) project mentioned in Getting Started, ESP-IDF comes with some example projects in the [examples](examples) directory.
+
+Once you've found the project you want to work with, change to its directory and you can configure and build it.
+
+To start your own project based on an example, copy the example project directory outside of the ESP-IDF directory.
+
+# Quick Reference
+
+See the Getting Started guide links above for a detailed setup guide. This is a quick reference for common commands when working with ESP-IDF projects:
+
+## Setup Build Environment
+
+(See the Getting Started guide listed above for a full list of required steps with more details.)
+
+* Install host build dependencies mentioned in the Getting Started guide.
+* Run the install script to set up the build environment. The options include `install.bat` or `install.ps1` for Windows, and `install.sh` or `install.fish` for Unix shells.
+* Run the export script on Windows (`export.bat`) or source it on Unix (`source export.sh`) in every shell environment before using ESP-IDF.
+
+## Configuring the Project
+
+* `idf.py set-target <chip_name>` sets the target of the project to `<chip_name>`. Run `idf.py set-target` without any arguments to see a list of supported targets.
+* `idf.py menuconfig` opens a text-based configuration menu where you can configure the project.
+
+## Compiling the Project
+
+`idf.py build`
+
+... will compile app, bootloader and generate a partition table based on the config.
+
+## Flashing the Project
+
+When the build finishes, it will print a command line to use esptool.py to flash the chip. However you can also do this automatically by running:
+
+`idf.py -p PORT flash`
+
+Replace PORT with the name of your serial port (like `COM3` on Windows, `/dev/ttyUSB0` on Linux, or `/dev/cu.usbserial-X` on MacOS. If the `-p` option is left out, `idf.py flash` will try to flash the first available serial port.
+
+This will flash the entire project (app, bootloader and partition table) to a new chip. The settings for serial port flashing can be configured with `idf.py menuconfig`.
+
+You don't need to run `idf.py build` before running `idf.py flash`, `idf.py flash` will automatically rebuild anything which needs it.
+
+## Viewing Serial Output
+
+The `idf.py monitor` target uses the [idf_monitor tool](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/idf-monitor.html) to display serial output from Espressif SoCs. idf_monitor also has a range of features to decode crash output and interact with the device. [Check the documentation page for details](https://docs.espressif.com/projects/esp-idf/en/latest/get-started/idf-monitor.html).
+
+Exit the monitor by typing Ctrl-].
+
+To build, flash and monitor output in one pass, you can run:
+
+`idf.py flash monitor`
+
+## Compiling & Flashing Only the App
+
+After the initial flash, you may just want to build and flash just your app, not the bootloader and partition table:
+
+* `idf.py app` - build just the app.
+* `idf.py app-flash` - flash just the app.
+
+`idf.py app-flash` will automatically rebuild the app if any source files have changed.
+
+(In normal development there's no downside to reflashing the bootloader and partition table each time, if they haven't changed.)
+
+## Erasing Flash
+
+The `idf.py flash` target does not erase the entire flash contents. However it is sometimes useful to set the device back to a totally erased state, particularly when making partition table changes or OTA app updates. To erase the entire flash, run `idf.py erase-flash`.
+
+This can be combined with other targets, ie `idf.py -p PORT erase-flash flash` will erase everything and then re-flash the new app, bootloader and partition table.
+
+# Resources
+
+* Documentation for the latest version: https://docs.espressif.com/projects/esp-idf/. This documentation is built from the [docs directory](docs) of this repository.
+
+* The [esp32.com forum](https://esp32.com/) is a place to ask questions and find community resources.
+
+* [Check the Issues section on github](https://github.com/espressif/esp-idf/issues) if you find a bug or have a feature request. Please check existing Issues before opening a new one.
+
+* If you're interested in contributing to ESP-IDF, please check the [Contributions Guide](https://docs.espressif.com/projects/esp-idf/en/latest/contribute/index.html).

code/components/esp-sdmmc/include/sdmmc_cmd_mh.h

@@ -0,0 +1,357 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+#include <stdio.h>
+#include "esp_err.h"
+#include "driver/sdmmc_types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int FF_CAN_TRIM;
+
+/**
+ * Probe and initialize SD/MMC card using given host
+ *
+ * @note Only SD cards (SDSC and SDHC/SDXC) are supported now.
+ *       Support for MMC/eMMC cards will be added later.
+ *
+ * @param host  pointer to structure defining host controller
+ * @param out_card  pointer to structure which will receive information
+ *                  about the card when the function completes
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_card_init(const sdmmc_host_t* host,
+        sdmmc_card_t* out_card);
+
+/**
+ * @brief Print information about the card to a stream
+ * @param stream  stream obtained using fopen or fdopen
+ * @param card  card information structure initialized using sdmmc_card_init
+ */
+void sdmmc_card_print_info(FILE* stream, const sdmmc_card_t* card);
+
+/**
+ * Get status of SD/MMC card
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_get_status(sdmmc_card_t* card);
+
+/**
+ * Write given number of sectors to SD/MMC card
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param src   pointer to data buffer to read data from; data size must be
+ *              equal to sector_count * card->csd.sector_size
+ * @param start_sector  sector where to start writing
+ * @param sector_count  number of sectors to write
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_write_sectors(sdmmc_card_t* card, const void* src,
+        size_t start_sector, size_t sector_count);
+
+/**
+ * Read given number of sectors from the SD/MMC card
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param dst   pointer to data buffer to write into; buffer size must be
+ *              at least sector_count * card->csd.sector_size
+ * @param start_sector  sector where to start reading
+ * @param sector_count  number of sectors to read
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_read_sectors(sdmmc_card_t* card, void* dst,
+        size_t start_sector, size_t sector_count);
+
+/**
+ * Erase given number of sectors from the SD/MMC card
+ *
+ * @note When sdmmc_erase_sectors used with cards in SDSPI mode, it was
+ * observed that card requires re-init after erase operation.
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param start_sector  sector where to start erase
+ * @param sector_count  number of sectors to erase
+ * @param arg  erase command (CMD38) argument
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_erase_sectors(sdmmc_card_t* card, size_t start_sector,
+        size_t sector_count, sdmmc_erase_arg_t arg);
+
+/**
+ * Check if SD/MMC card supports discard
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @return
+ *      - ESP_OK if supported by the card/device
+ *      - ESP_FAIL if not supported by the card/device
+ */
+esp_err_t sdmmc_can_discard(sdmmc_card_t* card);
+
+/**
+ * Check if SD/MMC card supports trim
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @return
+ *      - ESP_OK if supported by the card/device
+ *      - ESP_FAIL if not supported by the card/device
+ */
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card);
+
+/**
+ * Check if SD/MMC card supports sanitize
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @return
+ *      - ESP_OK if supported by the card/device
+ *      - ESP_FAIL if not supported by the card/device
+ */
+esp_err_t sdmmc_mmc_can_sanitize(sdmmc_card_t* card);
+
+/**
+ * Sanitize the data that was unmapped by a Discard command
+ *
+ * @note  Discard command has to precede sanitize operation. To discard, use
+ *        MMC_DICARD_ARG with sdmmc_erase_sectors argument
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param timeout_ms timeout value in milliseconds required to sanitize the
+ *                   selected range of sectors.
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_mmc_sanitize(sdmmc_card_t* card, uint32_t timeout_ms);
+
+/**
+ * Erase complete SD/MMC card
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_full_erase(sdmmc_card_t* card);
+
+/**
+ * Read one byte from an SDIO card using IO_RW_DIRECT (CMD52)
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param function  IO function number
+ * @param reg  byte address within IO function
+ * @param[out] out_byte  output, receives the value read from the card
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_io_read_byte(sdmmc_card_t* card, uint32_t function,
+        uint32_t reg, uint8_t *out_byte);
+
+/**
+ * Write one byte to an SDIO card using IO_RW_DIRECT (CMD52)
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param function  IO function number
+ * @param reg  byte address within IO function
+ * @param in_byte  value to be written
+ * @param[out] out_byte  if not NULL, receives new byte value read
+ *                       from the card (read-after-write).
+ * @return
+ *      - ESP_OK on success
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_io_write_byte(sdmmc_card_t* card, uint32_t function,
+        uint32_t reg, uint8_t in_byte, uint8_t* out_byte);
+
+/**
+ * Read multiple bytes from an SDIO card using IO_RW_EXTENDED (CMD53)
+ *
+ * This function performs read operation using CMD53 in byte mode.
+ * For block mode, see sdmmc_io_read_blocks.
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param function  IO function number
+ * @param addr  byte address within IO function where reading starts
+ * @param dst  buffer which receives the data read from card
+ * @param size  number of bytes to read
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_SIZE if size exceeds 512 bytes
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_io_read_bytes(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, void* dst, size_t size);
+
+/**
+ * Write multiple bytes to an SDIO card using IO_RW_EXTENDED (CMD53)
+ *
+ * This function performs write operation using CMD53 in byte mode.
+ * For block mode, see sdmmc_io_write_blocks.
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param function  IO function number
+ * @param addr  byte address within IO function where writing starts
+ * @param src  data to be written
+ * @param size  number of bytes to write
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_SIZE if size exceeds 512 bytes
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_io_write_bytes(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, const void* src, size_t size);
+
+/**
+ * Read blocks of data from an SDIO card using IO_RW_EXTENDED (CMD53)
+ *
+ * This function performs read operation using CMD53 in block mode.
+ * For byte mode, see sdmmc_io_read_bytes.
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param function  IO function number
+ * @param addr  byte address within IO function where writing starts
+ * @param dst  buffer which receives the data read from card
+ * @param size  number of bytes to read, must be divisible by the card block
+ *              size.
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_SIZE if size is not divisible by 512 bytes
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_io_read_blocks(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, void* dst, size_t size);
+
+/**
+ * Write blocks of data to an SDIO card using IO_RW_EXTENDED (CMD53)
+ *
+ * This function performs write operation using CMD53 in block mode.
+ * For byte mode, see sdmmc_io_write_bytes.
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param function  IO function number
+ * @param addr  byte address within IO function where writing starts
+ * @param src  data to be written
+ * @param size  number of bytes to read, must be divisible by the card block
+ *              size.
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_INVALID_SIZE if size is not divisible by 512 bytes
+ *      - One of the error codes from SDMMC host controller
+ */
+esp_err_t sdmmc_io_write_blocks(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, const void* src, size_t size);
+
+/**
+ * Enable SDIO interrupt in the SDMMC host
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @return
+ *      - ESP_OK on success
+ *      - ESP_ERR_NOT_SUPPORTED if the host controller does not support
+ *        IO interrupts
+ */
+esp_err_t sdmmc_io_enable_int(sdmmc_card_t* card);
+
+/**
+ * Block until an SDIO interrupt is received
+ *
+ * Slave uses D1 line to signal interrupt condition to the host.
+ * This function can be used to wait for the interrupt.
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param timeout_ticks  time to wait for the interrupt, in RTOS ticks
+ * @return
+ *      - ESP_OK if the interrupt is received
+ *      - ESP_ERR_NOT_SUPPORTED if the host controller does not support
+ *        IO interrupts
+ *      - ESP_ERR_TIMEOUT if the interrupt does not happen in timeout_ticks
+ */
+esp_err_t sdmmc_io_wait_int(sdmmc_card_t* card, TickType_t timeout_ticks);
+
+/**
+ * Get the data of CIS region of an SDIO card.
+ *
+ * You may provide a buffer not sufficient to store all the CIS data. In this
+ * case, this function stores as much data into your buffer as possible. Also,
+ * this function will try to get and return the size required for you.
+ *
+ * @param card  pointer to card information structure previously initialized
+ *              using sdmmc_card_init
+ * @param out_buffer Output buffer of the CIS data
+ * @param buffer_size Size of the buffer.
+ * @param inout_cis_size Mandatory, pointer to a size, input and output.
+ *              - input: Limitation of maximum searching range, should be 0 or larger than
+ *                      buffer_size. The function searches for CIS_CODE_END until this range. Set to
+ *                      0 to search infinitely.
+ *              - output: The size required to store all the CIS data, if CIS_CODE_END is found.
+ *
+ * @return
+ *      - ESP_OK: on success
+ *      - ESP_ERR_INVALID_RESPONSE: if the card does not (correctly) support CIS.
+ *      - ESP_ERR_INVALID_SIZE: CIS_CODE_END found, but buffer_size is less than
+ *              required size, which is stored in the inout_cis_size then.
+ *      - ESP_ERR_NOT_FOUND: if the CIS_CODE_END not found. Increase input value of
+ *              inout_cis_size or set it to 0, if you still want to search for the end;
+ *              output value of inout_cis_size is invalid in this case.
+ *      - and other error code return from sdmmc_io_read_bytes
+ */
+esp_err_t sdmmc_io_get_cis_data(sdmmc_card_t* card, uint8_t* out_buffer, size_t buffer_size, size_t* inout_cis_size);
+
+/**
+ * Parse and print the CIS information of an SDIO card.
+ *
+ * @note Not all the CIS codes and all kinds of tuples are supported. If you
+ * see some unresolved code, you can add the parsing of these code in
+ * sdmmc_io.c and contribute to the IDF through the Github repository.
+ *
+ *              using sdmmc_card_init
+ * @param buffer Buffer to parse
+ * @param buffer_size Size of the buffer.
+ * @param fp File pointer to print to, set to NULL to print to stdout.
+ *
+ * @return
+ *      - ESP_OK: on success
+ *      - ESP_ERR_NOT_SUPPORTED: if the value from the card is not supported to be parsed.
+ *      - ESP_ERR_INVALID_SIZE: if the CIS size fields are not correct.
+ */
+esp_err_t sdmmc_io_print_cis_info(uint8_t* buffer, size_t buffer_size, FILE* fp);
+
+
+#ifdef __cplusplus
+}
+#endif

code/components/esp-sdmmc/sdmmc_cmd_mh.c

@@ -0,0 +1,701 @@
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "sdmmc_common_mh.h"
+
+int FF_CAN_TRIM = 0;
+
+static const char* TAG = "sdmmc_cmd";
+
+
+esp_err_t sdmmc_send_cmd(sdmmc_card_t* card, sdmmc_command_t* cmd)
+{
+    if (card->host.command_timeout_ms != 0) {
+        cmd->timeout_ms = card->host.command_timeout_ms;
+    } else if (cmd->timeout_ms == 0) {
+        cmd->timeout_ms = SDMMC_DEFAULT_CMD_TIMEOUT_MS;
+    }
+
+    int slot = card->host.slot;
+    ESP_LOGV(TAG, "sending cmd slot=%d op=%d arg=%x flags=%x data=%p blklen=%d datalen=%d timeout=%d",
+            slot, cmd->opcode, cmd->arg, cmd->flags, cmd->data, cmd->blklen, cmd->datalen, cmd->timeout_ms);
+    esp_err_t err = (*card->host.do_transaction)(slot, cmd);
+    if (err != 0) {
+        ESP_LOGD(TAG, "cmd=%d, sdmmc_req_run returned 0x%x", cmd->opcode, err);
+        return err;
+    }
+    int state = MMC_R1_CURRENT_STATE(cmd->response);
+    ESP_LOGV(TAG, "cmd response %08x %08x %08x %08x err=0x%x state=%d",
+               cmd->response[0],
+               cmd->response[1],
+               cmd->response[2],
+               cmd->response[3],
+               cmd->error,
+               state);
+    return cmd->error;
+}
+
+esp_err_t sdmmc_send_app_cmd(sdmmc_card_t* card, sdmmc_command_t* cmd)
+{
+    sdmmc_command_t app_cmd = {
+        .opcode = MMC_APP_CMD,
+        .flags = SCF_CMD_AC | SCF_RSP_R1,
+        .arg = MMC_ARG_RCA(card->rca),
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &app_cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    // Check APP_CMD status bit (only in SD mode)
+    if (!host_is_spi(card) && !(MMC_R1(app_cmd.response) & MMC_R1_APP_CMD)) {
+        ESP_LOGW(TAG, "card doesn't support APP_CMD");
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    return sdmmc_send_cmd(card, cmd);
+}
+
+
+esp_err_t sdmmc_send_cmd_go_idle_state(sdmmc_card_t* card)
+{
+    sdmmc_command_t cmd = {
+        .opcode = MMC_GO_IDLE_STATE,
+        .flags = SCF_CMD_BC | SCF_RSP_R0,
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (host_is_spi(card)) {
+        /* To enter SPI mode, CMD0 needs to be sent twice (see figure 4-1 in
+         * SD Simplified spec v4.10). Some cards enter SD mode on first CMD0,
+         * so don't expect the above command to succeed.
+         * SCF_RSP_R1 flag below tells the lower layer to expect correct R1
+         * response (in SPI mode).
+         */
+        (void) err;
+        vTaskDelay(SDMMC_GO_IDLE_DELAY_MS / portTICK_PERIOD_MS);
+
+        cmd.flags |= SCF_RSP_R1;
+        err = sdmmc_send_cmd(card, &cmd);
+    }
+    if (err == ESP_OK) {
+        vTaskDelay(SDMMC_GO_IDLE_DELAY_MS / portTICK_PERIOD_MS);
+    }
+    return err;
+}
+
+
+esp_err_t sdmmc_send_cmd_send_if_cond(sdmmc_card_t* card, uint32_t ocr)
+{
+    const uint8_t pattern = 0xaa; /* any pattern will do here */
+    sdmmc_command_t cmd = {
+        .opcode = SD_SEND_IF_COND,
+        .arg = (((ocr & SD_OCR_VOL_MASK) != 0) << 8) | pattern,
+        .flags = SCF_CMD_BCR | SCF_RSP_R7,
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    uint8_t response = cmd.response[0] & 0xff;
+    if (response != pattern) {
+        ESP_LOGD(TAG, "%s: received=0x%x expected=0x%x", __func__, response, pattern);
+        return ESP_ERR_INVALID_RESPONSE;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_send_cmd_send_op_cond(sdmmc_card_t* card, uint32_t ocr, uint32_t *ocrp)
+{
+    esp_err_t err;
+
+    sdmmc_command_t cmd = {
+            .arg = ocr,
+            .flags = SCF_CMD_BCR | SCF_RSP_R3,
+            .opcode = SD_APP_OP_COND
+    };
+    int nretries = SDMMC_SEND_OP_COND_MAX_RETRIES;
+    int err_cnt = SDMMC_SEND_OP_COND_MAX_ERRORS;
+    for (; nretries != 0; --nretries)  {
+        bzero(&cmd, sizeof cmd);
+        cmd.arg = ocr;
+        cmd.flags = SCF_CMD_BCR | SCF_RSP_R3;
+        if (!card->is_mmc) { /* SD mode */
+            cmd.opcode = SD_APP_OP_COND;
+            err = sdmmc_send_app_cmd(card, &cmd);
+        } else { /* MMC mode */
+            cmd.arg &= ~MMC_OCR_ACCESS_MODE_MASK;
+            cmd.arg |= MMC_OCR_SECTOR_MODE;
+            cmd.opcode = MMC_SEND_OP_COND;
+            err = sdmmc_send_cmd(card, &cmd);
+        }
+
+        if (err != ESP_OK) {
+            if (--err_cnt == 0) {
+                ESP_LOGD(TAG, "%s: sdmmc_send_app_cmd err=0x%x", __func__, err);
+                return err;
+            } else {
+                ESP_LOGV(TAG, "%s: ignoring err=0x%x", __func__, err);
+                continue;
+            }
+        }
+        // In SD protocol, card sets MEM_READY bit in OCR when it is ready.
+        // In SPI protocol, card clears IDLE_STATE bit in R1 response.
+        if (!host_is_spi(card)) {
+            if ((MMC_R3(cmd.response) & MMC_OCR_MEM_READY) ||
+                ocr == 0) {
+                break;
+            }
+        } else {
+            if ((SD_SPI_R1(cmd.response) & SD_SPI_R1_IDLE_STATE) == 0) {
+                break;
+            }
+        }
+        vTaskDelay(10 / portTICK_PERIOD_MS);
+    }
+    if (nretries == 0) {
+        return ESP_ERR_TIMEOUT;
+    }
+    if (ocrp) {
+        *ocrp = MMC_R3(cmd.response);
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_send_cmd_read_ocr(sdmmc_card_t *card, uint32_t *ocrp)
+{
+    assert(ocrp);
+    sdmmc_command_t cmd = {
+        .opcode = SD_READ_OCR,
+        .flags = SCF_CMD_BCR | SCF_RSP_R2
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    *ocrp = SD_SPI_R3(cmd.response);
+    return ESP_OK;
+}
+
+
+esp_err_t sdmmc_send_cmd_all_send_cid(sdmmc_card_t* card, sdmmc_response_t* out_raw_cid)
+{
+    assert(out_raw_cid);
+    sdmmc_command_t cmd = {
+            .opcode = MMC_ALL_SEND_CID,
+            .flags = SCF_CMD_BCR | SCF_RSP_R2
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    memcpy(out_raw_cid, &cmd.response, sizeof(sdmmc_response_t));
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_send_cmd_send_cid(sdmmc_card_t *card, sdmmc_cid_t *out_cid)
+{
+    assert(out_cid);
+    assert(host_is_spi(card) && "SEND_CID should only be used in SPI mode");
+    assert(!card->is_mmc && "MMC cards are not supported in SPI mode");
+    sdmmc_response_t buf;
+    sdmmc_command_t cmd = {
+        .opcode = MMC_SEND_CID,
+        .flags = SCF_CMD_READ | SCF_CMD_ADTC,
+        .arg = 0,
+        .data = &buf[0],
+        .datalen = sizeof(buf)
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    sdmmc_flip_byte_order(buf, sizeof(buf));
+    return sdmmc_decode_cid(buf, out_cid);
+}
+
+
+esp_err_t sdmmc_send_cmd_set_relative_addr(sdmmc_card_t* card, uint16_t* out_rca)
+{
+    assert(out_rca);
+    sdmmc_command_t cmd = {
+            .opcode = SD_SEND_RELATIVE_ADDR,
+            .flags = SCF_CMD_BCR | SCF_RSP_R6
+    };
+
+    /* MMC cards expect us to set the RCA.
+     * Set RCA to 1 since we don't support multiple cards on the same bus, for now.
+     */
+    uint16_t mmc_rca = 1;
+    if (card->is_mmc) {
+        cmd.arg = MMC_ARG_RCA(mmc_rca);
+    }
+
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    *out_rca = (card->is_mmc) ? mmc_rca : SD_R6_RCA(cmd.response);
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_send_cmd_set_blocklen(sdmmc_card_t* card, sdmmc_csd_t* csd)
+{
+    sdmmc_command_t cmd = {
+            .opcode = MMC_SET_BLOCKLEN,
+            .arg = csd->sector_size,
+            .flags = SCF_CMD_AC | SCF_RSP_R1
+    };
+    return sdmmc_send_cmd(card, &cmd);
+}
+
+esp_err_t sdmmc_send_cmd_send_csd(sdmmc_card_t* card, sdmmc_csd_t* out_csd)
+{
+    /* The trick with SEND_CSD is that in SPI mode, it acts as a data read
+     * command, while in SD mode it is an AC command with R2 response.
+     */
+    sdmmc_response_t spi_buf;
+    const bool is_spi = host_is_spi(card);
+    sdmmc_command_t cmd = {
+            .opcode = MMC_SEND_CSD,
+            .arg = is_spi ? 0 : MMC_ARG_RCA(card->rca),
+            .flags = is_spi ? (SCF_CMD_READ | SCF_CMD_ADTC | SCF_RSP_R1) :
+                    (SCF_CMD_AC | SCF_RSP_R2),
+            .data = is_spi ? &spi_buf[0] : 0,
+            .datalen = is_spi ? sizeof(spi_buf) : 0,
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    uint32_t* ptr = cmd.response;
+    if (is_spi) {
+        sdmmc_flip_byte_order(spi_buf,  sizeof(spi_buf));
+        ptr = spi_buf;
+    }
+    if (card->is_mmc) {
+        err = sdmmc_mmc_decode_csd(cmd.response, out_csd);
+    } else {
+        err = sdmmc_decode_csd(ptr, out_csd);
+    }
+    return err;
+}
+
+esp_err_t sdmmc_send_cmd_select_card(sdmmc_card_t* card, uint32_t rca)
+{
+    /* Don't expect to see a response when de-selecting a card */
+    uint32_t response = (rca == 0) ? 0 : SCF_RSP_R1;
+    sdmmc_command_t cmd = {
+            .opcode = MMC_SELECT_CARD,
+            .arg = MMC_ARG_RCA(rca),
+            .flags = SCF_CMD_AC | response
+    };
+    return sdmmc_send_cmd(card, &cmd);
+}
+
+esp_err_t sdmmc_send_cmd_send_scr(sdmmc_card_t* card, sdmmc_scr_t *out_scr)
+{
+    size_t datalen = 8;
+    uint32_t* buf = (uint32_t*) heap_caps_malloc(datalen, MALLOC_CAP_DMA);
+    if (buf == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+    sdmmc_command_t cmd = {
+            .data = buf,
+            .datalen = datalen,
+            .blklen = datalen,
+            .flags = SCF_CMD_ADTC | SCF_CMD_READ | SCF_RSP_R1,
+            .opcode = SD_APP_SEND_SCR
+    };
+    esp_err_t err = sdmmc_send_app_cmd(card, &cmd);
+    if (err == ESP_OK) {
+        err = sdmmc_decode_scr(buf, out_scr);
+    }
+    free(buf);
+    return err;
+}
+
+esp_err_t sdmmc_send_cmd_set_bus_width(sdmmc_card_t* card, int width)
+{
+    sdmmc_command_t cmd = {
+            .opcode = SD_APP_SET_BUS_WIDTH,
+            .flags = SCF_RSP_R1 | SCF_CMD_AC,
+            .arg = (width == 4) ? SD_ARG_BUS_WIDTH_4 : SD_ARG_BUS_WIDTH_1,
+    };
+
+    return sdmmc_send_app_cmd(card, &cmd);
+}
+
+esp_err_t sdmmc_send_cmd_crc_on_off(sdmmc_card_t* card, bool crc_enable)
+{
+    assert(host_is_spi(card) && "CRC_ON_OFF can only be used in SPI mode");
+    sdmmc_command_t cmd = {
+            .opcode = SD_CRC_ON_OFF,
+            .arg = crc_enable ? 1 : 0,
+            .flags = SCF_CMD_AC | SCF_RSP_R1
+    };
+    return sdmmc_send_cmd(card, &cmd);
+}
+
+esp_err_t sdmmc_send_cmd_send_status(sdmmc_card_t* card, uint32_t* out_status)
+{
+    sdmmc_command_t cmd = {
+            .opcode = MMC_SEND_STATUS,
+            .arg = MMC_ARG_RCA(card->rca),
+            .flags = SCF_CMD_AC | SCF_RSP_R1
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        return err;
+    }
+    if (out_status) {
+        if (host_is_spi(card)) {
+            *out_status = SD_SPI_R2(cmd.response);
+        } else {
+            *out_status = MMC_R1(cmd.response);
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_write_sectors(sdmmc_card_t* card, const void* src,
+        size_t start_block, size_t block_count)
+{
+    esp_err_t err = ESP_OK;
+    size_t block_size = card->csd.sector_size;
+    if (esp_ptr_dma_capable(src) && (intptr_t)src % 4 == 0) {
+        err = sdmmc_write_sectors_dma(card, src, start_block, block_count);
+    } else {
+        // SDMMC peripheral needs DMA-capable buffers. Split the write into
+        // separate single block writes, if needed, and allocate a temporary
+        // DMA-capable buffer.
+        void* tmp_buf = heap_caps_malloc(block_size, MALLOC_CAP_DMA);
+        if (tmp_buf == NULL) {
+            return ESP_ERR_NO_MEM;
+        }
+        const uint8_t* cur_src = (const uint8_t*) src;
+        for (size_t i = 0; i < block_count; ++i) {
+            memcpy(tmp_buf, cur_src, block_size);
+            cur_src += block_size;
+            err = sdmmc_write_sectors_dma(card, tmp_buf, start_block + i, 1);
+            if (err != ESP_OK) {
+                ESP_LOGD(TAG, "%s: error 0x%x writing block %d+%d",
+                        __func__, err, start_block, i);
+                break;
+            }
+        }
+        free(tmp_buf);
+    }
+    return err;
+}
+
+esp_err_t sdmmc_write_sectors_dma(sdmmc_card_t* card, const void* src,
+        size_t start_block, size_t block_count)
+{
+    if (start_block + block_count > card->csd.capacity) {
+        return ESP_ERR_INVALID_SIZE;
+    }
+    size_t block_size = card->csd.sector_size;
+    sdmmc_command_t cmd = {
+            .flags = SCF_CMD_ADTC | SCF_RSP_R1,
+            .blklen = block_size,
+            .data = (void*) src,
+            .datalen = block_count * block_size,
+            .timeout_ms = SDMMC_WRITE_CMD_TIMEOUT_MS
+    };
+    if (block_count == 1) {
+        cmd.opcode = MMC_WRITE_BLOCK_SINGLE;
+    } else {
+        cmd.opcode = MMC_WRITE_BLOCK_MULTIPLE;
+    }
+    if (card->ocr & SD_OCR_SDHC_CAP) {
+        cmd.arg = start_block;
+    } else {
+        cmd.arg = start_block * block_size;
+    }
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd returned 0x%x", __func__, err);
+        return err;
+    }
+    uint32_t status = 0;
+    size_t count = 0;
+    /* SD mode: wait for the card to become idle based on R1 status */
+    while (!host_is_spi(card) && !(status & MMC_R1_READY_FOR_DATA)) {
+        // TODO: add some timeout here
+        err = sdmmc_send_cmd_send_status(card, &status);
+        if (err != ESP_OK) {
+            return err;
+        }
+        if (++count % 10 == 0) {
+            ESP_LOGV(TAG, "waiting for card to become ready (%d)", count);
+        }
+    }
+    /* SPI mode: although card busy indication is based on the busy token,
+     * SD spec recommends that the host checks the results of programming by sending
+     * SEND_STATUS command. Some of the conditions reported in SEND_STATUS are not
+     * reported via a data error token.
+     */
+    if (host_is_spi(card)) {
+        err = sdmmc_send_cmd_send_status(card, &status);
+        if (err != ESP_OK) {
+            return err;
+        }
+        if (status & SD_SPI_R2_CARD_LOCKED) {
+            ESP_LOGE(TAG, "%s: write failed, card is locked: r2=0x%04x",
+                     __func__, status);
+            return ESP_ERR_INVALID_STATE;
+        }
+        if (status != 0) {
+            ESP_LOGE(TAG, "%s: card status indicates an error after write operation: r2=0x%04x",
+                     __func__, status);
+            return ESP_ERR_INVALID_RESPONSE;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_read_sectors(sdmmc_card_t* card, void* dst,
+        size_t start_block, size_t block_count)
+{
+    esp_err_t err = ESP_OK;
+    size_t block_size = card->csd.sector_size;
+    if (esp_ptr_dma_capable(dst) && (intptr_t)dst % 4 == 0) {
+        err = sdmmc_read_sectors_dma(card, dst, start_block, block_count);
+    } else {
+        // SDMMC peripheral needs DMA-capable buffers. Split the read into
+        // separate single block reads, if needed, and allocate a temporary
+        // DMA-capable buffer.
+        void* tmp_buf = heap_caps_malloc(block_size, MALLOC_CAP_DMA);
+        if (tmp_buf == NULL) {
+            return ESP_ERR_NO_MEM;
+        }
+        uint8_t* cur_dst = (uint8_t*) dst;
+        for (size_t i = 0; i < block_count; ++i) {
+            err = sdmmc_read_sectors_dma(card, tmp_buf, start_block + i, 1);
+            if (err != ESP_OK) {
+                ESP_LOGD(TAG, "%s: error 0x%x writing block %d+%d",
+                        __func__, err, start_block, i);
+                break;
+            }
+            memcpy(cur_dst, tmp_buf, block_size);
+            cur_dst += block_size;
+        }
+        free(tmp_buf);
+    }
+    return err;
+}
+
+esp_err_t sdmmc_read_sectors_dma(sdmmc_card_t* card, void* dst,
+        size_t start_block, size_t block_count)
+{
+    if (start_block + block_count > card->csd.capacity) {
+        return ESP_ERR_INVALID_SIZE;
+    }
+    size_t block_size = card->csd.sector_size;
+    sdmmc_command_t cmd = {
+            .flags = SCF_CMD_ADTC | SCF_CMD_READ | SCF_RSP_R1,
+            .blklen = block_size,
+            .data = (void*) dst,
+            .datalen = block_count * block_size
+    };
+    if (block_count == 1) {
+        cmd.opcode = MMC_READ_BLOCK_SINGLE;
+    } else {
+        cmd.opcode = MMC_READ_BLOCK_MULTIPLE;
+    }
+    if (card->ocr & SD_OCR_SDHC_CAP) {
+        cmd.arg = start_block;
+    } else {
+        cmd.arg = start_block * block_size;
+    }
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd returned 0x%x", __func__, err);
+        return err;
+    }
+    uint32_t status = 0;
+    size_t count = 0;
+    while (!host_is_spi(card) && !(status & MMC_R1_READY_FOR_DATA)) {
+        // TODO: add some timeout here
+        err = sdmmc_send_cmd_send_status(card, &status);
+        if (err != ESP_OK) {
+            return err;
+        }
+        if (++count % 10 == 0) {
+            ESP_LOGV(TAG, "waiting for card to become ready (%d)", count);
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_erase_sectors(sdmmc_card_t* card, size_t start_sector,
+        size_t sector_count, sdmmc_erase_arg_t arg)
+{
+    if (start_sector + sector_count > card->csd.capacity) {
+        return ESP_ERR_INVALID_SIZE;
+    }
+
+    uint32_t cmd38_arg;
+    if (arg == SDMMC_ERASE_ARG) {
+        cmd38_arg = card->is_mmc ? SDMMC_MMC_TRIM_ARG : SDMMC_SD_ERASE_ARG;
+    } else {
+        cmd38_arg = card->is_mmc ? SDMMC_MMC_DISCARD_ARG : SDMMC_SD_DISCARD_ARG;
+    }
+
+    /* validate the CMD38 argument against card supported features */
+    if (card->is_mmc) {
+        if ((cmd38_arg == SDMMC_MMC_TRIM_ARG) && (sdmmc_can_trim(card) != ESP_OK)) {
+            return ESP_ERR_NOT_SUPPORTED;
+        }
+        if ((cmd38_arg == SDMMC_MMC_DISCARD_ARG) && (sdmmc_can_discard(card) != ESP_OK)) {
+            return ESP_ERR_NOT_SUPPORTED;
+        }
+    } else { // SD card
+        if ((cmd38_arg == SDMMC_SD_DISCARD_ARG) && (sdmmc_can_discard(card) != ESP_OK)) {
+            return ESP_ERR_NOT_SUPPORTED;
+        }
+    }
+
+    /* default as block unit address */
+    size_t addr_unit_mult = 1;
+
+    if (!(card->ocr & SD_OCR_SDHC_CAP)) {
+        addr_unit_mult = card->csd.sector_size;
+    }
+
+    /* prepare command to set the start address */
+    sdmmc_command_t cmd = {
+            .flags = SCF_CMD_AC | SCF_RSP_R1 | SCF_WAIT_BUSY,
+            .opcode = card->is_mmc ? MMC_ERASE_GROUP_START :
+                    SD_ERASE_GROUP_START,
+            .arg = (start_sector * addr_unit_mult),
+    };
+
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd (ERASE_GROUP_START) returned 0x%x", __func__, err);
+        return err;
+    }
+
+    /* prepare command to set the end address */
+    cmd.opcode = card->is_mmc ? MMC_ERASE_GROUP_END : SD_ERASE_GROUP_END;
+    cmd.arg = ((start_sector + (sector_count - 1)) * addr_unit_mult);
+
+    err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd (ERASE_GROUP_END) returned 0x%x", __func__, err);
+        return err;
+    }
+
+    /* issue erase command */
+    memset((void *)&cmd, 0 , sizeof(sdmmc_command_t));
+    cmd.flags = SCF_CMD_AC | SCF_RSP_R1B | SCF_WAIT_BUSY;
+    cmd.opcode = MMC_ERASE;
+    cmd.arg = cmd38_arg;
+    cmd.timeout_ms = sdmmc_get_erase_timeout_ms(card, cmd38_arg, sector_count * card->csd.sector_size / 1024);
+
+    err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd (ERASE) returned 0x%x", __func__, err);
+        return err;
+    }
+
+    if (host_is_spi(card)) {
+        uint32_t status;
+        err = sdmmc_send_cmd_send_status(card, &status);
+        if (err != ESP_OK) {
+            return err;
+        }
+        if (status != 0) {
+            ESP_LOGE(TAG, "%s: card status indicates an error after erase operation: r2=0x%04x",
+                     __func__, status);
+            return ESP_ERR_INVALID_RESPONSE;
+        }
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_can_discard(sdmmc_card_t* card)
+{
+    if ((card->is_mmc) && (card->ext_csd.rev >= EXT_CSD_REV_1_6)) {
+         return ESP_OK;
+    }
+    // SD card
+    if ((!card->is_mmc) && !host_is_spi(card) && (card->ssr.discard_support == 1)) {
+        return ESP_OK;
+    }
+    return ESP_FAIL;
+}
+
+esp_err_t sdmmc_can_trim(sdmmc_card_t* card)
+{
+    if ((card->is_mmc) && (card->ext_csd.sec_feature & EXT_CSD_SEC_GB_CL_EN)) {
+        FF_CAN_TRIM = 1;
+        return ESP_OK;
+    }
+    FF_CAN_TRIM = 0;
+    return ESP_FAIL;
+}
+
+esp_err_t sdmmc_mmc_can_sanitize(sdmmc_card_t* card)
+{
+    if ((card->is_mmc) && (card->ext_csd.sec_feature & EXT_CSD_SEC_SANITIZE)) {
+        return ESP_OK;
+    }
+    return ESP_FAIL;
+}
+
+esp_err_t sdmmc_mmc_sanitize(sdmmc_card_t* card, uint32_t timeout_ms)
+{
+    esp_err_t err;
+    uint8_t index = EXT_CSD_SANITIZE_START;
+    uint8_t set = EXT_CSD_CMD_SET_NORMAL;
+    uint8_t value = 0x01;
+
+    if (sdmmc_mmc_can_sanitize(card) != ESP_OK) {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    /*
+     * A Sanitize operation is initiated by writing a value to the extended
+     * CSD[165] SANITIZE_START. While the device is performing the sanitize
+     * operation, the busy line is asserted.
+     * SWITCH command is used to write the EXT_CSD register.
+     */
+    sdmmc_command_t cmd = {
+            .opcode = MMC_SWITCH,
+            .arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | (index << 16) | (value << 8) | set,
+            .flags = SCF_RSP_R1B | SCF_CMD_AC | SCF_WAIT_BUSY,
+            .timeout_ms = timeout_ms,
+    };
+    err = sdmmc_send_cmd(card, &cmd);
+    if (err == ESP_OK) {
+        //check response bit to see that switch was accepted
+        if (MMC_R1(cmd.response) & MMC_R1_SWITCH_ERROR) {
+            err = ESP_ERR_INVALID_RESPONSE;
+        }
+    }
+    return err;
+}
+
+esp_err_t sdmmc_full_erase(sdmmc_card_t* card)
+{
+    sdmmc_erase_arg_t arg = SDMMC_SD_ERASE_ARG; // erase by default for SD card
+    esp_err_t err;
+    if (card->is_mmc) {
+        arg = sdmmc_mmc_can_sanitize(card) == ESP_OK ? SDMMC_MMC_DISCARD_ARG: SDMMC_MMC_TRIM_ARG;
+    }
+    err = sdmmc_erase_sectors(card, 0, card->csd.capacity, arg);
+    if ((err == ESP_OK) && (arg == SDMMC_MMC_DISCARD_ARG)) {
+        uint32_t timeout_ms = sdmmc_get_erase_timeout_ms(card, SDMMC_MMC_DISCARD_ARG, card->csd.capacity * ((uint64_t) card->csd.sector_size) / 1024);
+        return sdmmc_mmc_sanitize(card, timeout_ms);
+    }
+    return err;
+}
+
+esp_err_t sdmmc_get_status(sdmmc_card_t* card)
+{
+    uint32_t stat;
+    return sdmmc_send_cmd_send_status(card, &stat);
+}

code/components/esp-sdmmc/sdmmc_common_mh.c

@@ -0,0 +1,332 @@
+/*
+ * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
+ * Adaptations to ESP-IDF Copyright (c) 2016-2018 Espressif Systems (Shanghai) PTE LTD
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "sdmmc_common_mh.h"
+
+bool card_is_mmc = 0;
+
+static const char* TAG = "sdmmc_common";
+
+esp_err_t sdmmc_init_ocr(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    /* In SPI mode, READ_OCR (CMD58) command is used to figure out which voltage
+     * ranges the card can support. This step is skipped since 1.8V isn't
+     * supported on the ESP32.
+     */
+
+    uint32_t host_ocr = get_host_ocr(card->host.io_voltage);
+    if ((card->ocr & SD_OCR_SDHC_CAP) != 0) {
+        host_ocr |= SD_OCR_SDHC_CAP;
+    }
+    /* Send SEND_OP_COND (ACMD41) command to the card until it becomes ready. */
+    err = sdmmc_send_cmd_send_op_cond(card, host_ocr, &card->ocr);
+
+    /* If time-out, re-try send_op_cond as MMC */
+    if (err == ESP_ERR_TIMEOUT && !host_is_spi(card)) {
+        ESP_LOGD(TAG, "send_op_cond timeout, trying MMC");
+        card->is_mmc = 1;
+        card_is_mmc = 1;
+        err = sdmmc_send_cmd_send_op_cond(card, host_ocr, &card->ocr);
+    }
+
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_op_cond (1) returned 0x%x", __func__, err);
+        return err;
+    }
+    if (host_is_spi(card)) {
+        err = sdmmc_send_cmd_read_ocr(card, &card->ocr);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: read_ocr returned 0x%x", __func__, err);
+            return err;
+        }
+    }
+    ESP_LOGD(TAG, "host_ocr=0x%x card_ocr=0x%x", host_ocr, card->ocr);
+
+    /* Clear all voltage bits in host's OCR which the card doesn't support.
+     * Don't touch CCS bit because in SPI mode cards don't report CCS in ACMD41
+     * response.
+     */
+    host_ocr &= (card->ocr | (~SD_OCR_VOL_MASK));
+    ESP_LOGD(TAG, "sdmmc_card_init: host_ocr=%08x, card_ocr=%08x", host_ocr, card->ocr);
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_cid(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    sdmmc_response_t raw_cid;
+    if (!host_is_spi(card)) {
+        err = sdmmc_send_cmd_all_send_cid(card, &raw_cid);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: all_send_cid returned 0x%x", __func__, err);
+            return err;
+        }
+        if (!card->is_mmc) {
+            err = sdmmc_decode_cid(raw_cid, &card->cid);
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "%s: decoding CID failed (0x%x)", __func__, err);
+                return err;
+            }
+        } else {
+            /* For MMC, need to know CSD to decode CID. But CSD can only be read
+             * in data transfer mode, and it is not possible to read CID in data
+             * transfer mode. We temporiliy store the raw cid and do the
+             * decoding after the RCA is set and the card is in data transfer
+             * mode.
+             */
+            memcpy(card->raw_cid, raw_cid, sizeof(sdmmc_response_t));
+        }
+    } else {
+        err = sdmmc_send_cmd_send_cid(card, &card->cid);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: send_cid returned 0x%x", __func__, err);
+            return err;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_rca(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    err = sdmmc_send_cmd_set_relative_addr(card, &card->rca);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: set_relative_addr returned 0x%x", __func__, err);
+        return err;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_mmc_decode_cid(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    sdmmc_response_t raw_cid;
+    memcpy(raw_cid, card->raw_cid, sizeof(raw_cid));
+    err = sdmmc_mmc_decode_cid(card->csd.mmc_ver, raw_cid, &card->cid);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: decoding CID failed (0x%x)", __func__, err);
+        return err;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_csd(sdmmc_card_t* card)
+{
+    assert(card->is_mem == 1);
+    /* Get and decode the contents of CSD register. Determine card capacity. */
+    esp_err_t err = sdmmc_send_cmd_send_csd(card, &card->csd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_csd returned 0x%x", __func__, err);
+        return err;
+    }
+    const size_t max_sdsc_capacity = UINT32_MAX / card->csd.sector_size + 1;
+    if (!(card->ocr & SD_OCR_SDHC_CAP) &&
+         card->csd.capacity > max_sdsc_capacity) {
+        ESP_LOGW(TAG, "%s: SDSC card reports capacity=%u. Limiting to %u.",
+                __func__, card->csd.capacity, max_sdsc_capacity);
+        card->csd.capacity = max_sdsc_capacity;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_select_card(sdmmc_card_t* card)
+{
+    assert(!host_is_spi(card));
+    esp_err_t err = sdmmc_send_cmd_select_card(card, card->rca);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: select_card returned 0x%x", __func__, err);
+        return err;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_card_hs_mode(sdmmc_card_t* card)
+{
+    esp_err_t err = ESP_ERR_NOT_SUPPORTED;
+    if (card->is_mem && !card->is_mmc) {
+        err = sdmmc_enable_hs_mode_and_check(card);
+    } else if (card->is_sdio) {
+        err = sdmmc_io_enable_hs_mode(card);
+    } else if (card->is_mmc){
+        err = sdmmc_mmc_enable_hs_mode(card);
+    }
+    if (err == ESP_ERR_NOT_SUPPORTED) {
+        ESP_LOGD(TAG, "%s: host supports HS mode, but card doesn't", __func__);
+        card->max_freq_khz = SDMMC_FREQ_DEFAULT;
+    } else if (err != ESP_OK) {
+        return err;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_host_bus_width(sdmmc_card_t* card)
+{
+    int bus_width = 1;
+
+    if ((card->host.flags & SDMMC_HOST_FLAG_4BIT) &&
+        (card->log_bus_width == 2)) {
+        bus_width = 4;
+    } else if ((card->host.flags & SDMMC_HOST_FLAG_8BIT) &&
+        (card->log_bus_width == 3)) {
+        bus_width = 8;
+    }
+    ESP_LOGD(TAG, "%s: using %d-bit bus", __func__, bus_width);
+    if (bus_width > 1) {
+        esp_err_t err = (*card->host.set_bus_width)(card->host.slot, bus_width);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "host.set_bus_width failed (0x%x)", err);
+            return err;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_host_frequency(sdmmc_card_t* card)
+{
+    assert(card->max_freq_khz <= card->host.max_freq_khz);
+
+    /* Find highest frequency in the following list,
+     * which is below card->max_freq_khz.
+     */
+    const uint32_t freq_values[] = {
+            SDMMC_FREQ_52M,
+            SDMMC_FREQ_HIGHSPEED,
+            SDMMC_FREQ_26M,
+            SDMMC_FREQ_DEFAULT
+            //NOTE: in sdspi mode, 20MHz may not work. in that case, add 10MHz here.
+    };
+    const int n_freq_values = sizeof(freq_values) / sizeof(freq_values[0]);
+
+    uint32_t selected_freq = SDMMC_FREQ_PROBING;
+    for (int i = 0; i < n_freq_values; ++i) {
+        uint32_t freq = freq_values[i];
+        if (card->max_freq_khz >= freq) {
+            selected_freq = freq;
+            break;
+        }
+    }
+
+    ESP_LOGD(TAG, "%s: using %d kHz bus frequency", __func__, selected_freq);
+    if (selected_freq > SDMMC_FREQ_PROBING) {
+        esp_err_t err = (*card->host.set_card_clk)(card->host.slot, selected_freq);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "failed to switch bus frequency (0x%x)", err);
+            return err;
+        }
+    }
+
+    if (card->is_ddr) {
+        if (card->host.set_bus_ddr_mode == NULL) {
+            ESP_LOGE(TAG, "host doesn't support DDR mode or voltage switching");
+            return ESP_ERR_NOT_SUPPORTED;
+        }
+        esp_err_t err = (*card->host.set_bus_ddr_mode)(card->host.slot, true);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "failed to switch bus to DDR mode (0x%x)", err);
+            return err;
+        }
+    }
+    return ESP_OK;
+}
+
+void sdmmc_flip_byte_order(uint32_t* response, size_t size)
+{
+    assert(size % (2 * sizeof(uint32_t)) == 0);
+    const size_t n_words = size / sizeof(uint32_t);
+    for (int i = 0; i < n_words / 2; ++i) {
+        uint32_t left = __builtin_bswap32(response[i]);
+        uint32_t right = __builtin_bswap32(response[n_words - i - 1]);
+        response[i] = right;
+        response[n_words - i - 1] = left;
+    }
+}
+
+void sdmmc_card_print_info(FILE* stream, const sdmmc_card_t* card)
+{
+    bool print_scr = false;
+    bool print_csd = false;
+    const char* type;
+    fprintf(stream, "Name: %s\n", card->cid.name);
+    if (card->is_sdio) {
+        type = "SDIO";
+        print_scr = true;
+        print_csd = true;
+    } else if (card->is_mmc) {
+        type = "MMC";
+        print_csd = true;
+    } else {
+        type = (card->ocr & SD_OCR_SDHC_CAP) ? "SDHC/SDXC" : "SDSC";
+        print_csd = true;
+    }
+    fprintf(stream, "Type: %s\n", type);
+    if (card->max_freq_khz < 1000) {
+        fprintf(stream, "Speed: %d kHz\n", card->max_freq_khz);
+    } else {
+        fprintf(stream, "Speed: %d MHz%s\n", card->max_freq_khz / 1000,
+                card->is_ddr ? ", DDR" : "");
+    }
+    fprintf(stream, "Size: %lluMB\n", ((uint64_t) card->csd.capacity) * card->csd.sector_size / (1024 * 1024));
+
+    if (print_csd) {
+        fprintf(stream, "CSD: ver=%d, sector_size=%d, capacity=%d read_bl_len=%d\n",
+                (card->is_mmc ? card->csd.csd_ver : card->csd.csd_ver + 1),
+                card->csd.sector_size, card->csd.capacity, card->csd.read_block_len);
+        if (card->is_mmc) {
+            fprintf(stream, "EXT CSD: bus_width=%d\n", (1 << card->log_bus_width));
+        } else if (!card->is_sdio){ // make sure card is SD
+            fprintf(stream, "SSR: bus_width=%d\n", (card->ssr.cur_bus_width ? 4 : 1));
+        }
+    }
+    if (print_scr) {
+        fprintf(stream, "SCR: sd_spec=%d, bus_width=%d\n", card->scr.sd_spec, card->scr.bus_width);
+    }
+}
+
+esp_err_t sdmmc_fix_host_flags(sdmmc_card_t* card)
+{
+    const uint32_t width_1bit = SDMMC_HOST_FLAG_1BIT;
+    const uint32_t width_4bit = SDMMC_HOST_FLAG_4BIT;
+    const uint32_t width_8bit = SDMMC_HOST_FLAG_8BIT;
+    const uint32_t width_mask = width_1bit | width_4bit | width_8bit;
+
+    int slot_bit_width = card->host.get_bus_width(card->host.slot);
+    if (slot_bit_width == 1 &&
+            (card->host.flags & (width_4bit | width_8bit))) {
+        card->host.flags &= ~width_mask;
+        card->host.flags |= width_1bit;
+    } else if (slot_bit_width == 4 && (card->host.flags & width_8bit)) {
+        if ((card->host.flags & width_4bit) == 0) {
+            ESP_LOGW(TAG, "slot width set to 4, but host flags don't have 4 line mode enabled; using 1 line mode");
+            card->host.flags &= ~width_mask;
+            card->host.flags |= width_1bit;
+        } else {
+            card->host.flags &= ~width_mask;
+            card->host.flags |= width_4bit;
+        }
+    }
+    return ESP_OK;
+}
+
+uint32_t sdmmc_get_erase_timeout_ms(const sdmmc_card_t* card, int arg, size_t erase_size_kb)
+{
+    if (card->is_mmc) {
+        return sdmmc_mmc_get_erase_timeout_ms(card, arg, erase_size_kb);
+    } else {
+        return sdmmc_sd_get_erase_timeout_ms(card, arg, erase_size_kb);
+    }
+}

code/components/esp-sdmmc/sdmmc_common_mh.h

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
+ * Adaptations to ESP-IDF Copyright (c) 2016-2018 Espressif Systems (Shanghai) PTE LTD
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#pragma once
+
+#include <string.h>
+#include "esp_log.h"
+#include "esp_heap_caps.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "driver/sdmmc_defs.h"
+#include "driver/sdmmc_types.h"
+#include "sdmmc_cmd_mh.h"
+#include "sys/param.h"
+#include "soc/soc_memory_layout.h"
+
+extern bool card_is_mmc;
+
+#define SDMMC_GO_IDLE_DELAY_MS              20
+#define SDMMC_IO_SEND_OP_COND_DELAY_MS      10
+
+/* These delay values are mostly useful for cases when CD pin is not used, and
+ * the card is removed. In this case, SDMMC peripheral may not always return
+ * CMD_DONE / DATA_DONE interrupts after signaling the error. These timeouts work
+ * as a safety net in such cases.
+ */
+#define SDMMC_DEFAULT_CMD_TIMEOUT_MS  1000   // Max timeout of ordinary commands
+#define SDMMC_WRITE_CMD_TIMEOUT_MS    5000   // Max timeout of write commands
+
+
+#define SDMMC_SD_DISCARD_TIMEOUT  250    // SD erase (discard) timeout
+
+/* Maximum retry/error count for SEND_OP_COND (CMD1).
+ * These are somewhat arbitrary, values originate from OpenBSD driver.
+ */
+#define SDMMC_SEND_OP_COND_MAX_RETRIES  100
+#define SDMMC_SEND_OP_COND_MAX_ERRORS   3
+
+/* supported arguments for erase command 38 */
+#define SDMMC_SD_ERASE_ARG      0
+#define SDMMC_SD_DISCARD_ARG    1
+#define SDMMC_MMC_TRIM_ARG      1
+#define SDMMC_MMC_DISCARD_ARG   3
+
+/* Functions to send individual commands */
+esp_err_t sdmmc_send_cmd(sdmmc_card_t* card, sdmmc_command_t* cmd);
+esp_err_t sdmmc_send_app_cmd(sdmmc_card_t* card, sdmmc_command_t* cmd);
+esp_err_t sdmmc_send_cmd_go_idle_state(sdmmc_card_t* card);
+esp_err_t sdmmc_send_cmd_send_if_cond(sdmmc_card_t* card, uint32_t ocr);
+esp_err_t sdmmc_send_cmd_send_op_cond(sdmmc_card_t* card, uint32_t ocr, uint32_t *ocrp);
+esp_err_t sdmmc_send_cmd_read_ocr(sdmmc_card_t *card, uint32_t *ocrp);
+esp_err_t sdmmc_send_cmd_send_cid(sdmmc_card_t *card, sdmmc_cid_t *out_cid);
+esp_err_t sdmmc_send_cmd_all_send_cid(sdmmc_card_t* card, sdmmc_response_t* out_raw_cid);
+esp_err_t sdmmc_send_cmd_set_relative_addr(sdmmc_card_t* card, uint16_t* out_rca);
+esp_err_t sdmmc_send_cmd_set_blocklen(sdmmc_card_t* card, sdmmc_csd_t* csd);
+esp_err_t sdmmc_send_cmd_switch_func(sdmmc_card_t* card,
+        uint32_t mode, uint32_t group, uint32_t function,
+        sdmmc_switch_func_rsp_t* resp);
+esp_err_t sdmmc_send_cmd_send_csd(sdmmc_card_t* card, sdmmc_csd_t* out_csd);
+esp_err_t sdmmc_send_cmd_select_card(sdmmc_card_t* card, uint32_t rca);
+esp_err_t sdmmc_send_cmd_send_scr(sdmmc_card_t* card, sdmmc_scr_t *out_scr);
+esp_err_t sdmmc_send_cmd_set_bus_width(sdmmc_card_t* card, int width);
+esp_err_t sdmmc_send_cmd_send_status(sdmmc_card_t* card, uint32_t* out_status);
+esp_err_t sdmmc_send_cmd_crc_on_off(sdmmc_card_t* card, bool crc_enable);
+
+/* Higher level functions */
+esp_err_t sdmmc_enable_hs_mode(sdmmc_card_t* card);
+esp_err_t sdmmc_enable_hs_mode_and_check(sdmmc_card_t* card);
+esp_err_t sdmmc_write_sectors_dma(sdmmc_card_t* card, const void* src,
+        size_t start_block, size_t block_count);
+esp_err_t sdmmc_read_sectors_dma(sdmmc_card_t* card, void* dst,
+        size_t start_block, size_t block_count);
+uint32_t sdmmc_get_erase_timeout_ms(const sdmmc_card_t* card, int arg, size_t erase_size_kb);
+
+/* SD specific */
+esp_err_t sdmmc_check_scr(sdmmc_card_t* card);
+esp_err_t sdmmc_decode_cid(sdmmc_response_t resp, sdmmc_cid_t* out_cid);
+esp_err_t sdmmc_decode_csd(sdmmc_response_t response, sdmmc_csd_t* out_csd);
+esp_err_t sdmmc_decode_scr(uint32_t *raw_scr, sdmmc_scr_t* out_scr);
+esp_err_t sdmmc_decode_ssr(uint32_t *raw_ssr, sdmmc_ssr_t* out_ssr);
+uint32_t sdmmc_sd_get_erase_timeout_ms(const sdmmc_card_t* card, int arg, size_t erase_size_kb);
+
+/* SDIO specific */
+esp_err_t sdmmc_io_reset(sdmmc_card_t* card);
+esp_err_t sdmmc_io_enable_hs_mode(sdmmc_card_t* card);
+esp_err_t sdmmc_io_send_op_cond(sdmmc_card_t* card, uint32_t ocr, uint32_t *ocrp);
+esp_err_t sdmmc_io_rw_direct(sdmmc_card_t* card, int function,
+        uint32_t reg, uint32_t arg, uint8_t *byte);
+esp_err_t sdmmc_io_rw_extended(sdmmc_card_t* card, int function,
+        uint32_t reg, int arg, void *data, size_t size);
+
+
+/* MMC specific */
+esp_err_t sdmmc_mmc_send_ext_csd_data(sdmmc_card_t* card, void *out_data, size_t datalen);
+esp_err_t sdmmc_mmc_switch(sdmmc_card_t* card, uint8_t set, uint8_t index, uint8_t value);
+esp_err_t sdmmc_mmc_decode_cid(int mmc_ver, sdmmc_response_t resp, sdmmc_cid_t* out_cid);
+esp_err_t sdmmc_mmc_decode_csd(sdmmc_response_t response, sdmmc_csd_t* out_csd);
+esp_err_t sdmmc_mmc_enable_hs_mode(sdmmc_card_t* card);
+uint32_t sdmmc_mmc_get_erase_timeout_ms(const sdmmc_card_t* card, int arg, size_t erase_size_kb);
+
+/* Parts of card initialization flow */
+esp_err_t sdmmc_init_sd_if_cond(sdmmc_card_t* card);
+esp_err_t sdmmc_init_select_card(sdmmc_card_t* card);
+esp_err_t sdmmc_init_csd(sdmmc_card_t* card);
+esp_err_t sdmmc_init_cid(sdmmc_card_t* card);
+esp_err_t sdmmc_init_rca(sdmmc_card_t* card);
+esp_err_t sdmmc_init_mmc_decode_cid(sdmmc_card_t* card);
+esp_err_t sdmmc_init_ocr(sdmmc_card_t* card);
+esp_err_t sdmmc_init_spi_crc(sdmmc_card_t* card);
+esp_err_t sdmmc_init_io(sdmmc_card_t* card);
+esp_err_t sdmmc_init_sd_blocklen(sdmmc_card_t* card);
+esp_err_t sdmmc_init_sd_scr(sdmmc_card_t* card);
+esp_err_t sdmmc_init_sd_ssr(sdmmc_card_t* card);
+esp_err_t sdmmc_init_sd_wait_data_ready(sdmmc_card_t* card);
+esp_err_t sdmmc_init_mmc_read_ext_csd(sdmmc_card_t* card);
+esp_err_t sdmmc_init_mmc_read_cid(sdmmc_card_t* card);
+esp_err_t sdmmc_init_host_bus_width(sdmmc_card_t* card);
+esp_err_t sdmmc_init_sd_bus_width(sdmmc_card_t* card);
+esp_err_t sdmmc_init_io_bus_width(sdmmc_card_t* card);
+esp_err_t sdmmc_init_mmc_bus_width(sdmmc_card_t* card);
+esp_err_t sdmmc_init_card_hs_mode(sdmmc_card_t* card);
+esp_err_t sdmmc_init_host_frequency(sdmmc_card_t* card);
+esp_err_t sdmmc_init_mmc_check_ext_csd(sdmmc_card_t* card);
+
+/* Various helper functions */
+static inline bool host_is_spi(const sdmmc_card_t* card)
+{
+    return (card->host.flags & SDMMC_HOST_FLAG_SPI) != 0;
+}
+
+static inline uint32_t get_host_ocr(float voltage)
+{
+    // TODO: report exact voltage to the card
+    // For now tell that the host has 2.8-3.6V voltage range
+    (void) voltage;
+    return SD_OCR_VOL_MASK;
+}
+
+void sdmmc_flip_byte_order(uint32_t* response, size_t size);
+
+esp_err_t sdmmc_fix_host_flags(sdmmc_card_t* card);

code/components/esp-sdmmc/sdmmc_init_mh.c

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
+ * Adaptations to ESP-IDF Copyright (c) 2016-2018 Espressif Systems (Shanghai) PTE LTD
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "sdmmc_common_mh.h"
+
+static const char* TAG = "sdmmc_init";
+
+#define SDMMC_INIT_STEP(condition, function) \
+    do { \
+        if ((condition)) { \
+            esp_err_t err = (function)(card); \
+            if (err != ESP_OK) { \
+                ESP_LOGD(TAG, "%s: %s returned 0x%x", __func__, #function, err); \
+                return err; \
+            } \
+        } \
+    } while(0);
+
+
+esp_err_t sdmmc_card_init(const sdmmc_host_t* config, sdmmc_card_t* card)
+{
+    memset(card, 0, sizeof(*card));
+    memcpy(&card->host, config, sizeof(*config));
+    const bool is_spi = host_is_spi(card);
+    const bool always = true;
+    const bool io_supported = true;
+
+    /* Check if host flags are compatible with slot configuration. */
+    SDMMC_INIT_STEP(!is_spi, sdmmc_fix_host_flags);
+
+    /* Reset SDIO (CMD52, RES) before re-initializing IO (CMD5). */
+    SDMMC_INIT_STEP(io_supported, sdmmc_io_reset);
+
+    /* GO_IDLE_STATE (CMD0) command resets the card */
+    SDMMC_INIT_STEP(always, sdmmc_send_cmd_go_idle_state);
+
+    /* SEND_IF_COND (CMD8) command is used to identify SDHC/SDXC cards. */
+    SDMMC_INIT_STEP(always, sdmmc_init_sd_if_cond);
+
+    /* IO_SEND_OP_COND(CMD5), Determine if the card is an IO card. */
+    SDMMC_INIT_STEP(io_supported, sdmmc_init_io);
+
+    const bool is_mem = card->is_mem;
+    const bool is_sdio = !is_mem;
+
+    /* Enable CRC16 checks for data transfers in SPI mode */
+    SDMMC_INIT_STEP(is_spi, sdmmc_init_spi_crc);
+
+    /* Use SEND_OP_COND to set up card OCR */
+    SDMMC_INIT_STEP(is_mem, sdmmc_init_ocr);
+
+    const bool is_mmc = is_mem && card->is_mmc;
+    const bool is_sdmem = is_mem && !is_mmc;
+
+    ESP_LOGD(TAG, "%s: card type is %s", __func__,
+            is_sdio ? "SDIO" : is_mmc ? "MMC" : "SD");
+
+    /* Read the contents of CID register*/
+    SDMMC_INIT_STEP(is_mem, sdmmc_init_cid);
+
+    /* Assign RCA */
+    SDMMC_INIT_STEP(!is_spi, sdmmc_init_rca);
+
+    /* Read and decode the contents of CSD register */
+    SDMMC_INIT_STEP(is_mem, sdmmc_init_csd);
+
+    /* Decode the contents of mmc CID register */
+    SDMMC_INIT_STEP(is_mmc && !is_spi, sdmmc_init_mmc_decode_cid);
+
+    /* Switch the card from stand-by mode to data transfer mode (not needed if
+     * SPI interface is used). This is needed to issue SET_BLOCKLEN and
+     * SEND_SCR commands.
+     */
+    SDMMC_INIT_STEP(!is_spi, sdmmc_init_select_card);
+
+    /* SD memory cards:
+     * Set block len for SDSC cards to 512 bytes (same as SDHC)
+     * Read SCR
+     * Wait to enter data transfer state
+     */
+    SDMMC_INIT_STEP(is_sdmem, sdmmc_init_sd_blocklen);
+    SDMMC_INIT_STEP(is_sdmem, sdmmc_init_sd_scr);
+    SDMMC_INIT_STEP(is_sdmem, sdmmc_init_sd_wait_data_ready);
+
+    /* MMC cards: read CXD */
+    SDMMC_INIT_STEP(is_mmc, sdmmc_init_mmc_read_ext_csd);
+
+    /* Try to switch card to HS mode if the card supports it.
+     * Set card->max_freq_khz value accordingly.
+     */
+    SDMMC_INIT_STEP(always, sdmmc_init_card_hs_mode);
+
+    /* Set bus width. One call for every kind of card, then one for the host */
+    if (!is_spi) {
+        SDMMC_INIT_STEP(is_sdmem, sdmmc_init_sd_bus_width);
+        SDMMC_INIT_STEP(is_sdio, sdmmc_init_io_bus_width);
+        SDMMC_INIT_STEP(is_mmc, sdmmc_init_mmc_bus_width);
+        SDMMC_INIT_STEP(always, sdmmc_init_host_bus_width);
+    }
+
+    /* SD card: read SD Status register */
+    SDMMC_INIT_STEP(is_sdmem, sdmmc_init_sd_ssr);
+
+    /* Switch to the host to use card->max_freq_khz frequency. */
+    SDMMC_INIT_STEP(always, sdmmc_init_host_frequency);
+
+    /* Sanity check after switching the bus mode and frequency */
+    SDMMC_INIT_STEP(is_sdmem, sdmmc_check_scr);
+    /* Sanity check after eMMC switch to HS mode */
+    SDMMC_INIT_STEP(is_mmc, sdmmc_init_mmc_check_ext_csd);
+    /* TODO: add similar checks for SDIO */
+
+    return ESP_OK;
+}

code/components/esp-sdmmc/sdmmc_io_mh.c

@@ -0,0 +1,636 @@
+/*
+ * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
+ * Adaptations to ESP-IDF Copyright (c) 2016-2018 Espressif Systems (Shanghai) PTE LTD
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "sdmmc_common_mh.h"
+#include "esp_attr.h"
+#include "esp_compiler.h"
+
+
+#define CIS_TUPLE(NAME)  (cis_tuple_t) {.code=CISTPL_CODE_##NAME, .name=#NAME, .func=&cis_tuple_func_default, }
+#define CIS_TUPLE_WITH_FUNC(NAME, FUNC)  (cis_tuple_t) {.code=CISTPL_CODE_##NAME, .name=#NAME, .func=&(FUNC), }
+
+#define CIS_CHECK_SIZE(SIZE, MINIMAL) do {int store_size = (SIZE); if((store_size) < (MINIMAL)) return ESP_ERR_INVALID_SIZE;} while(0)
+#define CIS_CHECK_UNSUPPORTED(COND) do {if(!(COND)) return ESP_ERR_NOT_SUPPORTED;} while(0)
+#define CIS_GET_MINIMAL_SIZE    32
+
+typedef esp_err_t (*cis_tuple_info_func_t)(const void* tuple_info, uint8_t* data, FILE* fp);
+
+typedef struct {
+    int code;
+    const char *name;
+    cis_tuple_info_func_t   func;
+} cis_tuple_t;
+
+static const char* TAG = "sdmmc_io";
+
+static esp_err_t cis_tuple_func_default(const void* p, uint8_t* data, FILE* fp);
+static esp_err_t cis_tuple_func_manfid(const void* p, uint8_t* data, FILE* fp);
+static esp_err_t cis_tuple_func_cftable_entry(const void* p, uint8_t* data, FILE* fp);
+static esp_err_t cis_tuple_func_end(const void* p, uint8_t* data, FILE* fp);
+
+static const cis_tuple_t cis_table[] = {
+    CIS_TUPLE(NULL),
+    CIS_TUPLE(DEVICE),
+    CIS_TUPLE(CHKSUM),
+    CIS_TUPLE(VERS1),
+    CIS_TUPLE(ALTSTR),
+    CIS_TUPLE(CONFIG),
+    CIS_TUPLE_WITH_FUNC(CFTABLE_ENTRY, cis_tuple_func_cftable_entry),
+    CIS_TUPLE_WITH_FUNC(MANFID, cis_tuple_func_manfid),
+    CIS_TUPLE(FUNCID),
+    CIS_TUPLE(FUNCE),
+    CIS_TUPLE(VENDER_BEGIN),
+    CIS_TUPLE(VENDER_END),
+    CIS_TUPLE(SDIO_STD),
+    CIS_TUPLE(SDIO_EXT),
+    CIS_TUPLE_WITH_FUNC(END, cis_tuple_func_end),
+};
+
+
+esp_err_t sdmmc_io_reset(sdmmc_card_t* card)
+{
+    uint8_t sdio_reset = CCCR_CTL_RES;
+    esp_err_t err = sdmmc_io_rw_direct(card, 0, SD_IO_CCCR_CTL, SD_ARG_CMD52_WRITE, &sdio_reset);
+    if (err == ESP_ERR_TIMEOUT || (host_is_spi(card) && err == ESP_ERR_NOT_SUPPORTED)) {
+        /* Non-IO cards are allowed to time out (in SD mode) or
+         * return "invalid command" error (in SPI mode).
+         */
+    } else if (err == ESP_ERR_NOT_FOUND) {
+        ESP_LOGD(TAG, "%s: card not present", __func__);
+        return err;
+    } else if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: unexpected return: 0x%x", __func__, err );
+        return err;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_io(sdmmc_card_t* card)
+{
+    /* IO_SEND_OP_COND(CMD5), Determine if the card is an IO card.
+     * Non-IO cards will not respond to this command.
+     */
+    esp_err_t err = sdmmc_io_send_op_cond(card, 0, &card->ocr);
+    if (err != ESP_OK) {
+        ESP_LOGD(TAG, "%s: io_send_op_cond (1) returned 0x%x; not IO card", __func__, err);
+        card->is_sdio = 0;
+        card->is_mem = 1;
+    } else {
+        card->is_sdio = 1;
+
+        if (card->ocr & SD_IO_OCR_MEM_PRESENT) {
+            ESP_LOGD(TAG, "%s: IO-only card", __func__);
+            card->is_mem = 0;
+        }
+        card->num_io_functions = SD_IO_OCR_NUM_FUNCTIONS(card->ocr);
+        ESP_LOGD(TAG, "%s: number of IO functions: %d", __func__, card->num_io_functions);
+        if (card->num_io_functions == 0) {
+            card->is_sdio = 0;
+        }
+        uint32_t host_ocr = get_host_ocr(card->host.io_voltage);
+        host_ocr &= card->ocr;
+        err = sdmmc_io_send_op_cond(card, host_ocr, &card->ocr);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: sdmmc_io_send_op_cond (1) returned 0x%x", __func__, err);
+            return err;
+        }
+        err = sdmmc_io_enable_int(card);
+        if (err != ESP_OK) {
+            ESP_LOGD(TAG, "%s: sdmmc_enable_int failed (0x%x)", __func__, err);
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_io_bus_width(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    card->log_bus_width = 0;
+    if (card->host.flags & SDMMC_HOST_FLAG_4BIT) {
+        uint8_t card_cap = 0;
+        err = sdmmc_io_rw_direct(card, 0, SD_IO_CCCR_CARD_CAP,
+                SD_ARG_CMD52_READ, &card_cap);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: sdmmc_io_rw_direct (read SD_IO_CCCR_CARD_CAP) returned 0x%0x", __func__, err);
+            return err;
+        }
+        ESP_LOGD(TAG, "IO card capabilities byte: %02x", card_cap);
+        if (!(card_cap & CCCR_CARD_CAP_LSC) ||
+                (card_cap & CCCR_CARD_CAP_4BLS)) {
+            // This card supports 4-bit bus mode
+            uint8_t bus_width = CCCR_BUS_WIDTH_4;
+            err = sdmmc_io_rw_direct(card, 0, SD_IO_CCCR_BUS_WIDTH,
+                                SD_ARG_CMD52_WRITE, &bus_width);
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "%s: sdmmc_io_rw_direct (write SD_IO_CCCR_BUS_WIDTH) returned 0x%0x", __func__, err);
+                return err;
+            }
+            card->log_bus_width = 2;
+        }
+    }
+    return ESP_OK;
+}
+
+
+esp_err_t sdmmc_io_enable_hs_mode(sdmmc_card_t* card)
+{
+    /* If the host is configured to use low frequency, don't attempt to switch */
+    if (card->host.max_freq_khz < SDMMC_FREQ_DEFAULT) {
+        card->max_freq_khz = card->host.max_freq_khz;
+        return ESP_OK;
+    } else if (card->host.max_freq_khz < SDMMC_FREQ_HIGHSPEED) {
+        card->max_freq_khz = SDMMC_FREQ_DEFAULT;
+        return ESP_OK;
+    }
+
+    /* For IO cards, do write + read operation on "High Speed" register,
+     * setting EHS bit. If both EHS and SHS read back as set, then HS mode
+     * has been enabled.
+     */
+    uint8_t val = CCCR_HIGHSPEED_ENABLE;
+    esp_err_t err = sdmmc_io_rw_direct(card, 0, SD_IO_CCCR_HIGHSPEED,
+            SD_ARG_CMD52_WRITE | SD_ARG_CMD52_EXCHANGE, &val);
+    if (err != ESP_OK) {
+        ESP_LOGD(TAG, "%s: sdmmc_io_rw_direct returned 0x%x", __func__, err);
+        return err;
+    }
+
+    ESP_LOGD(TAG, "%s: CCCR_HIGHSPEED=0x%02x", __func__, val);
+    const uint8_t hs_mask = CCCR_HIGHSPEED_ENABLE | CCCR_HIGHSPEED_SUPPORT;
+    if ((val & hs_mask) != hs_mask) {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    card->max_freq_khz = SDMMC_FREQ_HIGHSPEED;
+    return ESP_OK;
+}
+
+
+esp_err_t sdmmc_io_send_op_cond(sdmmc_card_t* card, uint32_t ocr, uint32_t *ocrp)
+{
+    esp_err_t err = ESP_OK;
+    sdmmc_command_t cmd = {
+        .flags = SCF_CMD_BCR | SCF_RSP_R4,
+        .arg = ocr,
+        .opcode = SD_IO_SEND_OP_COND
+    };
+    for (size_t i = 0; i < 100; i++) {
+        err = sdmmc_send_cmd(card, &cmd);
+        if (err != ESP_OK) {
+            break;
+        }
+        if ((MMC_R4(cmd.response) & SD_IO_OCR_MEM_READY) ||
+            ocr == 0) {
+            break;
+        }
+        err = ESP_ERR_TIMEOUT;
+        vTaskDelay(SDMMC_IO_SEND_OP_COND_DELAY_MS / portTICK_PERIOD_MS);
+    }
+    if (err == ESP_OK && ocrp != NULL)
+        *ocrp = MMC_R4(cmd.response);
+
+    return err;
+}
+
+esp_err_t sdmmc_io_rw_direct(sdmmc_card_t* card, int func,
+        uint32_t reg, uint32_t arg, uint8_t *byte)
+{
+    esp_err_t err;
+    sdmmc_command_t cmd = {
+        .flags = SCF_CMD_AC | SCF_RSP_R5,
+        .arg = 0,
+        .opcode = SD_IO_RW_DIRECT
+    };
+
+    arg |= (func & SD_ARG_CMD52_FUNC_MASK) << SD_ARG_CMD52_FUNC_SHIFT;
+    arg |= (reg & SD_ARG_CMD52_REG_MASK) << SD_ARG_CMD52_REG_SHIFT;
+    arg |= (*byte & SD_ARG_CMD52_DATA_MASK) << SD_ARG_CMD52_DATA_SHIFT;
+    cmd.arg = arg;
+
+    err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGV(TAG, "%s: sdmmc_send_cmd returned 0x%x", __func__, err);
+        return err;
+    }
+
+    *byte = SD_R5_DATA(cmd.response);
+
+    return ESP_OK;
+}
+
+
+esp_err_t sdmmc_io_read_byte(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, uint8_t *out_byte)
+{
+    esp_err_t ret = sdmmc_io_rw_direct(card, function, addr, SD_ARG_CMD52_READ, out_byte);
+    if (unlikely(ret != ESP_OK)) {
+        ESP_LOGE(TAG, "%s: sdmmc_io_rw_direct (read 0x%x) returned 0x%x", __func__, addr, ret);
+    }
+    return ret;
+}
+
+esp_err_t sdmmc_io_write_byte(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, uint8_t in_byte, uint8_t* out_byte)
+{
+    uint8_t tmp_byte = in_byte;
+    esp_err_t ret = sdmmc_io_rw_direct(card, function, addr,
+            SD_ARG_CMD52_WRITE | SD_ARG_CMD52_EXCHANGE, &tmp_byte);
+    if (unlikely(ret != ESP_OK)) {
+        ESP_LOGE(TAG, "%s: sdmmc_io_rw_direct (write 0x%x) returned 0x%x", __func__, addr, ret);
+        return ret;
+    }
+    if (out_byte != NULL) {
+        *out_byte = tmp_byte;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_io_rw_extended(sdmmc_card_t* card, int func,
+    uint32_t reg, int arg, void *datap, size_t datalen)
+{
+    esp_err_t err;
+    const size_t max_byte_transfer_size = 512;
+    sdmmc_command_t cmd = {
+        .flags = SCF_CMD_AC | SCF_RSP_R5,
+        .arg = 0,
+        .opcode = SD_IO_RW_EXTENDED,
+        .data = datap,
+        .datalen = datalen,
+        .blklen = max_byte_transfer_size /* TODO: read max block size from CIS */
+    };
+
+    uint32_t count; /* number of bytes or blocks, depending on transfer mode */
+    if (arg & SD_ARG_CMD53_BLOCK_MODE) {
+        if (cmd.datalen % cmd.blklen != 0) {
+            return ESP_ERR_INVALID_SIZE;
+        }
+        count = cmd.datalen / cmd.blklen;
+    } else {
+        if (datalen > max_byte_transfer_size) {
+            /* TODO: split into multiple operations? */
+            return ESP_ERR_INVALID_SIZE;
+        }
+        if (datalen == max_byte_transfer_size) {
+            count = 0;  // See 5.3.1 SDIO simplifed spec
+        } else {
+            count = datalen;
+        }
+        cmd.blklen = datalen;
+    }
+
+    arg |= (func & SD_ARG_CMD53_FUNC_MASK) << SD_ARG_CMD53_FUNC_SHIFT;
+    arg |= (reg & SD_ARG_CMD53_REG_MASK) << SD_ARG_CMD53_REG_SHIFT;
+    arg |= (count & SD_ARG_CMD53_LENGTH_MASK) << SD_ARG_CMD53_LENGTH_SHIFT;
+    cmd.arg = arg;
+
+    if ((arg & SD_ARG_CMD53_WRITE) == 0) {
+        cmd.flags |= SCF_CMD_READ;
+    }
+
+    err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd returned 0x%x", __func__, err);
+        return err;
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_io_read_bytes(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, void* dst, size_t size)
+{
+    /* host quirk: SDIO transfer with length not divisible by 4 bytes
+     * has to be split into two transfers: one with aligned length,
+     * the other one for the remaining 1-3 bytes.
+     */
+    uint8_t *pc_dst = dst;
+    while (size > 0) {
+        size_t size_aligned = size & (~3);
+        size_t will_transfer = size_aligned > 0 ? size_aligned : size;
+
+        esp_err_t err = sdmmc_io_rw_extended(card, function, addr,
+                SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT,
+                pc_dst, will_transfer);
+        if (unlikely(err != ESP_OK)) {
+            return err;
+        }
+        pc_dst += will_transfer;
+        size -= will_transfer;
+        addr += will_transfer;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_io_write_bytes(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, const void* src, size_t size)
+{
+    /* same host quirk as in sdmmc_io_read_bytes */
+    const uint8_t *pc_src = (const uint8_t*) src;
+
+    while (size > 0) {
+        size_t size_aligned = size & (~3);
+        size_t will_transfer = size_aligned > 0 ? size_aligned : size;
+
+        esp_err_t err = sdmmc_io_rw_extended(card, function, addr,
+                SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT,
+                (void*) pc_src, will_transfer);
+        if (unlikely(err != ESP_OK)) {
+            return err;
+        }
+        pc_src += will_transfer;
+        size -= will_transfer;
+        addr += will_transfer;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_io_read_blocks(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, void* dst, size_t size)
+{
+    if (unlikely(size % 4 != 0)) {
+        return ESP_ERR_INVALID_SIZE;
+    }
+    return sdmmc_io_rw_extended(card, function, addr,
+            SD_ARG_CMD53_READ | SD_ARG_CMD53_INCREMENT | SD_ARG_CMD53_BLOCK_MODE,
+            dst, size);
+}
+
+esp_err_t sdmmc_io_write_blocks(sdmmc_card_t* card, uint32_t function,
+        uint32_t addr, const void* src, size_t size)
+{
+    if (unlikely(size % 4 != 0)) {
+        return ESP_ERR_INVALID_SIZE;
+    }
+    return sdmmc_io_rw_extended(card, function, addr,
+            SD_ARG_CMD53_WRITE | SD_ARG_CMD53_INCREMENT | SD_ARG_CMD53_BLOCK_MODE,
+            (void*) src, size);
+}
+
+esp_err_t sdmmc_io_enable_int(sdmmc_card_t* card)
+{
+    if (card->host.io_int_enable == NULL) {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    return (*card->host.io_int_enable)(card->host.slot);
+}
+
+esp_err_t sdmmc_io_wait_int(sdmmc_card_t* card, TickType_t timeout_ticks)
+{
+    if (card->host.io_int_wait == NULL) {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    return (*card->host.io_int_wait)(card->host.slot, timeout_ticks);
+}
+
+
+/*
+ * Print the CIS information of a CIS card, currently only ESP slave supported.
+ */
+
+static esp_err_t cis_tuple_func_default(const void* p, uint8_t* data, FILE* fp)
+{
+    const cis_tuple_t* tuple = (const cis_tuple_t*)p;
+    uint8_t code = *(data++);
+    int size = *(data++);
+    if (tuple) {
+        fprintf(fp, "TUPLE: %s, size: %d: ", tuple->name, size);
+    } else {
+        fprintf(fp, "TUPLE: unknown(%02X), size: %d: ", code, size);
+    }
+    for (int i = 0; i < size; i++) fprintf(fp, "%02X ", *(data++));
+    fprintf(fp, "\n");
+    return ESP_OK;
+}
+
+static esp_err_t cis_tuple_func_manfid(const void* p, uint8_t* data, FILE* fp)
+{
+    const cis_tuple_t* tuple = (const cis_tuple_t*)p;
+    data++;
+    int size = *(data++);
+    fprintf(fp, "TUPLE: %s, size: %d\n", tuple->name, size);
+    CIS_CHECK_SIZE(size, 4);
+    fprintf(fp, "  MANF: %04X, CARD: %04X\n", *(uint16_t*)(data), *(uint16_t*)(data+2));
+    return ESP_OK;
+}
+
+static esp_err_t cis_tuple_func_end(const void* p, uint8_t* data, FILE* fp)
+{
+    const cis_tuple_t* tuple = (const cis_tuple_t*)p;
+    data++;
+    fprintf(fp, "TUPLE: %s\n", tuple->name);
+    return ESP_OK;
+}
+
+static esp_err_t cis_tuple_func_cftable_entry(const void* p, uint8_t* data, FILE* fp)
+{
+    const cis_tuple_t* tuple = (const cis_tuple_t*)p;
+    data++;
+    int size = *(data++);
+    fprintf(fp, "TUPLE: %s, size: %d\n", tuple->name, size);
+    CIS_CHECK_SIZE(size, 2);
+
+    CIS_CHECK_SIZE(size--, 1);
+    bool interface = data[0] & BIT(7);
+    bool def = data[0] & BIT(6);
+    int conf_ent_num = data[0] & 0x3F;
+    fprintf(fp, "  INDX: %02X, Intface: %d, Default: %d, Conf-Entry-Num: %d\n", *(data++), interface, def, conf_ent_num);
+
+    if (interface) {
+        CIS_CHECK_SIZE(size--, 1);
+        fprintf(fp, "  IF: %02X\n", *(data++));
+    }
+
+    CIS_CHECK_SIZE(size--, 1);
+    bool misc = data[0] & BIT(7);
+    int mem_space = (data[0] >> 5 )&(0x3);
+    bool irq = data[0] & BIT(4);
+    bool io_sp = data[0] & BIT(3);
+    bool timing = data[0] & BIT(2);
+    int power = data[0] & 3;
+    fprintf(fp, "  FS: %02X, misc: %d, mem_space: %d, irq: %d, io_space: %d, timing: %d, power: %d\n", *(data++), misc, mem_space, irq, io_sp, timing, power);
+
+    CIS_CHECK_UNSUPPORTED(power == 0);  //power descriptor is not handled yet
+    CIS_CHECK_UNSUPPORTED(!timing);     //timing descriptor is not handled yet
+    CIS_CHECK_UNSUPPORTED(!io_sp);      //io space descriptor is not handled yet
+
+    if (irq) {
+        CIS_CHECK_SIZE(size--, 1);
+        bool mask = data[0] & BIT(4);
+        fprintf(fp, "  IR: %02X, mask: %d, ",*(data++), mask);
+        if (mask) {
+            CIS_CHECK_SIZE(size, 2);
+            size-=2;
+            fprintf(fp, "  IRQ: %02X %02X\n", data[0], data[1]);
+            data+=2;
+        }
+    }
+
+    if (mem_space) {
+        CIS_CHECK_SIZE(size, 2);
+        size-=2;
+        CIS_CHECK_UNSUPPORTED(mem_space==1); //other cases not handled yet
+        int len = *(uint16_t*)data;
+        fprintf(fp, "  LEN: %04X\n", len);
+        data+=2;
+    }
+
+    CIS_CHECK_UNSUPPORTED(misc==0);    //misc descriptor is not handled yet
+    return ESP_OK;
+}
+
+static const cis_tuple_t* get_tuple(uint8_t code)
+{
+    for (int i = 0; i < sizeof(cis_table)/sizeof(cis_tuple_t); i++) {
+        if (code == cis_table[i].code) return &cis_table[i];
+    }
+    return NULL;
+}
+
+esp_err_t sdmmc_io_print_cis_info(uint8_t* buffer, size_t buffer_size, FILE* fp)
+{
+    ESP_LOG_BUFFER_HEXDUMP("CIS", buffer, buffer_size, ESP_LOG_DEBUG);
+    if (!fp) fp = stdout;
+
+    uint8_t* cis = buffer;
+    do {
+        const cis_tuple_t* tuple = get_tuple(cis[0]);
+        int size = cis[1];
+        esp_err_t ret = ESP_OK;
+        if (tuple) {
+            ret = tuple->func(tuple, cis, fp);
+        } else {
+            ret = cis_tuple_func_default(NULL, cis, fp);
+        }
+        if (ret != ESP_OK) return ret;
+        cis += 2 + size;
+        if (tuple && tuple->code == CISTPL_CODE_END) break;
+    } while (cis < buffer + buffer_size) ;
+    return ESP_OK;
+}
+
+/**
+ * Check tuples in the buffer.
+ *
+ * @param buf Buffer to check
+ * @param buffer_size Size of the buffer
+ * @param inout_cis_offset
+ *          - input: the last cis_offset, relative to the beginning of the buf. -1 if
+ *                      this buffer begin with the tuple length, otherwise should be no smaller than
+ *                      zero.
+ *          - output: when the end tuple found, output offset of the CISTPL_CODE_END
+ *                      byte + 1 (relative to the beginning of the buffer; when not found, output
+ *                      the address of next tuple code.
+ *
+ * @return true if found, false if haven't.
+ */
+static bool check_tuples_in_buffer(uint8_t* buf, int buffer_size, int* inout_cis_offset)
+{
+    int cis_offset = *inout_cis_offset;
+    if (cis_offset == -1) {
+        //the CIS code is checked in the last buffer, skip to next tuple
+        cis_offset += buf[0] + 2;
+    }
+    assert(cis_offset >= 0);
+    while (1) {
+        if (cis_offset < buffer_size) {
+            //A CIS code in the buffer, check it
+            if (buf[cis_offset] == CISTPL_CODE_END) {
+                *inout_cis_offset = cis_offset + 1;
+                return true;
+            }
+        }
+        if (cis_offset + 1 < buffer_size) {
+            cis_offset += buf[cis_offset+1] + 2;
+        } else {
+            break;
+        }
+    }
+    *inout_cis_offset = cis_offset;
+    return false;
+}
+
+esp_err_t sdmmc_io_get_cis_data(sdmmc_card_t* card, uint8_t* out_buffer, size_t buffer_size, size_t* inout_cis_size)
+{
+    esp_err_t ret = ESP_OK;
+    WORD_ALIGNED_ATTR uint8_t buf[CIS_GET_MINIMAL_SIZE];
+
+    /* Pointer to size is a mandatory parameter */
+    assert(inout_cis_size);
+
+    /*
+     * CIS region exist in 0x1000~0x17FFF of FUNC 0, get the start address of it
+     * from CCCR register.
+     */
+    uint32_t addr;
+    ret = sdmmc_io_read_bytes(card, 0, 9, &addr, 3);
+    if (ret != ESP_OK) return ret;
+    //the sdmmc_io driver reads 4 bytes, the most significant byte is not the address.
+    addr &= 0xffffff;
+    if (addr < 0x1000 || addr > 0x17FFF) {
+        return ESP_ERR_INVALID_RESPONSE;
+    }
+
+    /*
+     * To avoid reading too long, take the input value as limitation if
+     * existing.
+     */
+    size_t max_reading = UINT32_MAX;
+    if (*inout_cis_size != 0) {
+        max_reading = *inout_cis_size;
+    }
+
+    /*
+     * Parse the length while reading. If find the end tuple, or reaches the
+     * limitation, read no more and return both the data and the size already
+     * read.
+     */
+    int buffer_offset = 0;
+    int cur_cis_offset = 0;
+    bool end_tuple_found = false;
+    do {
+        ret = sdmmc_io_read_bytes(card, 0, addr + buffer_offset, &buf, CIS_GET_MINIMAL_SIZE);
+        if (ret != ESP_OK) return ret;
+
+        //calculate relative to the beginning of the buffer
+        int offset = cur_cis_offset - buffer_offset;
+        bool finish = check_tuples_in_buffer(buf, CIS_GET_MINIMAL_SIZE, &offset);
+
+        int remain_size = buffer_size - buffer_offset;
+        int copy_len;
+        if (finish) {
+            copy_len = MIN(offset, remain_size);
+            end_tuple_found = true;
+        } else {
+            copy_len = MIN(CIS_GET_MINIMAL_SIZE, remain_size);
+        }
+        if (copy_len > 0) {
+            memcpy(out_buffer + buffer_offset, buf, copy_len);
+        }
+        cur_cis_offset = buffer_offset + offset;
+        buffer_offset += CIS_GET_MINIMAL_SIZE;
+    } while (!end_tuple_found && buffer_offset < max_reading);
+
+    if (end_tuple_found) {
+        *inout_cis_size = cur_cis_offset;
+        if (cur_cis_offset > buffer_size) {
+            return ESP_ERR_INVALID_SIZE;
+        } else {
+            return ESP_OK;
+        }
+    } else {
+        return ESP_ERR_NOT_FOUND;
+    }
+}

code/components/esp-sdmmc/sdmmc_mmc_mh.c

@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
+ * Adaptations to ESP-IDF Copyright (c) 2016-2018 Espressif Systems (Shanghai) PTE LTD
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <unistd.h>
+#include "sdmmc_common_mh.h"
+
+static const char* TAG = "sdmmc_mmc";
+
+
+esp_err_t sdmmc_init_mmc_read_ext_csd(sdmmc_card_t* card)
+{
+    int card_type;
+    esp_err_t err = ESP_OK;
+
+    uint8_t* ext_csd = heap_caps_malloc(EXT_CSD_MMC_SIZE, MALLOC_CAP_DMA);
+    if (!ext_csd) {
+        ESP_LOGE(TAG, "%s: could not allocate ext_csd", __func__);
+        return ESP_ERR_NO_MEM;
+    }
+
+    uint32_t sectors = 0;
+
+    ESP_LOGD(TAG, "MMC version: %d", card->csd.mmc_ver);
+    if (card->csd.mmc_ver < MMC_CSD_MMCVER_4_0) {
+        err = ESP_ERR_NOT_SUPPORTED;
+        goto out;
+    }
+
+    /* read EXT_CSD */
+    err = sdmmc_mmc_send_ext_csd_data(card, ext_csd, EXT_CSD_MMC_SIZE);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_ext_csd_data error 0x%x", __func__, err);
+        goto out;
+    }
+    card_type = ext_csd[EXT_CSD_CARD_TYPE];
+    card->is_ddr = 0;
+    if (card_type & EXT_CSD_CARD_TYPE_F_52M_1_8V) {
+        card->max_freq_khz = SDMMC_FREQ_52M;
+        if ((card->host.flags & SDMMC_HOST_FLAG_DDR) &&
+                card->host.max_freq_khz >= SDMMC_FREQ_26M &&
+                card->host.get_bus_width(card->host.slot) == 4) {
+            ESP_LOGD(TAG, "card and host support DDR mode");
+            card->is_ddr = 1;
+        }
+    } else if (card_type & EXT_CSD_CARD_TYPE_F_52M) {
+        card->max_freq_khz = SDMMC_FREQ_52M;
+    } else if (card_type & EXT_CSD_CARD_TYPE_F_26M) {
+        card->max_freq_khz = SDMMC_FREQ_26M;
+    } else {
+        ESP_LOGW(TAG, "%s: unknown CARD_TYPE 0x%x", __func__, card_type);
+    }
+    /* For MMC cards, use speed value from EXT_CSD */
+    card->csd.tr_speed = card->max_freq_khz * 1000;
+    ESP_LOGD(TAG, "MMC card type %d, max_freq_khz=%d, is_ddr=%d", card_type, card->max_freq_khz, card->is_ddr);
+    card->max_freq_khz = MIN(card->max_freq_khz, card->host.max_freq_khz);
+
+    if (card->host.flags & SDMMC_HOST_FLAG_8BIT) {
+        card->ext_csd.power_class = ext_csd[(card->max_freq_khz > SDMMC_FREQ_26M) ?
+                EXT_CSD_PWR_CL_52_360 : EXT_CSD_PWR_CL_26_360] >> 4;
+        card->log_bus_width = 3;
+    } else if (card->host.flags & SDMMC_HOST_FLAG_4BIT) {
+        card->ext_csd.power_class = ext_csd[(card->max_freq_khz > SDMMC_FREQ_26M) ?
+                EXT_CSD_PWR_CL_52_360 : EXT_CSD_PWR_CL_26_360] & 0x0f;
+        card->log_bus_width = 2;
+    } else {
+        card->ext_csd.power_class = 0; //card must be able to do full rate at powerclass 0 in 1-bit mode
+        card->log_bus_width = 0;
+    }
+
+    sectors = ( ext_csd[EXT_CSD_SEC_COUNT + 0] << 0 )
+        | ( ext_csd[EXT_CSD_SEC_COUNT + 1] << 8 )
+        | ( ext_csd[EXT_CSD_SEC_COUNT + 2] << 16 )
+        | ( ext_csd[EXT_CSD_SEC_COUNT + 3] << 24 );
+
+    if (sectors > (2u * 1024 * 1024 * 1024) / 512) {
+        card->csd.capacity = sectors;
+    }
+
+    /* erased state of a bit, if 1 byte value read is 0xFF else 0x00 */
+    card->ext_csd.erase_mem_state = ext_csd[EXT_CSD_ERASED_MEM_CONT];
+    card->ext_csd.rev = ext_csd[EXT_CSD_REV];
+    card->ext_csd.sec_feature = ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
+
+out:
+    free(ext_csd);
+    return err;
+}
+
+esp_err_t sdmmc_init_mmc_bus_width(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    if (card->ext_csd.power_class != 0) {
+        err = sdmmc_mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                EXT_CSD_POWER_CLASS, card->ext_csd.power_class);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: can't change power class (%d bit), 0x%x"
+                    , __func__, card->ext_csd.power_class, err);
+            return err;
+        }
+    }
+
+    if (card->log_bus_width > 0) {
+        int csd_bus_width_value = EXT_CSD_BUS_WIDTH_1;
+        int bus_width = 1;
+        if (card->log_bus_width == 2) {
+            if (card->is_ddr) {
+                csd_bus_width_value = EXT_CSD_BUS_WIDTH_4_DDR;
+            } else {
+                csd_bus_width_value = EXT_CSD_BUS_WIDTH_4;
+            }
+            bus_width = 4;
+        } else if (card->log_bus_width == 3) {
+            if (card->is_ddr) {
+                csd_bus_width_value = EXT_CSD_BUS_WIDTH_8_DDR;
+            } else {
+                csd_bus_width_value = EXT_CSD_BUS_WIDTH_8;
+            }
+            bus_width = 8;
+        }
+        err = sdmmc_mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                EXT_CSD_BUS_WIDTH, csd_bus_width_value);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: can't change bus width (%d bit), 0x%x",
+                    __func__, bus_width, err);
+            return err;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_mmc_enable_hs_mode(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    if (card->max_freq_khz > SDMMC_FREQ_26M) {
+        /* switch to high speed timing */
+        err = sdmmc_mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
+                EXT_CSD_HS_TIMING, EXT_CSD_HS_TIMING_HS);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: mmc_switch EXT_CSD_HS_TIMING_HS error 0x%x",
+                    __func__, err);
+            return err;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_mmc_decode_cid(int mmc_ver, sdmmc_response_t resp, sdmmc_cid_t* out_cid)
+{
+    if (mmc_ver == MMC_CSD_MMCVER_1_0 ||
+            mmc_ver == MMC_CSD_MMCVER_1_4) {
+        out_cid->mfg_id = MMC_CID_MID_V1(resp);
+        out_cid->oem_id = 0;
+        MMC_CID_PNM_V1_CPY(resp, out_cid->name);
+        out_cid->revision = MMC_CID_REV_V1(resp);
+        out_cid->serial = MMC_CID_PSN_V1(resp);
+        out_cid->date = MMC_CID_MDT_V1(resp);
+    } else if (mmc_ver == MMC_CSD_MMCVER_2_0 ||
+            mmc_ver == MMC_CSD_MMCVER_3_1 ||
+            mmc_ver == MMC_CSD_MMCVER_4_0) {
+        out_cid->mfg_id = MMC_CID_MID_V2(resp);
+        out_cid->oem_id = MMC_CID_OID_V2(resp);
+        MMC_CID_PNM_V1_CPY(resp, out_cid->name);
+        out_cid->revision = 0;
+        out_cid->serial = MMC_CID_PSN_V1(resp);
+        out_cid->date = 0;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_mmc_decode_csd(sdmmc_response_t response, sdmmc_csd_t* out_csd)
+{
+    out_csd->csd_ver = MMC_CSD_CSDVER(response);
+    if (out_csd->csd_ver == MMC_CSD_CSDVER_1_0 ||
+            out_csd->csd_ver == MMC_CSD_CSDVER_2_0 ||
+            out_csd->csd_ver == MMC_CSD_CSDVER_EXT_CSD) {
+        out_csd->mmc_ver = MMC_CSD_MMCVER(response);
+        out_csd->capacity = MMC_CSD_CAPACITY(response);
+        out_csd->read_block_len = MMC_CSD_READ_BL_LEN(response);
+    } else {
+        ESP_LOGE(TAG, "unknown MMC CSD structure version 0x%x\n", out_csd->csd_ver);
+        return 1;
+    }
+    int read_bl_size = 1 << out_csd->read_block_len;
+    out_csd->sector_size = MIN(read_bl_size, 512);
+    if (out_csd->sector_size < read_bl_size) {
+        out_csd->capacity *= read_bl_size / out_csd->sector_size;
+    }
+    /* tr_speed will be determined when reading CXD */
+    out_csd->tr_speed = 0;
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_mmc_send_ext_csd_data(sdmmc_card_t* card, void *out_data, size_t datalen)
+{
+    assert(esp_ptr_dma_capable(out_data));
+    sdmmc_command_t cmd = {
+        .data = out_data,
+        .datalen = datalen,
+        .blklen = datalen,
+        .opcode = MMC_SEND_EXT_CSD,
+        .arg = 0,
+        .flags = SCF_CMD_ADTC | SCF_RSP_R1 | SCF_CMD_READ
+    };
+    return sdmmc_send_cmd(card, &cmd);
+}
+
+esp_err_t sdmmc_mmc_switch(sdmmc_card_t* card, uint8_t set, uint8_t index, uint8_t value)
+{
+    sdmmc_command_t cmd = {
+            .opcode = MMC_SWITCH,
+            .arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | (index << 16) | (value << 8) | set,
+            .flags = SCF_RSP_R1B | SCF_CMD_AC | SCF_WAIT_BUSY,
+    };
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err == ESP_OK) {
+        //check response bit to see that switch was accepted
+        if (MMC_R1(cmd.response) & MMC_R1_SWITCH_ERROR) {
+            err = ESP_ERR_INVALID_RESPONSE;
+        }
+    }
+
+    return err;
+}
+
+esp_err_t sdmmc_init_mmc_check_ext_csd(sdmmc_card_t* card)
+{
+    assert(card->is_mem == 1 && card->rca != 0);
+
+    /*
+     * Integrity check required if card switched to HS mode
+     * card->max_freq_khz = MIN(card->max_freq_khz, card->host.max_freq_khz)
+     * For 26MHz limit background see sdmmc_mmc_enable_hs_mode()
+     */
+    if (card->max_freq_khz <= SDMMC_FREQ_26M) {
+        return ESP_OK;
+    }
+
+    /* ensure EXT_CSD buffer is available before starting any SD-card operation */
+    uint8_t* ext_csd = heap_caps_malloc(EXT_CSD_MMC_SIZE, MALLOC_CAP_DMA);
+    if (!ext_csd) {
+        ESP_LOGE(TAG, "%s: could not allocate ext_csd", __func__);
+        return ESP_ERR_NO_MEM;
+    }
+
+    /* ensure card is in transfer state before read ext_csd */
+    uint32_t status;
+    esp_err_t err = sdmmc_send_cmd_send_status(card, &status);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_status returned 0x%x", __func__, err);
+        goto out;
+    }
+    status = ((status & MMC_R1_CURRENT_STATE_MASK) >> MMC_R1_CURRENT_STATE_POS);
+    if (status != MMC_R1_CURRENT_STATE_TRAN) {
+        ESP_LOGE(TAG, "%s: card not in transfer state", __func__);
+        err = ESP_ERR_INVALID_STATE;
+        goto out;
+    }
+
+    /* read EXT_CSD to ensure device works fine in HS mode */
+    err = sdmmc_mmc_send_ext_csd_data(card, ext_csd, EXT_CSD_MMC_SIZE);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_ext_csd_data error 0x%x", __func__, err);
+        goto out;
+    }
+
+    /* EXT_CSD static fields should match the previous read values in sdmmc_card_init */
+    if ((card->ext_csd.rev != ext_csd[EXT_CSD_REV]) ||
+            (card->ext_csd.sec_feature != ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT])) {
+        ESP_LOGE(TAG, "%s: Data integrity test fail in HS mode", __func__);
+        err = ESP_FAIL;
+    }
+
+out:
+    free(ext_csd);
+    return err;
+}
+
+uint32_t sdmmc_mmc_get_erase_timeout_ms(const sdmmc_card_t* card, int arg, size_t erase_size_kb)
+{
+    /* TODO: calculate erase timeout based on ext_csd (trim_timeout) */
+    uint32_t timeout_ms = SDMMC_SD_DISCARD_TIMEOUT * erase_size_kb / card->csd.sector_size;
+    timeout_ms = MAX(1000, timeout_ms);
+    ESP_LOGD(TAG, "%s: erase timeout %u s (erasing %u kB, %ums per sector)",
+             __func__, timeout_ms / 1000, erase_size_kb, SDMMC_SD_DISCARD_TIMEOUT);
+    return timeout_ms;
+}

code/components/esp-sdmmc/sdmmc_sd_mh.c

@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
+ * Adaptations to ESP-IDF Copyright (c) 2016-2018 Espressif Systems (Shanghai) PTE LTD
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include "sdmmc_common_mh.h"
+
+static const char* TAG = "sdmmc_sd";
+
+esp_err_t sdmmc_init_sd_if_cond(sdmmc_card_t* card)
+{
+    /* SEND_IF_COND (CMD8) command is used to identify SDHC/SDXC cards.
+     * SD v1 and non-SD cards will not respond to this command.
+     */
+    uint32_t host_ocr = get_host_ocr(card->host.io_voltage);
+    esp_err_t err = sdmmc_send_cmd_send_if_cond(card, host_ocr);
+    if (err == ESP_OK) {
+        ESP_LOGD(TAG, "SDHC/SDXC card");
+        host_ocr |= SD_OCR_SDHC_CAP;
+    } else if (err == ESP_ERR_TIMEOUT) {
+        ESP_LOGD(TAG, "CMD8 timeout; not an SD v2.00 card");
+    } else if (host_is_spi(card) && err == ESP_ERR_NOT_SUPPORTED) {
+        ESP_LOGD(TAG, "CMD8 rejected; not an SD v2.00 card");
+    } else {
+        ESP_LOGE(TAG, "%s: send_if_cond (1) returned 0x%x", __func__, err);
+        return err;
+    }
+    card->ocr = host_ocr;
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_sd_blocklen(sdmmc_card_t* card)
+{
+    /* SDSC cards support configurable data block lengths.
+     * We don't use this feature and set the block length to 512 bytes,
+     * same as the block length for SDHC cards.
+     */
+    if ((card->ocr & SD_OCR_SDHC_CAP) == 0) {
+        esp_err_t err = sdmmc_send_cmd_set_blocklen(card, &card->csd);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: set_blocklen returned 0x%x", __func__, err);
+            return err;
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_sd_scr(sdmmc_card_t* card)
+{
+    esp_err_t err;
+    /* Get the contents of SCR register: bus width and the version of SD spec
+     * supported by the card.
+     * In SD mode, this is the first command which uses D0 line. Errors at
+     * this step usually indicate connection issue or lack of pull-up resistor.
+     */
+    err = sdmmc_send_cmd_send_scr(card, &card->scr);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_scr (1) returned 0x%x", __func__, err);
+        return err;
+    }
+
+    if ((card->scr.bus_width & SCR_SD_BUS_WIDTHS_4BIT)
+            && (card->host.flags & SDMMC_HOST_FLAG_4BIT)) {
+        card->log_bus_width = 2;
+    } else {
+        card->log_bus_width = 0;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_sd_ssr(sdmmc_card_t* card)
+{
+    esp_err_t err = ESP_OK;
+    /* Get the contents of SSR register: SD additional information
+     * ACMD13 to read 512byte SD status information
+     */
+    uint32_t* sd_ssr = heap_caps_calloc(1, SD_SSR_SIZE, MALLOC_CAP_DMA);
+    if (!sd_ssr) {
+        ESP_LOGE(TAG, "%s: could not allocate sd_ssr", __func__);
+        return ESP_ERR_NO_MEM;
+    }
+
+    sdmmc_command_t cmd = {
+        .data = sd_ssr,
+        .datalen = SD_SSR_SIZE,
+        .blklen = SD_SSR_SIZE,
+        .opcode = SD_APP_SD_STATUS,
+        .arg = 0,
+        .flags = SCF_CMD_ADTC | SCF_RSP_R1 | SCF_CMD_READ
+    };
+
+    // read SD status register
+    err = sdmmc_send_app_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        free(sd_ssr);
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd returned 0x%x", __func__, err);
+        return err;
+    }
+
+    err = sdmmc_decode_ssr(sd_ssr, &card->ssr);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: error sdmmc_decode_scr returned 0x%x", __func__, err);
+    }
+    free(sd_ssr);
+    return err;
+}
+
+esp_err_t sdmmc_init_sd_bus_width(sdmmc_card_t* card)
+{
+    int width = 1;
+    if (card->log_bus_width == 2) {
+        width = 4;
+    } else if (card->log_bus_width == 3) {
+        width = 8;
+    }
+    esp_err_t err = sdmmc_send_cmd_set_bus_width(card, width);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "set_bus_width failed (0x%x)", err);
+        return err;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_sd_wait_data_ready(sdmmc_card_t* card)
+{
+    /* Wait for the card to be ready for data transfers */
+    uint32_t status = 0;
+    uint32_t count = 0;
+    while (!host_is_spi(card) && !(status & MMC_R1_READY_FOR_DATA)) {
+        // TODO: add some timeout here
+        esp_err_t err = sdmmc_send_cmd_send_status(card, &status);
+        if (err != ESP_OK) {
+            return err;
+        }
+        if (++count % 16 == 0) {
+            ESP_LOGV(TAG, "waiting for card to become ready (%d)", count);
+        }
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_send_cmd_switch_func(sdmmc_card_t* card,
+        uint32_t mode, uint32_t group, uint32_t function,
+        sdmmc_switch_func_rsp_t* resp)
+{
+    if (card->scr.sd_spec < SCR_SD_SPEC_VER_1_10 ||
+        ((card->csd.card_command_class & SD_CSD_CCC_SWITCH) == 0)) {
+            return ESP_ERR_NOT_SUPPORTED;
+    }
+
+    if (group == 0 ||
+        group > SD_SFUNC_GROUP_MAX ||
+        function > SD_SFUNC_FUNC_MAX) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (mode > 1) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    uint32_t group_shift = (group - 1) << 2;
+    /* all functions which should not be affected are set to 0xf (no change) */
+    uint32_t other_func_mask = (0x00ffffff & ~(0xf << group_shift));
+    uint32_t func_val = (function << group_shift) | other_func_mask;
+
+    sdmmc_command_t cmd = {
+            .opcode = MMC_SWITCH,
+            .flags = SCF_CMD_ADTC | SCF_CMD_READ | SCF_RSP_R1,
+            .blklen = sizeof(sdmmc_switch_func_rsp_t),
+            .data = resp->data,
+            .datalen = sizeof(sdmmc_switch_func_rsp_t),
+            .arg = (!!mode << 31) | func_val
+    };
+
+    esp_err_t err = sdmmc_send_cmd(card, &cmd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd returned 0x%x", __func__, err);
+        return err;
+    }
+    sdmmc_flip_byte_order(resp->data, sizeof(sdmmc_switch_func_rsp_t));
+    uint32_t resp_ver = SD_SFUNC_VER(resp->data);
+    if (resp_ver == 0) {
+        /* busy response is never sent */
+    } else if (resp_ver == 1) {
+        if (SD_SFUNC_BUSY(resp->data, group) & (1 << function)) {
+            ESP_LOGD(TAG, "%s: response indicates function %d:%d is busy",
+                    __func__, group, function);
+            return ESP_ERR_INVALID_STATE;
+        }
+    } else {
+        ESP_LOGD(TAG, "%s: got an invalid version of SWITCH_FUNC response: 0x%02x",
+                __func__, resp_ver);
+        return ESP_ERR_INVALID_RESPONSE;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_enable_hs_mode(sdmmc_card_t* card)
+{
+    /* This will determine if the card supports SWITCH_FUNC command,
+     * and high speed mode. If the cards supports both, this will enable
+     * high speed mode at the card side.
+     */
+    if (card->scr.sd_spec < SCR_SD_SPEC_VER_1_10 ||
+        ((card->csd.card_command_class & SD_CSD_CCC_SWITCH) == 0)) {
+            return ESP_ERR_NOT_SUPPORTED;
+    }
+    sdmmc_switch_func_rsp_t* response = (sdmmc_switch_func_rsp_t*)
+            heap_caps_malloc(sizeof(*response), MALLOC_CAP_DMA);
+    if (response == NULL) {
+        return ESP_ERR_NO_MEM;
+    }
+
+    esp_err_t err = sdmmc_send_cmd_switch_func(card, 0, SD_ACCESS_MODE, 0, response);
+    if (err != ESP_OK) {
+        ESP_LOGD(TAG, "%s: sdmmc_send_cmd_switch_func (1) returned 0x%x", __func__, err);
+        goto out;
+    }
+    uint32_t supported_mask = SD_SFUNC_SUPPORTED(response->data, 1);
+    if ((supported_mask & BIT(SD_ACCESS_MODE_SDR25)) == 0) {
+        err = ESP_ERR_NOT_SUPPORTED;
+        goto out;
+    }
+    err = sdmmc_send_cmd_switch_func(card, 1, SD_ACCESS_MODE, SD_ACCESS_MODE_SDR25, response);
+    if (err != ESP_OK) {
+        ESP_LOGD(TAG, "%s: sdmmc_send_cmd_switch_func (2) returned 0x%x", __func__, err);
+        goto out;
+    }
+
+out:
+    free(response);
+    return err;
+}
+
+esp_err_t sdmmc_enable_hs_mode_and_check(sdmmc_card_t* card)
+{
+    /* All cards should support at least default speed */
+    card->max_freq_khz = SDMMC_FREQ_DEFAULT;
+    if (card->host.max_freq_khz <= card->max_freq_khz) {
+        /* Host is configured to use low frequency, don't attempt to switch */
+        card->max_freq_khz = card->host.max_freq_khz;
+        return ESP_OK;
+    }
+
+    /* Try to enabled HS mode */
+    esp_err_t err = sdmmc_enable_hs_mode(card);
+    if (err != ESP_OK) {
+        return err;
+    }
+    /* HS mode has been enabled on the card.
+     * Read CSD again, it should now indicate that the card supports
+     * 50MHz clock.
+     * Since SEND_CSD is allowed only in standby mode, and the card is currently in data transfer
+     * mode, deselect the card first, then get the CSD, then select the card again. This step is
+     * not required in SPI mode, since CMD7 (select_card) is not supported.
+     */
+    const bool is_spi = host_is_spi(card);
+    if (!is_spi) {
+        err = sdmmc_send_cmd_select_card(card, 0);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: select_card (1) returned 0x%x", __func__, err);
+            return err;
+        }
+    }
+    err = sdmmc_send_cmd_send_csd(card, &card->csd);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_csd returned 0x%x", __func__, err);
+        return err;
+    }
+    if (!is_spi) {
+        err = sdmmc_send_cmd_select_card(card, card->rca);
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "%s: select_card (2) returned 0x%x", __func__, err);
+            return err;
+        }
+    }
+
+    if (card->csd.tr_speed != 50000000) {
+        ESP_LOGW(TAG, "unexpected: after enabling HS mode, tr_speed=%d", card->csd.tr_speed);
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+
+    card->max_freq_khz = SDMMC_FREQ_HIGHSPEED;
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_check_scr(sdmmc_card_t* card)
+{
+    /* If frequency switch has been performed, read SCR register one more time
+     * and compare the result with the previous one. Use this simple check as
+     * an indicator of potential signal integrity issues.
+     */
+    sdmmc_scr_t scr_tmp = { 0 };
+    esp_err_t err = sdmmc_send_cmd_send_scr(card, &scr_tmp);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: send_scr returned 0x%x", __func__, err);
+        return err;
+    }
+    if (memcmp(&card->scr, &scr_tmp, sizeof(scr_tmp)) != 0) {
+        ESP_LOGE(TAG, "got corrupted data after increasing clock frequency");
+        return ESP_ERR_INVALID_RESPONSE;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_init_spi_crc(sdmmc_card_t* card)
+{
+    /* In SD mode, CRC checks of data transfers are mandatory and performed
+     * by the hardware. In SPI mode, CRC16 of data transfers is optional and
+     * needs to be enabled.
+     */
+    assert(host_is_spi(card));
+    esp_err_t err = sdmmc_send_cmd_crc_on_off(card, true);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "%s: sdmmc_send_cmd_crc_on_off returned 0x%x", __func__, err);
+        return err;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_decode_cid(sdmmc_response_t resp, sdmmc_cid_t* out_cid)
+{
+    out_cid->mfg_id = SD_CID_MID(resp);
+    out_cid->oem_id = SD_CID_OID(resp);
+    SD_CID_PNM_CPY(resp, out_cid->name);
+    out_cid->revision = SD_CID_REV(resp);
+    out_cid->serial = SD_CID_PSN(resp);
+    out_cid->date = SD_CID_MDT(resp);
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_decode_csd(sdmmc_response_t response, sdmmc_csd_t* out_csd)
+{
+    out_csd->csd_ver = SD_CSD_CSDVER(response);
+    switch (out_csd->csd_ver) {
+    case SD_CSD_CSDVER_2_0:
+        out_csd->capacity = SD_CSD_V2_CAPACITY(response);
+        out_csd->read_block_len = SD_CSD_V2_BL_LEN;
+        break;
+    case SD_CSD_CSDVER_1_0:
+        out_csd->capacity = SD_CSD_CAPACITY(response);
+        out_csd->read_block_len = SD_CSD_READ_BL_LEN(response);
+        break;
+    default:
+        ESP_LOGE(TAG, "unknown SD CSD structure version 0x%x", out_csd->csd_ver);
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    out_csd->card_command_class = SD_CSD_CCC(response);
+    int read_bl_size = 1 << out_csd->read_block_len;
+    out_csd->sector_size = MIN(read_bl_size, 512);
+    if (out_csd->sector_size < read_bl_size) {
+        out_csd->capacity *= read_bl_size / out_csd->sector_size;
+    }
+    int speed = SD_CSD_SPEED(response);
+    if (speed == SD_CSD_SPEED_50_MHZ) {
+        out_csd->tr_speed = 50000000;
+    } else {
+        out_csd->tr_speed = 25000000;
+    }
+    return ESP_OK;
+}
+
+esp_err_t sdmmc_decode_scr(uint32_t *raw_scr, sdmmc_scr_t* out_scr)
+{
+    sdmmc_response_t resp = { 0 };
+    resp[1] = __builtin_bswap32(raw_scr[0]);
+    resp[0] = __builtin_bswap32(raw_scr[1]);
+    int ver = SCR_STRUCTURE(resp);
+    if (ver != 0) {
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    out_scr->sd_spec = SCR_SD_SPEC(resp);
+    out_scr->erase_mem_state = SCR_DATA_STAT_AFTER_ERASE(resp);
+    out_scr->bus_width = SCR_SD_BUS_WIDTHS(resp);
+    return ESP_OK;
+}
+
+static const uint32_t s_au_to_size_kb[] = {
+    0, 16, 32, 64,
+    128, 256, 512, 1024,
+    2 * 1024, 4 * 1024,
+    8 * 1024, 12 * 1024,
+    16 * 1024, 24 * 1024,
+    32 * 1024, 64 * 1024
+};
+_Static_assert(sizeof(s_au_to_size_kb)/sizeof(s_au_to_size_kb[0]) == 16, "invalid number of elements in s_au_to_size_kb");
+
+esp_err_t sdmmc_decode_ssr(uint32_t *raw_ssr, sdmmc_ssr_t* out_ssr)
+{
+    uint32_t ssr[(SD_SSR_SIZE/sizeof(uint32_t))] = { 0 };
+    size_t j = (SD_SSR_SIZE/sizeof(uint32_t) - 1);
+
+    for(size_t i = 0; i < (SD_SSR_SIZE/sizeof(uint32_t)); i++) {
+        ssr[j - i] = __builtin_bswap32(raw_ssr[i]);
+    }
+
+    out_ssr->cur_bus_width = SSR_DAT_BUS_WIDTH(ssr);
+    out_ssr->discard_support = SSR_DISCARD_SUPPORT(ssr);
+    out_ssr->fule_support = SSR_FULE_SUPPORT(ssr);
+    uint32_t au = SSR_AU_SIZE(ssr);
+    out_ssr->alloc_unit_kb = s_au_to_size_kb[au];
+    out_ssr->erase_timeout = SSR_ERASE_TIMEOUT(ssr);
+    out_ssr->erase_size_au = SSR_ERASE_SIZE(ssr);
+    out_ssr->erase_offset = SSR_ERASE_OFFSET(ssr);
+
+    return ESP_OK;
+}
+
+uint32_t sdmmc_sd_get_erase_timeout_ms(const sdmmc_card_t* card, int arg, size_t erase_size_kb)
+{
+    if (arg == SDMMC_SD_DISCARD_ARG) {
+        return SDMMC_SD_DISCARD_TIMEOUT;
+    } else if (arg == SDMMC_SD_ERASE_ARG) {
+        if (card->ssr.alloc_unit_kb != 0 &&
+                card->ssr.erase_size_au != 0 &&
+                card->ssr.erase_timeout != 0 &&
+                card->ssr.erase_offset != 0) {
+            /* Card supports erase timeout estimation. See the erase timeout equation in SD spec. */
+            uint32_t timeout_sec = card->ssr.erase_offset +
+                card->ssr.erase_timeout * (erase_size_kb + card->ssr.alloc_unit_kb - 1) /
+                    (card->ssr.erase_size_au * card->ssr.alloc_unit_kb);
+            ESP_LOGD(TAG, "%s: erase timeout %u s (erasing %u kB, ES=%u, ET=%u, EO=%u, AU=%u kB)",
+                     __func__, timeout_sec, erase_size_kb, card->ssr.erase_size_au,
+                     card->ssr.erase_timeout, card->ssr.erase_offset, card->ssr.alloc_unit_kb);
+            return timeout_sec * 1000;
+        } else {
+            uint32_t timeout_ms = SDMMC_SD_DISCARD_TIMEOUT * erase_size_kb / card->csd.sector_size;
+            timeout_ms = MAX(1000, timeout_ms);
+            ESP_LOGD(TAG, "%s: erase timeout %u s (erasing %u kB, %ums per sector)",
+                     __func__, timeout_ms / 1000, erase_size_kb, SDMMC_SD_DISCARD_TIMEOUT);
+            return timeout_ms;
+        }
+    } else {
+        assert(false && "unexpected SD erase argument");
+        return 0;
+    }
+}

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

@@ -35,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"
@@ -65,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 {

code/components/jomjol_controlGPIO/server_GPIO.cpp

@@ -6,9 +6,6 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "esp_system.h"
-#include "esp_event.h"
-
-#include "server_tflite.h"
 
 #include "esp_log.h"
 
@@ -22,8 +19,10 @@
 #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
 
 
@@ -331,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";

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

@@ -21,6 +21,7 @@
 #include <nvs_flash.h>
 #include <sys/param.h>
 #include <string.h>
+#include <sys/stat.h>
 
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
@@ -28,10 +29,31 @@
 #include "esp_camera.h"
 
 #include "driver/ledc.h"
-#include "server_tflite.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
 
 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,
@@ -512,7 +534,7 @@ esp_err_t CCamera::CaptureToHTTP(httpd_req_t *req, int delay)
     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);
@@ -521,6 +543,74 @@ esp_err_t CCamera::CaptureToHTTP(httpd_req_t *req, int delay)
 }
 
 
+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;
+}
+
+
 void CCamera::LightOnOff(bool status)
 {
     GpioHandler* gpioHandler = gpio_handler_get();

code/components/jomjol_controlcamera/ClassControllCamera.h

@@ -40,6 +40,7 @@ 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);

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

@@ -36,7 +36,7 @@ extern "C" {
 #include "../../include/defines.h"
 #include "ClassLogFile.h"
 
-#include "server_tflite.h"
+#include "MainFlowControl.h"
 
 #include "server_help.h"
 #ifdef ENABLE_MQTT
@@ -47,7 +47,6 @@ extern "C" {
 #include "Helper.h"
 #include "miniz.h"
 
-
 static const char *TAG = "OTA FILE";
 
 struct file_server_data {
@@ -74,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());
 
@@ -548,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);
                 }
             }
         }
@@ -589,7 +588,9 @@ static esp_err_t download_get_handler(httpd_req_t *req)
         /* Read file in chunks into the scratch buffer */
         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);
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
@@ -607,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;
 }
 
@@ -718,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("/");
@@ -737,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;
 }
@@ -838,16 +844,15 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
             return ESP_FAIL;
         }
 
-        if (stat(filepath, &file_stat) == -1) {
-            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File does not exist: " + string(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));
         }
 
-        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Deleting file: " + string(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("/");
@@ -864,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;
@@ -930,7 +949,7 @@ 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);
-    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Numbers of files to be extracted: " + to_string(numberoffiles));
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Files to be extracted: " + to_string(numberoffiles));
 
     sort_iter = 0;
     {
@@ -994,7 +1013,7 @@ 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);
@@ -1098,7 +1117,7 @@ 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());
+            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);

code/components/jomjol_fileserver_ota/server_help.cpp

@@ -61,7 +61,13 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)
         endsWith(filename, ".jpeg") ||
         endsWith(filename, ".ico") ||
         endsWith(filename, ".png")) {
-        httpd_resp_set_hdr(req, "Cache-Control", "max-age=86400");
+
+    	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());

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,7 +28,7 @@
 
 #include <sys/stat.h>
 
-#include "server_tflite.h"
+#include "MainFlowControl.h"
 #include "server_file.h"
 #include "server_GPIO.h"
 #ifdef ENABLE_MQTT
@@ -157,12 +159,12 @@ static bool ota_update_task(std::string fn)
         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;
@@ -467,7 +469,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)
         {
             const char* resp_str; 
 
-            KillTFliteTasks();
+            DeleteMainFlowTask();
             gpio_handler_deinit();
             if (ota_update_task(fn))
             {
@@ -546,7 +548,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)
 /*  
     const char* resp_str;    
 
-    KillTFliteTasks();
+    DeleteMainFlowTask();
     gpio_handler_deinit();
     if (ota_update_task(fn))
     {
@@ -570,13 +572,19 @@ esp_err_t handler_ota_update(httpd_req_t *req)
 
 void hard_restart() 
 {
-  esp_task_wdt_init(1,true);
+  esp_task_wdt_config_t twdt_config = {
+    .timeout_ms = 1,
+    .idle_core_mask = (1 << portNUM_PROCESSORS) - 1,    // Bitmask of all cores
+    .trigger_panic = true,
+  };
+  ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
+
   esp_task_wdt_add(NULL);
   while(true);
 }
 
 
-void task_reboot(void *KillAutoFlow)
+void task_reboot(void *DeleteMainFlow)
 {
     // write a reboot, to identify a reboot by purpouse
     FILE* pfile = fopen("/sdcard/reboot.txt", "w");
@@ -586,8 +594,8 @@ void task_reboot(void *KillAutoFlow)
 
     vTaskDelay(3000 / portTICK_PERIOD_MS);
 
-    if ((bool)KillAutoFlow) {
-        KillTFliteTasks();  // Kill autoflow task if executed in extra task, if not don't kill parent task
+    if ((bool)DeleteMainFlow) {
+        DeleteMainFlowTask();  // Kill autoflow task if executed in extra task, if not don't kill parent task
     }
 
     Camera.LightOnOff(false);

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/ClassFlowAlignment.cpp

@@ -1,7 +1,7 @@
 #include "ClassFlowAlignment.h"
 #include "ClassFlowTakeImage.h"
 #include "ClassFlow.h"
-#include "server_tflite.h"
+#include "MainFlowControl.h"
 
 #include "CRotateImage.h"
 #include "esp_log.h"
@@ -190,10 +190,10 @@ bool ClassFlowAlignment::doFlow(string time)
 
     if (!ImageTMP) 
     {
-        ImageTMP = new CImageBasis("ImageTMP", ImageBasis);
+        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 ImageTMP -> Exec this round aborted!");
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate tmpImage -> Exec this round aborted!");
             LogFile.WriteHeapInfo("ClassFlowAlignment-doFlow");
             return false;
         }
@@ -256,8 +256,8 @@ bool ClassFlowAlignment::doFlow(string time)
             if(References[0].alignment_algo != 3){
                 DrawRef(ImageTMP);
             }
-            tfliteflow.DigitalDrawROI(ImageTMP);
-            tfliteflow.AnalogDrawROI(ImageTMP);
+            flowctrl.DigitalDrawROI(ImageTMP);
+            flowctrl.AnalogDrawROI(ImageTMP);
             ImageTMP->writeToMemoryAsJPG((ImageData*)AlgROI, 90);
         }
     #endif

code/components/jomjol_flowcontroll/ClassFlowCNNGeneral.cpp

@@ -55,7 +55,7 @@ string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution
 //        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))
+        if (_extendedResolution)
             result = result + std::to_string(result_after_decimal_point);
 
         for (int i = GENERAL[_analog]->ROI.size() - 2; i >= 0; --i)
@@ -134,7 +134,22 @@ string ClassFlowCNNGeneral::getReadout(int _analog = 0, bool _extendedResolution
     return result;
 }
 
-
+/**
+ * @brief Determines the number of an ROI in connection with previous ROI results
+ * 
+ * @param number: is the current ROI as float value from recognition
+ * @param number_of_predecessors: is the last (lower) ROI as float from recognition
+ * @param eval_predecessors: is the evaluated number. Sometimes a much lower value can change higer values
+ *                          example: 9.8, 9.9, 0.1
+ *                          0.1 => 0 (eval_predecessors)
+ *                          The 0 makes a 9.9 to 0 (eval_predecessors)
+ *                          The 0 makes a 9.8 to 0 
+ * @param Analog_Predecessors false/true if the last ROI is an analog or 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;
@@ -142,11 +157,11 @@ int ClassFlowCNNGeneral::PointerEvalHybridNew(float number, float number_of_pred
     int result_before_decimal_point = ((int) floor(number) + 10) % 10;
 
     if (eval_predecessors < 0)
-    {
-        if ((result_after_decimal_point <= Digital_Uncertainty * 10) || (result_after_decimal_point >= Digital_Uncertainty * 10))     // Band around the digit --> Rounding, as digit reaches inaccuracy in the frame
-            result = (int) (round(number) + 10) % 10;
-        else
-            result = (int) ((int) trunc(number) + 10) % 10;
+    {   
+        // on first digit is no spezial logic for transition needed
+        // we use the recognition as given. The result is the int value of the recognition
+        // add precisition of 2 digits and round before trunc
+        result = (int) ((int) trunc(round((number+10 % 10)*100)) )  / 100;
 
         LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "PointerEvalHybridNew - No predecessor - Result = " + std::to_string(result) +
                                                     " number: " + std::to_string(number) + " number_of_predecessors = " + std::to_string(number_of_predecessors)+ " eval_predecessors = " + std::to_string(eval_predecessors) + " Digital_Uncertainty = " +  std::to_string(Digital_Uncertainty));
@@ -374,8 +389,11 @@ bool ClassFlowCNNGeneral::ReadParameter(FILE* pfile, string& aktparamgraph)
         }
     }
 
-    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)
@@ -482,7 +500,7 @@ bool ClassFlowCNNGeneral::doFlow(string time)
 
     if (!doAlignAndCut(time)){
         return false;
-    };
+    }
 
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "doFlow after alignment");
 
@@ -850,10 +868,9 @@ bool ClassFlowCNNGeneral::doNeuralNetwork(string time)
 
 bool ClassFlowCNNGeneral::isExtendedResolution(int _number)
 {
-    if (!(CNNType == Digital))
-        return true;
-
-    return false;
+    if (CNNType == Digital)
+        return false;
+    return true;
 }
 
 

code/components/jomjol_flowcontroll/ClassFlowControll.cpp

@@ -25,10 +25,10 @@ extern "C" {
 #endif //ENABLE_MQTT
 
 #include "server_help.h"
-#include "server_tflite.h"
+#include "MainFlowControl.h"
 #include "../../include/defines.h"
 
-static const char* TAG = "CTRL";
+static const char* TAG = "FLOWCTRL";
 
 //#define DEBUG_DETAIL_ON
 
@@ -99,8 +99,6 @@ std::string ClassFlowControll::TranslateAktstatus(std::string _input)
     #endif //ENABLE_INFLUXDB
     if (_input.compare("ClassFlowPostProcessing") == 0)
         return ("Post-Processing");
-    if (_input.compare("ClassFlowWriteList") == 0)
-        return ("Writing List");
 
     return "Unkown Status";
 }
@@ -164,16 +162,8 @@ void ClassFlowControll::AnalogDrawROI(CImageBasis *_zw)
 
 
 #ifdef ENABLE_MQTT
-string ClassFlowControll::GetMQTTMainTopic()
+bool ClassFlowControll::StartMQTTService() 
 {
-    for (int i = 0; i < FlowControll.size(); ++i)
-        if (FlowControll[i]->name().compare("ClassFlowMQTT") == 0)
-            return ((ClassFlowMQTT*) (FlowControll[i]))->GetMQTTMainTopic();
-
-    return "";
-}
-
-bool ClassFlowControll::StartMQTTService() {
     /* Start the MQTT service */
         for (int i = 0; i < FlowControll.size(); ++i) {
             if (FlowControll[i]->name().compare("ClassFlowMQTT") == 0) {
@@ -200,10 +190,15 @@ void ClassFlowControll::SetInitialParameter(void)
 }
 
 
-bool ClassFlowControll::isAutoStart(long &_interval)
+bool ClassFlowControll::getIsAutoStart(void)
+{
+    return AutoStart;
+}
+
+
+void ClassFlowControll::setAutoStartInterval(long &_interval)
 {
     _interval = AutoInterval * 60 * 1000; // AutoInterval: minutes -> ms
-    return AutoStart;
 }
 
 
@@ -243,8 +238,6 @@ ClassFlow* ClassFlowControll::CreateClassFlow(std::string _type)
     if (toUpper(_type).compare("[INFLUXDBV2]") == 0)
         cfc = new ClassFlowInfluxDBv2(&FlowControll);
     #endif //ENABLE_INFLUXDB  
-    if (toUpper(_type).compare("[WRITELIST]") == 0)
-        cfc = new ClassFlowWriteList(&FlowControll);
 
     if (toUpper(_type).compare("[POSTPROCESSING]") == 0)
     {
@@ -385,7 +378,7 @@ bool ClassFlowControll::doFlow(string time)
         zw_time = getCurrentTimeString("%H:%M:%S");
         aktstatus = TranslateAktstatus(FlowControll[i]->name());
         aktstatusWithTime = aktstatus + " (" + zw_time + ")";
-        //LogFile.WriteToFile(ESP_LOG_INFO, TAG, aktstatusWithTime);
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Status: " + aktstatusWithTime);
         #ifdef ENABLE_MQTT
             MQTTPublish(mqttServer_getMainTopic() + "/" + "status", aktstatus, qos, false);
         #endif //ENABLE_MQTT
@@ -470,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 = "";
@@ -501,37 +494,40 @@ 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();
 }
 
 
@@ -737,7 +733,7 @@ esp_err_t ClassFlowControll::GetJPGStream(std::string _fn, httpd_req_t *req)
 
                 httpd_resp_set_type(req, "image/jpeg");
                 result = httpd_resp_send(req, (const char *)fileBuffer, fileSize); 
-                delete fileBuffer;
+                free(fileBuffer);
             }
             else if (aktstatus.find("Initialization") != -1) {
                 FILE* file = fopen("/sdcard/html/Flowstate_initialization.jpg", "rb"); 
@@ -764,7 +760,7 @@ esp_err_t ClassFlowControll::GetJPGStream(std::string _fn, httpd_req_t *req)
 
                 httpd_resp_set_type(req, "image/jpeg");
                 result = httpd_resp_send(req, (const char *)fileBuffer, fileSize); 
-                delete fileBuffer;
+                free(fileBuffer);
             }
             else if (aktstatus.find("Take Image") != -1) {
                 if (flowalignment && flowalignment->AlgROI) {

code/components/jomjol_flowcontroll/ClassFlowControll.h

@@ -18,7 +18,6 @@
 	#include "ClassFlowInfluxDBv2.h"
 #endif //ENABLE_INFLUXDB
 #include "ClassFlowCNNGeneral.h"
-#include "ClassFlowWriteList.h"
 
 class ClassFlowControll :
     public ClassFlow
@@ -35,20 +34,21 @@ protected:
 
 	bool AutoStart;
 	float AutoInterval;
-	bool SetupModeActive;
 	void SetInitialParameter(void);	
 	std::string aktstatusWithTime;
 	std::string aktstatus;
 	int aktRunNr;
 
 public:
+	bool SetupModeActive;
+
 	void InitFlow(std::string config);
 	bool doFlow(string time);
 	void doFlowTakeImageOnly(string time);
 	bool getStatusSetupModus(){return SetupModeActive;};
-	string getReadout(bool _rawvalue, bool _noerror);
+	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();
@@ -56,10 +56,6 @@ public:
 
 	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);
@@ -70,7 +66,8 @@ public:
 
 	std::string doSingleStep(std::string _stepname, std::string _host);
 
-	bool isAutoStart(long &_interval);
+	bool getIsAutoStart();
+	void setAutoStartInterval(long &_interval);
 
 	std::string* getActStatusWithTime();
 	std::string* getActStatus();

code/components/jomjol_flowcontroll/ClassFlowDefineTypes.h

@@ -34,6 +34,7 @@ struct NumberPost {
     bool AllowNegativeRates;
     bool checkDigitIncreaseConsistency;
     time_t lastvalue;
+    time_t timeStampTimeUTC;
     string timeStamp;
     double FlowRateAct; // m3 / min
     double PreValue; // last value that was read out well
@@ -50,7 +51,12 @@ struct NumberPost {
     int DecimalShiftInitial;
     float AnalogDigitalTransitionStart; // When is the digit > x.1, i.e. when does it start to tilt?
     int Nachkomma;
-    string Fieldname; // Fieldname in InfluxDB2  
+
+    string FieldV1; // Fieldname in InfluxDBv1  
+    string MeasurementV1;   // Measurement in InfluxDBv1
+
+    string FieldV2;         // Fieldname in InfluxDBv2  
+    string MeasurementV2;   // Measurement in InfluxDBv2
 
     bool isExtendedResolution;
 

code/components/jomjol_flowcontroll/ClassFlowImage.cpp

@@ -17,7 +17,8 @@ extern "C" {
 #include "esp_log.h"
 #include "../../include/defines.h"
 
-static const char* TAG = "IMG";
+static const char* TAG = "FLOWIMAGE";
+
 
 ClassFlowImage::ClassFlowImage(const char* logTag)
 {

code/components/jomjol_flowcontroll/ClassFlowInfluxDB.cpp

@@ -15,13 +15,12 @@
 
 #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;  
@@ -86,33 +85,39 @@ bool ClassFlowInfluxDB::ReadParameter(FILE* pfile, string& aktparamgraph)
     {
         ESP_LOGD(TAG, "while loop reading line: %s", aktparamgraph.c_str());
         splitted = ZerlegeZeile(aktparamgraph);
-        if ((toUpper(splitted[0]) == "USER") && (splitted.size() > 1))
+        std::string _param = GetParameterName(splitted[0]);
+
+        if ((toUpper(_param) == "USER") && (splitted.size() > 1))
         {
             this->user = splitted[1];
         }  
-        if ((toUpper(splitted[0]) == "PASSWORD") && (splitted.size() > 1))
+        if ((toUpper(_param) == "PASSWORD") && (splitted.size() > 1))
         {
             this->password = splitted[1];
         }               
-        if ((toUpper(splitted[0]) == "URI") && (splitted.size() > 1))
+        if ((toUpper(_param) == "URI") && (splitted.size() > 1))
         {
             this->uri = splitted[1];
         }
-        if (((toUpper(splitted[0]) == "MEASUREMENT")) && (splitted.size() > 1))
-        {
-            this->measurement = splitted[1];
-        }
-        if (((toUpper(splitted[0]) == "DATABASE")) && (splitted.size() > 1))
+        if (((toUpper(_param) == "DATABASE")) && (splitted.size() > 1))
         {
             this->database = splitted[1];
         }
+        if (((toUpper(_param) == "MEASUREMENT")) && (splitted.size() > 1))
+        {
+            handleMeasurement(splitted[0], splitted[1]);
+        }
+        if (((toUpper(_param) == "FIELD")) && (splitted.size() > 1))
+        {
+            handleFieldname(splitted[0], splitted[1]);
+        }
     }
 
-    if ((uri.length() > 0) && (database.length() > 0) && (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());
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Init InfluxDB with uri: " + uri + ", measurement: " + measurement + ", user: " + user + ", password: " + password);
-        InfluxDBInit(uri, database, measurement, user, password); 
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Init InfluxDB with uri: " + uri + ", user: " + user + ", password: " + password);
+        InfluxDBInit(uri, database, user, password); 
         InfluxDBenable = true;
     } else {
         LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "InfluxDB init skipped as we are missing some parameters");
@@ -121,23 +126,18 @@ bool ClassFlowInfluxDB::ReadParameter(FILE* pfile, string& aktparamgraph)
     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 = "";
 
@@ -147,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);
         }
     }
    
@@ -169,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

@@ -21,14 +21,19 @@ 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);

code/components/jomjol_flowcontroll/ClassFlowInfluxDBv2.cpp

@@ -15,13 +15,12 @@
 
 #include <time.h>
 
-static const char* TAG = "class_flow_influxDbv2";
+static const char* TAG = "INFLUXDBV2";
 
 void ClassFlowInfluxDBv2::SetInitialParameter(void)
 {
     uri = "";
-    database = "";
-    measurement = "";
+    bucket = "";
     dborg = "";  
     dbtoken = "";  
 //    dbfield = "";
@@ -102,30 +101,29 @@ bool ClassFlowInfluxDBv2::ReadParameter(FILE* pfile, string& aktparamgraph)
         {
             this->uri = splitted[1];
         }
-        if (((toUpper(_param) == "MEASUREMENT")) && (splitted.size() > 1))
-        {
-            this->measurement = splitted[1];
-        }
-        if (((toUpper(_param) == "FIELDNAME")) && (splitted.size() > 1))
+        if (((toUpper(_param) == "FIELD")) && (splitted.size() > 1))
         {
             handleFieldname(splitted[0], splitted[1]);
         }
-        if (((toUpper(splitted[0]) == "DATABASE")) && (splitted.size() > 1))
+        if (((toUpper(_param) == "MEASUREMENT")) && (splitted.size() > 1))
         {
-            this->database = splitted[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("measurement: %s\n", measurement.c_str());
     printf("org:         %s\n", dborg.c_str());
     printf("token:       %s\n", dbtoken.c_str());
 
-    if ((uri.length() > 0) && (database.length() > 0) && (measurement.length() > 0) && (dbtoken.length() > 0) && (dborg.length() > 0)) 
+    if ((uri.length() > 0) && (bucket.length() > 0) && (dbtoken.length() > 0) && (dborg.length() > 0)) 
     { 
-        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Init InfluxDB with uri: " + uri + ", measurement: " + measurement + ", org: " + dborg + ", token: *****");
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Init InfluxDB with uri: " + uri + ", org: " + dborg + ", token: *****");
 //        printf("vor V2 Init\n");
-        InfluxDB_V2_Init(uri, database, measurement, dborg, dbtoken); 
+        InfluxDB_V2_Init(uri, bucket, dborg, dbtoken); 
 //        printf("nach V2 Init\n");
         InfluxDBenable = true;
     } else {
@@ -135,11 +133,12 @@ bool ClassFlowInfluxDBv2::ReadParameter(FILE* pfile, string& aktparamgraph)
     return true;
 }
 
-
+/*
 string ClassFlowInfluxDBv2::GetInfluxDBMeasurement()
 {
     return measurement;
 }
+*/
 
 void ClassFlowInfluxDBv2::handleFieldname(string _decsep, string _value)
 {
@@ -154,15 +153,36 @@ void ClassFlowInfluxDBv2::handleFieldname(string _decsep, string _value)
     {
         if (_digit == "default")                        //  Set to default first (if nothing else is set)
         {
-            flowpostprocessing->NUMBERS[j]->Fieldname = _value;
+            flowpostprocessing->NUMBERS[j]->FieldV2 = _value;
         }
         if (flowpostprocessing->NUMBERS[j]->name == _digit)
         {
-            flowpostprocessing->NUMBERS[j]->Fieldname = _value;
+            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)
@@ -170,29 +190,35 @@ 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]->Fieldname.length() > 0)
+
+            if ((*NUMBERS)[i]->FieldV2.length() > 0)
             {
-                namenumber = (*NUMBERS)[i]->Fieldname;
+                namenumber = (*NUMBERS)[i]->FieldV2;
             }
             else
             {
@@ -206,8 +232,7 @@ bool ClassFlowInfluxDBv2::doFlow(string zwtime)
             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(namenumber, result, resulttimestamp);
-//                InfluxDB_V2_Publish(namenumber, result, resulttimestamp);
+                InfluxDB_V2_Publish(measurement, namenumber, result, resulttimeutc);
         }
     }
    

code/components/jomjol_flowcontroll/ClassFlowInfluxDBv2.h

@@ -15,7 +15,7 @@ class ClassFlowInfluxDBv2 :
     public ClassFlow
 {
 protected:
-    std::string uri, database, measurement;
+    std::string uri, bucket;
     std::string dborg, dbtoken, dbfield;
     std::string OldValue;
 	ClassFlowPostProcessing* flowpostprocessing;  
@@ -24,13 +24,15 @@ protected:
     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();
+//    string GetInfluxDBMeasurement();
 
     bool ReadParameter(FILE* pfile, string& aktparamgraph);
     bool doFlow(string time);

code/components/jomjol_flowcontroll/ClassFlowMQTT.cpp

@@ -37,6 +37,9 @@ void ClassFlowMQTT::SetInitialParameter(void)
     topicUptime = "";
     topicFreeMem = "";
 
+    caCertFilename = "";
+    clientCertFilename = "";
+    clientKeyFilename = "";
     clientname = wlan_config.hostname;
 
     OldValue = "";
@@ -102,6 +105,18 @@ bool ClassFlowMQTT::ReadParameter(FILE* pfile, string& aktparamgraph)
     while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
     {
         splitted = ZerlegeZeile(aktparamgraph);
+        if ((toUpper(splitted[0]) == "CACERT") && (splitted.size() > 1))
+        {
+            this->caCertFilename = splitted[1];
+        }  
+        if ((toUpper(splitted[0]) == "CLIENTCERT") && (splitted.size() > 1))
+        {
+            this->clientCertFilename = splitted[1];
+        }  
+        if ((toUpper(splitted[0]) == "CLIENTKEY") && (splitted.size() > 1))
+        {
+            this->clientKeyFilename = splitted[1];
+        }  
         if ((toUpper(splitted[0]) == "USER") && (splitted.size() > 1))
         {
             this->user = splitted[1];
@@ -183,12 +198,6 @@ bool ClassFlowMQTT::ReadParameter(FILE* pfile, string& aktparamgraph)
 }
 
 
-string ClassFlowMQTT::GetMQTTMainTopic()
-{
-    return maintopic;
-}
-
-
 bool ClassFlowMQTT::Start(float AutoInterval) 
 {
     roundInterval = AutoInterval; // Minutes
@@ -202,7 +211,8 @@ bool ClassFlowMQTT::Start(float AutoInterval)
     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;

code/components/jomjol_flowcontroll/ClassFlowMQTT.h

@@ -19,6 +19,7 @@ protected:
     std::string OldValue;
 	ClassFlowPostProcessing* flowpostprocessing;  
     std::string user, password; 
+    std::string caCertFilename, clientCertFilename, clientKeyFilename; 
     bool SetRetainFlag;
     int keepAlive; // Seconds
     float roundInterval; // Minutes
@@ -31,7 +32,6 @@ public:
     ClassFlowMQTT(std::vector<ClassFlow*>* lfc);
     ClassFlowMQTT(std::vector<ClassFlow*>* lfc, ClassFlow *_prev);
 
-    string GetMQTTMainTopic();
     bool Start(float AutoInterval);
 
     bool ReadParameter(FILE* pfile, string& aktparamgraph);

code/components/jomjol_flowcontroll/ClassFlowPostProcessing.cpp

@@ -5,6 +5,7 @@
 
 #include <iomanip>
 #include <sstream>
+#include <cassert>
 
 #include <time.h>
 
@@ -96,27 +97,49 @@ 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)
 }
 
 
@@ -262,6 +285,7 @@ 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";
@@ -703,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 = "";
@@ -746,6 +894,8 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
 
         int previous_value = -1;
 
+        // ------------------- start processing analog values --------------------------//
+
         if (NUMBERS[j]->analog_roi)
         {
             NUMBERS[j]->ReturnRawValue = flowAnalog->getReadout(j, NUMBERS[j]->isExtendedResolution); 
@@ -759,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 only if there are no analogue digits
+            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
@@ -791,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
             {
@@ -804,6 +973,13 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
                 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
@@ -844,17 +1020,21 @@ bool ClassFlowPostProcessing::doFlow(string zwtime)
             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
-            
-                // Include inaccuracy of 0.2 for isExtendedResolution.
-                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 = "";

code/components/jomjol_flowcontroll/ClassFlowPostProcessing.h

@@ -68,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();

code/components/jomjol_flowcontroll/ClassFlowTakeImage.cpp

@@ -8,6 +8,7 @@
 #include "esp_wifi.h"
 #include "esp_log.h"
 #include "../../include/defines.h"
+#include "psram.h"
 
 #include <time.h>
 
@@ -15,7 +16,7 @@
 
 // #define WIFITURNOFF
 
-static const char* TAG = "flow_make_image";
+static const char* TAG = "TAKEIMAGE";
 
 esp_err_t ClassFlowTakeImage::camera_capture(){
     string nm =  namerawimage;
@@ -183,6 +184,8 @@ string ClassFlowTakeImage::getHTMLSingleStep(string host)
 
 bool ClassFlowTakeImage::doFlow(string zwtime)
 {
+    psram_init_shared_memory_for_take_image_step();
+
     string logPath = CreateLogFolder(zwtime);
 
     int flash_duration = (int) (waitbeforepicture * 1000);
@@ -215,6 +218,8 @@ bool ClassFlowTakeImage::doFlow(string zwtime)
         LogFile.WriteHeapInfo("ClassFlowTakeImage::doFlow - After RemoveOldLogs");
     #endif
 
+    psram_deinit_shared_memory_for_take_image_step();
+
     return true;
 }
 

code/components/jomjol_flowcontroll/ClassFlowWriteList.cpp

@@ -1,91 +0,0 @@
-#include <sstream>
-#include "ClassFlowWriteList.h"
-#include "Helper.h"
-
-#include "time_sntp.h"
-#include "../../include/defines.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> splitted;
-
-    aktparamgraph = trim(aktparamgraph);
-
-    if (aktparamgraph.size() == 0)
-        if (!this->GetNextParagraph(pfile, aktparamgraph))
-            return false;
-
-    if (toUpper(aktparamgraph).compare("[MQTT]") != 0)  
-        return false;
-
-    while (this->getNextLine(pfile, &aktparamgraph) && !this->isNewParagraph(aktparamgraph))
-    {
-        splitted = ZerlegeZeile(aktparamgraph);
-    }
-   
-    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,27 +0,0 @@
-#pragma once
-
-#ifndef CLASSFFLOWPWRITELIST_H
-#define CLASSFFLOWPWRITELIST_H
-
-#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";};
-};
-
-#endif //CLASSFFLOWPWRITELIST_H

code/components/jomjol_flowcontroll/MainFlowControl.cpp

@@ -1,9 +1,10 @@
-#include "server_tflite.h"
+#include "MainFlowControl.h"
 
 #include <string>
 #include <vector>
 #include "string.h"
 #include "esp_log.h"
+#include <esp_timer.h>
 
 #include <iomanip>
 #include <sstream>
@@ -27,8 +28,12 @@
 #include "connect_wlan.h"
 #include "psram.h"
 
+// support IDF 5.x
+#ifndef portTICK_RATE_MS
+#define portTICK_RATE_MS portTICK_PERIOD_MS
+#endif
 
-ClassFlowControll tfliteflow;
+ClassFlowControll flowctrl;
 
 TaskHandle_t xHandletask_autodoFlow = NULL;
 
@@ -36,12 +41,13 @@ bool bTaskAutoFlowCreated = false;
 bool flowisrunning = false;
 
 long auto_interval = 0;
-bool auto_isrunning = false;
+bool autostartIsEnabled = false;
 
 int countRounds = 0;
 bool isPlannedReboot = false;
 
-static const char *TAG = "TFLITE SERVER";
+static const char *TAG = "MAINCTRL";
+
 
 //#define DEBUG_DETAIL_ON
 
@@ -75,26 +81,26 @@ int getCountFlowRounds()
 
 esp_err_t GetJPG(std::string _filename, httpd_req_t *req)
 {
-    return tfliteflow.GetJPGStream(_filename, req);
+    return flowctrl.GetJPGStream(_filename, req);
 }
 
 
 esp_err_t GetRawJPG(httpd_req_t *req)
 {
-    return tfliteflow.SendRawJPG(req);
+    return flowctrl.SendRawJPG(req);
 }
 
 
-bool isSetupModusActive() {
-    return tfliteflow.getStatusSetupModus();
-    return false;
+bool isSetupModusActive() 
+{
+    return flowctrl.getStatusSetupModus();
 }
 
 
-void KillTFliteTasks()
+void DeleteMainFlowTask()
 {
     #ifdef DEBUG_DETAIL_ON      
-        ESP_LOGD(TAG, "KillTFliteTasks: xHandletask_autodoFlow: %ld", (long) xHandletask_autodoFlow);
+        ESP_LOGD(TAG, "DeleteMainFlowTask: xHandletask_autodoFlow: %ld", (long) xHandletask_autodoFlow);
     #endif
     if( xHandletask_autodoFlow != NULL )
     {
@@ -109,19 +115,19 @@ void KillTFliteTasks()
 
 void doInit(void)
 {
-    #ifdef DEBUG_DETAIL_ON             
-        ESP_LOGD(TAG, "Start tfliteflow.InitFlow(config);");
+    #ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Start flowctrl.InitFlow(config);");
     #endif
-    tfliteflow.InitFlow(CONFIG_FILE);
-    #ifdef DEBUG_DETAIL_ON      
-        ESP_LOGD(TAG, "Finished tfliteflow.InitFlow(config);");
+    flowctrl.InitFlow(CONFIG_FILE);
+    #ifdef DEBUG_DETAIL_ON
+        ESP_LOGD(TAG, "Finished flowctrl.InitFlow(config);");
     #endif
     
     /* GPIO handler has to be initialized before MQTT init to ensure proper topic subscription */
     gpio_handler_init();
 
     #ifdef ENABLE_MQTT
-        tfliteflow.StartMQTTService();
+        flowctrl.StartMQTTService();
     #endif //ENABLE_MQTT
 }
 
@@ -131,7 +137,7 @@ bool doflow(void)
     std::string zw_time = getCurrentTimeString(LOGFILE_TIME_FORMAT);
     ESP_LOGD(TAG, "doflow - start %s", zw_time.c_str());
     flowisrunning = true;
-    tfliteflow.doFlow(zw_time);
+    flowctrl.doFlow(zw_time);
     flowisrunning = false;
 
     #ifdef DEBUG_DETAIL_ON      
@@ -207,6 +213,40 @@ esp_err_t handler_init(httpd_req_t *req)
 }
 
 
+esp_err_t handler_stream(httpd_req_t *req)
+{
+    #ifdef DEBUG_DETAIL_ON      
+        LogFile.WriteHeapInfo("handler_stream - Start");       
+        ESP_LOGD(TAG, "handler_stream uri: %s", req->uri);
+    #endif
+
+    char _query[50];
+    char _value[10];
+    bool flashlightOn = false;
+
+    if (httpd_req_get_url_query_str(req, _query, 50) == ESP_OK)
+    {
+//        ESP_LOGD(TAG, "Query: %s", _query);
+        if (httpd_query_key_value(_query, "flashlight", _value, 10) == ESP_OK)
+        {
+            #ifdef DEBUG_DETAIL_ON       
+                ESP_LOGD(TAG, "flashlight is found%s", _value);
+            #endif
+            if (strlen(_value) > 0)
+                flashlightOn = true;
+        }
+    }
+
+    Camera.CaptureToStream(req, flashlightOn);
+
+    #ifdef DEBUG_DETAIL_ON      
+        LogFile.WriteHeapInfo("handler_stream - Done");       
+    #endif
+
+    return ESP_OK;
+}
+
+
 esp_err_t handler_flow_start(httpd_req_t *req) {
 
     #ifdef DEBUG_DETAIL_ON          
@@ -217,7 +257,7 @@ esp_err_t handler_flow_start(httpd_req_t *req) {
 
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
 
-    if (auto_isrunning) {
+    if (autostartIsEnabled) {
         xTaskAbortDelay(xHandletask_autodoFlow); // Delay will be aborted if task is in blocked (waiting) state. If task is already running, no action
         LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Flow start triggered by REST API /flow_start");
         const char* resp_str = "The flow is going to be started immediately or is already running";
@@ -246,7 +286,7 @@ esp_err_t MQTTCtrlFlowStart(std::string _topic) {
 
     ESP_LOGD(TAG, "MQTTCtrlFlowStart: topic %s", _topic.c_str());
 
-    if (auto_isrunning) 
+    if (autostartIsEnabled) 
     {
         xTaskAbortDelay(xHandletask_autodoFlow); // Delay will be aborted if task is in blocked (waiting) state. If task is already running, no action
         LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Flow start triggered by MQTT topic " + _topic);
@@ -278,7 +318,7 @@ esp_err_t handler_json(httpd_req_t *req)
         httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
         httpd_resp_set_type(req, "application/json");
 
-        std::string zw = tfliteflow.getJSON();
+        std::string zw = flowctrl.getJSON();
         if (zw.length() > 0) 
         {
             httpd_resp_send(req, zw.c_str(), zw.length());
@@ -371,7 +411,7 @@ esp_err_t handler_wasserzaehler(httpd_req_t *req)
                 _intype = READOUT_TYPE_ERROR;
 
 
-            zw = tfliteflow.getReadoutAll(_intype);
+            zw = flowctrl.getReadoutAll(_intype);
             ESP_LOGD(TAG, "ZW: %s", zw.c_str());
             if (zw.length() > 0)
                 httpd_resp_send(req, zw.c_str(), zw.length()); 
@@ -380,7 +420,7 @@ esp_err_t handler_wasserzaehler(httpd_req_t *req)
         }
 
 
-        std::string *status = tfliteflow.getActStatus();
+        std::string *status = flowctrl.getActStatus();
         string query = std::string(_query);
     //    ESP_LOGD(TAG, "Query: %s, query.c_str());
         if (query.find("full") != std::string::npos)
@@ -398,8 +438,7 @@ esp_err_t handler_wasserzaehler(httpd_req_t *req)
             httpd_resp_sendstr_chunk(req, txt.c_str());
         }
 
-
-        zw = tfliteflow.getReadout(_rawValue, _noerror);
+        zw = flowctrl.getReadout(_rawValue, _noerror, 0);
         if (zw.length() > 0)
             httpd_resp_sendstr_chunk(req, zw.c_str()); 
 
@@ -414,15 +453,15 @@ esp_err_t handler_wasserzaehler(httpd_req_t *req)
             else {
                 /* Digital ROIs */
                 txt = "<body style=\"font-family: arial\">";
-                txt += "<h3>Recognized Digit ROIs (previous round)</h3>\n";
+                txt += "<hr><h3>Recognized Digit ROIs (previous round)</h3>\n";
                 txt += "<table style=\"border-spacing: 5px\"><tr style=\"text-align: center; vertical-align: top;\">\n";
 
                 std::vector<HTMLInfo*> htmlinfodig;
-                htmlinfodig = tfliteflow.GetAllDigital(); 
+                htmlinfodig = flowctrl.GetAllDigital(); 
 
                 for (int i = 0; i < htmlinfodig.size(); ++i)
                 {
-                    if (tfliteflow.GetTypeDigital() == Digital)
+                    if (flowctrl.GetTypeDigital() == Digital)
                     {
                         if (htmlinfodig[i]->val == 10)
                             zw = "NaN";
@@ -449,11 +488,11 @@ esp_err_t handler_wasserzaehler(httpd_req_t *req)
 
 
                 /* Analog ROIs */
-                txt = "<h3>Recognized Analog ROIs (previous round)</h3>\n";
+                txt = "<hr><h3>Recognized Analog ROIs (previous round)</h3>\n";
                 txt += "<table style=\"border-spacing: 5px\"><tr style=\"text-align: center; vertical-align: top;\">\n";
                 
                 std::vector<HTMLInfo*> htmlinfoana;
-                htmlinfoana = tfliteflow.GetAllAnalog();
+                htmlinfoana = flowctrl.GetAllAnalog();
                 for (int i = 0; i < htmlinfoana.size(); ++i)
                 {
                     std::stringstream stream;
@@ -471,7 +510,7 @@ esp_err_t handler_wasserzaehler(httpd_req_t *req)
 
                 /* Full Image 
                  * Only show it after the image got taken and aligned */
-                txt = "<h3>Aligned Image (current round)</h3>\n";
+                txt = "<hr><h3>Aligned Image (current round)</h3>\n";
                 if ((*status == std::string("Initialization")) || 
                     (*status == std::string("Initialization (delayed)")) || 
                     (*status == std::string("Take Image"))) {
@@ -618,20 +657,33 @@ esp_err_t handler_editflow(httpd_req_t *req)
 
         string out2 = out.substr(0, out.length() - 4) + "_org.jpg";
 
-        CAlignAndCutImage *caic = new CAlignAndCutImage("cutref", in);
-        caic->CutAndSave(out2, x, y, dx, dy);
-        delete caic;    
+        if ((flowctrl.SetupModeActive || (*flowctrl.getActStatus() == "Flow finished")) && psram_init_shared_memory_for_take_image_step()) {
+            LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Taking image for Alignment Mark Update...");
 
-        CImageBasis *cim = new CImageBasis("cutref", out2);
-        if (enhance)
-        {
-            cim->Contrast(90);
+            CAlignAndCutImage *caic = new CAlignAndCutImage("cutref", in);
+            caic->CutAndSave(out2, x, y, dx, dy);
+            delete caic;   
+
+            CImageBasis *cim = new CImageBasis("cutref", out2);
+            if (enhance)
+            {
+                cim->Contrast(90);
+            }
+
+            cim->SaveToFile(out);
+            delete cim;        
+
+            psram_deinit_shared_memory_for_take_image_step();
+
+
+            zw = "CutImage Done";
+        }
+        else {
+            LogFile.WriteToFile(ESP_LOG_WARN, TAG, std::string("Taking image for Alignment Mark not possible while device") +
+            " is busy with a round (Current State: '" + *flowctrl.getActStatus() + "')!");
+            zw = "Device Busy";
         }
 
-        cim->SaveToFile(out);
-        delete cim;        
-
-        zw = "CutImage Done";
         httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
         httpd_resp_send(req, zw.c_str(), zw.length()); 
         
@@ -675,7 +727,7 @@ esp_err_t handler_editflow(httpd_req_t *req)
         Camera.SetBrightnessContrastSaturation(bri, con, sat);
         Camera.SetLEDIntensity(intens);
         ESP_LOGD(TAG, "test_take - vor TakeImage");
-        std::string zw = tfliteflow.doSingleStep("[TakeImage]", _host);
+        std::string zw = flowctrl.doSingleStep("[TakeImage]", _host);
         httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
         httpd_resp_send(req, zw.c_str(), zw.length()); 
     } 
@@ -690,7 +742,7 @@ esp_err_t handler_editflow(httpd_req_t *req)
 //        ESP_LOGD(TAG, "Parameter host: %s", _host.c_str());
 
 //        string zwzw = "Do " + _task + " start\n"; ESP_LOGD(TAG, zwzw.c_str());
-        std::string zw = tfliteflow.doSingleStep("[Alignment]", _host);
+        std::string zw = flowctrl.doSingleStep("[Alignment]", _host);
         httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
         httpd_resp_send(req, zw.c_str(), zw.length()); 
     }
@@ -706,7 +758,7 @@ esp_err_t handler_editflow(httpd_req_t *req)
 esp_err_t handler_statusflow(httpd_req_t *req)
 {
     #ifdef DEBUG_DETAIL_ON       
-        LogFile.WriteHeapInfo("handler_prevalue - Start");       
+        LogFile.WriteHeapInfo("handler_statusflow - Start");       
     #endif
 
     const char* resp_str;
@@ -715,10 +767,10 @@ esp_err_t handler_statusflow(httpd_req_t *req)
     if (bTaskAutoFlowCreated) 
     {
         #ifdef DEBUG_DETAIL_ON       
-            ESP_LOGD(TAG, "handler_prevalue: %s", req->uri);
+            ESP_LOGD(TAG, "handler_statusflow: %s", req->uri);
         #endif
 
-        string* zw = tfliteflow.getActStatusWithTime();
+        string* zw = flowctrl.getActStatusWithTime();
         resp_str = zw->c_str();
 
         httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);   
@@ -730,7 +782,7 @@ esp_err_t handler_statusflow(httpd_req_t *req)
     }
 
     #ifdef DEBUG_DETAIL_ON       
-        LogFile.WriteHeapInfo("handler_prevalue - Done");       
+        LogFile.WriteHeapInfo("handler_statusflow - Done");       
     #endif
 
     return ESP_OK;
@@ -802,50 +854,81 @@ esp_err_t handler_uptime(httpd_req_t *req)
 esp_err_t handler_prevalue(httpd_req_t *req)
 {
     #ifdef DEBUG_DETAIL_ON       
-        LogFile.WriteHeapInfo("handler_prevalue - Start");       
-    #endif
-
-    const char* resp_str;
-    string zw;
-
-    #ifdef DEBUG_DETAIL_ON       
+        LogFile.WriteHeapInfo("handler_prevalue - Start");          
         ESP_LOGD(TAG, "handler_prevalue: %s", req->uri);
     #endif
 
-    char _query[100];
-    char _size[10] = "";
-    char _numbers[50] = "default";
+    // Default usage message when handler gets called without any parameter
+    const std::string RESTUsageInfo = 
+        "00: Handler usage:<br>"
+        "- To retrieve actual PreValue, please provide only a numbersname, e.g. /setPreValue?numbers=main<br>"
+        "- To set PreValue to a new value, please provide a numbersname and a value, e.g. /setPreValue?numbers=main&value=1234.5678<br>"
+        "NOTE:<br>"
+        "value >= 0.0: Set PreValue to provided value<br>"
+        "value <  0.0: Set PreValue to actual RAW value (as long RAW value is a valid number, without N)";
 
-    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
-    {
+    // Default return error message when no return is programmed
+    std::string sReturnMessage = "E90: Uninitialized";
+
+    char _query[100];
+    char _numbersname[50] = "default";
+    char _value[20] = "";
+
+    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
+
+    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK) {
         #ifdef DEBUG_DETAIL_ON       
             ESP_LOGD(TAG, "Query: %s", _query);
         #endif
 
-        if (httpd_query_key_value(_query, "value", _size, 10) == ESP_OK)
-        {
-            #ifdef DEBUG_DETAIL_ON       
-                ESP_LOGD(TAG, "Value: %s", _size);
-            #endif
+        if (httpd_query_key_value(_query, "numbers", _numbersname, 50) != ESP_OK) { // If request is incomplete
+            sReturnMessage = "E91: Query parameter incomplete or not valid!<br> "
+                             "Call /setPreValue to show REST API usage info and/or check documentation";
+            httpd_resp_send(req, sReturnMessage.c_str(), sReturnMessage.length());
+            return ESP_FAIL; 
         }
 
-        httpd_query_key_value(_query, "numbers", _numbers, 50);
-    }      
-
-    if (strlen(_size) == 0)
-    {
-        zw = tfliteflow.GetPrevalue(std::string(_numbers));
+        if (httpd_query_key_value(_query, "value", _value, 20) == ESP_OK) {
+            #ifdef DEBUG_DETAIL_ON       
+                ESP_LOGD(TAG, "Value: %s", _value);
+            #endif
+        }
     }
-    else
-    {
-        zw = "SetPrevalue to " + tfliteflow.UpdatePrevalue(_size, _numbers, true);
-    }
-    
-    resp_str = zw.c_str();
+    else {  // if no parameter is provided, print handler usage
+        httpd_resp_send(req, RESTUsageInfo.c_str(), RESTUsageInfo.length());
+        return ESP_OK; 
+    }   
 
-    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
-    
-    httpd_resp_send(req, resp_str, HTTPD_RESP_USE_STRLEN);  
+    if (strlen(_value) == 0) { // If no value is povided --> return actual PreValue
+        sReturnMessage = flowctrl.GetPrevalue(std::string(_numbersname));
+
+        if (sReturnMessage.empty()) {
+            sReturnMessage = "E92: Numbers name not found";
+            httpd_resp_send(req, sReturnMessage.c_str(), sReturnMessage.length());
+            return ESP_FAIL;
+        }
+    }
+    else {
+        // New value is positive: Set PreValue to provided value and return value
+        // New value is negative and actual RAW value is a valid number: Set PreValue to RAW value and return value
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "REST API handler_prevalue called: numbersname: " + std::string(_numbersname) + 
+                                                ", value: " + std::string(_value));
+        if (!flowctrl.UpdatePrevalue(_value, _numbersname, true)) {
+            sReturnMessage = "E93: Update request rejected. Please check device logs for more details";
+            httpd_resp_send(req, sReturnMessage.c_str(), sReturnMessage.length());  
+            return ESP_FAIL;
+        }
+
+        sReturnMessage = flowctrl.GetPrevalue(std::string(_numbersname));
+
+        if (sReturnMessage.empty()) {
+            sReturnMessage = "E94: Numbers name not found";
+            httpd_resp_send(req, sReturnMessage.c_str(), sReturnMessage.length());
+            return ESP_FAIL;
+        }
+    }
+
+    httpd_resp_send(req, sReturnMessage.c_str(), sReturnMessage.length());  
 
     #ifdef DEBUG_DETAIL_ON       
         LogFile.WriteHeapInfo("handler_prevalue - End");       
@@ -863,7 +946,7 @@ void task_autodoFlow(void *pvParameter)
 
     if (!isPlannedReboot && (esp_reset_reason() == ESP_RST_PANIC))
     {
-        tfliteflow.setActStatus("Initialization (delayed)");
+        flowctrl.setActStatus("Initialization (delayed)");
         //#ifdef ENABLE_MQTT
             //MQTTPublish(mqttServer_getMainTopic() + "/" + "status", "Initialization (delayed)", false); // Right now, not possible -> MQTT Service is going to be started later
         //#endif //ENABLE_MQTT
@@ -873,16 +956,25 @@ void task_autodoFlow(void *pvParameter)
     ESP_LOGD(TAG, "task_autodoFlow: start");
     doInit();
 
-    auto_isrunning = tfliteflow.isAutoStart(auto_interval);
+    flowctrl.setAutoStartInterval(auto_interval);
+    autostartIsEnabled = flowctrl.getIsAutoStart();
 
     if (isSetupModusActive()) 
     {
-        auto_isrunning = false;
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "We are in Setup Mode -> Not starting Auto Flow!");
+        autostartIsEnabled = false;
         std::string zw_time = getCurrentTimeString(LOGFILE_TIME_FORMAT);
-        tfliteflow.doFlowTakeImageOnly(zw_time);
+        flowctrl.doFlowTakeImageOnly(zw_time);
+    }
+
+    if (autostartIsEnabled) {
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Starting Flow...");
+    }
+    else {
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Autostart is not enabled -> Not starting Flow");
     }
     
-    while (auto_isrunning)
+    while (autostartIsEnabled)
     {
         LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "----------------------------------------------------------------"); // Clear separation between runs
         std::string _zw = "Round #" + std::to_string(++countRounds) + " started";
@@ -944,13 +1036,19 @@ void task_autodoFlow(void *pvParameter)
             vTaskDelay( xDelay );        
         }
     }
+
+    while(1) // Keep flow task running to handle necessary sub tasks like reboot handler, etc..
+    {
+        vTaskDelay(2000 / portTICK_PERIOD_MS); 
+    }
+
     vTaskDelete(NULL); //Delete this task if it exits from the loop above
     xHandletask_autodoFlow = NULL;
     ESP_LOGD(TAG, "task_autodoFlow: end");
 }
 
 
-void TFliteDoAutoStart()
+void InitializeFlowTask()
 {
     BaseType_t xReturned;
 
@@ -967,17 +1065,9 @@ void TFliteDoAutoStart()
 }
 
 
-#ifdef ENABLE_MQTT
-std::string GetMQTTMainTopic()
+void register_server_main_flow_task_uri(httpd_handle_t server)
 {
-    return tfliteflow.GetMQTTMainTopic();
-}
-#endif//ENABLE_MQTT
-
-
-void register_server_tflite_uri(httpd_handle_t server)
-{
-    ESP_LOGI(TAG, "server_part_camera - Registering URI handlers");
+    ESP_LOGI(TAG, "server_main_flow_task - Registering URI handlers");
     
     httpd_uri_t camuri = { };
     camuri.method    = HTTP_GET;
@@ -1071,4 +1161,10 @@ void register_server_tflite_uri(httpd_handle_t server)
     camuri.handler   = handler_get_heap;
     camuri.user_ctx  = (void*) "Heap"; 
     httpd_register_uri_handler(server, &camuri);
+
+    camuri.uri       = "/stream";
+    camuri.handler   = handler_stream;
+    camuri.user_ctx  = (void*) "stream"; 
+    httpd_register_uri_handler(server, &camuri);
+
 }

code/components/jomjol_flowcontroll/MainFlowControl.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#ifndef SERVERTFLITE_H
-#define SERVERTFLITE_H
+#ifndef MAINFLOWCONTROL_H
+#define MAINFLOWCONTROL_H
 
 #include <esp_log.h>
 #include <string>
@@ -10,25 +10,25 @@
 #include "CImageBasis.h"
 #include "ClassFlowControll.h"
 
-//#include "ClassControllCamera.h"
+extern ClassFlowControll flowctrl;
 
-extern ClassFlowControll tfliteflow;
-void register_server_tflite_uri(httpd_handle_t server);
 
-void KillTFliteTasks();
-void TFliteDoAutoStart();
-bool isSetupModusActive();
-int getCountFlowRounds();
+void register_server_main_flow_task_uri(httpd_handle_t server);
 
 void CheckIsPlannedReboot();
 bool getIsPlannedReboot();
 
-esp_err_t GetJPG(std::string _filename, httpd_req_t *req);
-esp_err_t GetRawJPG(httpd_req_t *req);
+void InitializeFlowTask();
+void DeleteMainFlowTask();
+bool isSetupModusActive();
+
+int getCountFlowRounds();
 
 #ifdef ENABLE_MQTT
-std::string GetMQTTMainTopic();
-esp_err_t MQTTCtrlFlowStart(std::string);
+esp_err_t MQTTCtrlFlowStart(std::string _topic);
 #endif //ENABLE_MQTT
 
-#endif //SERVERTFLITE_H
+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_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 esp-fatfs esp-sdmmc)
 
 

code/components/jomjol_helper/Helper.cpp

@@ -23,12 +23,16 @@ 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 "esp_vfs_fat.h"
+#include "esp_vfs_fat_mh.h"
+#include "sdmmc_common_mh.h"
 
 static const char* TAG = "HELPER";
 
@@ -672,7 +676,7 @@ struct SDCard_Manufacturer_database {
 
 /* 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,
@@ -777,25 +781,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 (card_is_mmc)
+    {
+        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;
+    }
 }
 
 

code/components/jomjol_helper/Helper.h

@@ -6,7 +6,8 @@
 #include <string>
 #include <fstream>
 #include <vector>
-#include "sdmmc_cmd.h"
+//#include "sdmmc_cmd.h"
+#include "sdmmc_cmd_mh.h"
 
 using namespace std;
 

code/components/jomjol_helper/esp_sys.cpp

@@ -3,6 +3,7 @@
 #ifdef DEBUG_ENABLE_SYSINFO
 
 #include "esp_sys.h"
+#include "esp_chip_info.h"
 
 #include <string>
 
@@ -121,7 +122,7 @@ std::string get_device_info()
     }
 
     #ifdef USE_HIMEM_IF_AVAILABLE
-        sprintf(aMsgBuf,"spiram size %u\n", esp_spiram_get_size());
+        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);

code/components/jomjol_helper/esp_sys.h

@@ -16,9 +16,9 @@
 #include <esp_spi_flash.h>
 #include <esp_heap_caps.h>
 
-// for esp_spiram_get_size
+// for esp_psram_get_size
 extern "C" {
-    #include <esp32/spiram.h>
+    #include "esp_psram.h"
     #ifdef USE_HIMEM_IF_AVAILABLE
         #include <esp32/himem.h>
     #endif

code/components/jomjol_helper/psram.cpp

@@ -1,11 +1,167 @@
 #include "ClassLogFile.h"
-#include "esp_heap_caps.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;
 
@@ -21,12 +177,25 @@ 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) {
+	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_DEBUG, TAG, "Allocated " + to_string(size) + " bytes in PSRAM for '" + name + "'");
+	    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 + "'!");
@@ -39,4 +208,4 @@ 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) {
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Freeing memory in PSRAM used for '" + name + "'...");
     heap_caps_free(ptr);
-}
+}

code/components/jomjol_helper/psram.h

@@ -1,7 +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);
+void free_psram_heap(std::string name, void *ptr);
+
+#endif // PSRAM_h

code/components/jomjol_helper/sdcard_check.cpp

@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <unistd.h>
 #include <inttypes.h>
 #include <sys/stat.h>
 
@@ -147,12 +148,6 @@ bool SDCardCheckFolderFilePresence()
         bRetval = false;
     }
 
-    /* check if file exists: gethost.js */
-    if (stat("/sdcard/html/gethost.js", &sb) != 0) {
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Folder/file check: File /html/gethost.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");
@@ -163,4 +158,4 @@ bool SDCardCheckFolderFilePresence()
         LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Folder/file presence check successful");
     
     return bRetval;
-}
+}

code/components/jomjol_helper/statusled.cpp

@@ -7,6 +7,11 @@
 #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";
 

code/components/jomjol_image_proc/CImageBasis.cpp

@@ -477,7 +477,13 @@ CImageBasis::CImageBasis(string _name, CImageBasis *_copyfrom)
 
     memsize = width * height * channels;
 
-    rgb_image = (unsigned char*)malloc_psram_heap(std::string(TAG) + "->CImageBasis (" + name + ")", memsize, MALLOC_CAP_SPIRAM);
+
+    if (name == "tmpImage") {
+        rgb_image = (unsigned char*)psram_reserve_shared_tmp_image_memory();
+    }
+    else {
+        rgb_image = (unsigned char*)malloc_psram_heap(std::string(TAG) + "->CImageBasis (" + name + ")", memsize, MALLOC_CAP_SPIRAM);
+    }
 
     if (rgb_image == NULL)
     {
@@ -618,9 +624,20 @@ CImageBasis::~CImageBasis()
 {
     RGBImageLock();
 
+
     if (!externalImage) {
-        //stbi_image_free(rgb_image);
-        free_psram_heap(std::string(TAG) + "->CImageBasis (" + name + ", " + to_string(memsize) + ")", rgb_image);
+        if (name == "tmpImage") { // This image should be placed in the shared part of PSRAM
+            psram_free_shared_temp_image_memory();
+        }
+        else { // All other images are much smaller and can go into the normal PSRAM region
+            //stbi_image_free(rgb_image);
+            if (memsize == 0) {
+                LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Not freeing (" + name + " as there was never PSRAM allocated for it)");
+            }
+            else {
+                free_psram_heap(std::string(TAG) + "->CImageBasis (" + name + ", " + to_string(memsize) + ")", rgb_image);
+            }
+        }
     }
 
     RGBImageRelease();