sensor sweep tester

bin/esp-plant-dev-tools.Containerfile

@@ -1,16 +0,0 @@
-FROM debian:latest
-
-RUN apt update -y && apt upgrade -y && apt install unzip curl xz-utils nodejs -y
-
-RUN cd /root && \
-    curl -L -o xpack-riscv-toolchain.tar.gz "https://github.com/xpack-dev-tools/riscv-none-elf-gcc-xpack/releases/download/v14.2.0-3/xpack-riscv-none-elf-gcc-14.2.0-3-linux-x64.tar.gz" && \
-    mkdir xpack-toolchain && \
-    tar -xvf xpack-riscv-toolchain.tar.gz -C xpack-toolchain --strip-components=1 && \
-    mv xpack-toolchain/bin/* /usr/local/bin && \
-    mv xpack-toolchain/lib/ /usr/local && \
-    mv xpack-toolchain/lib64/ /usr/local && \
-    mv xpack-toolchain/libexec /usr/local && \
-    mv xpack-toolchain/riscv-none-elf /usr/local && \
-    rm -rf xpack-toolchain xpack-riscv-toolchain.tar.gz
-
-RUN apt install npm -y

bin/npm

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-CONTAINER_IMAGE="localhost/esp-plant-dev-tools:latest"
-CONTAINER_TOOLS_BASEDIR="$(dirname "$(readlink -f "$0")")"
-PLANTCTL_PROJECT_DIR="$(readlink -f "$CONTAINER_TOOLS_BASEDIR/..")"
-
-function _fatal {
-	echo -e "\e[31mERROR\e[0m   $(</dev/stdin)$*" 1>&2
-	exit 1
-}
-
-declare -a PODMAN_ARGS=(
-	"--rm" "-i" "--log-driver=none"
-	"-v" "$PLANTCTL_PROJECT_DIR:$PLANTCTL_PROJECT_DIR:rw"
-	"-v" "$PWD:$PWD:rw"
-	"-w" "$PWD"
-)
-
-[[ -t 1 ]] && PODMAN_ARGS+=("-t")
-
-if ! podman image exists "$CONTAINER_IMAGE"; then
-    #attempt to build container
-    "$CONTAINER_TOOLS_BASEDIR/build-esp-plant-dev-tools.sh" 1>&2 ||
-        _fatal "faild to build local image, cannot continue! … please ensure you have an internet connection"
-fi
-
-podman run "${PODMAN_ARGS[@]}" --entrypoint npm "$CONTAINER_IMAGE" "$@"

bin/riscv32-unknown-elf-gcc

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-CONTAINER_IMAGE="localhost/esp-plant-dev-tools:latest"
-CONTAINER_TOOLS_BASEDIR="$(dirname "$(readlink -f "$0")")"
-PLANTCTL_PROJECT_DIR="$(readlink -f "$CONTAINER_TOOLS_BASEDIR/..")"
-
-function _fatal {
-	echo -e "\e[31mERROR\e[0m   $(</dev/stdin)$*" 1>&2
-	exit 1
-}
-
-declare -a PODMAN_ARGS=(
-	"--rm" "-i" "--log-driver=none"
-	"-v" "$PLANTCTL_PROJECT_DIR:$PLANTCTL_PROJECT_DIR:rw"
-	"-v" "$PWD:$PWD:rw"
-	"-w" "$PWD"
-)
-
-[[ -t 1 ]] && PODMAN_ARGS+=("-t")
-
-if ! podman image exists "$CONTAINER_IMAGE"; then
-    #attempt to build container
-    "$CONTAINER_TOOLS_BASEDIR/build-esp-plant-dev-tools.sh" 1>&2 ||
-        _fatal "faild to build local image, cannot continue! … please ensure you have an internet connection"
-fi
-
-podman run "${PODMAN_ARGS[@]}" --entrypoint riscv-none-elf-gcc "$CONTAINER_IMAGE" "$@"

board/.gitignore

@@ -34,3 +34,5 @@ _autosave-*
 
 # Autorouter files (exported from Pcbnew)
 fp-info-cache
+*.zip
+netlist.ipc

board/modules/3v3/fabrication-toolkit-options.json

@@ -0,0 +1 @@
+{"EXTRA_LAYERS": "", "ALL_ACTIVE_LAYERS": false, "EXTEND_EDGE_CUT": false, "ALTERNATIVE_EDGE_CUT": false, "AUTO TRANSLATE": true, "AUTO FILL": true, "EXCLUDE DNP": false}

board/modules/LightOut/fabrication-toolkit-options.json

@@ -0,0 +1 @@
+{"EXTRA_LAYERS": "", "ALL_ACTIVE_LAYERS": false, "EXTEND_EDGE_CUT": false, "ALTERNATIVE_EDGE_CUT": false, "AUTO TRANSLATE": true, "AUTO FILL": true, "EXCLUDE DNP": false}

board/modules/MPPT/fabrication-toolkit-options.json

@@ -0,0 +1 @@
+{"EXTRA_LAYERS": "", "ALL_ACTIVE_LAYERS": false, "EXTEND_EDGE_CUT": false, "ALTERNATIVE_EDGE_CUT": false, "AUTO TRANSLATE": true, "AUTO FILL": true, "EXCLUDE DNP": false}

board/modules/Sensors/Sensors/fabrication-toolkit-options.json

@@ -0,0 +1 @@
+{"EXTRA_LAYERS": "", "ALL_ACTIVE_LAYERS": false, "EXTEND_EDGE_CUT": false, "ALTERNATIVE_EDGE_CUT": false, "AUTO TRANSLATE": true, "AUTO FILL": true, "EXCLUDE DNP": false}

board/modules/Sensors_can/Sensors/fabrication-toolkit-options.json

@@ -0,0 +1 @@
+{"EXTRA_LAYERS": "", "ALL_ACTIVE_LAYERS": false, "EXTEND_EDGE_CUT": false, "ALTERNATIVE_EDGE_CUT": false, "AUTO TRANSLATE": true, "AUTO FILL": true, "EXCLUDE DNP": false}

board/modules/Sensors_can/Sensors/fp-lib-table

@@ -0,0 +1,4 @@
+(fp_lib_table
+  (version 7)
+  (lib (name "Sensor")(type "KiCad")(uri "/home/empire/workspace/PlantCtrl/board/modules/Sensors/Sensors/Sensor.pretty")(options "")(descr ""))
+)

board/modules/Sensors_can/Sensors/production/netlist.ipc

@@ -0,0 +1,71 @@
+P  CODE 00
+P  UNITS CUST 0
+P  arrayDim   N
+317GND              VIA        MD0118PA00X+040551Y-024902X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+054232Y-022933X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+053346Y-021949X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+040846Y-019980X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+041043Y-025787X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+040059Y-019980X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+044291Y-025787X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+046654Y-025000X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+041240Y-021949X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+043307Y-020768X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+039961Y-022539X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+049606Y-021260X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+043898Y-024803X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+044587Y-023917X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+041142Y-024016X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+052461Y-022835X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+053642Y-024016X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+047835Y-026378X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+042618Y-020669X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+049409Y-022047X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+042520Y-022441X0236Y0000R000S3
+317GND              VIA        MD0118PA00X+048622Y-022835X0236Y0000R000S3
+327GND              R_slop-1          A01X+053967Y-020177X0315Y0374R180S2
+327NET-(U1-RS)      R_slop-2          A01X+053317Y-020177X0315Y0374R180S2
+3173_3V             U6    -1    D0394PA00X+039016Y-019370X0669Y0669R000S0
+317(U6-VBAT-PAD2)   U6    -2    D0394PA00X+039016Y-020370X0669Y0000R000S0
+317-(U6-SDA-PAD3)   U6    -3    D0394PA00X+039016Y-021370X0669Y0000R000S0
+317-(U6-SCL-PAD4)   U6    -4    D0394PA00X+039016Y-022370X0669Y0000R000S0
+317ENABLE_CAN       U6    -5    D0394PA00X+039016Y-023370X0669Y0000R000S0
+317CAN+             U6    -6    D0394PA00X+039016Y-024370X0669Y0000R000S0
+317CAN-             U6    -7    D0394PA00X+039016Y-025370X0669Y0000R000S0
+317GND              U6    -8    D0394PA00X+039016Y-026370X0669Y0000R000S0
+317GND              U6    -9    D0394PA00X+071260Y-034252X0669Y0669R000S0
+317GND              U6    -10   D0394PA00X+055512Y-031299X0669Y0669R000S0
+317GND              U6    -11   D0394PA00X+038780Y-034252X0669Y0669R000S0
+317GND              U6    -12   D0394PA00X+055512Y-020669X0669Y0669R000S0
+317GND              U6    -13   D0394PA00X+071260Y-019094X0669Y0669R000S0
+327NET-(QP_1-G)     QP_1  -1          A01X+047835Y-021280X0354Y0315R000S2
+3273_3V             QP_1  -2          A01X+047835Y-022028X0354Y0315R000S2
+327CAN_POWER        QP_1  -3          A01X+048622Y-021654X0354Y0315R000S2
+327CAN_POWER        R5    -1          A01X+047835Y-022904X0315Y0374R090S2
+327NET-(I1-A)       R5    -2          A01X+047835Y-023553X0315Y0374R090S2
+327NET-(QP_1-G)     R6    -1          A01X+046654Y-021329X0315Y0374R090S2
+3273_3V             R6    -2          A01X+046654Y-021978X0315Y0374R090S2
+327NET-(QP_1-G)     R7    -1          A01X+045669Y-021329X0315Y0374R090S2
+327NET-(Q1-D)       R7    -2          A01X+045669Y-021978X0315Y0374R090S2
+317CAN_POWER        J1    -1    D0374PA00X+055197Y-025394X0669Y0768R270S0
+317NET-(J1-PIN_2)   J1    -2    D0374PA00X+055197Y-024409X0669Y0768R270S0
+317NET-(J1-PIN_3)   J1    -3    D0374PA00X+055197Y-023425X0669Y0768R270S0
+317GND              J1    -4    D0374PA00X+055197Y-022441X0669Y0768R270S0
+327NET-(Q1-G)       Q1    -1          A01X+043819Y-021280X0354Y0315R000S2
+327GND              Q1    -2          A01X+043819Y-022028X0354Y0315R000S2
+327NET-(Q1-D)       Q1    -3          A01X+044606Y-021654X0354Y0315R000S2
+327CAN+             U1    -1          A01X+050295Y-020707X0768Y0236R000S2
+327GND              U1    -2          A01X+050295Y-021207X0768Y0236R000S2
+327CAN_POWER        U1    -3          A01X+050295Y-021707X0768Y0236R000S2
+327CAN-             U1    -4          A01X+050295Y-022207X0768Y0236R000S2
+327(U1-VREF-PAD5)   U1    -5          A01X+052244Y-022207X0768Y0236R000S2
+327NET-(J1-PIN_2)   U1    -6          A01X+052244Y-021707X0768Y0236R000S2
+327NET-(J1-PIN_3)   U1    -7          A01X+052244Y-021207X0768Y0236R000S2
+327NET-(U1-RS)      U1    -8          A01X+052244Y-020707X0768Y0236R000S2
+327NET-(Q1-G)       R8    -1          A01X+042520Y-021329X0315Y0374R090S2
+327GND              R8    -2          A01X+042520Y-021978X0315Y0374R090S2
+327GND              I1    -1          A01X+047835Y-025541X0384Y0551R270S2
+327NET-(I1-A)       I1    -2          A01X+047835Y-024803X0384Y0551R270S2
+327NET-(Q1-G)       R4    -1          A01X+040846Y-023346X0315Y0374R180S2
+327ENABLE_CAN       R4    -2          A01X+040197Y-023346X0315Y0374R180S2
+999

board/modules/Sensors_can/ch32-sensor/.doomrc

@@ -0,0 +1,32 @@
+;;; .doomrc --- doom runtime config -*- mode: emacs-lisp; lexical-binding: t; -*-
+;;; Commentary:
+;;; Code:
+(require 'doom) ; be silent, byte-compiler
+
+(after! dape
+        (add-to-list
+        'dape-configs
+        `(gdb-dap-openocd
+        ensure (lambda (config)
+                (dape-ensure-command config)
+                (let* ((default-directory
+                        (or (dape-config-get config 'command-cwd)
+                                default-directory))
+                        (command (dape-config-get config 'command))
+                        (output (shell-command-to-string (format "%s --version" command)))
+                        (version (save-match-data
+                                        (when (string-match "GNU gdb \\(?:(.*) \\)?\\([0-9.]+\\)" output)
+                                        (string-to-number (match-string 1 output))))))
+                        (unless (>= version 14.1)
+                        (user-error "Requires gdb version >= 14.1"))))
+        modes ()
+        command-cwd dape-command-cwd
+        command "gdb"
+        command-args ("--interpreter=dap")
+        :request nil
+        :program nil
+        :args []
+        :stopAtBeginningOfMainSubprogram nil))
+)
+
+;;; .doomrc ends here

board/modules/Sensors_can/ch32-sensor/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

board/modules/Sensors_can/ch32-sensor/.idea/ch32-sensor.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="EMPTY_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/target" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

bootloader/.gitignore

@@ -0,0 +1,10 @@
+# ESP-IDF build artifacts
+build/
+.sdkconfig*
+CMakeFiles/
+CMakeCache.txt
+cmake-build-*/
+*.log
+*.bin
+*.elf
+*.map

bootloader/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

bootloader/.idea/bootloader.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="EMPTY_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

bootloader/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/bootloader.iml" filepath="$PROJECT_DIR$/.idea/bootloader.iml" />
+    </modules>
+  </component>
+</project>

bootloader/.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/../website/themes/blowfish" vcs="Git" />
+  </component>
+</project>

bootloader/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.16)
+
+# Minimal ESP-IDF project to build only the bootloader
+# You must have ESP-IDF installed and IDF_PATH exported.
+
+# Pin the target to ESP32-C6 to ensure correct bootloader build
+# (must be set before including project.cmake)
+set(IDF_TARGET "esp32c6")
+
+include($ENV{IDF_PATH}/tools/cmake/project.cmake)
+project(custom_bootloader)

bootloader/README.md

@@ -0,0 +1,43 @@
+Custom ESP-IDF Bootloader (Rollback Enabled)
+
+This minimal project builds a custom ESP-IDF bootloader with rollback support enabled.
+You can flash it later alongside a Rust firmware using `espflash`.
+
+What this provides
+- A minimal ESP-IDF project (CMake) that can build just the bootloader.
+- Rollback support enabled via sdkconfig.defaults (CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y).
+- A sample OTA partition table (partitions.csv) suitable for OTA and rollback (otadata + two OTA slots).
+- A convenience script to build the bootloader for the desired target.
+
+Requirements
+- ESP-IDF installed and set up (IDF_PATH exported, Python env activated).
+- A selected target (esp32, esp32s3, esp32c3, etc.).
+
+Build
+1) Ensure ESP-IDF is set up:
+   source "$IDF_PATH/export.sh"
+
+2) Pick a target (examples):
+   idf.py set-target esp32
+   # or use the script:
+   ./build_bootloader.sh esp32
+
+3) Build only the bootloader:
+   idf.py bootloader
+   # or using the script (which also supports setting target):
+   ./build_bootloader.sh esp32
+
+Artifacts
+- build/bootloader/bootloader.bin
+
+Using with espflash (Rust)
+- For a no_std Rust firmware, you can pass this custom bootloader to espflash:
+  espflash flash --bootloader build/bootloader/bootloader.bin \
+                 --partition-table partitions.csv \
+                 <your-app-binary-or-elf>
+
+Notes
+- Rollback logic requires an OTA layout (otadata + at least two OTA app partitions). The provided partitions.csv is a starting point; adjust sizes/offsets to match your needs.
+- This project doesn’t build an application; it exists solely to produce a bootloader with the right configuration.
+- If you need different log verbosity or features, run `idf.py menuconfig` and then diff/port the changes back into sdkconfig.defaults.
+- Targets supported depend on your ESP-IDF version. Use `idf.py set-target <chip>` or `./build_bootloader.sh <chip>`.

bootloader/build_bootloader.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Build script for custom ESP-IDF bootloader with rollback enabled.
+# Requirements:
+#   - ESP-IDF installed
+#   - IDF_PATH exported
+#   - Python env prepared (the usual ESP-IDF setup)
+# Usage:
+#   ./build_bootloader.sh [esp32|esp32s3|esp32c3|esp32s2|esp32c2|esp32c6|esp32h2]
+#   If target is omitted, the last configured target will be used.
+
+TARGET=${1:-}
+
+if [[ -z "${IDF_PATH:-}" ]]; then
+  echo "ERROR: IDF_PATH is not set. Please install ESP-IDF and export the environment (source export.sh)." >&2
+  exit 1
+fi
+
+# shellcheck source=/dev/null
+source "$IDF_PATH/export.sh"
+
+if [[ -n "$TARGET" ]]; then
+  idf.py set-target "$TARGET"
+fi
+
+# Ensure sdkconfig.defaults is considered (ESP-IDF does this automatically).
+# Build only the bootloader.
+idf.py bootloader
+
+echo
+BOOTLOADER_BIN="build/bootloader/bootloader.bin"
+if [[ -f "$BOOTLOADER_BIN" ]]; then
+  echo "Bootloader built: $BOOTLOADER_BIN"
+  echo "You can use this with espflash via:"
+  echo "  espflash flash --bootloader $BOOTLOADER_BIN [--partition-table partitions.csv] <your-app-binary>"
+else
+  echo "ERROR: Bootloader binary not found. Check build logs above." >&2
+  exit 2
+fi
+cp build/bootloader/bootloader.bin ../rust/bootloader.bin

bootloader/main/CMakeLists.txt

@@ -0,0 +1 @@
+idf_component_register(SRCS "dummy.c" INCLUDE_DIRS ".")

bootloader/main/dummy.c

@@ -0,0 +1,4 @@
+// This file intentionally left almost empty.
+// ESP-IDF expects at least one component; the bootloader build does not use this.
+
+void __unused_dummy_symbol(void) {}

bootloader/partitions.csv

@@ -0,0 +1,6 @@
+nvs,      data, nvs,     ,        16k,
+otadata,  data, ota,     ,        8k,
+phy_init, data, phy,     ,        4k,
+ota_0,    app,  ota_0,   ,        3968k,
+ota_1,    app,  ota_1,   ,        3968k,
+storage,  data, littlefs,,        8M,

bootloader/sdkconfig.defaults

@@ -0,0 +1,17 @@
+# Target can be set with: idf.py set-target esp32|esp32s3|esp32c3|...
+# If not set via idf.py, ESP-IDF may default to a target; it's recommended to set it explicitly.
+
+# Explicitly pin target to ESP32-C6
+CONFIG_IDF_TARGET="esp32c6"
+CONFIG_IDF_TARGET_ESP32C6=y
+CONFIG_IDF_TARGET_ARCH_RISCV=y
+
+# Bootloader configuration
+CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE=y
+CONFIG_BOOTLOADER_LOG_LEVEL_INFO=y
+# Slightly faster boot by skipping GPIO checks unless you need that feature
+CONFIG_BOOTLOADER_SKIP_VALIDATE_IN_DEEP_SLEEP=y
+
+# Partition table config is not required to build bootloader, but shown for clarity when you build full app later
+# CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
+# CONFIG_PARTITION_TABLE_FILENAME="partitions.csv"

rust/.cargo/config.toml

@@ -10,7 +10,7 @@ rustflags = [
 target = "riscv32imac-unknown-none-elf"
 
 [target.riscv32imac-unknown-none-elf]
-runner = "espflash flash --monitor --chip esp32c6 --baud 921600 --partition-table partitions.csv"
+#runner = "espflash flash --monitor --bootloader bootloader.bin --chip esp32c6 --baud 921600 --partition-table partitions.csv"
 #runner = "espflash flash --monitor --baud 921600 --partition-table partitions.csv -b no-reset" # Select this runner in case of usb ttl
 #runner = "espflash flash --monitor"
 #runner = "cargo runner"

rust/Cargo.toml

@@ -1,4 +1,3 @@
-
 [package]
 edition = "2021"
 name = "plant-ctrl2"
@@ -14,19 +13,6 @@ test = false
 bench = false
 doc = false
 
-[package.metadata.cargo_runner]
-# The string `$TARGET_FILE` will be replaced with the path from cargo.
-command = [
-    "cargo",
-    "espflash",
-    "save-image",
-    "--chip",
-    "esp32c6",
-    "image.bin",
-    "--partition-table",
-    "partitions.csv"
-]
-
 #this strips the bootloader, we need that tho
 #strip = true
 
@@ -52,43 +38,79 @@ partition_table = "partitions.csv"
 
 [dependencies]
 #ESP stuff
-log = "0.4.28"
-esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32c6", "log-04"] }
-esp-hal = { version = "1.1.0", features = ["esp32c6", "log-04"] }
-esp-rtos = { version = "0.3.0", features = ["esp32c6", "embassy", "esp-radio"] }
-esp-backtrace = { version = "0.19.0", features = ["esp32c6", "panic-handler", "println", "colors", "custom-halt"] }
-esp-println = { version = "0.17.0", features = ["esp32c6", "log-04", "auto"] }
-esp-storage = { version = "0.9.0", features = ["esp32c6"] }
-esp-radio = { version = "0.18.0", features = ["esp32c6", "log-04", "wifi", "unstable"] }
-esp-alloc = { version = "0.10.0", features = ["esp32c6", "internal-heap-stats"] }
+esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32c6"] }
+esp-hal = { version = "=1.0.0-rc.0", features = [
+    "esp32c6",
+    "log-04",
+    "unstable",
+    "rt"
+] }
+log = "0.4.27"
 
-# Async runtime (Embassy core)
-embassy-executor = { version = "0.10.0", features = ["log", "nightly"] }
-embassy-time = { version = "0.5.1", features = ["log"], default-features = false }
-embassy-sync = { version = "0.8.0", features = ["log"] }
+embassy-net = { version = "0.7.1", default-features = false, features = [
+    "dhcpv4",
+    "log",
+    "medium-ethernet",
+    "tcp",
+    "udp",
+    "proto-ipv4",
+    "dns"
+] }
+embedded-io = "0.6.1"
+embedded-io-async = "0.6.1"
+esp-alloc = "0.8.0"
+esp-backtrace = { version = "0.17.0", features = [
+    "esp32c6",
+    "exception-handler",
+    "panic-handler",
+    "println",
+    "colors",
+    "custom-halt"
+] }
+esp-println = { version = "0.15.0", features = ["esp32c6", "log-04"] }
+# for more networking protocol support see https://crates.io/crates/edge-net
+embassy-executor = { version = "0.7.0", features = [
+    "log",
+    "task-arena-size-64",
+    "nightly"
+] }
+embassy-time = { version = "0.5.0", features = ["log"], default-features = false }
+esp-hal-embassy = { version = "0.9.0", features = ["esp32c6", "log-04"] }
+esp-storage = { version = "0.7.0", features = ["esp32c6"] }
 
-# Networking and protocol stacks
-embassy-net = { version = "0.8.0", features = ["dhcpv4", "log", "medium-ethernet", "tcp", "udp", "proto-ipv4", "dns", "proto-ipv6"] }
-sntpc = { version = "0.6.1", default-features = false, features = ["log", "embassy-socket", "embassy-socket-ipv6"] }
-edge-dhcp = "0.7.0"
-edge-nal = "0.6.0"
-edge-nal-embassy = "0.8.1"
-edge-http = { version = "0.7.0", features = ["log"] }
-
-esp32c6 = { version = "0.23.2" }
-
-# Hardware abstraction traits and HAL adapters
+esp-wifi = { version = "0.15.0", features = [
+    "builtin-scheduler",
+    "esp-alloc",
+    "esp32c6",
+    "log-04",
+    "smoltcp",
+    "wifi",
+] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+    "alloc",
+    "log",
+    "medium-ethernet",
+    "multicast",
+    "proto-dhcpv4",
+    "proto-ipv6",
+    "proto-dns",
+    "proto-ipv4",
+    "socket-dns",
+    "socket-icmp",
+    "socket-raw",
+    "socket-tcp",
+    "socket-udp",
+] }
+#static_cell = "2.1.1"
 embedded-hal = "1.0.0"
-embedded-storage = "0.3.1"
-embassy-embedded-hal = "0.6.0"
-nb = "1.1.0"
+embedded-hal-bus = { version = "0.3.0" }
 
 #Hardware additional driver
 
 #bq34z100 = { version = "0.3.0", default-features = false }
-lib-bms-protocol = { git = "https://gitea.wlandt.de/judge/ch32-bms.git", default-features = false }
 onewire = "0.4.0"
 #strum = { version = "0.27.0", default-feature = false, features = ["derive"] }
+measurements = "0.11.0"
 ds323x = "0.6.0"
 
 #json
@@ -103,23 +125,35 @@ strum_macros = "0.27.0"
 unit-enum = "1.4.1"
 pca9535 = { version = "2.0.0" }
 ina219 = { version = "0.2.0" }
+embedded-storage = "=0.3.1"
 portable-atomic = "1.11.1"
+embassy-sync = { version = "0.7.2", features = ["log"] }
 async-trait = "0.1.89"
 bq34z100 = { version = "0.4.0", default-features = false }
+edge-dhcp = "0.6.0"
+edge-nal = "0.5.0"
+edge-nal-embassy = "0.6.0"
 static_cell = "2.1.1"
+edge-http = { version = "0.6.1", features = ["log"] }
 littlefs2 = { version = "0.6.1", features = ["c-stubs", "alloc"] }
 littlefs2-core = "0.1.1"
 bytemuck = { version = "1.23.2", features = ["derive", "min_const_generics", "pod_saturating", "extern_crate_alloc"] }
 deranged = "0.5.3"
+embassy-embedded-hal = "0.5.0"
 bincode = { version = "2.0.1", default-features = false, features = ["derive"] }
+sntpc = { version = "0.6.0", default-features = false, features = ["log", "embassy-socket", "embassy-socket-ipv6"] }
 option-lock = { version = "0.3.1", default-features = false }
-measurements = "0.11.1"
+
+#stay in sync with mcutie version here!
 heapless = { version = "0.7.17", features = ["serde"] }
-mcutie = { path = "./src/mcutie_3_0_0/", default-features = false, features = ["log"] }
+mcutie = { version = "0.3.0", default-features = false, features = ["log", "homeassistant"] }
+nb = "1.1.0"
+embedded-can = "0.4.1"
 
 
 
 [patch.crates-io]
+mcutie = { git = 'https://github.com/empirephoenix/mcutie.git' }
 #bq34z100 = { path = "../../bq34z100_rust" }
 
 [build-dependencies]

rust/all.sh

@@ -0,0 +1,12 @@
+rm ./src/webserver/index.html.gz
+rm ./src/webserver/bundle.js.gz
+set -e
+cd ./src_webpack/
+npx webpack build
+cp index.html.gz ../src/webserver/index.html.gz
+cp bundle.js.gz ../src/webserver/bundle.js.gz
+cd ../
+
+cargo build --release
+espflash save-image --bootloader bootloader.bin --partition-table partitions.csv --chip esp32c6 target/riscv32imac-unknown-none-elf/release/plant-ctrl2 image.bin
+espflash flash --monitor --bootloader bootloader.bin --chip esp32c6 --baud 921600 --partition-table partitions.csv  target/riscv32imac-unknown-none-elf/release/plant-ctrl2

rust/build.rs

@@ -50,7 +50,7 @@ fn linker_be_nice() {
 }
 
 fn main() {
-    webpack();
+    //webpack();
     linker_be_nice();
     let _ = EmitBuilder::builder().all_git().all_build().emit();
 }

rust/flash.sh

@@ -0,0 +1,11 @@
+rm ./src/webserver/index.html.gz
+rm ./src/webserver/bundle.js.gz
+set -e
+cd ./src_webpack/
+npx webpack build
+cp index.html.gz ../src/webserver/index.html.gz
+cp bundle.js.gz ../src/webserver/bundle.js.gz
+cd ../
+
+cargo build --release
+espflash flash --monitor --bootloader bootloader.bin --chip esp32c6 --baud 921600 --partition-table partitions.csv  target/riscv32imac-unknown-none-elf/release/plant-ctrl2

rust/image_build.sh

@@ -0,0 +1,13 @@
+rm image.bin
+rm ./src/webserver/index.html.gz
+rm ./src/webserver/bundle.js.gz
+set -e
+cd ./src_webpack/
+npx webpack build
+cp index.html.gz ../src/webserver/index.html.gz
+cp bundle.js.gz ../src/webserver/bundle.js.gz
+cd ../
+
+set -e
+cargo build --release
+espflash save-image --bootloader bootloader.bin --partition-table partitions.csv --chip esp32c6 target/riscv32imac-unknown-none-elf/release/plant-ctrl2 image.bin

rust/src/fat_error.rs

@@ -6,9 +6,11 @@ use core::str::Utf8Error;
 use embassy_embedded_hal::shared_bus::I2cDeviceError;
 use embassy_executor::SpawnError;
 use embassy_sync::mutex::TryLockError;
+use embedded_storage::nor_flash::NorFlashErrorKind;
 use esp_hal::i2c::master::ConfigError;
 use esp_hal::pcnt::unit::{InvalidHighLimit, InvalidLowLimit};
-use esp_radio::wifi::WifiError;
+use esp_hal::twai::EspTwaiError;
+use esp_wifi::wifi::WifiError;
 use ina219::errors::{BusVoltageReadError, ShuntVoltageReadError};
 use littlefs2_core::PathError;
 use onewire::Error;
@@ -45,7 +47,6 @@ pub enum FatError {
     SpawnError {
         error: SpawnError,
     },
-    OTAError,
     PartitionError {
         error: esp_bootloader_esp_idf::partitions::Error,
     },
@@ -61,6 +62,9 @@ pub enum FatError {
     ExpanderError {
         error: String,
     },
+    CanBusError {
+        error: EspTwaiError,
+    },
     SNTPError {
         error: sntpc::Error,
     },
@@ -92,10 +96,10 @@ impl fmt::Display for FatError {
             FatError::DS323 { error } => write!(f, "DS323 {:?}", error),
             FatError::Eeprom24x { error } => write!(f, "Eeprom24x {:?}", error),
             FatError::ExpanderError { error } => write!(f, "ExpanderError {:?}", error),
-            FatError::SNTPError { error } => write!(f, "SNTPError {error:?}"),
-            FatError::OTAError => {
-                write!(f, "OTA missing partition")
+            FatError::CanBusError { error } => {
+                write!(f, "CanBusError {:?}", error)
             }
+            FatError::SNTPError { error } => write!(f, "SNTPError {:?}", error),
         }
     }
 }
@@ -135,24 +139,6 @@ impl<T> ContextExt<T> for Option<T> {
     }
 }
 
-impl<T, E> ContextExt<T> for Result<T, E>
-where
-    E: fmt::Debug,
-{
-    fn context<C>(self, context: C) -> Result<T, FatError>
-    where
-        C: AsRef<str>,
-    {
-        match self {
-            Ok(value) => Ok(value),
-            Err(err) => Err(FatError::String {
-                error: format!("{}: {:?}", context.as_ref(), err),
-            }),
-        }
-    }
-}
-
-
 impl From<Error<Infallible>> for FatError {
     fn from(error: Error<Infallible>) -> Self {
         FatError::OneWireError { error }
@@ -194,12 +180,6 @@ impl From<SpawnError> for FatError {
     }
 }
 
-impl From<sntpc::Error> for FatError {
-    fn from(value: sntpc::Error) -> Self {
-        FatError::SNTPError { error: value }
-    }
-}
-
 impl From<esp_bootloader_esp_idf::partitions::Error> for FatError {
     fn from(value: esp_bootloader_esp_idf::partitions::Error) -> Self {
         FatError::PartitionError { error: value }
@@ -312,10 +292,27 @@ impl From<InvalidHighLimit> for FatError {
     }
 }
 
-impl From<chrono::format::ParseError> for FatError {
-    fn from(value: chrono::format::ParseError) -> Self {
-        FatError::String {
-            error: format!("Parsing error: {value:?}"),
+impl From<nb::Error<EspTwaiError>> for FatError {
+    fn from(value: nb::Error<EspTwaiError>) -> Self {
+        match value {
+            nb::Error::Other(can_error) => FatError::CanBusError { error: can_error },
+            nb::Error::WouldBlock => FatError::String {
+                error: "Would block".to_string(),
+            },
         }
     }
 }
+
+impl From<NorFlashErrorKind> for FatError {
+    fn from(value: NorFlashErrorKind) -> Self {
+        FatError::String {
+            error: value.to_string(),
+        }
+    }
+}
+
+impl From<sntpc::Error> for FatError {
+    fn from(value: sntpc::Error) -> Self {
+        FatError::SNTPError { error: value }
+    }
+}

rust/src/hal/can_api.rs

@@ -0,0 +1,13 @@
+use crate::hal::Sensor;
+use bincode::{Decode, Encode};
+
+pub(crate) const SENSOR_BASE_ADDRESS: u16 = 1000;
+#[derive(Debug, Clone, Copy, Encode, Decode)]
+pub(crate) struct AutoDetectRequest {}
+
+#[derive(Debug, Clone, Copy, Encode, Decode)]
+pub(crate) struct ResponseMoisture {
+    pub plant: u8,
+    pub sensor: Sensor,
+    pub hz: u32,
+}

rust/src/hal/esp.rs

@@ -1,30 +1,29 @@
 use crate::bail;
 use crate::config::{NetworkConfig, PlantControllerConfig};
-use crate::hal::PLANT_COUNT;
-use crate::log::{log, LogMessage};
-use alloc::vec;
+use crate::hal::{get_current_slot_and_fix_ota_data, PLANT_COUNT, TIME_ACCESS};
+use crate::log::{LogMessage, LOG_ACCESS};
 use chrono::{DateTime, Utc};
-use esp_hal::Blocking;
-use esp_hal::uart::Uart;
 use serde::Serialize;
 
 use crate::fat_error::{ContextExt, FatError, FatResult};
 use crate::hal::little_fs2storage_adapter::LittleFs2Filesystem;
 use alloc::string::ToString;
 use alloc::sync::Arc;
-use alloc::{format, string::String, vec::Vec};
+use alloc::{format, string::String, vec, vec::Vec};
 use core::net::{IpAddr, Ipv4Addr, SocketAddr};
 use core::str::FromStr;
 use core::sync::atomic::Ordering;
 use embassy_executor::Spawner;
-use embassy_net::{DhcpConfig, IpAddress, Ipv4Cidr, Runner, Stack, StackResources, StaticConfigV4};
+use embassy_net::udp::UdpSocket;
+use embassy_net::{DhcpConfig, Ipv4Cidr, Runner, Stack, StackResources, StaticConfigV4};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::mutex::{Mutex, MutexGuard};
+use embassy_sync::once_lock::OnceLock;
 use embassy_time::{Duration, Timer, WithTimeout};
-use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash, RmwNorFlashStorage};
+use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash};
 use esp_bootloader_esp_idf::ota::OtaImageState::Valid;
-use esp_bootloader_esp_idf::ota::{Ota, OtaImageState};
-use esp_bootloader_esp_idf::partitions::{AppPartitionSubType, FlashRegion};
+use esp_bootloader_esp_idf::ota::{Ota, OtaImageState, Slot};
+use esp_bootloader_esp_idf::partitions::FlashRegion;
 use esp_hal::gpio::{Input, RtcPinWithResistors};
 use esp_hal::rng::Rng;
 use esp_hal::rtc_cntl::{
@@ -33,32 +32,39 @@ use esp_hal::rtc_cntl::{
 };
 use esp_hal::system::software_reset;
 use esp_println::println;
-use esp_radio::wifi::ap::{AccessPointConfig, AccessPointInfo};
-use esp_radio::wifi::scan::{ScanConfig, ScanTypeConfig};
-use esp_radio::wifi::sta::StationConfig;
-use esp_radio::wifi::{AuthenticationMethod, Config, Interface, WifiController};
 use esp_storage::FlashStorage;
+use esp_wifi::wifi::{
+    AccessPointConfiguration, AccessPointInfo, AuthMethod, ClientConfiguration, Configuration,
+    ScanConfig, ScanTypeConfig, WifiController, WifiDevice, WifiState,
+};
 use littlefs2::fs::Filesystem;
 use littlefs2_core::{FileType, PathBuf, SeekFrom};
-use log::{info, warn, error};
+use log::{info, warn};
+use mcutie::{
+    Error, McutieBuilder, McutieReceiver, McutieTask, MqttMessage, PublishDisplay, Publishable,
+    QoS, Topic,
+};
 use portable_atomic::AtomicBool;
+use smoltcp::socket::udp::PacketMetadata;
+use smoltcp::wire::DnsQueryType;
+use sntpc::{get_time, NtpContext, NtpTimestampGenerator};
 
-use super::shared_flash::MutexFlashStorage;
-use crate::network::{net_task, run_dhcp};
-
-#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
+#[esp_hal::ram(rtc_fast, persistent)]
 static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];
-#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
+#[esp_hal::ram(rtc_fast, persistent)]
 static mut CONSECUTIVE_WATERING_PLANT: [u32; PLANT_COUNT] = [0; PLANT_COUNT];
-#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
+#[esp_hal::ram(rtc_fast, persistent)]
 static mut LOW_VOLTAGE_DETECTED: i8 = 0;
-#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
+#[esp_hal::ram(rtc_fast, persistent)]
 static mut RESTART_TO_CONF: i8 = 0;
-#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
-static mut LAST_CORROSION_PROTECTION_CHECK_DAY: i8 = -1;
-
 
 const CONFIG_FILE: &str = "config.json";
+const NTP_SERVER: &str = "pool.ntp.org";
+
+static MQTT_CONNECTED_EVENT_RECEIVED: AtomicBool = AtomicBool::new(false);
+static MQTT_ROUND_TRIP_RECEIVED: AtomicBool = AtomicBool::new(false);
+pub static MQTT_STAY_ALIVE: AtomicBool = AtomicBool::new(false);
+static MQTT_BASE_TOPIC: OnceLock<String> = OnceLock::new();
 
 #[derive(Serialize, Debug)]
 pub struct FileInfo {
@@ -73,6 +79,11 @@ pub struct FileList {
     files: Vec<FileInfo>,
 }
 
+#[derive(Copy, Clone, Default)]
+struct Timestamp {
+    stamp: DateTime<Utc>,
+}
+
 // Minimal esp-idf equivalent for gpio_hold on esp32c6 via ROM functions
 extern "C" {
     fn gpio_pad_hold(gpio_num: u32);
@@ -89,25 +100,36 @@ pub fn hold_disable(gpio_num: u8) {
     unsafe { gpio_pad_unhold(gpio_num as u32) }
 }
 
+impl NtpTimestampGenerator for Timestamp {
+    fn init(&mut self) {
+        self.stamp = DateTime::default();
+    }
+
+    fn timestamp_sec(&self) -> u64 {
+        self.stamp.timestamp() as u64
+    }
+
+    fn timestamp_subsec_micros(&self) -> u32 {
+        self.stamp.timestamp_subsec_micros()
+    }
+}
+
 pub struct Esp<'a> {
     pub fs: Arc<Mutex<CriticalSectionRawMutex, Filesystem<'static, LittleFs2Filesystem>>>,
     pub rng: Rng,
     //first starter (ap or sta will take these)
-    pub interface_sta: Option<Interface<'static>>,
-    pub interface_ap: Option<Interface<'static>>,
+    pub interface_sta: Option<WifiDevice<'static>>,
+    pub interface_ap: Option<WifiDevice<'static>>,
     pub controller: Arc<Mutex<CriticalSectionRawMutex, WifiController<'static>>>,
 
     pub boot_button: Input<'a>,
 
     // RTC-capable GPIO used as external wake source (store the raw peripheral)
     pub wake_gpio1: esp_hal::peripherals::GPIO1<'static>,
-    pub uart0: Uart<'a, Blocking>,
 
-    pub rtc: Rtc<'a>,
-
-    pub ota: Ota<'static, RmwNorFlashStorage<'static, &'static mut MutexFlashStorage>>,
-    pub ota_target: &'static mut FlashRegion<'static, MutexFlashStorage>,
-    pub current: AppPartitionSubType,
+    pub ota: Ota<'static, FlashStorage>,
+    pub ota_target: &'static mut FlashRegion<'static, FlashStorage>,
+    pub current: Slot,
     pub slot0_state: OtaImageState,
     pub slot1_state: OtaImageState,
 }
@@ -120,48 +142,16 @@ pub struct Esp<'a> {
 // CPU cores/threads, reconsider this.
 unsafe impl Send for Esp<'_> {}
 
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
+
 impl Esp<'_> {
-    pub fn get_time(&self) -> DateTime<Utc> {
-        DateTime::from_timestamp_micros(self.rtc.current_time_us() as i64)
-            .unwrap_or(DateTime::UNIX_EPOCH)
-    }
-
-    pub fn set_time(&mut self, time: DateTime<Utc>) {
-        self.rtc.set_current_time_us(time.timestamp_micros() as u64);
-    }
-
-    pub(crate) async fn read_serial_line(&mut self) -> FatResult<Option<alloc::string::String>> {
-        let mut buf = [0u8; 1];
-        let mut line = String::new();
-        loop {
-            match self.uart0.read_buffered(&mut buf) {
-                Ok(read) => {
-                    if read == 0 {
-                        return Ok(None);
-                    }
-                    let c = buf[0] as char;
-                    if c == '\n' {
-                        return Ok(Some(line));
-                    }
-                    line.push(c);
-                }
-                Err(error) => {
-                    if line.is_empty() {
-                        return Ok(None);
-                    } else {
-                        error!("Error reading serial line: {error:?}");
-                        // If we already have some data, we should probably wait a bit or just return what we have?
-                        // But the protocol expects a full line or message.
-                        // For simplicity in config mode, we can block here or just return None if nothing is there yet.
-                        // However, if we started receiving, we should probably finish or timeout.
-                        continue;
-                    }
-                }
-            }
-        }
-    }
-
-
     pub(crate) async fn delete_file(&self, filename: String) -> FatResult<()> {
         let file = PathBuf::try_from(filename.as_str())?;
         let access = self.fs.lock().await;
@@ -228,7 +218,6 @@ impl Esp<'_> {
 
     pub(crate) async fn write_ota(&mut self, offset: u32, buf: &[u8]) -> Result<(), FatError> {
         let _ = check_erase(self.ota_target, offset, offset + 4096);
-        info!("erasing and writing block 0x{offset:x}");
         self.ota_target.erase(offset, offset + 4096)?;
 
         let mut temp = vec![0; buf.len()];
@@ -237,7 +226,7 @@ impl Esp<'_> {
         self.ota_target.write(offset, buf)?;
         self.ota_target.read(offset, read_back)?;
         if buf != read_back {
-            info!("Expected {buf:?} but got {read_back:?}");
+            info!("Expected {:?} but got {:?}", buf, read_back);
             bail!(
                 "Flash error, read back does not match write buffer at offset {:x}",
                 offset
@@ -247,49 +236,103 @@ impl Esp<'_> {
     }
 
     pub(crate) async fn finalize_ota(&mut self) -> Result<(), FatError> {
-        let current = self.ota.current_app_partition()?;
-        if self.ota.current_ota_state()? != Valid {
-            info!("Validating current slot {current:?} as it was able to ota");
+        let current = self.ota.current_slot()?;
+        if self.ota.current_ota_state()? != OtaImageState::Valid {
+            info!(
+                "Validating current slot {:?} as it was able to ota",
+                current
+            );
             self.ota.set_current_ota_state(Valid)?;
         }
-        let next = match current {
-            AppPartitionSubType::Ota0 => AppPartitionSubType::Ota1,
-            AppPartitionSubType::Ota1 => AppPartitionSubType::Ota0,
-            _ => {
-                bail!("Invalid current slot {current:?} for ota");
-            }
-        };
-        self.ota.set_current_app_partition(next)?;
+
+        self.ota.set_current_slot(current.next())?;
         info!("switched slot");
         self.ota.set_current_ota_state(OtaImageState::New)?;
         info!("switched state for new partition");
         let state_new = self.ota.current_ota_state()?;
-        info!("state on new partition now {state_new:?}");
+        info!("state on new partition now {:?}", state_new);
+        //determine nextslot crc
+
         self.set_restart_to_conf(true);
         Ok(())
     }
 
-    // let current = ota.current_slot()?;
-    // println!(
-    //     "current image state {:?} (only relevant if the bootloader was built with auto-rollback support)",
-    //     ota.current_ota_state()
-    // );
-    // println!("current {:?} - next {:?}", current, current.next());
-    // let ota_state = ota.current_ota_state()?;
-
     pub(crate) fn mode_override_pressed(&mut self) -> bool {
         self.boot_button.is_low()
     }
 
+    pub(crate) async fn sntp(
+        &mut self,
+        _max_wait_ms: u32,
+        stack: Stack<'_>,
+    ) -> FatResult<DateTime<Utc>> {
+        println!("start sntp");
+        let mut rx_meta = [PacketMetadata::EMPTY; 16];
+        let mut rx_buffer = [0; 4096];
+        let mut tx_meta = [PacketMetadata::EMPTY; 16];
+        let mut tx_buffer = [0; 4096];
+
+        let mut socket = UdpSocket::new(
+            stack,
+            &mut rx_meta,
+            &mut rx_buffer,
+            &mut tx_meta,
+            &mut tx_buffer,
+        );
+        socket.bind(123).unwrap();
+
+        let context = NtpContext::new(Timestamp::default());
+
+        let ntp_addrs = stack
+            .dns_query(NTP_SERVER, DnsQueryType::A)
+            .await
+            .expect("Failed to resolve DNS");
+        if ntp_addrs.is_empty() {
+            bail!("Failed to resolve DNS");
+        }
+        info!("NTP server: {:?}", ntp_addrs);
+
+        let mut counter = 0;
+        loop {
+            let addr: IpAddr = ntp_addrs[0].into();
+            let timeout = get_time(SocketAddr::from((addr, 123)), &socket, context)
+                .with_timeout(Duration::from_millis((_max_wait_ms / 10) as u64))
+                .await;
+
+            match timeout {
+                Ok(result) => {
+                    let time = result?;
+                    info!("Time: {:?}", time);
+                    return DateTime::from_timestamp(time.seconds as i64, 0)
+                        .context("Could not convert Sntp result");
+                }
+                Err(err) => {
+                    warn!("sntp timeout, retry: {:?}", err);
+                    counter += 1;
+                    if counter > 10 {
+                        bail!("Failed to get time from NTP server");
+                    }
+                    Timer::after(Duration::from_millis(100)).await;
+                }
+            }
+        }
+    }
+
     pub(crate) async fn wifi_scan(&mut self) -> FatResult<Vec<AccessPointInfo>> {
         info!("start wifi scan");
         let mut lock = self.controller.try_lock()?;
         info!("start wifi scan lock");
-        let scan_config = ScanConfig::default().with_scan_type(ScanTypeConfig::Active {
-            min: esp_hal::time::Duration::from_millis(0),
-            max: esp_hal::time::Duration::from_millis(0),
-        });
-        let rv = lock.scan_async(&scan_config).await?;
+        let scan_config = ScanConfig {
+            ssid: None,
+            bssid: None,
+            channel: None,
+            show_hidden: false,
+            scan_type: ScanTypeConfig::Active {
+                min: Default::default(),
+                max: Default::default(),
+            },
+        };
+        let rv = lock.scan_with_config_async(scan_config).await?;
         info!("end wifi scan lock");
         Ok(rv)
     }
@@ -338,32 +381,235 @@ impl Esp<'_> {
         }
     }
 
-    pub fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
+    pub(crate) async fn wifi_ap(&mut self) -> FatResult<Stack<'static>> {
+        let ssid = match self.load_config().await {
+            Ok(config) => config.network.ap_ssid.as_str().to_string(),
+            Err(_) => "PlantCtrl Emergency Mode".to_string(),
+        };
+
+        let spawner = Spawner::for_current_executor().await;
+
+        let device = self.interface_ap.take().unwrap();
+        let gw_ip_addr_str = "192.168.71.1";
+        let gw_ip_addr = Ipv4Addr::from_str(gw_ip_addr_str).expect("failed to parse gateway ip");
+
+        let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
+            address: Ipv4Cidr::new(gw_ip_addr, 24),
+            gateway: Some(gw_ip_addr),
+            dns_servers: Default::default(),
+        });
+
+        let seed = (self.rng.random() as u64) << 32 | self.rng.random() as u64;
+
+        println!("init secondary stack");
+        // Init network stack
+        let (stack, runner) = embassy_net::new(
+            device,
+            config,
+            mk_static!(StackResources<4>, StackResources::<4>::new()),
+            seed,
+        );
+        let stack = mk_static!(Stack, stack);
+
+        let client_config = Configuration::AccessPoint(AccessPointConfiguration {
+            ssid: ssid.clone(),
+            ..Default::default()
+        });
+
+        self.controller
+            .lock()
+            .await
+            .set_configuration(&client_config)?;
+
+        println!("start new");
+        self.controller.lock().await.start()?;
+        println!("start net task");
+        spawner.spawn(net_task(runner)).ok();
+        println!("run dhcp");
+        spawner.spawn(run_dhcp(stack.clone(), gw_ip_addr_str)).ok();
+
+        loop {
+            if stack.is_link_up() {
+                break;
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        while !stack.is_config_up() {
+            Timer::after(Duration::from_millis(100)).await
+        }
+        println!("Connect to the AP `${ssid}` and point your browser to http://{gw_ip_addr_str}/");
+        stack
+            .config_v4()
+            .inspect(|c| println!("ipv4 config: {c:?}"));
+
+        Ok(stack.clone())
+    }
+
+    pub(crate) async fn wifi(
+        &mut self,
+        network_config: &NetworkConfig,
+    ) -> FatResult<Stack<'static>> {
+        esp_wifi::wifi_set_log_verbose();
+        let ssid = network_config.ssid.clone();
+        match &ssid {
+            Some(ssid) => {
+                if ssid.is_empty() {
+                    bail!("Wifi ssid was empty")
+                }
+            }
+            None => {
+                bail!("Wifi ssid was empty")
+            }
+        }
+        let ssid = ssid.unwrap().to_string();
+        info!("attempting to connect wifi {ssid}");
+        let password = match network_config.password {
+            Some(ref password) => password.to_string(),
+            None => "".to_string(),
+        };
+        let max_wait = network_config.max_wait;
+
+        let spawner = Spawner::for_current_executor().await;
+
+        let device = self.interface_sta.take().unwrap();
+        let config = embassy_net::Config::dhcpv4(DhcpConfig::default());
+
+        let seed = (self.rng.random() as u64) << 32 | self.rng.random() as u64;
+
+        // Init network stack
+        let (stack, runner) = embassy_net::new(
+            device,
+            config,
+            mk_static!(StackResources<8>, StackResources::<8>::new()),
+            seed,
+        );
+        let stack = mk_static!(Stack, stack);
+
+        let client_config = Configuration::Client(ClientConfiguration {
+            ssid,
+            bssid: None,
+            auth_method: AuthMethod::WPA2Personal, //FIXME read from config, fill via scan
+            password,
+            channel: None,
+        });
+        self.controller
+            .lock()
+            .await
+            .set_configuration(&client_config)?;
+        spawner.spawn(net_task(runner)).ok();
+        self.controller.lock().await.start_async().await?;
+
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        loop {
+            let state = esp_wifi::wifi::sta_state();
+            match state {
+                WifiState::StaStarted => {
+                    self.controller.lock().await.connect()?;
+                    break;
+                }
+                _ => {}
+            }
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi sta ready")
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        loop {
+            let state = esp_wifi::wifi::sta_state();
+            match state {
+                WifiState::StaConnected => {
+                    break;
+                }
+                _ => {}
+            }
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi sta connected")
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        while !stack.is_link_up() {
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi link up")
+            }
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + max_wait as u64 * 1000;
+        while !stack.is_config_up() {
+            if {
+                let guard = TIME_ACCESS.get().await.lock().await;
+                guard.current_time_us()
+            } > timeout
+            {
+                bail!("Timeout waiting for wifi config up")
+            }
+            Timer::after(Duration::from_millis(100)).await
+        }
+
+        info!("Connected WIFI, dhcp: {:?}", stack.config_v4());
+        Ok(stack.clone())
+    }
+
+    pub fn deep_sleep(
+        &mut self,
+        duration_in_ms: u64,
+        mut rtc: MutexGuard<CriticalSectionRawMutex, Rtc>,
+    ) -> ! {
+        // Configure and enter deep sleep using esp-hal. Also keep prior behavior where
+        // duration_in_ms == 0 triggers an immediate reset.
+
         // Mark the current OTA image as valid if we reached here while in pending verify.
         if let Ok(cur) = self.ota.current_ota_state() {
             if cur == OtaImageState::PendingVerify {
-                info!("Marking OTA image as valid");
-                if let Err(err) = self.ota.set_current_ota_state(Valid) {
-                    error!("Could not set image to valid: {:?}", err);
-                }
+                self.ota
+                    .set_current_ota_state(OtaImageState::Valid)
+                    .expect("Could not set image to valid");
             }
-        } else {
-            info!("No OTA image to mark as valid");
         }
 
         if duration_in_ms == 0 {
             software_reset();
         } else {
-            let timer = TimerWakeupSource::new(core::time::Duration::from_millis(duration_in_ms));
+            ///let timer = TimerWakeupSource::new(core::time::Duration::from_millis(duration_in_ms));
+            let timer = TimerWakeupSource::new(core::time::Duration::from_millis(5000));
             let mut wake_pins: [(&mut dyn RtcPinWithResistors, WakeupLevel); 1] =
                 [(&mut self.wake_gpio1, WakeupLevel::Low)];
             let ext1 = esp_hal::rtc_cntl::sleep::Ext1WakeupSource::new(&mut wake_pins);
-            self.rtc.sleep_deep(&[&timer, &ext1]);
+            rtc.sleep_deep(&[&timer, &ext1]);
         }
     }
 
     pub(crate) async fn load_config(&mut self) -> FatResult<PlantControllerConfig> {
-        let cfg = PathBuf::try_from(CONFIG_FILE).unwrap();
+        let cfg = PathBuf::try_from(CONFIG_FILE)?;
+        let config_exist = self.fs.lock().await.exists(&cfg);
+        if !config_exist {
+            bail!("No config file stored")
+        }
         let data = self.fs.lock().await.read::<4096>(&cfg)?;
         let config: PlantControllerConfig = serde_json::from_slice(&data)?;
         return Ok(config);
@@ -417,39 +663,333 @@ impl Esp<'_> {
                 } else {
                     RESTART_TO_CONF = 0;
                 }
-                LAST_CORROSION_PROTECTION_CHECK_DAY = -1;
             };
         } else {
             unsafe {
                 if to_config_mode {
                     RESTART_TO_CONF = 1;
                 }
-                log(
-                    LogMessage::RestartToConfig,
-                    RESTART_TO_CONF as u32,
-                    0,
-                    "",
-                    "",
-                );
-                log(
-                    LogMessage::LowVoltage,
-                    LOW_VOLTAGE_DETECTED as u32,
-                    0,
-                    "",
-                    "",
-                );
-                // is executed before main, no other code will alter these values during printing
-                #[allow(static_mut_refs)]
-                for (i, time) in LAST_WATERING_TIMESTAMP.iter().enumerate() {
-                    info!("LAST_WATERING_TIMESTAMP[{i}] = UTC {time}");
+                LOG_ACCESS
+                    .lock()
+                    .await
+                    .log(
+                        LogMessage::RestartToConfig,
+                        RESTART_TO_CONF as u32,
+                        0,
+                        "",
+                        "",
+                    )
+                    .await;
+                LOG_ACCESS
+                    .lock()
+                    .await
+                    .log(
+                        LogMessage::LowVoltage,
+                        LOW_VOLTAGE_DETECTED as u32,
+                        0,
+                        "",
+                        "",
+                    )
+                    .await;
+                for i in 0..PLANT_COUNT {
+                    log::info!(
+                        "LAST_WATERING_TIMESTAMP[{}] = UTC {}",
+                        i,
+                        LAST_WATERING_TIMESTAMP[i]
+                    );
                 }
-                // is executed before main, no other code will alter these values during printing
-                #[allow(static_mut_refs)]
-                for (i, item) in CONSECUTIVE_WATERING_PLANT.iter().enumerate() {
-                    info!("CONSECUTIVE_WATERING_PLANT[{i}] = {item}");
+                for i in 0..PLANT_COUNT {
+                    log::info!(
+                        "CONSECUTIVE_WATERING_PLANT[{}] = {}",
+                        i,
+                        CONSECUTIVE_WATERING_PLANT[i]
+                    );
                 }
             }
         }
     }
 
+    pub(crate) async fn mqtt(
+        &mut self,
+        network_config: &'static NetworkConfig,
+        stack: Stack<'static>,
+    ) -> FatResult<()> {
+        let base_topic = network_config
+            .base_topic
+            .as_ref()
+            .context("missing base topic")?;
+        if base_topic.is_empty() {
+            bail!("Mqtt base_topic was empty")
+        }
+        MQTT_BASE_TOPIC
+            .init(base_topic.to_string())
+            .map_err(|_| FatError::String {
+                error: "Error setting basetopic".to_string(),
+            })?;
+
+        let mqtt_url = network_config
+            .mqtt_url
+            .as_ref()
+            .context("missing mqtt url")?;
+        if mqtt_url.is_empty() {
+            bail!("Mqtt url was empty")
+        }
+
+        let last_will_topic = format!("{}/state", base_topic);
+        let round_trip_topic = format!("{}/internal/roundtrip", base_topic);
+        let stay_alive_topic = format!("{}/stay_alive", base_topic);
+
+        let mut builder: McutieBuilder<'_, String, PublishDisplay<String, &str>, 0> =
+            McutieBuilder::new(stack, "plant ctrl", mqtt_url);
+        if network_config.mqtt_user.is_some() && network_config.mqtt_password.is_some() {
+            builder = builder.with_authentication(
+                network_config.mqtt_user.as_ref().unwrap().as_str(),
+                network_config.mqtt_password.as_ref().unwrap().as_str(),
+            );
+            info!("With authentification");
+        }
+
+        let lwt = Topic::General(last_will_topic);
+        let lwt = mk_static!(Topic<String>, lwt);
+        let lwt = lwt.with_display("lost").retain(true).qos(QoS::AtLeastOnce);
+        builder = builder.with_last_will(lwt);
+        //TODO make configurable
+        builder = builder.with_device_id("plantctrl");
+
+        let builder: McutieBuilder<'_, String, PublishDisplay<String, &str>, 2> = builder
+            .with_subscriptions([
+                Topic::General(round_trip_topic.clone()),
+                Topic::General(stay_alive_topic.clone()),
+            ]);
+
+        let keep_alive = Duration::from_secs(60 * 60 * 2).as_secs() as u16;
+        let (receiver, task) = builder.build(keep_alive);
+
+        let spawner = Spawner::for_current_executor().await;
+        spawner.spawn(mqtt_incoming_task(
+            receiver,
+            round_trip_topic.clone(),
+            stay_alive_topic.clone(),
+        ))?;
+        spawner.spawn(mqtt_runner(task))?;
+
+        LOG_ACCESS
+            .lock()
+            .await
+            .log(LogMessage::StayAlive, 0, 0, "", &stay_alive_topic)
+            .await;
+
+        LOG_ACCESS
+            .lock()
+            .await
+            .log(LogMessage::MqttInfo, 0, 0, "", mqtt_url)
+            .await;
+
+        let mqtt_timeout = 15000;
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + mqtt_timeout as u64 * 1000;
+        while !MQTT_CONNECTED_EVENT_RECEIVED.load(Ordering::Relaxed) {
+            let cur = TIME_ACCESS.get().await.lock().await.current_time_us();
+            if cur > timeout {
+                bail!("Timeout waiting MQTT connect event")
+            }
+            Timer::after(Duration::from_millis(100)).await;
+        }
+
+        Topic::General(round_trip_topic.clone())
+            .with_display("online_text")
+            .publish()
+            .await
+            .unwrap();
+
+        let timeout = {
+            let guard = TIME_ACCESS.get().await.lock().await;
+            guard.current_time_us()
+        } + mqtt_timeout as u64 * 1000;
+        while !MQTT_ROUND_TRIP_RECEIVED.load(Ordering::Relaxed) {
+            let cur = TIME_ACCESS.get().await.lock().await.current_time_us();
+            if cur > timeout {
+                //ensure we do not further try to publish
+                MQTT_CONNECTED_EVENT_RECEIVED.store(false, Ordering::Relaxed);
+                bail!("Timeout waiting MQTT roundtrip")
+            }
+            Timer::after(Duration::from_millis(100)).await;
+        }
+        Ok(())
+    }
+
+    pub(crate) async fn mqtt_inner(&mut self, subtopic: &str, message: &str) -> FatResult<()> {
+        if !subtopic.starts_with("/") {
+            bail!("Subtopic without / at start {}", subtopic);
+        }
+        if subtopic.len() > 192 {
+            bail!("Subtopic exceeds 192 chars {}", subtopic);
+        }
+        let base_topic = MQTT_BASE_TOPIC
+            .try_get()
+            .context("missing base topic in static!")?;
+
+        let full_topic = format!("{base_topic}{subtopic}");
+
+        loop {
+            let result = Topic::General(full_topic.as_str())
+                .with_display(message)
+                .retain(true)
+                .publish()
+                .await;
+            match result {
+                Ok(()) => return Ok(()),
+                Err(err) => {
+                    let retry = match err {
+                        Error::IOError => false,
+                        Error::TimedOut => true,
+                        Error::TooLarge => false,
+                        Error::PacketError => false,
+                        Error::Invalid => false,
+                    };
+                    if !retry {
+                        bail!(
+                            "Error during mqtt send on topic {} with message {:#?} error is {:?}",
+                            &full_topic,
+                            message,
+                            err
+                        );
+                    }
+                    info!(
+                        "Retransmit for {} with message {:#?} error is {:?} retrying {}",
+                        &full_topic, message, err, retry
+                    );
+                    Timer::after(Duration::from_millis(100)).await;
+                }
+            }
+        }
+    }
+    pub(crate) async fn mqtt_publish(&mut self, subtopic: &str, message: &str) {
+        let online = MQTT_CONNECTED_EVENT_RECEIVED.load(Ordering::Relaxed);
+        if !online {
+            return;
+        }
+        let roundtrip_ok = MQTT_ROUND_TRIP_RECEIVED.load(Ordering::Relaxed);
+        if !roundtrip_ok {
+            info!("MQTT roundtrip not received yet, dropping message");
+            return;
+        }
+        match self.mqtt_inner(subtopic, message).await {
+            Ok(()) => {}
+            Err(err) => {
+                info!(
+                    "Error during mqtt send on topic {} with message {:#?} error is {:?}",
+                    subtopic, message, err
+                );
+            }
+        };
+    }
+}
+
+#[embassy_executor::task]
+async fn mqtt_runner(
+    task: McutieTask<'static, String, PublishDisplay<'static, String, &'static str>, 2>,
+) {
+    task.run().await;
+}
+
+#[embassy_executor::task]
+async fn mqtt_incoming_task(
+    receiver: McutieReceiver,
+    round_trip_topic: String,
+    stay_alive_topic: String,
+) {
+    loop {
+        let message = receiver.receive().await;
+        match message {
+            MqttMessage::Connected => {
+                info!("Mqtt connected");
+                MQTT_CONNECTED_EVENT_RECEIVED.store(true, Ordering::Relaxed);
+            }
+            MqttMessage::Publish(topic, payload) => match topic {
+                Topic::DeviceType(_type_topic) => {}
+                Topic::Device(_device_topic) => {}
+                Topic::General(topic) => {
+                    let subtopic = topic.as_str();
+
+                    if subtopic.eq(round_trip_topic.as_str()) {
+                        MQTT_ROUND_TRIP_RECEIVED.store(true, Ordering::Relaxed);
+                    } else if subtopic.eq(stay_alive_topic.as_str()) {
+                        let value = payload.eq_ignore_ascii_case("true".as_ref())
+                            || payload.eq_ignore_ascii_case("1".as_ref());
+                        let a = match value {
+                            true => 1,
+                            false => 0,
+                        };
+                        LOG_ACCESS
+                            .lock()
+                            .await
+                            .log(LogMessage::MqttStayAliveRec, a, 0, "", "")
+                            .await;
+                        MQTT_STAY_ALIVE.store(value, Ordering::Relaxed);
+                    } else {
+                        LOG_ACCESS
+                            .lock()
+                            .await
+                            .log(LogMessage::UnknownTopic, 0, 0, "", &*topic)
+                            .await;
+                    }
+                }
+            },
+            MqttMessage::Disconnected => {
+                MQTT_CONNECTED_EVENT_RECEIVED.store(false, Ordering::Relaxed);
+                info!("Mqtt disconnected");
+            }
+            MqttMessage::HomeAssistantOnline => {
+                info!("Home assistant is online");
+            }
+        }
+    }
+}
+
+#[embassy_executor::task(pool_size = 2)]
+async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
+    runner.run().await;
+}
+
+#[embassy_executor::task]
+async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
+    use core::net::{Ipv4Addr, SocketAddrV4};
+
+    use edge_dhcp::{
+        io::{self, DEFAULT_SERVER_PORT},
+        server::{Server, ServerOptions},
+    };
+    use edge_nal::UdpBind;
+    use edge_nal_embassy::{Udp, UdpBuffers};
+
+    let ip = Ipv4Addr::from_str(gw_ip_addr).expect("dhcp task failed to parse gw ip");
+
+    let mut buf = [0u8; 1500];
+
+    let mut gw_buf = [Ipv4Addr::UNSPECIFIED];
+
+    let buffers = UdpBuffers::<3, 1024, 1024, 10>::new();
+    let unbound_socket = Udp::new(stack, &buffers);
+    let mut bound_socket = unbound_socket
+        .bind(SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::UNSPECIFIED,
+            DEFAULT_SERVER_PORT,
+        )))
+        .await
+        .unwrap();
+
+    loop {
+        _ = io::server::run(
+            &mut Server::<_, 64>::new_with_et(ip),
+            &ServerOptions::new(ip, Some(&mut gw_buf)),
+            &mut bound_socket,
+            &mut buf,
+        )
+        .await
+        .inspect_err(|e| log::warn!("DHCP server error: {e:?}"));
+        Timer::after(Duration::from_millis(500)).await;
+    }
 }

rust/src/hal/initial_hal.rs

@@ -3,14 +3,14 @@ use crate::fat_error::{FatError, FatResult};
 use crate::hal::esp::Esp;
 use crate::hal::rtc::{BackupHeader, RTCModuleInteraction};
 use crate::hal::water::TankSensor;
-use crate::hal::{BoardInteraction, FreePeripherals, Sensor};
+use crate::hal::{BoardInteraction, FreePeripherals, Sensor, TIME_ACCESS};
 use crate::{
     bail,
     config::PlantControllerConfig,
     hal::battery::{BatteryInteraction, NoBatteryMonitor},
 };
 use async_trait::async_trait;
-use chrono::{DateTime, FixedOffset, Utc};
+use chrono::{DateTime, Utc};
 use esp_hal::gpio::{Level, Output, OutputConfig};
 use measurements::{Current, Voltage};
 
@@ -90,22 +90,13 @@ impl<'a> BoardInteraction<'a> for Initial<'a> {
         &mut self.rtc
     }
 
-    async fn get_time(&mut self) -> DateTime<Utc> {
-        self.esp.get_time()
-    }
-
-    async fn set_time(&mut self, time: &DateTime<FixedOffset>) -> FatResult<()> {
-        self.rtc.set_rtc_time(&time.to_utc()).await?;
-        self.esp.set_time(time.to_utc());
-        Ok(())
-    }
-
     async fn set_charge_indicator(&mut self, _charging: bool) -> Result<(), FatError> {
         bail!("Please configure board revision")
     }
 
-    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
-        self.esp.deep_sleep_ms(duration_in_ms);
+    async fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+        let rtc = TIME_ACCESS.get().await.lock().await;
+        self.esp.deep_sleep(duration_in_ms, rtc);
     }
     fn is_day(&self) -> bool {
         false

rust/src/hal/little_fs2storage_adapter.rs

@@ -1,6 +1,6 @@
-use crate::hal::shared_flash::MutexFlashStorage;
 use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash};
 use esp_bootloader_esp_idf::partitions::FlashRegion;
+use esp_storage::FlashStorage;
 use littlefs2::consts::U4096 as lfsCache;
 use littlefs2::consts::U512 as lfsLookahead;
 use littlefs2::driver::Storage as lfs2Storage;
@@ -9,7 +9,7 @@ use littlefs2::io::Result as lfs2Result;
 use log::error;
 
 pub struct LittleFs2Filesystem {
-    pub(crate) storage: &'static mut FlashRegion<'static, MutexFlashStorage>,
+    pub(crate) storage: &'static mut FlashRegion<'static, FlashStorage>,
 }
 
 impl lfs2Storage for LittleFs2Filesystem {
@@ -24,7 +24,7 @@ impl lfs2Storage for LittleFs2Filesystem {
     fn read(&mut self, off: usize, buf: &mut [u8]) -> lfs2Result<usize> {
         let read_size: usize = Self::READ_SIZE;
         if off % read_size != 0 {
-            error!("Littlefs2Filesystem read error: offset not aligned to read size offset: {off} read_size: {read_size}");
+            error!("Littlefs2Filesystem read error: offset not aligned to read size offset: {} read_size: {}", off, read_size);
             return Err(lfs2Error::IO);
         }
         if buf.len() % read_size != 0 {
@@ -34,7 +34,7 @@ impl lfs2Storage for LittleFs2Filesystem {
         match self.storage.read(off as u32, buf) {
             Ok(..) => Ok(buf.len()),
             Err(err) => {
-                error!("Littlefs2Filesystem read error: {err:?}");
+                error!("Littlefs2Filesystem read error: {:?}", err);
                 Err(lfs2Error::IO)
             }
         }
@@ -43,7 +43,7 @@ impl lfs2Storage for LittleFs2Filesystem {
     fn write(&mut self, off: usize, data: &[u8]) -> lfs2Result<usize> {
         let write_size: usize = Self::WRITE_SIZE;
         if off % write_size != 0 {
-            error!("Littlefs2Filesystem write error: offset not aligned to write size offset: {off} write_size: {write_size}");
+            error!("Littlefs2Filesystem write error: offset not aligned to write size offset: {} write_size: {}", off, write_size);
             return Err(lfs2Error::IO);
         }
         if data.len() % write_size != 0 {
@@ -53,7 +53,7 @@ impl lfs2Storage for LittleFs2Filesystem {
         match self.storage.write(off as u32, data) {
             Ok(..) => Ok(data.len()),
             Err(err) => {
-                error!("Littlefs2Filesystem write error: {err:?}");
+                error!("Littlefs2Filesystem write error: {:?}", err);
                 Err(lfs2Error::IO)
             }
         }
@@ -62,26 +62,26 @@ impl lfs2Storage for LittleFs2Filesystem {
     fn erase(&mut self, off: usize, len: usize) -> lfs2Result<usize> {
         let block_size: usize = Self::BLOCK_SIZE;
         if off % block_size != 0 {
-            error!("Littlefs2Filesystem erase error: offset not aligned to block size offset: {off} block_size: {block_size}");
-            return Err(lfs2Error::IO);
+            error!("Littlefs2Filesystem erase error: offset not aligned to block size offset: {} block_size: {}", off, block_size);
+            return lfs2Result::Err(lfs2Error::IO);
         }
         if len % block_size != 0 {
-            error!("Littlefs2Filesystem erase error: length not aligned to block size length: {len} block_size: {block_size}");
-            return Err(lfs2Error::IO);
+            error!("Littlefs2Filesystem erase error: length not aligned to block size length: {} block_size: {}", len, block_size);
+            return lfs2Result::Err(lfs2Error::IO);
         }
 
-        match check_erase(self.storage, off as u32, (off + len) as u32) {
+        match check_erase(self.storage, off as u32, (off+len) as u32) {
             Ok(_) => {}
             Err(err) => {
-                error!("Littlefs2Filesystem check erase error: {err:?}");
-                return Err(lfs2Error::IO);
+                error!("Littlefs2Filesystem check erase error: {:?}", err);
+                return lfs2Result::Err(lfs2Error::IO);
             }
         }
         match self.storage.erase(off as u32, (off + len) as u32) {
-            Ok(..) => Ok(len),
+            Ok(..) => lfs2Result::Ok(len),
             Err(err) => {
-                error!("Littlefs2Filesystem erase error: {err:?}");
-                Err(lfs2Error::IO)
+                error!("Littlefs2Filesystem erase error: {:?}", err);
+                lfs2Result::Err(lfs2Error::IO)
             }
         }
     }

rust/src/hal/mod.rs

@@ -1,21 +1,18 @@
 pub(crate) mod battery;
+mod can_api;
 pub mod esp;
 mod initial_hal;
 mod little_fs2storage_adapter;
 pub(crate) mod rtc;
-mod shared_flash;
 mod v3_hal;
 mod v3_shift_register;
 mod v4_hal;
 mod v4_sensor;
 mod water;
-
 use crate::alloc::string::ToString;
 use crate::hal::rtc::{DS3231Module, RTCModuleInteraction};
-use esp_hal::interrupt::software::SoftwareInterruptControl;
 use esp_hal::peripherals::Peripherals;
 use esp_hal::peripherals::ADC1;
-use esp_hal::peripherals::APB_SARADC;
 use esp_hal::peripherals::GPIO0;
 use esp_hal::peripherals::GPIO10;
 use esp_hal::peripherals::GPIO11;
@@ -43,9 +40,7 @@ use esp_hal::peripherals::GPIO5;
 use esp_hal::peripherals::GPIO6;
 use esp_hal::peripherals::GPIO7;
 use esp_hal::peripherals::GPIO8;
-use esp_hal::peripherals::PCNT;
 use esp_hal::peripherals::TWAI0;
-use portable_atomic::AtomicBool;
 
 use crate::{
     bail,
@@ -61,6 +56,7 @@ use alloc::boxed::Box;
 use alloc::format;
 use alloc::sync::Arc;
 use async_trait::async_trait;
+use bincode::{Decode, Encode};
 use bq34z100::Bq34z100g1Driver;
 use chrono::{DateTime, FixedOffset, Utc};
 use core::cell::RefCell;
@@ -74,29 +70,25 @@ use eeprom24x::{Eeprom24x, SlaveAddr, Storage};
 use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::blocking_mutex::CriticalSectionMutex;
-use embedded_storage::nor_flash::RmwNorFlashStorage;
-use embedded_storage::ReadStorage;
 use esp_bootloader_esp_idf::partitions::{
-    AppPartitionSubType, DataPartitionSubType, FlashRegion, PartitionEntry, PartitionTable,
-    PartitionType, 
+    AppPartitionSubType, DataPartitionSubType, FlashRegion, PartitionEntry,
 };
 use esp_hal::clock::CpuClock;
 use esp_hal::gpio::{Input, InputConfig, Pull};
-use esp_hal::uart::{Config as UartConfig, Uart};
-use esp_storage::FlashStorage;
-use lib_bms_protocol::{BmsReadable, ProtocolVersion};
 use measurements::{Current, Voltage};
 
 use crate::fat_error::{ContextExt, FatError, FatResult};
 use crate::hal::battery::{print_battery_bq34z100, BQ34Z100G1};
 use crate::hal::little_fs2storage_adapter::LittleFs2Filesystem;
 use crate::hal::water::TankSensor;
-use crate::log::log;
+use crate::log::LOG_ACCESS;
 use embassy_sync::mutex::Mutex;
 use embassy_sync::once_lock::OnceLock;
+use embedded_storage::nor_flash::ReadNorFlash;
 use esp_alloc as _;
 use esp_backtrace as _;
-use esp_bootloader_esp_idf::ota::{OtaImageState, Ota};
+use esp_bootloader_esp_idf::ota::{Ota, OtaImageState};
+use esp_bootloader_esp_idf::ota::{Slot as ota_slot, Slot};
 use esp_hal::delay::Delay;
 use esp_hal::i2c::master::{BusTimeout, Config, I2c};
 use esp_hal::pcnt::unit::Unit;
@@ -105,31 +97,28 @@ use esp_hal::rng::Rng;
 use esp_hal::rtc_cntl::{Rtc, SocResetReason};
 use esp_hal::system::reset_reason;
 use esp_hal::time::Rate;
-use esp_hal::timer::timg::{TimerGroup, Wdt};
+use esp_hal::timer::timg::TimerGroup;
 use esp_hal::Blocking;
+use esp_storage::FlashStorage;
+use esp_wifi::{init, EspWifiController};
 use littlefs2::fs::{Allocation, Filesystem as lfs2Filesystem};
 use littlefs2::object_safe::DynStorage;
 use log::{error, info, warn};
-use shared_flash::MutexFlashStorage;
+use portable_atomic::AtomicBool;
 
-pub static PROGRESS_ACTIVE: AtomicBool = AtomicBool::new(false);
+pub static TIME_ACCESS: OnceLock<Mutex<CriticalSectionRawMutex, Rtc>> = OnceLock::new();
 
 //Only support for 8 right now!
 pub const PLANT_COUNT: usize = 8;
 
-pub static WATCHDOG: OnceLock<
-    embassy_sync::blocking_mutex::Mutex<
-        CriticalSectionRawMutex,
-        RefCell<Wdt<esp_hal::peripherals::TIMG0>>,
-    >,
-> = OnceLock::new();
+pub static PROGRESS_ACTIVE: AtomicBool = AtomicBool::new(false);
 
 const TANK_MULTI_SAMPLE: usize = 11;
 pub static I2C_DRIVER: OnceLock<
     embassy_sync::blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<I2c<Blocking>>>,
 > = OnceLock::new();
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy, Encode, Decode)]
 pub enum Sensor {
     A,
     B,
@@ -141,70 +130,6 @@ pub struct HAL<'a> {
     pub board_hal: Box<dyn BoardInteraction<'a> + Send>,
 }
 
-fn ota_state(
-    slot: AppPartitionSubType,
-    ota_data: &mut FlashRegion<RmwNorFlashStorage<&mut MutexFlashStorage>>,
-) -> OtaImageState {
-    // Read and log OTA states for both slots before constructing Ota
-    // Each OTA select entry is 32 bytes: [seq:4][label:20][state:4][crc:4]
-    // Offsets within the OTA data partition: slot0 @ 0x0000, slot1 @ 0x1000
-    let mut slot_buf = [0u8; 32];
-    if slot == AppPartitionSubType::Ota0 {
-        let _ = ReadStorage::read(ota_data, 0x0000, &mut slot_buf);
-    } else {
-        let _ = ReadStorage::read(ota_data, 0x1000, &mut slot_buf);
-    }
-    let raw_state = u32::from_le_bytes(slot_buf[24..28].try_into().unwrap_or([0xff; 4]));
-
-    OtaImageState::try_from(raw_state).unwrap_or(OtaImageState::Undefined)
-}
-fn get_current_slot(
-    pt: &PartitionTable,
-    ota: &mut Ota<RmwNorFlashStorage<&mut MutexFlashStorage>>,
-) -> Result<AppPartitionSubType, FatError> {
-    let booted = pt.booted_partition()?.ok_or(FatError::OTAError)?;
-    let booted_type = booted.partition_type();
-    let booted_ota_type = match booted_type {
-        PartitionType::App(subtype) => subtype,
-        _ => {
-            bail!("Booted partition is not an app partition");
-        }
-    };
-
-    let expected_partition = ota.current_app_partition()?;
-    if expected_partition == booted_ota_type {
-        info!("Booted partition matches expected partition");
-    } else {
-        info!("Booted partition does not match expected partition, fixing ota entry");
-        ota.set_current_app_partition(booted_ota_type)?;
-    }
-
-    let fixed = ota.current_app_partition()?;
-    let state = ota.current_ota_state();
-    info!("Expected partition: {expected_partition:?}, current partition: {booted_ota_type:?}, state: {state:?}");
-
-    if fixed != booted_ota_type {
-        bail!(
-            "Could not fix ota entry, booted partition is still not correct: {:?} != {:?}",
-            booted_ota_type,
-            fixed
-        );
-    }
-
-    Ok(booted_ota_type)
-}
-
-pub fn next_partition(current: AppPartitionSubType) -> FatResult<AppPartitionSubType> {
-    let next = match current {
-        AppPartitionSubType::Ota0 => AppPartitionSubType::Ota1,
-        AppPartitionSubType::Ota1 => AppPartitionSubType::Ota0,
-        _ => {
-            bail!("Current slot is not ota0 or ota1");
-        }
-    };
-    Ok(next)
-}
-
 #[async_trait]
 pub trait BoardInteraction<'a> {
     fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError>;
@@ -212,10 +137,8 @@ pub trait BoardInteraction<'a> {
     fn get_config(&mut self) -> &PlantControllerConfig;
     fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send>;
     fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send>;
-    async fn get_time(&mut self) -> DateTime<Utc>;
-    async fn set_time(&mut self, time: &DateTime<FixedOffset>) -> FatResult<()>;
     async fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError>;
-    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> !;
+    async fn deep_sleep(&mut self, duration_in_ms: u64) -> !;
 
     fn is_day(&self) -> bool;
     //should be multsampled
@@ -230,7 +153,15 @@ pub trait BoardInteraction<'a> {
     async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError>;
     async fn get_mptt_current(&mut self) -> Result<Current, FatError>;
 
+    // Return JSON string with autodetected sensors per plant. Default: not supported.
+    async fn detect_sensors(&mut self) -> Result<alloc::string::String, FatError> {
+        bail!("Autodetection is only available on v4 HAL with CAN bus");
+    }
+
     async fn progress(&mut self, counter: u32) {
+        // Indicate progress is active to suppress default wait_infinity blinking
+        crate::hal::PROGRESS_ACTIVE.store(true, core::sync::atomic::Ordering::Relaxed);
+
         let current = counter % PLANT_COUNT as u32;
         for led in 0..PLANT_COUNT {
             if let Err(err) = self.fault(led, current == led as u32).await {
@@ -248,6 +179,9 @@ pub trait BoardInteraction<'a> {
             }
         }
         let _ = self.general_fault(false).await;
+
+        // Reset progress active flag so wait_infinity can resume blinking
+        crate::hal::PROGRESS_ACTIVE.store(false, core::sync::atomic::Ordering::Relaxed);
     }
 }
 
@@ -275,14 +209,27 @@ pub struct FreePeripherals<'a> {
     pub gpio21: GPIO21<'a>,
     pub gpio22: GPIO22<'a>,
     pub gpio23: GPIO23<'a>,
+    pub gpio24: GPIO24<'a>,
+    pub gpio25: GPIO25<'a>,
+    pub gpio26: GPIO26<'a>,
     pub gpio27: GPIO27<'a>,
+    pub gpio28: GPIO28<'a>,
+    pub gpio29: GPIO29<'a>,
+    pub gpio30: GPIO30<'a>,
     pub twai: TWAI0<'a>,
     pub pcnt0: Unit<'a, 0>,
     pub pcnt1: Unit<'a, 1>,
     pub adc1: ADC1<'a>,
 }
 
-use crate::util::mk_static;
+macro_rules! mk_static {
+    ($t:ty,$val:expr) => {{
+        static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
+        #[deny(unused_attributes)]
+        let x = STATIC_CELL.uninit().write(($val));
+        x
+    }};
+}
 
 impl PlantHal {
     pub async fn create() -> Result<Mutex<CriticalSectionRawMutex, HAL<'static>>, FatError> {
@@ -292,12 +239,14 @@ impl PlantHal {
         esp_alloc::heap_allocator!(size: 64 * 1024);
         esp_alloc::heap_allocator!(#[link_section = ".dram2_uninit"] size: 64000);
 
-        let mut rtc_peripheral: Rtc = Rtc::new(peripherals.LPWR);
-        rtc_peripheral.rwdt.disable();
+        let rtc: Rtc = Rtc::new(peripherals.LPWR);
+        TIME_ACCESS
+            .init(Mutex::new(rtc))
+            .map_err(|_| FatError::String {
+                error: "Init error rct".to_string(),
+            })?;
 
-        let timg0 = TimerGroup::new(peripherals.TIMG0);
-        let sw_int = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
-        esp_rtos::start(timg0.timer0, sw_int.software_interrupt0);
+        let systimer = SystemTimer::new(peripherals.SYSTIMER);
 
         let boot_button = Input::new(
             peripherals.GPIO9,
@@ -307,13 +256,29 @@ impl PlantHal {
         // Reserve GPIO1 for deep sleep wake (configured just before entering sleep)
         let wake_gpio1 = peripherals.GPIO1;
 
-        let rng = Rng::new();
-        let (controller, interfaces) = esp_radio::wifi::new(peripherals.WIFI, Default::default())
-            .expect("Could not init wifi");
+        let rng = Rng::new(peripherals.RNG);
+        let timg0 = TimerGroup::new(peripherals.TIMG0);
+        let esp_wifi_ctrl = &*mk_static!(
+            EspWifiController<'static>,
+            init(timg0.timer0, rng.clone()).expect("Could not init wifi controller")
+        );
+
+        let (controller, interfaces) =
+            esp_wifi::wifi::new(&esp_wifi_ctrl, peripherals.WIFI).expect("Could not init wifi");
+
+        use esp_hal::timer::systimer::SystemTimer;
+        esp_hal_embassy::init(systimer.alarm0);
+
+        //let mut adc1 = Adc::new(peripherals.ADC1, adc1_config);
+        //
 
         let pcnt_module = Pcnt::new(peripherals.PCNT);
 
         let free_pins = FreePeripherals {
+            //     can: peripherals.can,
+            //     adc1: peripherals.adc1,
+            //     pcnt0: peripherals.pcnt0,
+            //     pcnt1: peripherals.pcnt1,
             gpio0: peripherals.GPIO0,
             gpio2: peripherals.GPIO2,
             gpio3: peripherals.GPIO3,
@@ -334,7 +299,13 @@ impl PlantHal {
             gpio21: peripherals.GPIO21,
             gpio22: peripherals.GPIO22,
             gpio23: peripherals.GPIO23,
+            gpio24: peripherals.GPIO24,
+            gpio25: peripherals.GPIO25,
+            gpio26: peripherals.GPIO26,
             gpio27: peripherals.GPIO27,
+            gpio28: peripherals.GPIO28,
+            gpio29: peripherals.GPIO29,
+            gpio30: peripherals.GPIO30,
             twai: peripherals.TWAI0,
             pcnt0: pcnt_module.unit0,
             pcnt1: pcnt_module.unit1,
@@ -345,18 +316,9 @@ impl PlantHal {
             [u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN],
             [0u8; esp_bootloader_esp_idf::partitions::PARTITION_TABLE_MAX_LEN]
         );
-
-        let bullshit = MutexFlashStorage {
-            inner: Arc::new(CriticalSectionMutex::new(RefCell::new(FlashStorage::new(
-                peripherals.FLASH,
-            )))),
-        };
-        let flash_storage = mk_static!(MutexFlashStorage, bullshit.clone());
-        let flash_storage_2 = mk_static!(MutexFlashStorage, bullshit.clone());
-        let flash_storage_3 = mk_static!(MutexFlashStorage, bullshit.clone());
-
+        let storage_ota = mk_static!(FlashStorage, FlashStorage::new());
         let pt =
-            esp_bootloader_esp_idf::partitions::read_partition_table(flash_storage, tablebuffer)?;
+            esp_bootloader_esp_idf::partitions::read_partition_table(storage_ota, tablebuffer)?;
 
         let ota_data = mk_static!(
             PartitionEntry,
@@ -366,39 +328,43 @@ impl PlantHal {
             .expect("No OTA data partition found")
         );
 
-        let mut ota_data = ota_data.as_embedded_storage(mk_static!(
-            RmwNorFlashStorage<&mut MutexFlashStorage>,
-            RmwNorFlashStorage::new(flash_storage_2, mk_static!([u8; 4096], [0_u8; 4096]))
-        ));
+        let ota_data = mk_static!(
+            FlashRegion<FlashStorage>,
+            ota_data.as_embedded_storage(storage_ota)
+        );
 
-        let state_0 = ota_state(AppPartitionSubType::Ota0, &mut ota_data);
-        let state_1 = ota_state(AppPartitionSubType::Ota1, &mut ota_data);
-        let mut ota = Ota::new(ota_data, 2)?;
-        let running = get_current_slot(&pt, &mut ota)?;
-        let target = next_partition(running)?;
+        let state_0 = ota_state(ota_slot::Slot0, ota_data);
+        let state_1 = ota_state(ota_slot::Slot1, ota_data);
+        let mut ota = Ota::new(ota_data)?;
+        let running = get_current_slot_and_fix_ota_data(&mut ota, state_0, state_1)?;
+        let target = running.next();
 
-        info!("Currently running OTA slot: {running:?}");
-        info!("Updates will be stored in OTA slot: {target:?}");
-        info!("Slot0 state: {state_0:?}");
-        info!("Slot1 state: {state_1:?}");
+        info!("Currently running OTA slot: {:?}", running);
+        info!("Slot0 state: {:?}", state_0);
+        info!("Slot1 state: {:?}", state_1);
 
-        //get current_state and next_state here!
+        //obtain current_state and next_state here!
         let ota_target = match target {
-            AppPartitionSubType::Ota0 => pt
-                .find_partition(PartitionType::App(AppPartitionSubType::Ota0))?
-                .context("Partition table invalid no ota0")?,
-            AppPartitionSubType::Ota1 => pt
-                .find_partition(PartitionType::App(AppPartitionSubType::Ota1))?
-                .context("Partition table invalid no ota1")?,
-            _ => {
-                bail!("Invalid target partition");
+            Slot::None => {
+                panic!("No OTA slot active?");
             }
+            Slot::Slot0 => pt
+                .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::App(
+                    AppPartitionSubType::Ota0,
+                ))?
+                .context("Partition table invalid no ota0")?,
+            Slot::Slot1 => pt
+                .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::App(
+                    AppPartitionSubType::Ota1,
+                ))?
+                .context("Partition table invalid no ota1")?,
         };
 
         let ota_target = mk_static!(PartitionEntry, ota_target);
+        let storage_ota = mk_static!(FlashStorage, FlashStorage::new());
         let ota_target = mk_static!(
-            FlashRegion<MutexFlashStorage>,
-            ota_target.as_embedded_storage(flash_storage)
+            FlashRegion<FlashStorage>,
+            ota_target.as_embedded_storage(storage_ota)
         );
 
         let data_partition = pt
@@ -408,38 +374,32 @@ impl PlantHal {
             .expect("Data partition with littlefs not found");
         let data_partition = mk_static!(PartitionEntry, data_partition);
 
+        let storage_data = mk_static!(FlashStorage, FlashStorage::new());
         let data = mk_static!(
-            FlashRegion<MutexFlashStorage>,
-            data_partition.as_embedded_storage(flash_storage_3)
+            FlashRegion<FlashStorage>,
+            data_partition.as_embedded_storage(storage_data)
         );
         let lfs2filesystem = mk_static!(LittleFs2Filesystem, LittleFs2Filesystem { storage: data });
         let alloc = mk_static!(Allocation<LittleFs2Filesystem>, lfs2Filesystem::allocate());
         if lfs2filesystem.is_mountable() {
-            info!("Littlefs2 filesystem is mountable");
+            log::info!("Littlefs2 filesystem is mountable");
         } else {
             match lfs2filesystem.format() {
-                Ok(..) => {
-                    info!("Littlefs2 filesystem is formatted");
+                Result::Ok(..) => {
+                    log::info!("Littlefs2 filesystem is formatted");
                 }
                 Err(err) => {
-                    error!("Littlefs2 filesystem could not be formatted: {err:?}");
+                    error!("Littlefs2 filesystem could not be formatted: {:?}", err);
                 }
             }
         }
 
-        #[allow(clippy::arc_with_non_send_sync)]
         let fs = Arc::new(Mutex::new(
             lfs2Filesystem::mount(alloc, lfs2filesystem).expect("Could not mount lfs2 filesystem"),
         ));
 
-
-        let uart0 =
-            Uart::new(peripherals.UART0, UartConfig::default()).map_err(|_| FatError::String {
-                error: "Uart creation failed".to_string(),
-            })?;
-
-        let ap = interfaces.access_point;
-        let sta = interfaces.station;
+        let ap = interfaces.ap;
+        let sta = interfaces.sta;
         let mut esp = Esp {
             fs,
             rng,
@@ -453,8 +413,6 @@ impl PlantHal {
             current: running,
             slot0_state: state_0,
             slot1_state: state_1,
-            uart0,
-            rtc: rtc_peripheral,
         };
 
         //init,reset rtc memory depending on cause
@@ -490,21 +448,24 @@ impl PlantHal {
                 SocResetReason::Cpu0JtagCpu => "cpu0 jtag cpu",
             },
         };
-        log(
-            LogMessage::ResetReason,
-            init_rtc_store as u32,
-            to_config_mode as u32,
-            "",
-            &format!("{reasons:?}"),
-        );
-
+        LOG_ACCESS
+            .lock()
+            .await
+            .log(
+                LogMessage::ResetReason,
+                init_rtc_store as u32,
+                to_config_mode as u32,
+                "",
+                &format!("{reasons:?}"),
+            )
+            .await;
 
         esp.init_rtc_deepsleep_memory(init_rtc_store, to_config_mode)
             .await;
 
         let config = esp.load_config().await;
 
-        info!("Init rtc driver");
+        log::info!("Init rtc driver");
 
         let sda = peripherals.GPIO20;
         let scl = peripherals.GPIO19;
@@ -522,30 +483,26 @@ impl PlantHal {
             RefCell<I2c<Blocking>>,
         > = CriticalSectionMutex::new(RefCell::new(i2c));
 
-
         I2C_DRIVER.init(i2c_bus).expect("Could not init i2c driver");
 
         let i2c_bus = I2C_DRIVER.get().await;
-        let rtc_device = I2cDevice::new(i2c_bus);
-        let mut bms_device = I2cDevice::new(i2c_bus);
-        let eeprom_device = I2cDevice::new(i2c_bus);
-
+        let rtc_device = I2cDevice::new(&i2c_bus);
+        let eeprom_device = I2cDevice::new(&i2c_bus);
 
         let mut rtc: Ds323x<
             I2cInterface<I2cDevice<CriticalSectionRawMutex, I2c<Blocking>>>,
             DS3231,
         > = Ds323x::new_ds3231(rtc_device);
 
-
         info!("Init rtc eeprom driver");
         let eeprom = Eeprom24x::new_24x32(eeprom_device, SlaveAddr::Alternative(true, true, true));
         let rtc_time = rtc.datetime();
         match rtc_time {
             Ok(tt) => {
-                info!("Rtc Module reports time at UTC {tt}");
+                log::info!("Rtc Module reports time at UTC {}", tt);
             }
             Err(err) => {
-                info!("Rtc Module could not be read {err:?}");
+                log::info!("Rtc Module could not be read {:?}", err);
             }
         }
 
@@ -560,26 +517,40 @@ impl PlantHal {
             Box::new(DS3231Module { rtc, storage }) as Box<dyn RTCModuleInteraction + Send>;
 
         let hal = match config {
-            Ok(config) => {
+            Result::Ok(config) => {
                 let battery_interaction: Box<dyn BatteryInteraction + Send> =
                     match config.hardware.battery {
                         BatteryBoardVersion::Disabled => Box::new(NoBatteryMonitor {}),
-                        BatteryBoardVersion::WchI2cSlave => {
-                            let version = ProtocolVersion::read_from_i2c(&mut bms_device);
-                            let version_val = match version {
-                                Ok(v) => unsafe { core::mem::transmute::<ProtocolVersion, u32>(v) },
-                                Err(_) => 0,
+                        BatteryBoardVersion::BQ34Z100G1 => {
+                            let battery_device = I2cDevice::new(I2C_DRIVER.get().await);
+                            let mut battery_driver = Bq34z100g1Driver {
+                                i2c: battery_device,
+                                delay: Delay::new(),
+                                flash_block_data: [0; 32],
                             };
-                            if version_val == 1 {
-                                //Box::new(WCHI2CSlave { i2c: bms_device })
-                                // todo fix the type above
-                                Box::new(NoBatteryMonitor {})
-                            } else {
-                                //todo should be an error variant instead?
-                                Box::new(NoBatteryMonitor {})
+                            let status = print_battery_bq34z100(&mut battery_driver);
+                            match status {
+                                Ok(_) => {}
+                                Err(err) => {
+                                    LOG_ACCESS
+                                        .lock()
+                                        .await
+                                        .log(
+                                            LogMessage::BatteryCommunicationError,
+                                            0u32,
+                                            0,
+                                            "",
+                                            &format!("{err:?})"),
+                                        )
+                                        .await;
+                                }
                             }
+                            Box::new(BQ34Z100G1 { battery_driver })
+                        }
+                        BatteryBoardVersion::WchI2cSlave => {
+                            // TODO use correct implementation once availible
+                            Box::new(NoBatteryMonitor {})
                         }
-                        BatteryBoardVersion::BQ34Z100G1 => Box::new(NoBatteryMonitor {}),
                     };
 
                 let board_hal: Box<dyn BoardInteraction + Send> = match config.hardware.board {
@@ -598,13 +569,17 @@ impl PlantHal {
                 HAL { board_hal }
             }
             Err(err) => {
-                log(
-                    LogMessage::ConfigModeMissingConfig,
-                    0,
-                    0,
-                    "",
-                    &err.to_string(),
-                );
+                LOG_ACCESS
+                    .lock()
+                    .await
+                    .log(
+                        LogMessage::ConfigModeMissingConfig,
+                        0,
+                        0,
+                        "",
+                        &err.to_string(),
+                    )
+                    .await;
                 HAL {
                     board_hal: initial_hal::create_initial_board(
                         free_pins,
@@ -617,13 +592,96 @@ impl PlantHal {
 
         Ok(Mutex::new(hal))
     }
-
-    /// Feed the watchdog timer to prevent system reset
-    pub fn feed_watchdog() {
-        if let Some(wdt_mutex) = WATCHDOG.try_get() {
-            wdt_mutex.lock(|cell| {
-                cell.borrow_mut().feed();
-            });
-        }
-    }
+}
+
+fn ota_state(slot: ota_slot, ota_data: &mut FlashRegion<FlashStorage>) -> OtaImageState {
+    // Read and log OTA states for both slots before constructing Ota
+    // Each OTA select entry is 32 bytes: [seq:4][label:20][state:4][crc:4]
+    // Offsets within the OTA data partition: slot0 @ 0x0000, slot1 @ 0x1000
+    if slot == ota_slot::None {
+        return OtaImageState::Undefined;
+    }
+    let mut slot_buf = [0u8; 32];
+    if slot == ota_slot::Slot0 {
+        let _ = ota_data.read(0x0000, &mut slot_buf);
+    } else {
+        let _ = ota_data.read(0x1000, &mut slot_buf);
+    }
+    let raw_state = u32::from_le_bytes(slot_buf[24..28].try_into().unwrap_or([0xff; 4]));
+    let state0 = OtaImageState::try_from(raw_state).unwrap_or(OtaImageState::Undefined);
+    state0
+}
+
+fn get_current_slot_and_fix_ota_data(
+    ota: &mut Ota<FlashStorage>,
+    state0: OtaImageState,
+    state1: OtaImageState,
+) -> Result<ota_slot, FatError> {
+    let state = ota.current_ota_state().unwrap_or_default();
+    let swap = match state {
+        OtaImageState::Invalid => true,
+        OtaImageState::Aborted => true,
+        OtaImageState::Undefined => {
+            info!("Undefined image in current slot, bootloader wrong?");
+            false
+        }
+        _ => false,
+    };
+    let current = ota.current_slot()?;
+    if swap {
+        let other = match current {
+            ota_slot::Slot0 => state1,
+            ota_slot::Slot1 => state0,
+            _ => OtaImageState::Invalid,
+        };
+
+        match other {
+            OtaImageState::Invalid => {
+                bail!(
+                    "cannot recover slot, as both slots in invalid state {:?} {:?} {:?}",
+                    current,
+                    state0,
+                    state1
+                );
+            }
+            OtaImageState::Aborted => {
+                bail!(
+                    "cannot recover slot, as both slots in invalid state {:?} {:?} {:?}",
+                    current,
+                    state0,
+                    state1
+                );
+            }
+            _ => {}
+        }
+        info!(
+            "Current slot has state {:?} other state has {:?} swapping",
+            state, other
+        );
+        ota.set_current_slot(current.next())?;
+        //we actually booted other slot, than partition table assumes
+        return Ok(ota.current_slot()?);
+    };
+    Ok(current)
+}
+
+pub async fn esp_time() -> DateTime<Utc> {
+    let guard = TIME_ACCESS.get().await.lock().await;
+    DateTime::from_timestamp_micros(guard.current_time_us() as i64).unwrap()
+}
+
+pub async fn esp_set_time(time: DateTime<FixedOffset>) -> FatResult<()> {
+    {
+        let guard = TIME_ACCESS.get().await.lock().await;
+        guard.set_current_time_us(time.timestamp_micros() as u64);
+    }
+    BOARD_ACCESS
+        .get()
+        .await
+        .lock()
+        .await
+        .board_hal
+        .get_rtc_module()
+        .set_rtc_time(&time.to_utc())
+        .await
 }

rust/src/hal/shared_flash.rs

@@ -1,65 +0,0 @@
-use alloc::sync::Arc;
-use core::cell::RefCell;
-use core::ops::{Deref, DerefMut};
-use embassy_sync::blocking_mutex::CriticalSectionMutex;
-use embedded_storage::nor_flash::{ErrorType, NorFlash, ReadNorFlash};
-use embedded_storage::ReadStorage;
-use esp_storage::{FlashStorage, FlashStorageError};
-use log::info;
-
-#[derive(Clone)]
-pub struct MutexFlashStorage {
-    pub(crate) inner: Arc<CriticalSectionMutex<RefCell<FlashStorage<'static>>>>,
-}
-
-impl ReadStorage for MutexFlashStorage {
-    type Error = FlashStorageError;
-
-    fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), FlashStorageError> {
-        self.inner
-            .lock(|f| ReadStorage::read(f.borrow_mut().deref_mut(), offset, bytes))
-    }
-
-    fn capacity(&self) -> usize {
-        self.inner
-            .lock(|f| ReadStorage::capacity(f.borrow().deref()))
-    }
-}
-
-impl embedded_storage::Storage for MutexFlashStorage {
-    fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
-        NorFlash::write(self, offset, bytes)
-    }
-}
-
-impl ErrorType for MutexFlashStorage {
-    type Error = FlashStorageError;
-}
-
-impl ReadNorFlash for MutexFlashStorage {
-    const READ_SIZE: usize = 1;
-
-    fn read(&mut self, offset: u32, bytes: &mut [u8]) -> Result<(), Self::Error> {
-        ReadStorage::read(self, offset, bytes)
-    }
-
-    fn capacity(&self) -> usize {
-        ReadStorage::capacity(self)
-    }
-}
-
-impl NorFlash for MutexFlashStorage {
-    const WRITE_SIZE: usize = 1;
-    const ERASE_SIZE: usize = 4096;
-
-    fn erase(&mut self, from: u32, to: u32) -> Result<(), Self::Error> {
-        info!("Erasing flash from 0x{:x} to 0x{:x}", from, to);
-        self.inner
-            .lock(|f| NorFlash::erase(f.borrow_mut().deref_mut(), from, to))
-    }
-
-    fn write(&mut self, offset: u32, bytes: &[u8]) -> Result<(), Self::Error> {
-        self.inner
-            .lock(|f| NorFlash::write(f.borrow_mut().deref_mut(), offset, bytes))
-    }
-}