Merge branch 'refactor/mqtt-data-serialization' into legacy/v3-support

- fix: use tagged enum serialization for TankError
- fix: rename TankInfo fields for consistent naming (volume_ml, pct, water_temp_c)
- renamed some fields for better clarity on contained value

.gitignore

@@ -8,6 +8,15 @@ target
 Cargo.lock
 node_modules/
 rust/src/webserver/bundle.js
+rust/src/webserver/bundle.js.gz
 rust/src/webserver/index.html
+rust/src/webserver/index.html.gz
+rust/src_webpack/bundle.js
+rust/src_webpack/bundle.js.gz
+rust/src_webpack/index.html
+rust/src_webpack/index.html.gz
 rust/build/
 rust/image.bin
+rust/target/
+rust/Cargo.lock
+rust/src_webpack/node_modules/

bin/build-esp-plant-dev-tools.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+CONTAINER_NAME="localhost/esp-plant-dev-tools:latest"
+CONTAINER_TOOLS_BASEDIR="$(dirname "$(readlink -f "$0")")"
+
+pushd "$CONTAINER_TOOLS_BASEDIR"
+podman build -t "$CONTAINER_NAME" -f "esp-plant-dev-tools.Containerfile" .
+popd

bin/esp-plant-dev-tools.Containerfile

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

@@ -0,0 +1,29 @@
+#!/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/npx

@@ -0,0 +1,29 @@
+#!/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 npx "$CONTAINER_IMAGE" "$@"

bin/riscv32-unknown-elf-gcc

@@ -0,0 +1,29 @@
+#!/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/modules/Sensors_simplified/Sensors/Sensors.kicad_pro

@@ -460,6 +460,7 @@
       "single_global_label": "ignore",
       "unannotated": "error",
       "unconnected_wire_endpoint": "warning",
+      "undefined_netclass": "error",
       "unit_value_mismatch": "error",
       "unresolved_variable": "error",
       "wire_dangling": "error"

rust/.cargo/config.toml

@@ -1,26 +1,31 @@
 [build]
-#target = "xtensa-esp32-espidf"
+rustflags = [
-target = "riscv32imac-esp-espidf"
+    # Required to obtain backtraces (e.g. when using the "esp-backtrace" crate.)
+    # NOTE: May negatively impact performance of produced code
+    "-C", "force-frame-pointers",
+    "-Z", "stack-protector=all",
+    "-C", "link-arg=-Tlinkall.x",
+]
 
-[target.riscv32imac-esp-espidf]
+target = "riscv32imac-unknown-none-elf"
-linker = "ldproxy"
+
+[target.riscv32imac-unknown-none-elf]
+runner = "espflash flash --monitor --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 = "espflash flash --monitor"
 #runner = "cargo runner"
 
 
 #runner = "espflash flash --monitor --partition-table partitions.csv -b no-reset" # create upgrade image file for webupload
 # runner = espflash erase-parts otadata  //ensure flash is clean
 
-rustflags = ["--cfg", "espidf_time64"] # Extending time_t for ESP IDF 5: https://github.com/esp-rs/rust/issues/110
-
-[unstable]
-build-std = ["std", "panic_abort"]
-
 [env]
-MCU = "esp32c6"
-# Note: this variable is not used by the pio builder (`cargo build --features pio`)
-ESP_IDF_VERSION = "v5.2.1"
 CHRONO_TZ_TIMEZONE_FILTER = "UTC|America/New_York|America/Chicago|America/Los_Angeles|Europe/London|Europe/Berlin|Europe/Paris|Asia/Tokyo|Asia/Shanghai|Asia/Kolkata|Australia/Sydney|America/Sao_Paulo|Africa/Johannesburg|Asia/Dubai|Pacific/Auckland"
 CARGO_WORKSPACE_DIR = { value = "", relative = true }
-RUST_BACKTRACE = "full"
+ESP_LOG = "info"
+
+
+
+[unstable]
+build-std = ["alloc", "core"]
+

rust/.idea/dictionaries/project.xml

@@ -1,14 +1,18 @@
 <component name="ProjectDictionaryState">
   <dictionary name="project">
     <words>
+      <w>boardtest</w>
       <w>buildtime</w>
       <w>deepsleep</w>
       <w>githash</w>
+      <w>lamptest</w>
       <w>lightstate</w>
       <w>mppt</w>
       <w>plantstate</w>
+      <w>pumptest</w>
       <w>sntp</w>
       <w>vergen</w>
+      <w>wifiscan</w>
     </words>
   </dictionary>
 </component>

rust/.idea/inspectionProfiles/Project_Default.xml

@@ -7,5 +7,6 @@
       </Languages>
     </inspection_tool>
     <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="NewCrateVersionAvailable" enabled="true" level="INFORMATION" enabled_by_default="true" />
   </profile>
 </component>

rust/Cargo.toml

@@ -1,31 +1,18 @@
+
 [package]
-name = "plant-ctrl2"
-version = "0.1.0"
-authors = ["Empire Phoenix"]
 edition = "2021"
-resolver = "2"
+name = "plant-ctrl2"
-#rust-version = "1.71"
+rust-version = "1.86"
+version = "0.1.0"
 
-[profile.dev]
+# Explicitly configure the binary target and disable building it as a test/bench.
-# Explicitly disable LTO which the Xtensa codegen backend has issues
+[[bin]]
-lto = false
+name = "plant-ctrl2"
-strip = false
+path = "src/main.rs"
-debug = true
+# Prevent IDEs/Cargo from trying to compile a test harness for this no_std binary.
-overflow-checks = true
+test = false
-panic = "abort"
+bench = false
-incremental = true
+doc = false
-opt-level = 2
-
-
-[profile.release]
-# Explicitly disable LTO which the Xtensa codegen backend has issues
-lto = false
-strip = true
-debug = false
-overflow-checks = false
-panic = "abort"
-incremental = true
-opt-level = "z"
 
 [package.metadata.cargo_runner]
 # The string `$TARGET_FILE` will be replaced with the path from cargo.
@@ -40,74 +27,100 @@ command = [
     "partitions.csv"
 ]
 
+#this strips the bootloader, we need that tho
+#strip = true
+
+[profile.dev]
+lto = "fat"
+debug = false
+overflow-checks = true
+panic = "abort"
+incremental = true
+opt-level = "z"
+
+[profile.release]
+lto = "fat"
+#debug = false
+overflow-checks = true
+panic = "abort"
+incremental = false
+opt-level = "z"
 
 [package.metadata.espflash]
 partition_table = "partitions.csv"
 
-[features]
-default = ["std", "esp-idf-svc/native"]
-pio = ["esp-idf-svc/pio"]
-std = ["alloc", "esp-idf-svc/binstart", "esp-idf-svc/std"]
-alloc = ["esp-idf-svc/alloc"]
-nightly = ["esp-idf-svc/nightly"]
-experimental = ["esp-idf-svc/experimental"]
-#embassy = ["esp-idf-svc/embassy-sync", "esp-idf-svc/critical-section", "esp-idf-svc/embassy-time-driver"]
 
 [dependencies]
 #ESP stuff
-embedded-svc = { version = "0.28.1", features = ["experimental"] }
+log = "0.4.28"
-esp-idf-hal = "0.45.2"
+esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32c6", "log-04"] }
-esp-idf-sys = { version = "0.36.1", features = ["binstart", "native"] }
+esp-hal = { version = "1.1.0", features = ["esp32c6", "log-04"] }
-esp-idf-svc = { version = "0.51.0", default-features = false }
+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"] }
+
+# 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"] }
+
+# 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
 embedded-hal = "1.0.0"
-heapless = { version = "0.8", features = ["serde"] }
+embedded-storage = "0.3.1"
-embedded-hal-bus = { version = "0.3.0", features = ["std"] }
+embassy-embedded-hal = "0.6.0"
+nb = "1.1.0"
 
 #Hardware additional driver
-ds18b20 = "0.1.1"
+
-bq34z100 = { version = "0.3.0", features = ["flashstream"] }
+#bq34z100 = { version = "0.3.0", default-features = false }
-one-wire-bus = "0.1.1"
+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"] }
 ds323x = "0.6.0"
 
-#pure code dependencies
-once_cell = "1.19.0"
-anyhow = { version = "1.0.75", features = ["std", "backtrace"] }
-strum = { version = "0.27.0", features = ["derive"] }
-measurements = "0.11.0"
-
 #json
-serde = { version = "1.0.192", features = ["derive"] }
+serde = { version = "1.0.219", features = ["derive", "alloc"], default-features = false }
-serde_json = "1.0.108"
+serde_json = { version = "1.0.143", default-features = false, features = ["alloc"] }
 
-#timezone
+chrono = { version = "0.4.42", default-features = false, features = ["iana-time-zone", "alloc", "serde"] }
-
+chrono-tz = { version = "0.10.4", default-features = false, features = ["filter-by-regex"] }
-chrono = { version = "0.4.23", default-features = false, features = ["iana-time-zone", "alloc", "serde"] }
-chrono-tz = { version = "0.10.3", default-features = false, features = ["filter-by-regex"] }
 eeprom24x = "0.7.2"
-url = "2.5.3"
 crc = "3.2.1"
-bincode = "2.0.1"
-ringbuffer = "0.15.0"
-text-template = "0.1.0"
 strum_macros = "0.27.0"
-esp-ota = { version = "0.2.2", features = ["log"] }
 unit-enum = "1.4.1"
-pca9535 = { version = "2.0.0", features = ["std"] }
+pca9535 = { version = "2.0.0" }
-ina219 = { version = "0.2.0", features = ["std"] }
+ina219 = { version = "0.2.0" }
-embedded-storage = "=0.3.1"
+portable-atomic = "1.11.1"
-ekv = "1.0.0"
+async-trait = "0.1.89"
-embedded-can = "0.4.1"
+bq34z100 = { version = "0.4.0", default-features = false }
+static_cell = "2.1.1"
+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"
+bincode = { version = "2.0.1", default-features = false, features = ["derive"] }
+option-lock = { version = "0.3.1", default-features = false }
+measurements = "0.11.1"
+heapless = { version = "0.7.17", features = ["serde"] }
+mcutie = { path = "./src/mcutie_3_0_0/", default-features = false, features = ["log"] }
+
 
 
 [patch.crates-io]
-#esp-idf-hal = { git = "https://github.com/esp-rs/esp-idf-hal.git" }
-#esp-idf-hal = { git = "https://github.com/empirephoenix/esp-idf-hal.git" }
-#esp-idf-sys = { git = "https://github.com/empirephoenix/esp-idf-sys.git" }
-#esp-idf-sys = { git = "https://github.com/esp-rs/esp-idf-sys.git" }
-#esp-idf-svc = { git = "https://github.com/esp-rs/esp-idf-svc.git" }
 #bq34z100 = { path = "../../bq34z100_rust" }
 
 [build-dependencies]
-cc = "=1.1.30"
-embuild = { version = "0.32.0", features = ["espidf"] }
 vergen = { version = "8.2.6", features = ["build", "git", "gitcl"] }

rust/all.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+"${SCRIPT_DIR}/build_website.sh"
+
+cargo build --release
+espflash save-image \
+    --bootloader "${SCRIPT_DIR}/bootloader.bin" \
+    --partition-table "${SCRIPT_DIR}/partitions.csv" \
+    --chip esp32c6 \
+    target/riscv32imac-unknown-none-elf/release/plant-ctrl2 \
+    "${SCRIPT_DIR}/image.bin"
+
+espflash flash --monitor \
+    --bootloader "${SCRIPT_DIR}/bootloader.bin" \
+    --chip esp32c6 \
+    --baud 921600 \
+    --partition-table "${SCRIPT_DIR}/partitions.csv" \
+    target/riscv32imac-unknown-none-elf/release/plant-ctrl2

rust/build.rs

@@ -1,70 +1,56 @@
-use std::process::Command;
-
 use vergen::EmitBuilder;
-fn main() {
-    println!("cargo:rerun-if-changed=./src/src_webpack");
-    Command::new("rm")
-        .arg("./src/webserver/bundle.js")
-        .output()
-        .unwrap();
 
-    match Command::new("cmd").spawn() {
+fn linker_be_nice() {
-        Ok(_) => {
+    let args: Vec<String> = std::env::args().collect();
-            println!("Assuming build on windows");
+    if args.len() > 1 {
-            let output = Command::new("cmd")
+        let kind = &args[1];
-                .arg("/K")
+        let what = &args[2];
-                .arg("npx")
-                .arg("webpack")
-                .current_dir("./src_webpack")
-                .output()
-                .unwrap();
-            println!("status: {}", output.status);
-            println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
-            println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
-            assert!(output.status.success());
 
-            // move webpack results to rust webserver src
+        match kind.as_str() {
-            let _ = Command::new("cmd")
+            "undefined-symbol" => match what.as_str() {
-                .arg("/K")
+                "_defmt_timestamp" => {
-                .arg("move")
+                    eprintln!();
-                .arg("./src_webpack/bundle.js")
+                    eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
-                .arg("./src/webserver")
+                    eprintln!();
-                .output()
+                }
-                .unwrap();
+                "_stack_start" => {
-            let _ = Command::new("cmd")
+                    eprintln!();
-                .arg("/K")
+                    eprintln!("💡 Is the linker script `linkall.x` missing?");
-                .arg("move")
+                    eprintln!();
-                .arg("./src_webpack/index.html")
+                }
-                .arg("./src/webserver")
+                "esp_wifi_preempt_enable"
-                .output()
+                | "esp_wifi_preempt_yield_task"
-                .unwrap();
+                | "esp_wifi_preempt_task_create" => {
+                    eprintln!();
+                    eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
+                    eprintln!();
+                }
+                "embedded_test_linker_file_not_added_to_rustflags" => {
+                    eprintln!();
+                    eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
+                    eprintln!();
+                }
+                _ => (),
+            },
+            // we don't have anything helpful for "missing-lib" yet
+            _ => {
+                std::process::exit(1);
+            }
         }
-        Err(_) => {
-            println!("Assuming build on linux");
-            let output = Command::new("npx")
-                .arg("webpack")
-                .current_dir("./src_webpack")
-                .output()
-                .unwrap();
-            println!("status: {}", output.status);
-            println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
-            println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
-            assert!(output.status.success());
 
-            // move webpack results to rust webserver src
+        std::process::exit(0);
-            let _ = Command::new("mv")
-                .arg("./src_webpack/bundle.js")
-                .arg("./src/webserver")
-                .output()
-                .unwrap();
-            let _ = Command::new("mv")
-                .arg("./src_webpack/index.html")
-                .arg("./src/webserver")
-                .output()
-                .unwrap();
-        }
     }
 
-    embuild::espidf::sysenv::output();
+    println!(
+        "cargo:rustc-link-arg=--error-handling-script={}",
+        std::env::current_exe().unwrap().display()
+    );
+}
+
+fn main() {
+    linker_be_nice();
+    // Non-existent path causes Cargo to always re-run this script,
+    // keeping VERGEN_BUILD_TIMESTAMP fresh on every build.
+    println!("cargo:rerun-if-changed=ALWAYS_REBUILD_SENTINEL");
     let _ = EmitBuilder::builder().all_git().all_build().emit();
 }

rust/build_website.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+WEBPACK_DIR="${SCRIPT_DIR}/src_webpack"
+WEBSERVER_DIR="${SCRIPT_DIR}/src/webserver"
+
+rm -f "${WEBSERVER_DIR}/index.html.gz"
+rm -f "${WEBSERVER_DIR}/bundle.js.gz"
+rm -f "${WEBPACK_DIR}/index.html.gz"
+rm -f "${WEBPACK_DIR}/bundle.js.gz"
+rm -f "${WEBPACK_DIR}/index.html"
+rm -f "${WEBPACK_DIR}/bundle.js"
+
+pushd "${WEBPACK_DIR}"
+npm install
+npx webpack build
+cp index.html.gz "${WEBSERVER_DIR}/index.html.gz"
+cp bundle.js.gz "${WEBSERVER_DIR}/bundle.js.gz"
+popd

rust/erase_ota.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+cargo espflash erase-parts otadata --partition-table "${SCRIPT_DIR}/partitions.csv"

rust/espflash.toml

@@ -1,5 +1,8 @@
-partition_table = "partitions.csv"
 [connection]
-serial = "/dev/ttyACM0"
+
+[[usb_device]]
+vid = "303a"
+pid = "1001"
+
 [flash]
-size = "16MB"
+size = "16MB"

rust/flash.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+"${SCRIPT_DIR}/build_website.sh"
+
+cargo build --release
+espflash flash --monitor \
+    --bootloader "${SCRIPT_DIR}/bootloader.bin" \
+    --chip esp32c6 \
+    --baud 921600 \
+    --partition-table "${SCRIPT_DIR}/partitions.csv" \
+    target/riscv32imac-unknown-none-elf/release/plant-ctrl2

rust/image_build.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+rm -f "${SCRIPT_DIR}/image.bin"
+
+"${SCRIPT_DIR}/build_website.sh"
+
+cargo build --release
+espflash save-image \
+    --bootloader "${SCRIPT_DIR}/bootloader.bin" \
+    --partition-table "${SCRIPT_DIR}/partitions.csv" \
+    --chip esp32c6 \
+    target/riscv32imac-unknown-none-elf/release/plant-ctrl2 \
+    "${SCRIPT_DIR}/image.bin"

rust/partitions.csv

@@ -3,4 +3,4 @@ otadata,  data, ota,     ,        8k,
 phy_init, data, phy,     ,        4k,
 ota_0,    app,  ota_0,   ,        3968k,
 ota_1,    app,  ota_1,   ,        3968k,
-storage,  data, spiffs,  ,        8M,
+storage,  data, littlefs,,        8M,

rust/rust-toolchain.toml

@@ -1,3 +1,2 @@
 [toolchain]
 channel = "nightly"
-toolchain = "esp"

rust/src/config.rs

@@ -1,7 +1,8 @@
 use crate::hal::PLANT_COUNT;
 use crate::plant_state::PlantWateringMode;
+use alloc::string::String;
+use core::str::FromStr;
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(default)]
@@ -9,10 +10,10 @@ pub struct NetworkConfig {
     pub ap_ssid: heapless::String<32>,
     pub ssid: Option<heapless::String<32>>,
     pub password: Option<heapless::String<64>>,
-    pub mqtt_url: Option<heapless::String<128>>,
+    pub mqtt_url: Option<String>,
     pub base_topic: Option<heapless::String<64>>,
-    pub mqtt_user: Option<heapless::String<32>>,
+    pub mqtt_user: Option<String>,
-    pub mqtt_password: Option<heapless::String<64>>,
+    pub mqtt_password: Option<String>,
     pub max_wait: u32,
 }
 impl Default for NetworkConfig {

rust/src/fat_error.rs

@@ -0,0 +1,321 @@
+use alloc::format;
+use alloc::string::{String, ToString};
+use core::convert::Infallible;
+use core::fmt;
+use core::str::Utf8Error;
+use embassy_embedded_hal::shared_bus::I2cDeviceError;
+use embassy_executor::SpawnError;
+use embassy_sync::mutex::TryLockError;
+use esp_hal::i2c::master::ConfigError;
+use esp_hal::pcnt::unit::{InvalidHighLimit, InvalidLowLimit};
+use esp_radio::wifi::WifiError;
+use ina219::errors::{BusVoltageReadError, ShuntVoltageReadError};
+use littlefs2_core::PathError;
+use onewire::Error;
+use pca9535::ExpanderError;
+
+//All error superconstruct
+#[derive(Debug)]
+pub enum FatError {
+    OneWireError {
+        error: Error<Infallible>,
+    },
+    String {
+        error: String,
+    },
+    LittleFSError {
+        error: littlefs2_core::Error,
+    },
+    PathError {
+        error: PathError,
+    },
+    TryLockError {
+        error: TryLockError,
+    },
+    WifiError {
+        error: WifiError,
+    },
+    SerdeError {
+        error: serde_json::Error,
+    },
+    PreconditionFailed {
+        error: String,
+    },
+    NoBatteryMonitor,
+    SpawnError {
+        error: SpawnError,
+    },
+    OTAError,
+    PartitionError {
+        error: esp_bootloader_esp_idf::partitions::Error,
+    },
+    I2CConfigError {
+        error: ConfigError,
+    },
+    DS323 {
+        error: String,
+    },
+    Eeprom24x {
+        error: String,
+    },
+    ExpanderError {
+        error: String,
+    },
+    SNTPError {
+        error: sntpc::Error,
+    },
+}
+
+pub type FatResult<T> = Result<T, FatError>;
+
+impl fmt::Display for FatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FatError::SpawnError { error } => {
+                write!(f, "SpawnError {:?}", error.to_string())
+            }
+            FatError::OneWireError { error } => write!(f, "OneWireError {:?}", error),
+            FatError::String { error } => write!(f, "{}", error),
+            FatError::LittleFSError { error } => write!(f, "LittleFSError {:?}", error),
+            FatError::PathError { error } => write!(f, "PathError {:?}", error),
+            FatError::TryLockError { error } => write!(f, "TryLockError {:?}", error),
+            FatError::WifiError { error } => write!(f, "WifiError {:?}", error),
+            FatError::SerdeError { error } => write!(f, "SerdeError {:?}", error),
+            FatError::PreconditionFailed { error } => write!(f, "PreconditionFailed {:?}", error),
+            FatError::PartitionError { error } => {
+                write!(f, "PartitionError {:?}", error)
+            }
+            FatError::NoBatteryMonitor => {
+                write!(f, "No Battery Monitor")
+            }
+            FatError::I2CConfigError { error } => write!(f, "I2CConfigError {:?}", error),
+            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")
+            }
+        }
+    }
+}
+
+#[macro_export]
+macro_rules! bail {
+    ($msg:literal $(,)?) => {
+        return $crate::fat_error::fat_bail($msg)
+    };
+    ($fmt:literal, $($arg:tt)*) => {
+        return $crate::fat_error::fat_bail(&alloc::format!($fmt, $($arg)*))
+    };
+}
+
+pub fn fat_bail<X>(message: &str) -> Result<X, FatError> {
+    Err(FatError::String {
+        error: message.to_string(),
+    })
+}
+
+pub trait ContextExt<T> {
+    fn context<C>(self, context: C) -> Result<T, FatError>
+    where
+        C: AsRef<str>;
+}
+impl<T> ContextExt<T> for Option<T> {
+    fn context<C>(self, context: C) -> Result<T, FatError>
+    where
+        C: AsRef<str>,
+    {
+        match self {
+            Some(value) => Ok(value),
+            None => Err(FatError::PreconditionFailed {
+                error: context.as_ref().to_string(),
+            }),
+        }
+    }
+}
+
+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 }
+    }
+}
+impl From<littlefs2_core::Error> for FatError {
+    fn from(value: littlefs2_core::Error) -> Self {
+        FatError::LittleFSError { error: value }
+    }
+}
+
+impl From<PathError> for FatError {
+    fn from(value: PathError) -> Self {
+        FatError::PathError { error: value }
+    }
+}
+
+impl From<TryLockError> for FatError {
+    fn from(value: TryLockError) -> Self {
+        FatError::TryLockError { error: value }
+    }
+}
+
+impl From<WifiError> for FatError {
+    fn from(value: WifiError) -> Self {
+        FatError::WifiError { error: value }
+    }
+}
+
+impl From<serde_json::error::Error> for FatError {
+    fn from(value: serde_json::Error) -> Self {
+        FatError::SerdeError { error: value }
+    }
+}
+
+impl From<SpawnError> for FatError {
+    fn from(value: SpawnError) -> Self {
+        FatError::SpawnError { error: value }
+    }
+}
+
+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 }
+    }
+}
+
+impl From<Utf8Error> for FatError {
+    fn from(value: Utf8Error) -> Self {
+        FatError::String {
+            error: value.to_string(),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<edge_http::io::Error<E>> for FatError {
+    fn from(value: edge_http::io::Error<E>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<ds323x::Error<E>> for FatError {
+    fn from(value: ds323x::Error<E>) -> Self {
+        FatError::DS323 {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<eeprom24x::Error<E>> for FatError {
+    fn from(value: eeprom24x::Error<E>) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<ExpanderError<I2cDeviceError<E>>> for FatError {
+    fn from(value: ExpanderError<I2cDeviceError<E>>) -> Self {
+        FatError::ExpanderError {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<bincode::error::DecodeError> for FatError {
+    fn from(value: bincode::error::DecodeError) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<bincode::error::EncodeError> for FatError {
+    fn from(value: bincode::error::EncodeError) -> Self {
+        FatError::Eeprom24x {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<ConfigError> for FatError {
+    fn from(value: ConfigError) -> Self {
+        FatError::I2CConfigError { error: value }
+    }
+}
+
+impl<E: core::fmt::Debug> From<I2cDeviceError<E>> for FatError {
+    fn from(value: I2cDeviceError<E>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl<E: core::fmt::Debug> From<BusVoltageReadError<I2cDeviceError<E>>> for FatError {
+    fn from(value: BusVoltageReadError<I2cDeviceError<E>>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+impl<E: core::fmt::Debug> From<ShuntVoltageReadError<I2cDeviceError<E>>> for FatError {
+    fn from(value: ShuntVoltageReadError<I2cDeviceError<E>>) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<Infallible> for FatError {
+    fn from(value: Infallible) -> Self {
+        panic!("Infallible error: {:?}", value)
+    }
+}
+
+impl From<InvalidLowLimit> for FatError {
+    fn from(value: InvalidLowLimit) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+impl From<InvalidHighLimit> for FatError {
+    fn from(value: InvalidHighLimit) -> Self {
+        FatError::String {
+            error: format!("{:?}", value),
+        }
+    }
+}
+
+impl From<chrono::format::ParseError> for FatError {
+    fn from(value: chrono::format::ParseError) -> Self {
+        FatError::String {
+            error: format!("Parsing error: {value:?}"),
+        }
+    }
+}

rust/src/hal/battery.rs

@@ -1,48 +1,48 @@
-use anyhow::anyhow;
+use crate::fat_error::{FatError, FatResult};
-use bq34z100::{Bq34Z100Error, Bq34z100g1, Bq34z100g1Driver};
+use crate::hal::Box;
-use embedded_hal_bus::i2c::MutexDevice;
+use alloc::string::String;
-use esp_idf_hal::delay::Delay;
+use async_trait::async_trait;
-use esp_idf_hal::i2c::{I2cDriver, I2cError};
+use bq34z100::{Bq34z100g1, Bq34z100g1Driver, Flags};
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use esp_hal::delay::Delay;
+use esp_hal::i2c::master::I2c;
+use esp_hal::Blocking;
 use measurements::Temperature;
 use serde::Serialize;
 
+#[async_trait]
 pub trait BatteryInteraction {
-    fn state_charge_percent(&mut self) -> Result<f32, BatteryError>;
+    async fn state_charge_percent(&mut self) -> FatResult<f32>;
-    fn remaining_milli_ampere_hour(&mut self) -> Result<u16, BatteryError>;
+    async fn remaining_milli_ampere_hour(&mut self) -> FatResult<u16>;
-    fn max_milli_ampere_hour(&mut self) -> Result<u16, BatteryError>;
+    async fn max_milli_ampere_hour(&mut self) -> FatResult<u16>;
-    fn design_milli_ampere_hour(&mut self) -> Result<u16, BatteryError>;
+    async fn design_milli_ampere_hour(&mut self) -> FatResult<u16>;
-    fn voltage_milli_volt(&mut self) -> Result<u16, BatteryError>;
+    async fn voltage_milli_volt(&mut self) -> FatResult<u16>;
-    fn average_current_milli_ampere(&mut self) -> Result<i16, BatteryError>;
+    async fn average_current_milli_ampere(&mut self) -> FatResult<i16>;
-    fn cycle_count(&mut self) -> Result<u16, BatteryError>;
+    async fn cycle_count(&mut self) -> FatResult<u16>;
-    fn state_health_percent(&mut self) -> Result<u16, BatteryError>;
+    async fn state_health_percent(&mut self) -> FatResult<u16>;
-    fn bat_temperature(&mut self) -> Result<u16, BatteryError>;
+    async fn bat_temperature(&mut self) -> FatResult<u16>;
-    fn get_battery_state(&mut self) -> Result<BatteryState, BatteryError>;
+    async fn get_battery_state(&mut self) -> FatResult<BatteryState>;
 }
 
 #[derive(Debug, Serialize)]
 pub struct BatteryInfo {
-    pub voltage_milli_volt: u16,
+    pub voltage_mv: Option<u16>,
-    pub average_current_milli_ampere: i16,
+    pub avg_current_ma: Option<i16>,
-    pub cycle_count: u16,
+    pub soc_pct: Option<f32>,
-    pub design_milli_ampere_hour: u16,
+    pub soh_pct: Option<u16>,
-    pub remaining_milli_ampere_hour: u16,
+    pub temperature_c: Option<u16>,
-    pub state_of_charge: f32,
+    pub cycle_count: Option<u16>,
-    pub state_of_health: u16,
+    pub remaining_mah: Option<u16>,
-    pub temperature: u16,
+    pub design_mah: Option<u16>,
+    pub error: Option<BatteryError>,
 }
 
 #[derive(Debug, Serialize)]
+#[serde(tag = "kind")]
 pub enum BatteryError {
     NoBatteryMonitor,
-    CommunicationError(String),
+    CommunicationError { message: String },
-}
-
-impl From<Bq34Z100Error<esp_idf_hal::i2c::I2cError>> for BatteryError {
-    fn from(err: Bq34Z100Error<esp_idf_hal::i2c::I2cError>) -> Self {
-        BatteryError::CommunicationError(
-            anyhow!("failed to communicate with battery monitor: {:?}", err).to_string(),
-        )
-    }
 }
 
 #[derive(Debug, Serialize)]
@@ -53,45 +53,46 @@ pub enum BatteryState {
 
 /// If no battery monitor is installed this implementation will be used
 pub struct NoBatteryMonitor {}
-
+#[async_trait]
 impl BatteryInteraction for NoBatteryMonitor {
-    fn state_charge_percent(&mut self) -> Result<f32, BatteryError> {
+    async fn state_charge_percent(&mut self) -> FatResult<f32> {
-        Err(BatteryError::NoBatteryMonitor)
+        // No monitor configured: assume full battery for lightstate logic
+        Ok(100.0)
     }
 
-    fn remaining_milli_ampere_hour(&mut self) -> Result<u16, BatteryError> {
+    async fn remaining_milli_ampere_hour(&mut self) -> FatResult<u16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn max_milli_ampere_hour(&mut self) -> Result<u16, BatteryError> {
+    async fn max_milli_ampere_hour(&mut self) -> FatResult<u16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn design_milli_ampere_hour(&mut self) -> Result<u16, BatteryError> {
+    async fn design_milli_ampere_hour(&mut self) -> FatResult<u16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn voltage_milli_volt(&mut self) -> Result<u16, BatteryError> {
+    async fn voltage_milli_volt(&mut self) -> FatResult<u16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn average_current_milli_ampere(&mut self) -> Result<i16, BatteryError> {
+    async fn average_current_milli_ampere(&mut self) -> FatResult<i16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn cycle_count(&mut self) -> Result<u16, BatteryError> {
+    async fn cycle_count(&mut self) -> FatResult<u16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn state_health_percent(&mut self) -> Result<u16, BatteryError> {
+    async fn state_health_percent(&mut self) -> FatResult<u16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn bat_temperature(&mut self) -> Result<u16, BatteryError> {
+    async fn bat_temperature(&mut self) -> FatResult<u16> {
-        Err(BatteryError::NoBatteryMonitor)
+        Err(FatError::NoBatteryMonitor)
     }
 
-    fn get_battery_state(&mut self) -> Result<BatteryState, BatteryError> {
+    async fn get_battery_state(&mut self) -> FatResult<BatteryState> {
         Ok(BatteryState::Unknown)
     }
 }
@@ -100,115 +101,168 @@ impl BatteryInteraction for NoBatteryMonitor {
 #[allow(dead_code)]
 pub struct WchI2cSlave {}
 
-pub struct BQ34Z100G1<'a> {
+pub type I2cDev = I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>;
-    pub battery_driver: Bq34z100g1Driver<MutexDevice<'a, I2cDriver<'a>>, Delay>,
+
+pub struct BQ34Z100G1 {
+    pub battery_driver: Bq34z100g1Driver<I2cDev, Delay>,
 }
 
-impl BatteryInteraction for BQ34Z100G1<'_> {
+#[async_trait]
-    fn state_charge_percent(&mut self) -> Result<f32, BatteryError> {
+impl BatteryInteraction for BQ34Z100G1 {
-        Ok(self.battery_driver.state_of_charge().map(f32::from)?)
+    async fn state_charge_percent(&mut self) -> FatResult<f32> {
+        self.battery_driver
+            .state_of_charge()
+            .map(|v| v as f32)
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn remaining_milli_ampere_hour(&mut self) -> Result<u16, BatteryError> {
+    async fn remaining_milli_ampere_hour(&mut self) -> FatResult<u16> {
-        Ok(self.battery_driver.remaining_capacity()?)
+        self.battery_driver
+            .remaining_capacity()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn max_milli_ampere_hour(&mut self) -> Result<u16, BatteryError> {
+    async fn max_milli_ampere_hour(&mut self) -> FatResult<u16> {
-        Ok(self.battery_driver.full_charge_capacity()?)
+        self.battery_driver
+            .full_charge_capacity()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn design_milli_ampere_hour(&mut self) -> Result<u16, BatteryError> {
+    async fn design_milli_ampere_hour(&mut self) -> FatResult<u16> {
-        Ok(self.battery_driver.design_capacity()?)
+        self.battery_driver
+            .design_capacity()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn voltage_milli_volt(&mut self) -> Result<u16, BatteryError> {
+    async fn voltage_milli_volt(&mut self) -> FatResult<u16> {
-        Ok(self.battery_driver.voltage()?)
+        self.battery_driver.voltage().map_err(|e| FatError::String {
+            error: alloc::format!("{:?}", e),
+        })
     }
 
-    fn average_current_milli_ampere(&mut self) -> Result<i16, BatteryError> {
+    async fn average_current_milli_ampere(&mut self) -> FatResult<i16> {
-        Ok(self.battery_driver.average_current()?)
+        self.battery_driver
+            .average_current()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn cycle_count(&mut self) -> Result<u16, BatteryError> {
+    async fn cycle_count(&mut self) -> FatResult<u16> {
-        Ok(self.battery_driver.cycle_count()?)
+        self.battery_driver
+            .cycle_count()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn state_health_percent(&mut self) -> Result<u16, BatteryError> {
+    async fn state_health_percent(&mut self) -> FatResult<u16> {
-        Ok(self.battery_driver.state_of_health()?)
+        self.battery_driver
+            .state_of_health()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn bat_temperature(&mut self) -> Result<u16, BatteryError> {
+    async fn bat_temperature(&mut self) -> FatResult<u16> {
-        Ok(self.battery_driver.temperature()?)
+        self.battery_driver
+            .temperature()
+            .map_err(|e| FatError::String {
+                error: alloc::format!("{:?}", e),
+            })
     }
 
-    fn get_battery_state(&mut self) -> Result<BatteryState, BatteryError> {
+    async fn get_battery_state(&mut self) -> FatResult<BatteryState> {
         Ok(BatteryState::Info(BatteryInfo {
-            voltage_milli_volt: self.voltage_milli_volt()?,
+            voltage_mv: Some(self.voltage_milli_volt().await?),
-            average_current_milli_ampere: self.average_current_milli_ampere()?,
+            avg_current_ma: Some(self.average_current_milli_ampere().await?),
-            cycle_count: self.cycle_count()?,
+            soc_pct: Some(self.state_charge_percent().await?),
-            design_milli_ampere_hour: self.design_milli_ampere_hour()?,
+            soh_pct: Some(self.state_health_percent().await?),
-            remaining_milli_ampere_hour: self.remaining_milli_ampere_hour()?,
+            temperature_c: Some(self.bat_temperature().await?),
-            state_of_charge: self.state_charge_percent()?,
+            cycle_count: Some(self.cycle_count().await?),
-            state_of_health: self.state_health_percent()?,
+            remaining_mah: Some(self.remaining_milli_ampere_hour().await?),
-            temperature: self.bat_temperature()?,
+            design_mah: Some(self.design_milli_ampere_hour().await?),
+            error: None,
         }))
     }
 }
 
 pub fn print_battery_bq34z100(
-    battery_driver: &mut Bq34z100g1Driver<MutexDevice<I2cDriver<'_>>, Delay>,
+    battery_driver: &mut Bq34z100g1Driver<I2cDevice<CriticalSectionRawMutex, I2c<Blocking>>, Delay>,
-) -> anyhow::Result<(), Bq34Z100Error<I2cError>> {
+) -> FatResult<()> {
-    println!("Try communicating with battery");
+    log::info!("Try communicating with battery");
     let fwversion = battery_driver.fw_version().unwrap_or_else(|e| {
-        println!("Firmware {:?}", e);
+        log::info!("Firmware {:?}", e);
         0
     });
-    println!("fw version is {}", fwversion);
+    log::info!("fw version is {}", fwversion);
 
     let design_capacity = battery_driver.design_capacity().unwrap_or_else(|e| {
-        println!("Design capacity {:?}", e);
+        log::info!("Design capacity {:?}", e);
         0
     });
-    println!("Design Capacity {}", design_capacity);
+    log::info!("Design Capacity {}", design_capacity);
     if design_capacity == 1000 {
-        println!("Still stock configuring battery, readouts are likely to be wrong!");
+        log::info!("Still stock configuring battery, readouts are likely to be wrong!");
     }
 
-    let flags = battery_driver.get_flags_decoded()?;
+    let flags = battery_driver.get_flags_decoded().unwrap_or(Flags {
-    println!("Flags {:?}", flags);
+        fast_charge_allowed: false,
+        full_chage: false,
+        charging_not_allowed: false,
+        charge_inhibit: false,
+        bat_low: false,
+        bat_high: false,
+        over_temp_discharge: false,
+        over_temp_charge: false,
+        discharge: false,
+        state_of_charge_f: false,
+        state_of_charge_1: false,
+        cf: false,
+        ocv_taken: false,
+    });
+    log::info!("Flags {:?}", flags);
 
     let chem_id = battery_driver.chem_id().unwrap_or_else(|e| {
-        println!("Chemid {:?}", e);
+        log::info!("Chemid {:?}", e);
         0
     });
 
     let bat_temp = battery_driver.internal_temperature().unwrap_or_else(|e| {
-        println!("Bat Temp {:?}", e);
+        log::info!("Bat Temp {:?}", e);
         0
     });
     let temp_c = Temperature::from_kelvin(bat_temp as f64 / 10_f64).as_celsius();
     let voltage = battery_driver.voltage().unwrap_or_else(|e| {
-        println!("Bat volt {:?}", e);
+        log::info!("Bat volt {:?}", e);
         0
     });
     let current = battery_driver.current().unwrap_or_else(|e| {
-        println!("Bat current {:?}", e);
+        log::info!("Bat current {:?}", e);
         0
     });
     let state = battery_driver.state_of_charge().unwrap_or_else(|e| {
-        println!("Bat Soc {:?}", e);
+        log::info!("Bat Soc {:?}", e);
         0
     });
     let charge_voltage = battery_driver.charge_voltage().unwrap_or_else(|e| {
-        println!("Bat Charge Volt {:?}", e);
+        log::info!("Bat Charge Volt {:?}", e);
         0
     });
     let charge_current = battery_driver.charge_current().unwrap_or_else(|e| {
-        println!("Bat Charge Current {:?}", e);
+        log::info!("Bat Charge Current {:?}", e);
         0
     });
-    println!("ChemId: {} Current voltage {} and current {} with charge {}% and temp {} CVolt: {} CCur {}", chem_id, voltage, current, state, temp_c, charge_voltage, charge_current);
+    log::info!("ChemId: {} Current voltage {} and current {} with charge {}% and temp {} CVolt: {} CCur {}", chem_id, voltage, current, state, temp_c, charge_voltage, charge_current);
     let _ = battery_driver.unsealed();
     let _ = battery_driver.it_enable();
-    anyhow::Result::Ok(())
+    Ok(())
 }

rust/src/hal/esp.rs

@@ -1,42 +1,64 @@
+use crate::bail;
 use crate::config::{NetworkConfig, PlantControllerConfig};
 use crate::hal::PLANT_COUNT;
 use crate::log::{log, LogMessage};
-use crate::STAY_ALIVE;
+use alloc::vec;
-use anyhow::{anyhow, bail, Context};
 use chrono::{DateTime, Utc};
-use embedded_svc::ipv4::IpInfo;
+use esp_hal::Blocking;
-use embedded_svc::mqtt::client::QoS::{AtLeastOnce, ExactlyOnce};
+use esp_hal::uart::Uart;
-use embedded_svc::wifi::{
-    AccessPointConfiguration, AccessPointInfo, AuthMethod, ClientConfiguration, Configuration,
-};
-use esp_idf_hal::delay::Delay;
-use esp_idf_hal::gpio::{Level, PinDriver};
-use esp_idf_svc::mqtt::client::{EspMqttClient, LwtConfiguration, MqttClientConfiguration};
-use esp_idf_svc::sntp;
-use esp_idf_svc::sntp::SyncStatus;
-use esp_idf_svc::systime::EspSystemTime;
-use esp_idf_svc::wifi::config::{ScanConfig, ScanType};
-use esp_idf_svc::wifi::EspWifi;
-use esp_idf_sys::{esp_spiffs_info, vTaskDelay};
 use serde::Serialize;
-use std::ffi::CString;
-use std::fs;
-use std::fs::File;
-use std::path::Path;
-use std::result::Result::Ok as OkStd;
-use std::str::FromStr;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
-use std::time::Duration;
 
-#[link_section = ".rtc.data"]
+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 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_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::{Mutex, MutexGuard};
+use embassy_time::{Duration, Timer, WithTimeout};
+use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash, RmwNorFlashStorage};
+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_hal::gpio::{Input, RtcPinWithResistors};
+use esp_hal::rng::Rng;
+use esp_hal::rtc_cntl::{
+    sleep::{TimerWakeupSource, WakeupLevel},
+    Rtc,
+};
+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 littlefs2::fs::Filesystem;
+use littlefs2_core::{FileType, PathBuf, SeekFrom};
+use log::{info, warn, error};
+use portable_atomic::AtomicBool;
+
+use super::shared_flash::MutexFlashStorage;
+use crate::network::{net_task, run_dhcp};
+
+#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
 static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];
-#[link_section = ".rtc.data"]
+#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
 static mut CONSECUTIVE_WATERING_PLANT: [u32; PLANT_COUNT] = [0; PLANT_COUNT];
-#[link_section = ".rtc.data"]
+#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
-static mut LOW_VOLTAGE_DETECTED: bool = false;
+static mut LOW_VOLTAGE_DETECTED: i8 = 0;
-#[link_section = ".rtc.data"]
+#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
-static mut RESTART_TO_CONF: bool = false;
+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";
 
 #[derive(Serialize, Debug)]
 pub struct FileInfo {
@@ -49,64 +71,227 @@ pub struct FileList {
     total: usize,
     used: usize,
     files: Vec<FileInfo>,
-    file_system_corrupt: Option<String>,
-    iter_error: Option<String>,
 }
 
-pub struct FileSystemSizeInfo {
+// Minimal esp-idf equivalent for gpio_hold on esp32c6 via ROM functions
-    pub total_size: usize,
+extern "C" {
-    pub used_size: usize,
+    fn gpio_pad_hold(gpio_num: u32);
-    pub free_size: usize,
+    fn gpio_pad_unhold(gpio_num: u32);
 }
 
-pub struct MqttClient<'a> {
+#[inline(always)]
-    mqtt_client: EspMqttClient<'a>,
+pub fn hold_enable(gpio_num: u8) {
-    base_topic: heapless::String<64>,
+    unsafe { gpio_pad_hold(gpio_num as u32) }
 }
+
+#[inline(always)]
+pub fn hold_disable(gpio_num: u8) {
+    unsafe { gpio_pad_unhold(gpio_num as u32) }
+}
+
 pub struct Esp<'a> {
-    pub(crate) mqtt_client: Option<MqttClient<'a>>,
+    pub fs: Arc<Mutex<CriticalSectionRawMutex, Filesystem<'static, LittleFs2Filesystem>>>,
-    pub(crate) wifi_driver: EspWifi<'a>,
+    pub rng: Rng,
-    pub(crate) boot_button: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
+    //first starter (ap or sta will take these)
-    pub(crate) delay: Delay,
+    pub interface_sta: Option<Interface<'static>>,
+    pub interface_ap: Option<Interface<'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 slot0_state: OtaImageState,
+    pub slot1_state: OtaImageState,
 }
 
+// SAFETY: On this target we never move Esp across OS threads; the firmware runs single-core
+// cooperative tasks with Embassy. All interior mutability of non-Send peripherals is gated
+// behind &mut self or embassy_sync Mutex with CriticalSectionRawMutex, which does not rely on
+// thread scheduling. Therefore it is sound to mark Esp as Send to satisfy trait object bounds
+// (e.g., Box<dyn BoardInteraction + Send>). If you add fields that are accessed from multiple
+// CPU cores/threads, reconsider this.
+unsafe impl Send for Esp<'_> {}
+
 impl Esp<'_> {
-    const SPIFFS_PARTITION_NAME: &'static str = "storage";
+    pub fn get_time(&self) -> DateTime<Utc> {
-    const CONFIG_FILE: &'static str = "/spiffs/config.cfg";
+        DateTime::from_timestamp_micros(self.rtc.current_time_us() as i64)
-    const BASE_PATH: &'static str = "/spiffs";
+            .unwrap_or(DateTime::UNIX_EPOCH)
-
-    pub(crate) fn mode_override_pressed(&mut self) -> bool {
-        self.boot_button.get_level() == Level::Low
     }
-    pub(crate) fn sntp(&mut self, max_wait_ms: u32) -> anyhow::Result<DateTime<Utc>> {
+
-        let sntp = sntp::EspSntp::new_default()?;
+    pub fn set_time(&mut self, time: DateTime<Utc>) {
-        let mut counter = 0;
+        self.rtc.set_current_time_us(time.timestamp_micros() as u64);
-        while sntp.get_sync_status() != SyncStatus::Completed {
+    }
-            self.delay.delay_ms(100);
+
-            counter += 100;
+    pub(crate) async fn read_serial_line(&mut self) -> FatResult<Option<alloc::string::String>> {
-            if counter > max_wait_ms {
+        let mut buf = [0u8; 1];
-                bail!("Reached sntp timeout, aborting")
+        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;
+                    }
+                }
             }
         }
-        self.time()
     }
-    pub(crate) fn time(&mut self) -> anyhow::Result<DateTime<Utc>> {
+
-        let time = EspSystemTime {}.now().as_millis();
+
-        let smaller_time = time as i64;
+    pub(crate) async fn delete_file(&self, filename: String) -> FatResult<()> {
-        let local_time = DateTime::from_timestamp_millis(smaller_time)
+        let file = PathBuf::try_from(filename.as_str())?;
-            .ok_or(anyhow!("could not convert timestamp"))?;
+        let access = self.fs.lock().await;
-        anyhow::Ok(local_time)
+        access.remove(&*file)?;
+        Ok(())
     }
-    pub(crate) fn wifi_scan(&mut self) -> anyhow::Result<Vec<AccessPointInfo>> {
+    pub(crate) async fn write_file(
-        self.wifi_driver.start_scan(
+        &mut self,
-            &ScanConfig {
+        filename: String,
-                scan_type: ScanType::Passive(Duration::from_secs(5)),
+        offset: u32,
-                show_hidden: false,
+        buf: &[u8],
-                ..Default::default()
+    ) -> Result<(), FatError> {
+        let file = PathBuf::try_from(filename.as_str())?;
+        let access = self.fs.lock().await;
+        access.open_file_with_options_and_then(
+            |options| options.read(true).write(true).create(true),
+            &*file,
+            |file| {
+                file.seek(SeekFrom::Start(offset))?;
+                file.write(buf)?;
+                Ok(())
             },
-            true,
         )?;
-        anyhow::Ok(self.wifi_driver.get_scan_result()?)
+        Ok(())
+    }
+
+    pub async fn get_size(&mut self, filename: String) -> FatResult<usize> {
+        let file = PathBuf::try_from(filename.as_str())?;
+        let access = self.fs.lock().await;
+        let data = access.metadata(&*file)?;
+        Ok(data.len())
+    }
+    pub(crate) async fn get_file(
+        &mut self,
+        filename: String,
+        chunk: u32,
+    ) -> FatResult<([u8; 512], usize)> {
+        use littlefs2::io::Error as lfs2Error;
+
+        let file = PathBuf::try_from(filename.as_str())?;
+        let access = self.fs.lock().await;
+        let mut buf = [0_u8; 512];
+        let mut read = 0;
+        let offset = chunk * buf.len() as u32;
+        access.open_file_with_options_and_then(
+            |options| options.read(true),
+            &*file,
+            |file| {
+                let length = file.len()? as u32;
+                if length == 0 {
+                    Err(lfs2Error::IO)
+                } else if length > offset {
+                    file.seek(SeekFrom::Start(offset))?;
+                    read = file.read(&mut buf)?;
+                    Ok(())
+                } else {
+                    //exactly at end, do nothing
+                    Ok(())
+                }
+            },
+        )?;
+        Ok((buf, read))
+    }
+
+    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()];
+        let read_back = temp.as_mut_slice();
+        //change to nor flash, align writes!
+        self.ota_target.write(offset, buf)?;
+        self.ota_target.read(offset, read_back)?;
+        if buf != read_back {
+            info!("Expected {buf:?} but got {read_back:?}");
+            bail!(
+                "Flash error, read back does not match write buffer at offset {:x}",
+                offset
+            )
+        }
+        Ok(())
+    }
+
+    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");
+            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)?;
+        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:?}");
+        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 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?;
+        info!("end wifi scan lock");
+        Ok(rv)
     }
 
     pub(crate) fn last_pump_time(&self, plant: usize) -> Option<DateTime<Utc>> {
@@ -120,17 +305,17 @@ impl Esp<'_> {
     }
     pub(crate) fn set_low_voltage_in_cycle(&mut self) {
         unsafe {
-            LOW_VOLTAGE_DETECTED = true;
+            LOW_VOLTAGE_DETECTED = 1;
         }
     }
     pub(crate) fn clear_low_voltage_in_cycle(&mut self) {
         unsafe {
-            LOW_VOLTAGE_DETECTED = false;
+            LOW_VOLTAGE_DETECTED = 0;
         }
     }
 
     pub(crate) fn low_voltage_in_cycle(&mut self) -> bool {
-        unsafe { LOW_VOLTAGE_DETECTED }
+        unsafe { LOW_VOLTAGE_DETECTED == 1 }
     }
     pub(crate) fn store_consecutive_pump_count(&mut self, plant: usize, count: u32) {
         unsafe {
@@ -141,226 +326,103 @@ impl Esp<'_> {
         unsafe { CONSECUTIVE_WATERING_PLANT[plant] }
     }
     pub(crate) fn get_restart_to_conf(&mut self) -> bool {
-        unsafe { RESTART_TO_CONF }
+        unsafe { RESTART_TO_CONF == 1 }
     }
     pub(crate) fn set_restart_to_conf(&mut self, to_conf: bool) {
         unsafe {
-            RESTART_TO_CONF = to_conf;
+            if to_conf {
-        }
+                RESTART_TO_CONF = 1;
-    }
+            } else {
-
+                RESTART_TO_CONF = 0;
-    pub(crate) fn wifi_ap(&mut self) -> anyhow::Result<()> {
-        let ssid = match self.load_config() {
-            Ok(config) => config.network.ap_ssid.clone(),
-            Err(_) => heapless::String::from_str("PlantCtrl Emergency Mode").unwrap(),
-        };
-
-        let apconfig = AccessPointConfiguration {
-            ssid,
-            auth_method: AuthMethod::None,
-            ssid_hidden: false,
-            ..Default::default()
-        };
-        self.wifi_driver
-            .set_configuration(&Configuration::AccessPoint(apconfig))?;
-        self.wifi_driver.start()?;
-        anyhow::Ok(())
-    }
-
-    pub(crate) fn wifi(&mut self, network_config: &NetworkConfig) -> anyhow::Result<IpInfo> {
-        let ssid = network_config
-            .ssid
-            .clone()
-            .ok_or(anyhow!("No ssid configured"))?;
-        let password = network_config.password.clone();
-        let max_wait = network_config.max_wait;
-
-        match password {
-            Some(pw) => {
-                //TODO expect error due to invalid pw or similar! //call this during configuration and check if works, revert to config mode if not
-                self.wifi_driver.set_configuration(&Configuration::Client(
-                    ClientConfiguration {
-                        ssid,
-                        password: pw,
-                        ..Default::default()
-                    },
-                ))?;
-            }
-            None => {
-                self.wifi_driver.set_configuration(&Configuration::Client(
-                    ClientConfiguration {
-                        ssid,
-                        auth_method: AuthMethod::None,
-                        ..Default::default()
-                    },
-                ))?;
             }
         }
-
-        self.wifi_driver.start()?;
-        self.wifi_driver.connect()?;
-
-        let delay = Delay::new_default();
-        let mut counter = 0_u32;
-        while !self.wifi_driver.is_connected()? {
-            delay.delay_ms(250);
-            counter += 250;
-            if counter > max_wait {
-                //ignore these errors, Wi-Fi will not be used this
-                self.wifi_driver.disconnect().unwrap_or(());
-                self.wifi_driver.stop().unwrap_or(());
-                bail!("Did not manage wifi connection within timeout");
-            }
-        }
-        println!("Should be connected now, waiting for link to be up");
-
-        while !self.wifi_driver.is_up()? {
-            delay.delay_ms(250);
-            counter += 250;
-            if counter > max_wait {
-                //ignore these errors, Wi-Fi will not be used this
-                self.wifi_driver.disconnect().unwrap_or(());
-                self.wifi_driver.stop().unwrap_or(());
-                bail!("Did not manage wifi connection within timeout");
-            }
-        }
-        //update freertos registers ;)
-        let address = self.wifi_driver.sta_netif().get_ip_info()?;
-        log(LogMessage::WifiInfo, 0, 0, "", &format!("{address:?}"));
-        anyhow::Ok(address)
-    }
-    pub(crate) fn load_config(&mut self) -> anyhow::Result<PlantControllerConfig> {
-        let cfg = File::open(Self::CONFIG_FILE)?;
-        let config: PlantControllerConfig = serde_json::from_reader(cfg)?;
-        anyhow::Ok(config)
-    }
-    pub(crate) fn save_config(&mut self, config: &PlantControllerConfig) -> anyhow::Result<()> {
-        let mut cfg = File::create(Self::CONFIG_FILE)?;
-        serde_json::to_writer(&mut cfg, &config)?;
-        println!("Wrote config config {:?}", config);
-        anyhow::Ok(())
-    }
-    pub(crate) fn mount_file_system(&mut self) -> anyhow::Result<()> {
-        log(LogMessage::MountingFilesystem, 0, 0, "", "");
-        let base_path = CString::new("/spiffs")?;
-        let storage = CString::new(Self::SPIFFS_PARTITION_NAME)?;
-        let conf = esp_idf_sys::esp_vfs_spiffs_conf_t {
-            base_path: base_path.as_ptr(),
-            partition_label: storage.as_ptr(),
-            max_files: 5,
-            format_if_mount_failed: true,
-        };
-
-        unsafe {
-            esp_idf_sys::esp!(esp_idf_sys::esp_vfs_spiffs_register(&conf))?;
-        }
-
-        let free_space = self.file_system_size()?;
-        log(
-            LogMessage::FilesystemMount,
-            free_space.free_size as u32,
-            free_space.total_size as u32,
-            &free_space.used_size.to_string(),
-            "",
-        );
-        anyhow::Ok(())
-    }
-    fn file_system_size(&mut self) -> anyhow::Result<FileSystemSizeInfo> {
-        let storage = CString::new(Self::SPIFFS_PARTITION_NAME)?;
-        let mut total_size = 0;
-        let mut used_size = 0;
-        unsafe {
-            esp_idf_sys::esp!(esp_spiffs_info(
-                storage.as_ptr(),
-                &mut total_size,
-                &mut used_size
-            ))?;
-        }
-        anyhow::Ok(FileSystemSizeInfo {
-            total_size,
-            used_size,
-            free_size: total_size - used_size,
-        })
     }
 
-    pub(crate) fn list_files(&self) -> FileList {
+    pub fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
-        let storage = CString::new(Self::SPIFFS_PARTITION_NAME).unwrap();
+        // Mark the current OTA image as valid if we reached here while in pending verify.
-
+        if let Ok(cur) = self.ota.current_ota_state() {
-        let mut file_system_corrupt = None;
+            if cur == OtaImageState::PendingVerify {
-
+                info!("Marking OTA image as valid");
-        let mut iter_error = None;
+                if let Err(err) = self.ota.set_current_ota_state(Valid) {
-        let mut result = Vec::new();
+                    error!("Could not set image to valid: {:?}", err);
-
-        let filepath = Path::new(Self::BASE_PATH);
-        let read_dir = fs::read_dir(filepath);
-        match read_dir {
-            OkStd(read_dir) => {
-                for item in read_dir {
-                    match item {
-                        OkStd(file) => {
-                            let f = FileInfo {
-                                filename: file.file_name().into_string().unwrap(),
-                                size: file.metadata().map(|it| it.len()).unwrap_or_default()
-                                    as usize,
-                            };
-                            result.push(f);
-                        }
-                        Err(err) => {
-                            iter_error = Some(format!("{err:?}"));
-                            break;
-                        }
-                    }
                 }
             }
-            Err(err) => {
-                file_system_corrupt = Some(format!("{err:?}"));
-            }
-        }
-        let mut total: usize = 0;
-        let mut used: usize = 0;
-        unsafe {
-            esp_spiffs_info(storage.as_ptr(), &mut total, &mut used);
-        }
-
-        FileList {
-            total,
-            used,
-            file_system_corrupt,
-            files: result,
-            iter_error,
-        }
-    }
-    pub(crate) fn delete_file(&self, filename: &str) -> anyhow::Result<()> {
-        let filepath = Path::new(Self::BASE_PATH).join(Path::new(filename));
-        match fs::remove_file(filepath) {
-            OkStd(_) => anyhow::Ok(()),
-            Err(err) => {
-                bail!(format!("{err:?}"))
-            }
-        }
-    }
-    pub(crate) fn get_file_handle(&self, filename: &str, write: bool) -> anyhow::Result<File> {
-        let filepath = Path::new(Self::BASE_PATH).join(Path::new(filename));
-        anyhow::Ok(if write {
-            File::create(filepath)?
         } else {
-            File::open(filepath)?
+            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 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]);
+        }
     }
 
-    pub(crate) fn init_rtc_deepsleep_memory(&self, init_rtc_store: bool, to_config_mode: bool) {
+    pub(crate) async fn load_config(&mut self) -> FatResult<PlantControllerConfig> {
+        let cfg = PathBuf::try_from(CONFIG_FILE).unwrap();
+        let data = self.fs.lock().await.read::<4096>(&cfg)?;
+        let config: PlantControllerConfig = serde_json::from_slice(&data)?;
+        return Ok(config);
+    }
+    pub(crate) async fn save_config(&mut self, config: Vec<u8>) -> FatResult<()> {
+        let filesystem = self.fs.lock().await;
+        let cfg = PathBuf::try_from(CONFIG_FILE)?;
+        filesystem.write(&cfg, &*config)?;
+        Ok(())
+    }
+    pub(crate) async fn list_files(&self) -> FatResult<FileList> {
+        let path = PathBuf::new();
+
+        let fs = self.fs.lock().await;
+        let free_size = fs.available_space()?;
+        let total_size = fs.total_space();
+
+        let mut result = FileList {
+            total: total_size,
+            used: total_size - free_size,
+            files: Vec::new(),
+        };
+
+        fs.read_dir_and_then(&path, |dir| {
+            for entry in dir {
+                let e = entry?;
+                if e.file_type() == FileType::File {
+                    result.files.push(FileInfo {
+                        filename: e.path().to_string(),
+                        size: e.metadata().len(),
+                    });
+                }
+            }
+            Ok(())
+        })?;
+        Ok(result)
+    }
+
+    pub(crate) async fn init_rtc_deepsleep_memory(
+        &self,
+        init_rtc_store: bool,
+        to_config_mode: bool,
+    ) {
         if init_rtc_store {
             unsafe {
                 LAST_WATERING_TIMESTAMP = [0; PLANT_COUNT];
                 CONSECUTIVE_WATERING_PLANT = [0; PLANT_COUNT];
-                LOW_VOLTAGE_DETECTED = false;
+                LOW_VOLTAGE_DETECTED = 0;
-                crate::log::init();
+                if to_config_mode {
-                RESTART_TO_CONF = to_config_mode;
+                    RESTART_TO_CONF = 1
+                } else {
+                    RESTART_TO_CONF = 0;
+                }
+                LAST_CORROSION_PROTECTION_CHECK_DAY = -1;
             };
         } else {
             unsafe {
                 if to_config_mode {
-                    RESTART_TO_CONF = true;
+                    RESTART_TO_CONF = 1;
                 }
                 log(
                     LogMessage::RestartToConfig,
@@ -376,227 +438,18 @@ impl Esp<'_> {
                     "",
                     "",
                 );
-                for i in 0..PLANT_COUNT {
+                // is executed before main, no other code will alter these values during printing
-                    println!(
+                #[allow(static_mut_refs)]
-                        "LAST_WATERING_TIMESTAMP[{}] = UTC {}",
+                for (i, time) in LAST_WATERING_TIMESTAMP.iter().enumerate() {
-                        i, LAST_WATERING_TIMESTAMP[i]
+                    info!("LAST_WATERING_TIMESTAMP[{i}] = UTC {time}");
-                    );
                 }
-                for i in 0..PLANT_COUNT {
+                // is executed before main, no other code will alter these values during printing
-                    println!(
+                #[allow(static_mut_refs)]
-                        "CONSECUTIVE_WATERING_PLANT[{}] = {}",
+                for (i, item) in CONSECUTIVE_WATERING_PLANT.iter().enumerate() {
-                        i, CONSECUTIVE_WATERING_PLANT[i]
+                    info!("CONSECUTIVE_WATERING_PLANT[{i}] = {item}");
-                    );
                 }
             }
         }
     }
 
-    pub(crate) fn mqtt(&mut self, network_config: &NetworkConfig) -> anyhow::Result<()> {
-        let base_topic = network_config
-            .base_topic
-            .as_ref()
-            .context("missing base topic")?;
-        if base_topic.is_empty() {
-            bail!("Mqtt base_topic was empty")
-        }
-        let base_topic_copy = base_topic.clone();
-        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 mqtt_client_config = MqttClientConfiguration {
-            lwt: Some(LwtConfiguration {
-                topic: &last_will_topic,
-                payload: "lost".as_bytes(),
-                qos: AtLeastOnce,
-                retain: true,
-            }),
-            client_id: Some("plantctrl"),
-            keep_alive_interval: Some(Duration::from_secs(60 * 60 * 2)),
-            username: network_config.mqtt_user.as_ref().map(|v| &**v),
-            password: network_config.mqtt_password.as_ref().map(|v| &**v),
-            //room for improvement
-            ..Default::default()
-        };
-
-        let mqtt_connected_event_received = Arc::new(AtomicBool::new(false));
-        let mqtt_connected_event_ok = Arc::new(AtomicBool::new(false));
-
-        let round_trip_ok = Arc::new(AtomicBool::new(false));
-        let round_trip_topic = format!("{}/internal/roundtrip", base_topic);
-        let stay_alive_topic = format!("{}/stay_alive", base_topic);
-        log(LogMessage::StayAlive, 0, 0, "", &stay_alive_topic);
-
-        let mqtt_connected_event_received_copy = mqtt_connected_event_received.clone();
-        let mqtt_connected_event_ok_copy = mqtt_connected_event_ok.clone();
-        let stay_alive_topic_copy = stay_alive_topic.clone();
-        let round_trip_topic_copy = round_trip_topic.clone();
-        let round_trip_ok_copy = round_trip_ok.clone();
-        let client_id = mqtt_client_config.client_id.unwrap_or("not set");
-        log(LogMessage::MqttInfo, 0, 0, client_id, mqtt_url);
-        let mut client = EspMqttClient::new_cb(mqtt_url, &mqtt_client_config, move |event| {
-            let payload = event.payload();
-            match payload {
-                embedded_svc::mqtt::client::EventPayload::Received {
-                    id: _,
-                    topic,
-                    data,
-                    details: _,
-                } => {
-                    let data = String::from_utf8_lossy(data);
-                    if let Some(topic) = topic {
-                        //todo use enums
-                        if topic.eq(round_trip_topic_copy.as_str()) {
-                            round_trip_ok_copy.store(true, std::sync::atomic::Ordering::Relaxed);
-                        } else if topic.eq(stay_alive_topic_copy.as_str()) {
-                            let value =
-                                data.eq_ignore_ascii_case("true") || data.eq_ignore_ascii_case("1");
-                            log(LogMessage::MqttStayAliveRec, 0, 0, &data, "");
-                            STAY_ALIVE.store(value, std::sync::atomic::Ordering::Relaxed);
-                        } else {
-                            log(LogMessage::UnknownTopic, 0, 0, "", topic);
-                        }
-                    }
-                }
-                esp_idf_svc::mqtt::client::EventPayload::Connected(_) => {
-                    mqtt_connected_event_received_copy
-                        .store(true, std::sync::atomic::Ordering::Relaxed);
-                    mqtt_connected_event_ok_copy.store(true, std::sync::atomic::Ordering::Relaxed);
-                    println!("Mqtt connected");
-                }
-                esp_idf_svc::mqtt::client::EventPayload::Disconnected => {
-                    mqtt_connected_event_received_copy
-                        .store(true, std::sync::atomic::Ordering::Relaxed);
-                    mqtt_connected_event_ok_copy.store(false, std::sync::atomic::Ordering::Relaxed);
-                    println!("Mqtt disconnected");
-                }
-                esp_idf_svc::mqtt::client::EventPayload::Error(esp_error) => {
-                    println!("EspMqttError reported {:?}", esp_error);
-                    mqtt_connected_event_received_copy
-                        .store(true, std::sync::atomic::Ordering::Relaxed);
-                    mqtt_connected_event_ok_copy.store(false, std::sync::atomic::Ordering::Relaxed);
-                    println!("Mqtt error");
-                }
-                esp_idf_svc::mqtt::client::EventPayload::BeforeConnect => {
-                    println!("Mqtt before connect")
-                }
-                esp_idf_svc::mqtt::client::EventPayload::Subscribed(_) => {
-                    println!("Mqtt subscribed")
-                }
-                esp_idf_svc::mqtt::client::EventPayload::Unsubscribed(_) => {
-                    println!("Mqtt unsubscribed")
-                }
-                esp_idf_svc::mqtt::client::EventPayload::Published(_) => {
-                    println!("Mqtt published")
-                }
-                esp_idf_svc::mqtt::client::EventPayload::Deleted(_) => {
-                    println!("Mqtt deleted")
-                }
-            }
-        })?;
-
-        let mut wait_for_connections_event = 0;
-        while wait_for_connections_event < 100 {
-            wait_for_connections_event += 1;
-            match mqtt_connected_event_received.load(std::sync::atomic::Ordering::Relaxed) {
-                true => {
-                    println!("Mqtt connection callback received, progressing");
-                    match mqtt_connected_event_ok.load(std::sync::atomic::Ordering::Relaxed) {
-                        true => {
-                            println!("Mqtt did callback as connected, testing with roundtrip now");
-                            //subscribe to roundtrip
-                            client.subscribe(round_trip_topic.as_str(), ExactlyOnce)?;
-                            client.subscribe(stay_alive_topic.as_str(), ExactlyOnce)?;
-                            //publish to roundtrip
-                            client.publish(
-                                round_trip_topic.as_str(),
-                                ExactlyOnce,
-                                false,
-                                "online_test".as_bytes(),
-                            )?;
-
-                            let mut wait_for_roundtrip = 0;
-                            while wait_for_roundtrip < 100 {
-                                wait_for_roundtrip += 1;
-                                match round_trip_ok.load(std::sync::atomic::Ordering::Relaxed) {
-                                    true => {
-                                        println!("Round trip registered, proceeding");
-                                        self.mqtt_client = Some(MqttClient {
-                                            mqtt_client: client,
-                                            base_topic: base_topic_copy,
-                                        });
-                                        return anyhow::Ok(());
-                                    }
-                                    false => {
-                                        unsafe { vTaskDelay(10) };
-                                    }
-                                }
-                            }
-                            bail!("Mqtt did not complete roundtrip in time");
-                        }
-                        false => {
-                            bail!("Mqtt did respond but with failure")
-                        }
-                    }
-                }
-                false => {
-                    unsafe { vTaskDelay(10) };
-                }
-            }
-        }
-        bail!("Mqtt did not fire connection callback in time");
-    }
-    pub(crate) fn mqtt_publish(&mut self, subtopic: &str, message: &[u8]) -> anyhow::Result<()> {
-        if self.mqtt_client.is_none() {
-            return anyhow::Ok(());
-        }
-        if !subtopic.starts_with("/") {
-            println!("Subtopic without / at start {}", subtopic);
-            bail!("Subtopic without / at start {}", subtopic);
-        }
-        if subtopic.len() > 192 {
-            println!("Subtopic exceeds 192 chars {}", subtopic);
-            bail!("Subtopic exceeds 192 chars {}", subtopic);
-        }
-        let client = self.mqtt_client.as_mut().unwrap();
-        let mut full_topic: heapless::String<256> = heapless::String::new();
-        if full_topic.push_str(client.base_topic.as_str()).is_err() {
-            println!("Some error assembling full_topic 1");
-            bail!("Some error assembling full_topic 1")
-        };
-        if full_topic.push_str(subtopic).is_err() {
-            println!("Some error assembling full_topic 2");
-            bail!("Some error assembling full_topic 2")
-        };
-        let publish = client
-            .mqtt_client
-            .publish(&full_topic, ExactlyOnce, true, message);
-        Delay::new(10).delay_ms(50);
-        match publish {
-            OkStd(message_id) => {
-                println!(
-                    "Published mqtt topic {} with message {:#?} msgid is {:?}",
-                    full_topic,
-                    String::from_utf8_lossy(message),
-                    message_id
-                );
-                anyhow::Ok(())
-            }
-            Err(err) => {
-                println!(
-                    "Error during mqtt send on topic {} with message {:#?} error is {:?}",
-                    full_topic,
-                    String::from_utf8_lossy(message),
-                    err
-                );
-                Err(err)?
-            }
-        }
-    }
 }

rust/src/hal/initial_hal.rs

@@ -1,64 +1,63 @@
+use crate::alloc::boxed::Box;
+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::{deep_sleep, BoardInteraction, FreePeripherals, Sensor};
+use crate::hal::{BoardInteraction, FreePeripherals, Sensor};
 use crate::{
+    bail,
     config::PlantControllerConfig,
     hal::battery::{BatteryInteraction, NoBatteryMonitor},
 };
-use anyhow::{bail, Result};
+use async_trait::async_trait;
-use chrono::{DateTime, Utc};
+use chrono::{DateTime, FixedOffset, Utc};
-use embedded_hal::digital::OutputPin;
+use esp_hal::gpio::{Level, Output, OutputConfig};
-use esp_idf_hal::gpio::{IOPin, Pull};
-use esp_idf_hal::gpio::{InputOutput, PinDriver};
 use measurements::{Current, Voltage};
 
 pub struct Initial<'a> {
-    pub(crate) general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    pub(crate) general_fault: Output<'a>,
     pub(crate) esp: Esp<'a>,
     pub(crate) config: PlantControllerConfig,
     pub(crate) battery: Box<dyn BatteryInteraction + Send>,
     pub rtc: Box<dyn RTCModuleInteraction + Send>,
 }
 
-struct NoRTC {}
+pub(crate) struct NoRTC {}
 
+#[async_trait]
 impl RTCModuleInteraction for NoRTC {
-    fn get_backup_info(&mut self) -> Result<BackupHeader> {
+    async fn get_backup_info(&mut self) -> Result<BackupHeader, FatError> {
         bail!("Please configure board revision")
     }
 
-    fn get_backup_config(&mut self) -> Result<Vec<u8>> {
+    async fn get_backup_config(&mut self, _chunk: usize) -> FatResult<([u8; 32], usize, u16)> {
         bail!("Please configure board revision")
     }
 
-    fn backup_config(&mut self, _bytes: &[u8]) -> Result<()> {
+    async fn backup_config(&mut self, _offset: usize, _bytes: &[u8]) -> FatResult<()> {
         bail!("Please configure board revision")
     }
 
-    fn get_rtc_time(&mut self) -> Result<DateTime<Utc>> {
+    async fn backup_config_finalize(&mut self, _crc: u16, _length: usize) -> FatResult<()> {
         bail!("Please configure board revision")
     }
 
-    fn set_rtc_time(&mut self, _time: &DateTime<Utc>) -> Result<()> {
+    async fn get_rtc_time(&mut self) -> Result<DateTime<Utc>, FatError> {
+        bail!("Please configure board revision")
+    }
+
+    async fn set_rtc_time(&mut self, _time: &DateTime<Utc>) -> Result<(), FatError> {
         bail!("Please configure board revision")
     }
 }
 
 pub(crate) fn create_initial_board(
-    free_pins: FreePeripherals,
+    free_pins: FreePeripherals<'static>,
-    fs_mount_error: bool,
     config: PlantControllerConfig,
     esp: Esp<'static>,
-) -> Result<Box<dyn BoardInteraction<'static> + Send>> {
+) -> Result<Box<dyn BoardInteraction<'static> + Send>, FatError> {
-    println!("Start initial");
+    log::info!("Start initial");
-    let mut general_fault = PinDriver::input_output(free_pins.gpio6.downgrade())?;
+    let general_fault = Output::new(free_pins.gpio23, Level::Low, OutputConfig::default());
-    general_fault.set_pull(Pull::Floating)?;
-    general_fault.set_low()?;
-
-    if fs_mount_error {
-        general_fault.set_high()?
-    }
     let v = Initial {
         general_fault,
         config,
@@ -69,9 +68,10 @@ pub(crate) fn create_initial_board(
     Ok(Box::new(v))
 }
 
+#[async_trait]
 impl<'a> BoardInteraction<'a> for Initial<'a> {
-    fn get_tank_sensor(&mut self) -> Option<&mut TankSensor<'a>> {
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
-        None
+        bail!("Please configure board revision")
     }
 
     fn get_esp(&mut self) -> &mut Esp<'a> {
@@ -90,55 +90,67 @@ impl<'a> BoardInteraction<'a> for Initial<'a> {
         &mut self.rtc
     }
 
-    fn set_charge_indicator(&mut self, _charging: bool) -> Result<()> {
+    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")
     }
 
-    fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
-        deep_sleep(duration_in_ms)
+        self.esp.deep_sleep_ms(duration_in_ms);
     }
     fn is_day(&self) -> bool {
         false
     }
-    fn light(&mut self, _enable: bool) -> Result<()> {
+    async fn light(&mut self, _enable: bool) -> Result<(), FatError> {
         bail!("Please configure board revision")
     }
 
-    fn pump(&mut self, _plant: usize, _enable: bool) -> Result<()> {
+    async fn pump(&mut self, _plant: usize, _enable: bool) -> Result<(), FatError> {
         bail!("Please configure board revision")
     }
 
-    fn pump_current(&mut self, _plant: usize) -> Result<Current> {
+    async fn pump_current(&mut self, _plant: usize) -> Result<Current, FatError> {
         bail!("Please configure board revision")
     }
 
-    fn fault(&mut self, _plant: usize, _enable: bool) -> Result<()> {
+    async fn fault(&mut self, _plant: usize, _enable: bool) -> Result<(), FatError> {
         bail!("Please configure board revision")
     }
 
-    fn measure_moisture_hz(&mut self, _plant: usize, _sensor: Sensor) -> Result<f32> {
+    async fn measure_moisture_hz(
+        &mut self,
+        _plant: usize,
+        _sensor: Sensor,
+    ) -> Result<f32, FatError> {
         bail!("Please configure board revision")
     }
 
-    fn general_fault(&mut self, enable: bool) {
+    async fn general_fault(&mut self, enable: bool) {
-        let _ = self.general_fault.set_state(enable.into());
+        self.general_fault.set_level(enable.into());
     }
 
-    fn test(&mut self) -> Result<()> {
+    async fn test(&mut self) -> Result<(), FatError> {
         bail!("Please configure board revision")
     }
 
-    fn set_config(&mut self, config: PlantControllerConfig) -> anyhow::Result<()> {
+    fn set_config(&mut self, config: PlantControllerConfig) {
         self.config = config;
-        self.esp.save_config(&self.config)?;
-        anyhow::Ok(())
     }
 
-    fn get_mptt_voltage(&mut self) -> Result<Voltage> {
+    async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError> {
         bail!("Please configure board revision")
     }
 
-    fn get_mptt_current(&mut self) -> Result<Current> {
+    async fn get_mptt_current(&mut self) -> Result<Current, FatError> {
         bail!("Please configure board revision")
     }
 }

rust/src/hal/little_fs2storage_adapter.rs

@@ -0,0 +1,88 @@
+use crate::hal::shared_flash::MutexFlashStorage;
+use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash};
+use esp_bootloader_esp_idf::partitions::FlashRegion;
+use littlefs2::consts::U4096 as lfsCache;
+use littlefs2::consts::U512 as lfsLookahead;
+use littlefs2::driver::Storage as lfs2Storage;
+use littlefs2::io::Error as lfs2Error;
+use littlefs2::io::Result as lfs2Result;
+use log::error;
+
+pub struct LittleFs2Filesystem {
+    pub(crate) storage: &'static mut FlashRegion<'static, MutexFlashStorage>,
+}
+
+impl lfs2Storage for LittleFs2Filesystem {
+    const READ_SIZE: usize = 4096;
+    const WRITE_SIZE: usize = 4096;
+    const BLOCK_SIZE: usize = 4096; //usually optimal for flash access
+    const BLOCK_COUNT: usize = 8 * 1000 * 1000 / 4096; //8Mb in 4k blocks + a little space for stupid calculation errors
+    const BLOCK_CYCLES: isize = 100;
+    type CACHE_SIZE = lfsCache;
+    type LOOKAHEAD_SIZE = lfsLookahead;
+
+    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}");
+            return Err(lfs2Error::IO);
+        }
+        if buf.len() % read_size != 0 {
+            error!("Littlefs2Filesystem read error: length not aligned to read size length: {} read_size: {}", buf.len(), read_size);
+            return Err(lfs2Error::IO);
+        }
+        match self.storage.read(off as u32, buf) {
+            Ok(..) => Ok(buf.len()),
+            Err(err) => {
+                error!("Littlefs2Filesystem read error: {err:?}");
+                Err(lfs2Error::IO)
+            }
+        }
+    }
+
+    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}");
+            return Err(lfs2Error::IO);
+        }
+        if data.len() % write_size != 0 {
+            error!("Littlefs2Filesystem write error: length not aligned to write size length: {} write_size: {}", data.len(), write_size);
+            return Err(lfs2Error::IO);
+        }
+        match self.storage.write(off as u32, data) {
+            Ok(..) => Ok(data.len()),
+            Err(err) => {
+                error!("Littlefs2Filesystem write error: {err:?}");
+                Err(lfs2Error::IO)
+            }
+        }
+    }
+
+    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);
+        }
+        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);
+        }
+
+        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);
+            }
+        }
+        match self.storage.erase(off as u32, (off + len) as u32) {
+            Ok(..) => Ok(len),
+            Err(err) => {
+                error!("Littlefs2Filesystem erase error: {err:?}");
+                Err(lfs2Error::IO)
+            }
+        }
+    }
+}

rust/src/hal/mod.rs

@@ -1,81 +1,133 @@
 pub(crate) mod battery;
-mod esp;
+pub mod esp;
 mod initial_hal;
-mod rtc;
+mod little_fs2storage_adapter;
+pub(crate) mod rtc;
+mod shared_flash;
 mod v3_hal;
+mod v3_shift_register;
 mod v4_hal;
-mod water;
 mod v4_sensor;
+mod water;
 
+use crate::alloc::string::ToString;
 use crate::hal::rtc::{DS3231Module, RTCModuleInteraction};
-use crate::hal::water::TankSensor;
+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;
+use esp_hal::peripherals::GPIO12;
+use esp_hal::peripherals::GPIO13;
+use esp_hal::peripherals::GPIO14;
+use esp_hal::peripherals::GPIO15;
+use esp_hal::peripherals::GPIO16;
+use esp_hal::peripherals::GPIO17;
+use esp_hal::peripherals::GPIO18;
+use esp_hal::peripherals::GPIO2;
+use esp_hal::peripherals::GPIO21;
+use esp_hal::peripherals::GPIO22;
+use esp_hal::peripherals::GPIO23;
+use esp_hal::peripherals::GPIO24;
+use esp_hal::peripherals::GPIO25;
+use esp_hal::peripherals::GPIO26;
+use esp_hal::peripherals::GPIO27;
+use esp_hal::peripherals::GPIO28;
+use esp_hal::peripherals::GPIO29;
+use esp_hal::peripherals::GPIO3;
+use esp_hal::peripherals::GPIO30;
+use esp_hal::peripherals::GPIO4;
+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,
     config::{BatteryBoardVersion, BoardVersion, PlantControllerConfig},
     hal::{
-        battery::{print_battery_bq34z100, BatteryInteraction, NoBatteryMonitor},
+        battery::{BatteryInteraction, NoBatteryMonitor},
         esp::Esp,
     },
-    log::{log, LogMessage},
+    log::LogMessage,
+    BOARD_ACCESS,
 };
-use anyhow::{Ok, Result};
+use alloc::boxed::Box;
-use battery::BQ34Z100G1;
+use alloc::format;
+use alloc::sync::Arc;
+use async_trait::async_trait;
 use bq34z100::Bq34z100g1Driver;
+use chrono::{DateTime, FixedOffset, Utc};
+use core::cell::RefCell;
+use ds323x::ic::DS3231;
+use ds323x::interface::I2cInterface;
 use ds323x::{DateTimeAccess, Ds323x};
+use eeprom24x::addr_size::TwoBytes;
+use eeprom24x::page_size::B32;
+use eeprom24x::unique_serial::No;
 use eeprom24x::{Eeprom24x, SlaveAddr, Storage};
-use embedded_hal_bus::i2c::MutexDevice;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
-use esp_idf_hal::pcnt::PCNT1;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use esp_idf_hal::{
+use embassy_sync::blocking_mutex::CriticalSectionMutex;
-    adc::ADC1,
+use embedded_storage::nor_flash::RmwNorFlashStorage;
-    delay::Delay,
+use embedded_storage::ReadStorage;
-    gpio::{
+use esp_bootloader_esp_idf::partitions::{
-        Gpio0, Gpio1, Gpio10, Gpio11, Gpio12, Gpio13, Gpio14, Gpio15, Gpio16, Gpio17, Gpio18,
+    AppPartitionSubType, DataPartitionSubType, FlashRegion, PartitionEntry, PartitionTable,
-        Gpio2, Gpio21, Gpio22, Gpio23, Gpio24, Gpio25, Gpio26, Gpio27, Gpio28, Gpio29, Gpio3,
+    PartitionType, 
-        Gpio30, Gpio4, Gpio5, Gpio6, Gpio7, Gpio8, IOPin, PinDriver, Pull,
-    },
-    i2c::{APBTickType, I2cConfig, I2cDriver},
-    pcnt::PCNT0,
-    prelude::Peripherals,
-    reset::ResetReason,
-    units::FromValueType,
 };
-use esp_idf_svc::{eventloop::EspSystemEventLoop, nvs::EspDefaultNvsPartition, wifi::EspWifi};
+use esp_hal::clock::CpuClock;
-use esp_idf_sys::{
+use esp_hal::gpio::{Input, InputConfig, Pull};
-    esp_deep_sleep, esp_restart, esp_sleep_enable_ext1_wakeup,
+use esp_hal::uart::{Config as UartConfig, Uart};
-    esp_sleep_ext1_wakeup_mode_t_ESP_EXT1_WAKEUP_ANY_LOW,
+use esp_storage::FlashStorage;
-};
+use lib_bms_protocol::{BmsReadable, ProtocolVersion};
-use esp_ota::mark_app_valid;
 use measurements::{Current, Voltage};
-use once_cell::sync::Lazy;
+
-use std::result::Result::Ok as OkStd;
+use crate::fat_error::{ContextExt, FatError, FatResult};
-use std::sync::Mutex;
+use crate::hal::battery::{print_battery_bq34z100, BQ34Z100G1};
-use std::time::Duration;
+use crate::hal::little_fs2storage_adapter::LittleFs2Filesystem;
-use esp_idf_hal::can::CAN;
+use crate::hal::water::TankSensor;
-use esp_idf_hal::pcnt::PCNT1;
+use crate::log::log;
+use embassy_sync::mutex::Mutex;
+use embassy_sync::once_lock::OnceLock;
+use esp_alloc as _;
+use esp_backtrace as _;
+use esp_bootloader_esp_idf::ota::{OtaImageState, Ota};
+use esp_hal::delay::Delay;
+use esp_hal::i2c::master::{BusTimeout, Config, I2c};
+use esp_hal::pcnt::unit::Unit;
+use esp_hal::pcnt::Pcnt;
+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::Blocking;
+use littlefs2::fs::{Allocation, Filesystem as lfs2Filesystem};
+use littlefs2::object_safe::DynStorage;
+use log::{error, info, warn};
+use shared_flash::MutexFlashStorage;
+
+pub static PROGRESS_ACTIVE: AtomicBool = AtomicBool::new(false);
 
 //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();
+
 const TANK_MULTI_SAMPLE: usize = 11;
-
+pub static I2C_DRIVER: OnceLock<
-pub static I2C_DRIVER: Lazy<Mutex<I2cDriver<'static>>> = Lazy::new(PlantHal::create_i2c);
+    embassy_sync::blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<I2c<Blocking>>>,
-
+> = OnceLock::new();
-fn deep_sleep(duration_in_ms: u64) -> ! {
-    unsafe {
-        //if we don't do this here, we might just revert newly flashed firmware
-        mark_app_valid();
-        //allow early wakeup by pressing the boot button
-        if duration_in_ms == 0 {
-            esp_restart();
-        } else {
-            //configure gpio 1 to wakeup on low, reused boot button for this
-            esp_sleep_enable_ext1_wakeup(
-                0b10u64,
-                esp_sleep_ext1_wakeup_mode_t_ESP_EXT1_WAKEUP_ANY_LOW,
-            );
-            esp_deep_sleep(duration_in_ms);
-        }
-    };
-}
 
 #[derive(Debug, PartialEq)]
 pub enum Sensor {
@@ -89,170 +141,354 @@ 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) -> Option<&mut TankSensor<'a>>;
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError>;
     fn get_esp(&mut self) -> &mut Esp<'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>;
-    fn set_charge_indicator(&mut self, charging: bool) -> Result<()>;
+    async fn get_time(&mut self) -> DateTime<Utc>;
-    fn deep_sleep(&mut self, duration_in_ms: u64) -> !;
+    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) -> !;
 
     fn is_day(&self) -> bool;
     //should be multsampled
-    fn light(&mut self, enable: bool) -> Result<()>;
+    async fn light(&mut self, enable: bool) -> Result<(), FatError>;
-    fn pump(&mut self, plant: usize, enable: bool) -> Result<()>;
+    async fn pump(&mut self, plant: usize, enable: bool) -> Result<(), FatError>;
-    fn pump_current(&mut self, plant: usize) -> Result<Current>;
+    async fn pump_current(&mut self, plant: usize) -> Result<Current, FatError>;
-    fn fault(&mut self, plant: usize, enable: bool) -> Result<()>;
+    async fn fault(&mut self, plant: usize, enable: bool) -> Result<(), FatError>;
-    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32>;
+    async fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32, FatError>;
-    fn general_fault(&mut self, enable: bool);
+    async fn general_fault(&mut self, enable: bool);
-    fn test(&mut self) -> Result<()>;
+    async fn test(&mut self) -> Result<(), FatError>;
-    fn set_config(&mut self, config: PlantControllerConfig) -> Result<()>;
+    fn set_config(&mut self, config: PlantControllerConfig);
-    fn get_mptt_voltage(&mut self) -> anyhow::Result<Voltage>;
+    async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError>;
-    fn get_mptt_current(&mut self) -> anyhow::Result<Current>;
+    async fn get_mptt_current(&mut self) -> Result<Current, FatError>;
-}
 
-impl dyn BoardInteraction<'_> {
+    async fn progress(&mut self, counter: u32) {
-    //the counter is just some arbitrary number that increases whenever some progress was made, try to keep the updates < 10 per second for ux reasons
+        let current = counter % PLANT_COUNT as u32;
-    fn progress(&mut self, counter: u32) {
-        let even = counter % 2 == 0;
-        let current = counter / (PLANT_COUNT as u32);
         for led in 0..PLANT_COUNT {
-            self.fault(led, current == led as u32).unwrap();
+            if let Err(err) = self.fault(led, current == led as u32).await {
+                warn!("Fault on plant {}: {:?}", led, err);
+            }
         }
-        let _ = self.general_fault(even.into());
+        let even = counter % 2 == 0;
+        let _ = self.general_fault(even.into()).await;
+    }
+
+    async fn clear_progress(&mut self) {
+        for led in 0..PLANT_COUNT {
+            if let Err(err) = self.fault(led, false).await {
+                warn!("Fault on plant {}: {:?}", led, err);
+            }
+        }
+        let _ = self.general_fault(false).await;
     }
 }
 
 #[allow(dead_code)]
-pub struct FreePeripherals {
+pub struct FreePeripherals<'a> {
-    pub gpio0: Gpio0,
+    pub gpio0: GPIO0<'a>,
-    pub gpio1: Gpio1,
+    pub gpio2: GPIO2<'a>,
-    pub gpio2: Gpio2,
+    pub gpio3: GPIO3<'a>,
-    pub gpio3: Gpio3,
+    pub gpio4: GPIO4<'a>,
-    pub gpio4: Gpio4,
+    pub gpio5: GPIO5<'a>,
-    pub gpio5: Gpio5,
+    pub gpio6: GPIO6<'a>,
-    pub gpio6: Gpio6,
+    pub gpio7: GPIO7<'a>,
-    pub gpio7: Gpio7,
+    pub gpio8: GPIO8<'a>,
-    pub gpio8: Gpio8,
+    // //config button here
-    //config button here
+    pub gpio10: GPIO10<'a>,
-    pub gpio10: Gpio10,
+    pub gpio11: GPIO11<'a>,
-    pub gpio11: Gpio11,
+    pub gpio12: GPIO12<'a>,
-    pub gpio12: Gpio12,
+    pub gpio13: GPIO13<'a>,
-    pub gpio13: Gpio13,
+    pub gpio14: GPIO14<'a>,
-    pub gpio14: Gpio14,
+    pub gpio15: GPIO15<'a>,
-    pub gpio15: Gpio15,
+    pub gpio16: GPIO16<'a>,
-    pub gpio16: Gpio16,
+    pub gpio17: GPIO17<'a>,
-    pub gpio17: Gpio17,
+    pub gpio18: GPIO18<'a>,
-    pub gpio18: Gpio18,
+    // //i2c here
-    //i2c here
+    pub gpio21: GPIO21<'a>,
-    pub gpio21: Gpio21,
+    pub gpio22: GPIO22<'a>,
-    pub gpio22: Gpio22,
+    pub gpio23: GPIO23<'a>,
-    pub gpio23: Gpio23,
+    pub gpio27: GPIO27<'a>,
-    pub gpio24: Gpio24,
+    pub twai: TWAI0<'a>,
-    pub gpio25: Gpio25,
+    pub pcnt0: Unit<'a, 0>,
-    pub gpio26: Gpio26,
+    pub pcnt1: Unit<'a, 1>,
-    pub gpio27: Gpio27,
+    pub adc1: ADC1<'a>,
-    pub gpio28: Gpio28,
-    pub gpio29: Gpio29,
-    pub gpio30: Gpio30,
-    pub pcnt0: PCNT0,
-    pub pcnt1: PCNT1,
-    pub adc1: ADC1,
-    pub can: CAN,
 }
 
+use crate::util::mk_static;
+
 impl PlantHal {
-    fn create_i2c() -> Mutex<I2cDriver<'static>> {
+    pub async fn create() -> Result<Mutex<CriticalSectionRawMutex, HAL<'static>>, FatError> {
-        let peripherals = unsafe { Peripherals::new() };
+        let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
+        let peripherals: Peripherals = esp_hal::init(config);
 
-        let config = I2cConfig::new()
+        esp_alloc::heap_allocator!(size: 64 * 1024);
-            .scl_enable_pullup(true)
+        esp_alloc::heap_allocator!(#[link_section = ".dram2_uninit"] size: 64000);
-            .sda_enable_pullup(true)
-            .baudrate(100_u32.kHz().into())
-            .timeout(APBTickType::from(Duration::from_millis(100)));
 
-        let i2c = peripherals.i2c0;
+        let mut rtc_peripheral: Rtc = Rtc::new(peripherals.LPWR);
-        let scl = peripherals.pins.gpio19.downgrade();
+        rtc_peripheral.rwdt.disable();
-        let sda = peripherals.pins.gpio20.downgrade();
 
-        Mutex::new(I2cDriver::new(i2c, sda, scl, &config).unwrap())
+        let timg0 = TimerGroup::new(peripherals.TIMG0);
-    }
+        let sw_int = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
+        esp_rtos::start(timg0.timer0, sw_int.software_interrupt0);
 
-    pub fn create() -> Result<Mutex<HAL<'static>>> {
+        let boot_button = Input::new(
-        let peripherals = Peripherals::take()?;
+            peripherals.GPIO9,
-        let sys_loop = EspSystemEventLoop::take()?;
+            InputConfig::default().with_pull(Pull::None),
-        let nvs = EspDefaultNvsPartition::take()?;
+        );
-        let wifi_driver = EspWifi::new(peripherals.modem, sys_loop, Some(nvs))?;
 
-        let mut boot_button = PinDriver::input(peripherals.pins.gpio9.downgrade())?;
+        // Reserve GPIO1 for deep sleep wake (configured just before entering sleep)
-        boot_button.set_pull(Pull::Floating)?;
+        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 pcnt_module = Pcnt::new(peripherals.PCNT);
 
         let free_pins = FreePeripherals {
-            can: peripherals.can,
+            gpio0: peripherals.GPIO0,
-            adc1: peripherals.adc1,
+            gpio2: peripherals.GPIO2,
-            pcnt0: peripherals.pcnt0,
+            gpio3: peripherals.GPIO3,
-            pcnt1: peripherals.pcnt1,
+            gpio4: peripherals.GPIO4,
-            gpio0: peripherals.pins.gpio0,
+            gpio5: peripherals.GPIO5,
-            gpio1: peripherals.pins.gpio1,
+            gpio6: peripherals.GPIO6,
-            gpio2: peripherals.pins.gpio2,
+            gpio7: peripherals.GPIO7,
-            gpio3: peripherals.pins.gpio3,
+            gpio8: peripherals.GPIO8,
-            gpio4: peripherals.pins.gpio4,
+            gpio10: peripherals.GPIO10,
-            gpio5: peripherals.pins.gpio5,
+            gpio11: peripherals.GPIO11,
-            gpio6: peripherals.pins.gpio6,
+            gpio12: peripherals.GPIO12,
-            gpio7: peripherals.pins.gpio7,
+            gpio13: peripherals.GPIO13,
-            gpio8: peripherals.pins.gpio8,
+            gpio14: peripherals.GPIO14,
-            gpio10: peripherals.pins.gpio10,
+            gpio15: peripherals.GPIO15,
-            gpio11: peripherals.pins.gpio11,
+            gpio16: peripherals.GPIO16,
-            gpio12: peripherals.pins.gpio12,
+            gpio17: peripherals.GPIO17,
-            gpio13: peripherals.pins.gpio13,
+            gpio18: peripherals.GPIO18,
-            gpio14: peripherals.pins.gpio14,
+            gpio21: peripherals.GPIO21,
-            gpio15: peripherals.pins.gpio15,
+            gpio22: peripherals.GPIO22,
-            gpio16: peripherals.pins.gpio16,
+            gpio23: peripherals.GPIO23,
-            gpio17: peripherals.pins.gpio17,
+            gpio27: peripherals.GPIO27,
-            gpio18: peripherals.pins.gpio18,
+            twai: peripherals.TWAI0,
-            gpio21: peripherals.pins.gpio21,
+            pcnt0: pcnt_module.unit0,
-            gpio22: peripherals.pins.gpio22,
+            pcnt1: pcnt_module.unit1,
-            gpio23: peripherals.pins.gpio23,
+            adc1: peripherals.ADC1,
-            gpio24: peripherals.pins.gpio24,
-            gpio25: peripherals.pins.gpio25,
-            gpio26: peripherals.pins.gpio26,
-            gpio27: peripherals.pins.gpio27,
-            gpio28: peripherals.pins.gpio28,
-            gpio29: peripherals.pins.gpio29,
-            gpio30: peripherals.pins.gpio30,
         };
 
+        let tablebuffer = mk_static!(
+            [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 pt =
+            esp_bootloader_esp_idf::partitions::read_partition_table(flash_storage, tablebuffer)?;
+
+        let ota_data = mk_static!(
+            PartitionEntry,
+            pt.find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
+                DataPartitionSubType::Ota,
+            ))?
+            .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 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)?;
+
+        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:?}");
+
+        //get 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");
+            }
+        };
+
+        let ota_target = mk_static!(PartitionEntry, ota_target);
+        let ota_target = mk_static!(
+            FlashRegion<MutexFlashStorage>,
+            ota_target.as_embedded_storage(flash_storage)
+        );
+
+        let data_partition = pt
+            .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
+                DataPartitionSubType::LittleFs,
+            ))?
+            .expect("Data partition with littlefs not found");
+        let data_partition = mk_static!(PartitionEntry, data_partition);
+
+        let data = mk_static!(
+            FlashRegion<MutexFlashStorage>,
+            data_partition.as_embedded_storage(flash_storage_3)
+        );
+        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");
+        } else {
+            match lfs2filesystem.format() {
+                Ok(..) => {
+                    info!("Littlefs2 filesystem is formatted");
+                }
+                Err(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 mut esp = Esp {
-            mqtt_client: None,
+            fs,
-            wifi_driver,
+            rng,
+            controller: Arc::new(Mutex::new(controller)),
+            interface_sta: Some(sta),
+            interface_ap: Some(ap),
             boot_button,
-            delay: Delay::new(1000),
+            wake_gpio1,
+            ota,
+            ota_target,
+            current: running,
+            slot0_state: state_0,
+            slot1_state: state_1,
+            uart0,
+            rtc: rtc_peripheral,
         };
 
         //init,reset rtc memory depending on cause
         let mut init_rtc_store: bool = false;
         let mut to_config_mode: bool = false;
-        let reasons = ResetReason::get();
+        let reasons = match reset_reason() {
-        match reasons {
+            None => "unknown",
-            ResetReason::Software => {}
+            Some(reason) => match reason {
-            ResetReason::ExternalPin => {}
+                SocResetReason::ChipPowerOn => "power on",
-            ResetReason::Watchdog => {
+                SocResetReason::CoreSDIO => "sdio reset",
-                init_rtc_store = true;
+                SocResetReason::CoreMwdt0 => "Watchdog Main",
-            }
+                SocResetReason::CoreMwdt1 => "Watchdog 1",
-            ResetReason::Sdio => init_rtc_store = true,
+                SocResetReason::CoreRtcWdt => "Watchdog RTC",
-            ResetReason::Panic => init_rtc_store = true,
+                SocResetReason::Cpu0Mwdt0 => "Watchdog MCpu0",
-            ResetReason::InterruptWatchdog => init_rtc_store = true,
+                SocResetReason::Cpu0Sw => "software reset cpu0",
-            ResetReason::PowerOn => init_rtc_store = true,
+                SocResetReason::SysRtcWdt => "Watchdog Sys rtc",
-            ResetReason::Unknown => init_rtc_store = true,
+                SocResetReason::Cpu0Mwdt1 => "cpu0 mwdt1",
-            ResetReason::Brownout => init_rtc_store = true,
+                SocResetReason::SysSuperWdt => "Watchdog Super",
-            ResetReason::TaskWatchdog => init_rtc_store = true,
+                SocResetReason::Cpu0RtcWdt => {
-            ResetReason::DeepSleep => {}
+                    init_rtc_store = true;
-            ResetReason::USBPeripheral => {
+                    "Watchdog RTC cpu0"
-                init_rtc_store = true;
+                }
-                to_config_mode = true;
+                SocResetReason::CoreSw => "software reset",
-            }
+                SocResetReason::CoreDeepSleep => "deep sleep",
-            ResetReason::JTAG => init_rtc_store = true,
+                SocResetReason::SysBrownOut => "sys brown out",
+                SocResetReason::CoreEfuseCrc => "core efuse crc",
+                SocResetReason::CoreUsbUart => {
+                    //TODO still required? or via button ignore? to_config_mode = true;
+                    to_config_mode = true;
+                    "core usb uart"
+                }
+                SocResetReason::CoreUsbJtag => "core usb jtag",
+                SocResetReason::Cpu0JtagCpu => "cpu0 jtag cpu",
+            },
         };
         log(
             LogMessage::ResetReason,
@@ -262,76 +498,100 @@ impl PlantHal {
             &format!("{reasons:?}"),
         );
 
-        esp.init_rtc_deepsleep_memory(init_rtc_store, to_config_mode);
-        let fs_mount_error = esp.mount_file_system().is_err();
 
-        let config = esp.load_config();
+        esp.init_rtc_deepsleep_memory(init_rtc_store, to_config_mode)
+            .await;
 
-        println!("Init rtc driver");
+        let config = esp.load_config().await;
-        let mut rtc = Ds323x::new_ds3231(MutexDevice::new(&I2C_DRIVER));
 
-        println!("Init rtc eeprom driver");
+        info!("Init rtc driver");
-        let eeprom = {
+
-            Eeprom24x::new_24x32(
+        let sda = peripherals.GPIO20;
-                MutexDevice::new(&I2C_DRIVER),
+        let scl = peripherals.GPIO19;
-                SlaveAddr::Alternative(true, true, true),
+
-            )
+        let i2c = I2c::new(
-        };
+            peripherals.I2C0,
+            Config::default()
+                .with_frequency(Rate::from_hz(100))
+                .with_timeout(BusTimeout::Maximum),
+        )?
+        .with_scl(scl)
+        .with_sda(sda);
+        let i2c_bus: embassy_sync::blocking_mutex::Mutex<
+            CriticalSectionRawMutex,
+            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 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 {
-            OkStd(tt) => {
+            Ok(tt) => {
-                println!("Rtc Module reports time at UTC {}", tt);
+                info!("Rtc Module reports time at UTC {tt}");
             }
             Err(err) => {
-                println!("Rtc Module could not be read {:?}", err);
+                info!("Rtc Module could not be read {err:?}");
             }
         }
 
-        let storage = Storage::new(eeprom, Delay::new(1000));
+        let storage: Storage<
+            I2cDevice<'static, CriticalSectionRawMutex, I2c<Blocking>>,
+            B32,
+            TwoBytes,
+            No,
+            Delay,
+        > = Storage::new(eeprom, Delay::new());
         let rtc_module: Box<dyn RTCModuleInteraction + Send> =
             Box::new(DS3231Module { rtc, storage }) as Box<dyn RTCModuleInteraction + Send>;
 
         let hal = match config {
-            Result::Ok(config) => {
+            Ok(config) => {
                 let battery_interaction: Box<dyn BatteryInteraction + Send> =
                     match config.hardware.battery {
                         BatteryBoardVersion::Disabled => Box::new(NoBatteryMonitor {}),
-                        BatteryBoardVersion::BQ34Z100G1 => {
-                            let mut battery_driver = Bq34z100g1Driver {
-                                i2c: MutexDevice::new(&I2C_DRIVER),
-                                delay: Delay::new(0),
-                                flash_block_data: [0; 32],
-                            };
-                            let status = print_battery_bq34z100(&mut battery_driver);
-                            match status {
-                                OkStd(_) => {}
-                                Err(err) => {
-                                    log(
-                                        LogMessage::BatteryCommunicationError,
-                                        0u32,
-                                        0,
-                                        "",
-                                        &format!("{err:?})"),
-                                    );
-                                }
-                            }
-                            Box::new(BQ34Z100G1 { battery_driver })
-                        }
                         BatteryBoardVersion::WchI2cSlave => {
-                            // TODO use correct implementation once availible
+                            let version = ProtocolVersion::read_from_i2c(&mut bms_device);
-                            Box::new(NoBatteryMonitor {})
+                            let version_val = match version {
+                                Ok(v) => unsafe { core::mem::transmute::<ProtocolVersion, u32>(v) },
+                                Err(_) => 0,
+                            };
+                            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 {})
+                            }
                         }
+                        BatteryBoardVersion::BQ34Z100G1 => Box::new(NoBatteryMonitor {}),
                     };
 
                 let board_hal: Box<dyn BoardInteraction + Send> = match config.hardware.board {
                     BoardVersion::INITIAL => {
-                        initial_hal::create_initial_board(free_pins, fs_mount_error, config, esp)?
+                        initial_hal::create_initial_board(free_pins, config, esp)?
                     }
                     BoardVersion::V3 => {
                         v3_hal::create_v3(free_pins, esp, config, battery_interaction, rtc_module)?
                     }
                     BoardVersion::V4 => {
-                        v4_hal::create_v4(free_pins, esp, config, battery_interaction, rtc_module)?
+                        v4_hal::create_v4(free_pins, esp, config, battery_interaction, rtc_module)
+                            .await?
                     }
                 };
 
@@ -348,7 +608,6 @@ impl PlantHal {
                 HAL {
                     board_hal: initial_hal::create_initial_board(
                         free_pins,
-                        fs_mount_error,
                         PlantControllerConfig::default(),
                         esp,
                     )?,
@@ -358,4 +617,13 @@ 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();
+            });
+        }
+    }
 }

rust/src/hal/rtc.rs

@@ -1,132 +1,133 @@
-use anyhow::{anyhow, bail};
+use crate::hal::Box;
+use crate::fat_error::FatResult;
+use async_trait::async_trait;
 use bincode::config::Configuration;
 use bincode::{config, Decode, Encode};
 use chrono::{DateTime, Utc};
+use ds323x::ic::DS3231;
+use ds323x::interface::I2cInterface;
 use ds323x::{DateTimeAccess, Ds323x};
 use eeprom24x::addr_size::TwoBytes;
 use eeprom24x::page_size::B32;
 use eeprom24x::unique_serial::No;
-use eeprom24x::Storage;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
-use embedded_hal_bus::i2c::MutexDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use embedded_storage::ReadStorage as embedded_storage_ReadStorage;
+use embedded_storage::{ReadStorage, Storage};
-use embedded_storage::Storage as embedded_storage_Storage;
+use esp_hal::delay::Delay;
-use esp_idf_hal::delay::Delay;
+use esp_hal::i2c::master::I2c;
-use esp_idf_hal::i2c::I2cDriver;
+use esp_hal::Blocking;
 use serde::{Deserialize, Serialize};
-use std::result::Result::Ok as OkStd;
 
-const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
+pub const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
 const CONFIG: Configuration = config::standard();
-
+//
+#[async_trait]
 pub trait RTCModuleInteraction {
-    fn get_backup_info(&mut self) -> anyhow::Result<BackupHeader>;
+    async fn get_backup_info(&mut self) -> FatResult<BackupHeader>;
-    fn get_backup_config(&mut self) -> anyhow::Result<Vec<u8>>;
+    async fn get_backup_config(&mut self, chunk: usize) -> FatResult<([u8; 32], usize, u16)>;
-    fn backup_config(&mut self, bytes: &[u8]) -> anyhow::Result<()>;
+    async fn backup_config(&mut self, offset: usize, bytes: &[u8]) -> FatResult<()>;
-    fn get_rtc_time(&mut self) -> anyhow::Result<DateTime<Utc>>;
+    async fn backup_config_finalize(&mut self, crc: u16, length: usize) -> FatResult<()>;
-    fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> anyhow::Result<()>;
+    async fn get_rtc_time(&mut self) -> FatResult<DateTime<Utc>>;
+    async fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> FatResult<()>;
 }
-
+//
 const BACKUP_HEADER_MAX_SIZE: usize = 64;
+
 #[derive(Serialize, Deserialize, PartialEq, Debug, Default, Encode, Decode)]
 pub struct BackupHeader {
     pub timestamp: i64,
     crc16: u16,
     pub size: u16,
 }
+//
+pub struct DS3231Module {
+    pub(crate) rtc: Ds323x<
+        I2cInterface<I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>>,
+        DS3231,
+    >,
 
-pub struct DS3231Module<'a> {
+    pub(crate) storage: eeprom24x::Storage<
-    pub(crate) rtc:
+        I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>,
-        Ds323x<ds323x::interface::I2cInterface<MutexDevice<'a, I2cDriver<'a>>>, ds323x::ic::DS3231>,
+        B32,
-
+        TwoBytes,
-    pub(crate) storage: Storage<MutexDevice<'a, I2cDriver<'a>>, B32, TwoBytes, No, Delay>,
+        No,
+        Delay,
+    >,
 }
 
-impl RTCModuleInteraction for DS3231Module<'_> {
+#[async_trait]
-    fn get_backup_info(&mut self) -> anyhow::Result<BackupHeader> {
+impl RTCModuleInteraction for DS3231Module {
+    async fn get_backup_info(&mut self) -> FatResult<BackupHeader> {
         let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
 
-        self.storage
+        self.storage.read(0, &mut header_page_buffer)?;
-            .read(0, &mut header_page_buffer)
-            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
 
         let (header, len): (BackupHeader, usize) =
             bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
 
-        println!("Raw header is {:?} with size {}", header_page_buffer, len);
+        log::info!("Raw header is {:?} with size {}", header_page_buffer, len);
-        anyhow::Ok(header)
+        Ok(header)
     }
 
-    fn get_backup_config(&mut self) -> anyhow::Result<Vec<u8>> {
+    async fn get_backup_config(&mut self, chunk: usize) -> FatResult<([u8; 32], usize, u16)> {
         let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
 
-        self.storage
+        self.storage.read(0, &mut header_page_buffer)?;
-            .read(0, &mut header_page_buffer)
-            .map_err(|err| anyhow!("Error reading eeprom header {:?}", err))?;
         let (header, _header_size): (BackupHeader, usize) =
             bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
 
-        let mut data_buffer = vec![0_u8; header.size as usize];
+        let mut buf = [0_u8; 32];
-        //read the specified number of bytes after the header
+        let offset = chunk * buf.len() + BACKUP_HEADER_MAX_SIZE;
-        self.storage
-            .read(BACKUP_HEADER_MAX_SIZE as u32, &mut data_buffer)
-            .map_err(|err| anyhow!("Error reading eeprom data {:?}", err))?;
 
-        let checksum = X25.checksum(&data_buffer);
+        let end: usize = header.size as usize + BACKUP_HEADER_MAX_SIZE;
-        if checksum != header.crc16 {
+        let current_end = offset + buf.len();
-            bail!(
+        let chunk_size = if current_end > end {
-                "Invalid checksum, got {} but expected {}",
+            end - offset
-                checksum,
+        } else {
-                header.crc16
+            buf.len()
-            );
+        };
+        if chunk_size == 0 {
+            Ok((buf, 0, header.crc16))
+        } else {
+            self.storage.read(offset as u32, &mut buf)?;
+            //&buf[..chunk_size];
+            Ok((buf, chunk_size, header.crc16))
         }
-
-        anyhow::Ok(data_buffer)
     }
-    fn backup_config(&mut self, bytes: &[u8]) -> anyhow::Result<()> {
+    async fn backup_config(&mut self, offset: usize, bytes: &[u8]) -> FatResult<()> {
+        //skip header and write after
+        self.storage
+            .write((BACKUP_HEADER_MAX_SIZE + offset) as u32, &bytes)?;
+
+        Ok(())
+    }
+
+    async fn backup_config_finalize(&mut self, crc: u16, length: usize) -> FatResult<()> {
         let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
 
-        let time = self.get_rtc_time()?.timestamp_millis();
+        let time = self.get_rtc_time().await?.timestamp_millis();
-        let checksum = X25.checksum(bytes);
-
         let header = BackupHeader {
-            crc16: checksum,
+            crc16: crc,
             timestamp: time,
-            size: bytes.len() as u16,
+            size: length as u16,
         };
         let config = config::standard();
         let encoded = bincode::encode_into_slice(&header, &mut header_page_buffer, config)?;
-        println!(
+        log::info!(
             "Raw header is {:?} with size {}",
-            header_page_buffer, encoded
+            header_page_buffer,
+            encoded
         );
-        self.storage
+        self.storage.write(0, &header_page_buffer)?;
-            .write(0, &header_page_buffer)
+        Ok(())
-            .map_err(|err| anyhow!("Error writing header {:?}", err))?;
-
-        //write rest after the header
-        self.storage
-            .write(BACKUP_HEADER_MAX_SIZE as u32, &bytes)
-            .map_err(|err| anyhow!("Error writing body {:?}", err))?;
-
-        anyhow::Ok(())
     }
 
-    fn get_rtc_time(&mut self) -> anyhow::Result<DateTime<Utc>> {
+    async fn get_rtc_time(&mut self) -> FatResult<DateTime<Utc>> {
-        match self.rtc.datetime() {
+        Ok(self.rtc.datetime()?.and_utc())
-            OkStd(rtc_time) => anyhow::Ok(rtc_time.and_utc()),
-            Err(err) => {
-                bail!("Error getting rtc time {:?}", err)
-            }
-        }
     }
 
-    fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> anyhow::Result<()> {
+    async fn set_rtc_time(&mut self, time: &DateTime<Utc>) -> FatResult<()> {
         let naive_time = time.naive_utc();
-        match self.rtc.set_datetime(&naive_time) {
+        Ok(self.rtc.set_datetime(&naive_time)?)
-            OkStd(_) => anyhow::Ok(()),
-            Err(err) => {
-                bail!("Error getting rtc time {:?}", err)
-            }
-        }
     }
 }

rust/src/hal/shared_flash.rs

@@ -0,0 +1,65 @@
+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))
+    }
+}

rust/src/hal/v3_hal.rs

@@ -1,23 +1,30 @@
+use crate::bail;
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::esp::{hold_disable, hold_enable};
 use crate::hal::rtc::RTCModuleInteraction;
+use crate::hal::v3_shift_register::ShiftRegister40;
 use crate::hal::water::TankSensor;
-use crate::hal::{
+use crate::hal::{BoardInteraction, FreePeripherals, Sensor, PLANT_COUNT};
-    deep_sleep, BoardInteraction, FreePeripherals, Sensor, PLANT_COUNT,
+use crate::log::{log, LogMessage, LOG_ACCESS};
-};
-use crate::log::{log, LogMessage};
 use crate::{
     config::PlantControllerConfig,
     hal::{battery::BatteryInteraction, esp::Esp},
 };
-use anyhow::{bail, Ok, Result};
+use alloc::boxed::Box;
-use embedded_hal::digital::OutputPin;
+use alloc::format;
-use esp_idf_hal::{
+use alloc::string::ToString;
-    gpio::{AnyInputPin, IOPin, InputOutput, PinDriver, Pull},
+use async_trait::async_trait;
-    pcnt::{PcntChannel, PcntChannelConfig, PcntControlMode, PcntCountMode, PcntDriver, PinIndex},
+use chrono::{DateTime, FixedOffset, Utc};
-};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use esp_idf_sys::{gpio_hold_dis, gpio_hold_en};
+use embassy_sync::mutex::Mutex;
+use embassy_time::Timer;
+use embedded_hal::digital::OutputPin as _;
+use esp_hal::gpio::{Flex, Input, InputConfig, Level, Output, OutputConfig, Pull};
+use esp_hal::pcnt::channel::CtrlMode::Keep;
+use esp_hal::pcnt::channel::EdgeMode;
+use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
+use esp_hal::pcnt::unit::Unit;
 use measurements::{Current, Voltage};
-use plant_ctrl2::sipo::ShiftRegister40;
-use std::result::Result::Ok as OkStd;
 
 const PUMP8_BIT: usize = 0;
 const PUMP1_BIT: usize = 1;
@@ -66,69 +73,57 @@ const FAULT_2: usize = 23;
 
 const REPEAT_MOIST_MEASURE: usize = 1;
 
-
 pub struct V3<'a> {
     config: PlantControllerConfig,
     battery_monitor: Box<dyn BatteryInteraction + Send>,
     rtc_module: Box<dyn RTCModuleInteraction + Send>,
     esp: Esp<'a>,
-    shift_register: ShiftRegister40<
+    shift_register:
-        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+        Mutex<CriticalSectionRawMutex, ShiftRegister40<Output<'a>, Output<'a>, Output<'a>>>,
-        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    _shift_register_enable_invert: Output<'a>,
-        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
-    >,
-    _shift_register_enable_invert:
-        PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Output>,
     tank_sensor: TankSensor<'a>,
-    solar_is_day: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
+    solar_is_day: Input<'a>,
-    light: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    light: Output<'a>,
-    main_pump: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    main_pump: Output<'a>,
-    general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    general_fault: Output<'a>,
-    signal_counter: PcntDriver<'a>,
+    pub signal_counter: Unit<'static, 0>,
 }
 
 pub(crate) fn create_v3(
-    peripherals: FreePeripherals,
+    peripherals: FreePeripherals<'static>,
     esp: Esp<'static>,
     config: PlantControllerConfig,
     battery_monitor: Box<dyn BatteryInteraction + Send>,
     rtc_module: Box<dyn RTCModuleInteraction + Send>,
-) -> Result<Box<dyn BoardInteraction<'static> + Send>> {
+) -> Result<Box<dyn BoardInteraction<'static> + Send + 'static>, FatError> {
-    println!("Start v3");
+    log::info!("Start v3");
-    let mut clock = PinDriver::input_output(peripherals.gpio15.downgrade())?;
+    let clock = Output::new(peripherals.gpio15, Level::Low, OutputConfig::default());
-    clock.set_pull(Pull::Floating)?;
+    let latch = Output::new(peripherals.gpio3, Level::Low, OutputConfig::default());
-    let mut latch = PinDriver::input_output(peripherals.gpio3.downgrade())?;
+    let data = Output::new(peripherals.gpio23, Level::Low, OutputConfig::default());
-    latch.set_pull(Pull::Floating)?;
-    let mut data = PinDriver::input_output(peripherals.gpio23.downgrade())?;
-    data.set_pull(Pull::Floating)?;
     let shift_register = ShiftRegister40::new(clock, latch, data);
     //disable all
     for mut pin in shift_register.decompose() {
-        pin.set_low()?;
+        let _ = pin.set_low();
     }
 
-    let awake = &mut shift_register.decompose()[AWAKE];
+    // Set always-on status bits
-    awake.set_high()?;
+    let _ = shift_register.decompose()[AWAKE].set_high();
+    let _ = shift_register.decompose()[CHARGING].set_high();
 
-    let charging = &mut shift_register.decompose()[CHARGING];
+    // Multiplexer defaults: ms0..ms3 low, ms4 high (disabled)
-    charging.set_high()?;
+    let _ = shift_register.decompose()[MS_0].set_low();
+    let _ = shift_register.decompose()[MS_1].set_low();
+    let _ = shift_register.decompose()[MS_2].set_low();
+    let _ = shift_register.decompose()[MS_3].set_low();
+    let _ = shift_register.decompose()[MS_4].set_high();
 
-    let ms0 = &mut shift_register.decompose()[MS_0];
+    let one_wire_pin = Flex::new(peripherals.gpio18);
-    ms0.set_low()?;
+    let tank_power_pin = Output::new(peripherals.gpio11, Level::Low, OutputConfig::default());
-    let ms1 = &mut shift_register.decompose()[MS_1];
-    ms1.set_low()?;
-    let ms2 = &mut shift_register.decompose()[MS_2];
-    ms2.set_low()?;
-    let ms3 = &mut shift_register.decompose()[MS_3];
-    ms3.set_low()?;
 
-    let ms4 = &mut shift_register.decompose()[MS_4];
+    let flow_sensor_pin = Input::new(
-    ms4.set_high()?;
+        peripherals.gpio4,
-
+        InputConfig::default().with_pull(Pull::Up),
-    let one_wire_pin = peripherals.gpio18.downgrade();
+    );
-    let tank_power_pin = peripherals.gpio11.downgrade();
-
-    let flow_sensor_pin = peripherals.gpio4.downgrade();
 
     let tank_sensor = TankSensor::create(
         one_wire_pin,
@@ -139,54 +134,37 @@ pub(crate) fn create_v3(
         peripherals.pcnt1,
     )?;
 
-    let mut signal_counter = PcntDriver::new(
+    let solar_is_day = Input::new(peripherals.gpio7, InputConfig::default());
-        peripherals.pcnt0,
+    let light = Output::new(peripherals.gpio10, Level::Low, OutputConfig::default());
-        Some(peripherals.gpio22),
+    let mut main_pump = Output::new(peripherals.gpio2, Level::Low, OutputConfig::default());
-        Option::<AnyInputPin>::None,
+    main_pump.set_low();
-        Option::<AnyInputPin>::None,
+    let mut general_fault = Output::new(peripherals.gpio6, Level::Low, OutputConfig::default());
-        Option::<AnyInputPin>::None,
+    general_fault.set_low();
-    )?;
 
-    signal_counter.channel_config(
+    hold_disable(21);
-        PcntChannel::Channel0,
+    let mut shift_register_enable_invert =
-        PinIndex::Pin0,
+        Output::new(peripherals.gpio21, Level::Low, OutputConfig::default());
-        PinIndex::Pin1,
+    shift_register_enable_invert.set_low();
-        &PcntChannelConfig {
+    hold_enable(21);
-            lctrl_mode: PcntControlMode::Keep,
-            hctrl_mode: PcntControlMode::Keep,
-            pos_mode: PcntCountMode::Increment,
-            neg_mode: PcntCountMode::Hold,
-            counter_h_lim: i16::MAX,
-            counter_l_lim: 0,
-        },
-    )?;
 
-    let mut solar_is_day = PinDriver::input(peripherals.gpio7.downgrade())?;
+    let signal_counter = peripherals.pcnt0;
-    solar_is_day.set_pull(Pull::Floating)?;
 
-    let mut light = PinDriver::input_output(peripherals.gpio10.downgrade())?;
+    signal_counter.set_low_limit(None)?;
-    light.set_pull(Pull::Floating)?;
+    signal_counter.set_high_limit(Some(i16::MAX))?;
 
-    let mut main_pump = PinDriver::input_output(peripherals.gpio2.downgrade())?;
+    let ch0 = &signal_counter.channel0;
-    main_pump.set_pull(Pull::Floating)?;
+    let edge_pin = Input::new(peripherals.gpio22, InputConfig::default());
-    main_pump.set_low()?;
+    ch0.set_edge_signal(edge_pin.peripheral_input());
-
+    ch0.set_input_mode(Hold, Increment);
-    let mut general_fault = PinDriver::input_output(peripherals.gpio6.downgrade())?;
+    ch0.set_ctrl_mode(Keep, Keep);
-    general_fault.set_pull(Pull::Floating)?;
+    signal_counter.listen();
-    general_fault.set_low()?;
-
-    let mut shift_register_enable_invert = PinDriver::output(peripherals.gpio21.downgrade())?;
-
-    unsafe { gpio_hold_dis(shift_register_enable_invert.pin()) };
-    shift_register_enable_invert.set_low()?;
-    unsafe { gpio_hold_en(shift_register_enable_invert.pin()) };
 
     Ok(Box::new(V3 {
         config,
         battery_monitor,
         rtc_module,
         esp,
-        shift_register,
+        shift_register: Mutex::new(shift_register),
         _shift_register_enable_invert: shift_register_enable_invert,
         tank_sensor,
         solar_is_day,
@@ -197,9 +175,10 @@ pub(crate) fn create_v3(
     }))
 }
 
+#[async_trait]
 impl<'a> BoardInteraction<'a> for V3<'a> {
-    fn get_tank_sensor(&mut self) -> Option<&mut TankSensor<'a>> {
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
-        Some(&mut self.tank_sensor)
+        Ok(&mut self.tank_sensor)
     }
 
     fn get_esp(&mut self) -> &mut Esp<'a> {
@@ -210,35 +189,56 @@ impl<'a> BoardInteraction<'a> for V3<'a> {
         &self.config
     }
 
-    fn get_battery_monitor(&mut self) -> &mut Box<(dyn BatteryInteraction + Send + 'static)> {
+    fn get_battery_monitor(&mut self) -> &mut Box<dyn BatteryInteraction + Send> {
         &mut self.battery_monitor
     }
 
     fn get_rtc_module(&mut self) -> &mut Box<dyn RTCModuleInteraction + Send> {
         &mut self.rtc_module
     }
-    fn set_charge_indicator(&mut self, charging: bool) -> Result<()> {
+
-        Ok(self.shift_register.decompose()[CHARGING].set_state(charging.into())?)
+    async fn get_time(&mut self) -> DateTime<Utc> {
+        self.esp.get_time()
     }
 
-    fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+    async fn set_time(&mut self, time: &DateTime<FixedOffset>) -> FatResult<()> {
-        let _ = self.shift_register.decompose()[AWAKE].set_low();
+        self.rtc_module.set_rtc_time(&time.to_utc()).await?;
-        deep_sleep(duration_in_ms)
+        self.esp.set_time(time.to_utc());
+        Ok(())
+    }
+
+    async fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError> {
+        let shift_register = self.shift_register.lock().await;
+        if charging {
+            let _ = shift_register.decompose()[CHARGING].set_high();
+        } else {
+            let _ = shift_register.decompose()[CHARGING].set_low();
+        }
+        Ok(())
+    }
+
+    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
+        let _ = self.shift_register.lock().await.decompose()[AWAKE].set_low();
+        self.esp.deep_sleep_ms(duration_in_ms)
     }
 
     fn is_day(&self) -> bool {
-        self.solar_is_day.get_level().into()
+        self.solar_is_day.is_high()
     }
 
-    fn light(&mut self, enable: bool) -> Result<()> {
+    async fn light(&mut self, enable: bool) -> Result<(), FatError> {
-        unsafe { gpio_hold_dis(self.light.pin()) };
+        hold_disable(10);
-        self.light.set_state(enable.into())?;
+        if enable {
-        unsafe { gpio_hold_en(self.light.pin()) };
+            self.light.set_high();
+        } else {
+            self.light.set_low();
+        }
+        hold_enable(10);
         Ok(())
     }
-    fn pump(&mut self, plant: usize, enable: bool) -> Result<()> {
+    async fn pump(&mut self, plant: usize, enable: bool) -> Result<(), FatError> {
         if enable {
-            self.main_pump.set_high()?;
+            self.main_pump.set_high();
         }
 
         let index = match plant {
@@ -250,21 +250,26 @@ impl<'a> BoardInteraction<'a> for V3<'a> {
             5 => PUMP6_BIT,
             6 => PUMP7_BIT,
             7 => PUMP8_BIT,
-            _ => bail!("Invalid pump {plant}",),
+            _ => bail!("Invalid pump {plant}"),
         };
-        self.shift_register.decompose()[index].set_state(enable.into())?;
+        let shift_register = self.shift_register.lock().await;
+        if enable {
+            let _ = shift_register.decompose()[index].set_high();
+        } else {
+            let _ = shift_register.decompose()[index].set_low();
+        }
 
         if !enable {
-            self.main_pump.set_low()?;
+            self.main_pump.set_low();
         }
         Ok(())
     }
 
-    fn pump_current(&mut self, _plant: usize) -> Result<Current> {
+    async fn pump_current(&mut self, _plant: usize) -> Result<Current, FatError> {
         bail!("Not implemented in v3")
     }
 
-    fn fault(&mut self, plant: usize, enable: bool) -> Result<()> {
+    async fn fault(&mut self, plant: usize, enable: bool) -> Result<(), FatError> {
         let index = match plant {
             0 => FAULT_1,
             1 => FAULT_2,
@@ -276,17 +281,25 @@ impl<'a> BoardInteraction<'a> for V3<'a> {
             7 => FAULT_8,
             _ => panic!("Invalid plant id {}", plant),
         };
-        self.shift_register.decompose()[index].set_state(enable.into())?;
+        let shift_register = self.shift_register.lock().await;
+        if enable {
+            let _ = shift_register.decompose()[index].set_high();
+        } else {
+            let _ = shift_register.decompose()[index].set_low();
+        }
         Ok(())
     }
 
-    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32> {
+    async fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32, FatError> {
         let mut results = [0_f32; REPEAT_MOIST_MEASURE];
         for repeat in 0..REPEAT_MOIST_MEASURE {
-            self.signal_counter.counter_pause()?;
+            self.signal_counter.pause();
-            self.signal_counter.counter_clear()?;
+            self.signal_counter.clear();
             //Disable all
-            self.shift_register.decompose()[MS_4].set_high()?;
+            {
+                let shift_register = self.shift_register.lock().await;
+                shift_register.decompose()[MS_4].set_high()?;
+            }
 
             let sensor_channel = match sensor {
                 Sensor::A => match plant {
@@ -314,46 +327,51 @@ impl<'a> BoardInteraction<'a> for V3<'a> {
             };
 
             let is_bit_set = |b: u8| -> bool { sensor_channel & (1 << b) != 0 };
-            let pin_0 = &mut self.shift_register.decompose()[MS_0];
+            {
-            let pin_1 = &mut self.shift_register.decompose()[MS_1];
+                let shift_register = self.shift_register.lock().await;
-            let pin_2 = &mut self.shift_register.decompose()[MS_2];
+                let pin_0 = &mut shift_register.decompose()[MS_0];
-            let pin_3 = &mut self.shift_register.decompose()[MS_3];
+                let pin_1 = &mut shift_register.decompose()[MS_1];
-            if is_bit_set(0) {
+                let pin_2 = &mut shift_register.decompose()[MS_2];
-                pin_0.set_high()?;
+                let pin_3 = &mut shift_register.decompose()[MS_3];
-            } else {
+                if is_bit_set(0) {
-                pin_0.set_low()?;
+                    pin_0.set_high()?;
-            }
+                } else {
-            if is_bit_set(1) {
+                    pin_0.set_low()?;
-                pin_1.set_high()?;
+                }
-            } else {
+                if is_bit_set(1) {
-                pin_1.set_low()?;
+                    pin_1.set_high()?;
-            }
+                } else {
-            if is_bit_set(2) {
+                    pin_1.set_low()?;
-                pin_2.set_high()?;
+                }
-            } else {
+                if is_bit_set(2) {
-                pin_2.set_low()?;
+                    pin_2.set_high()?;
-            }
+                } else {
-            if is_bit_set(3) {
+                    pin_2.set_low()?;
-                pin_3.set_high()?;
+                }
-            } else {
+                if is_bit_set(3) {
-                pin_3.set_low()?;
+                    pin_3.set_high()?;
-            }
+                } else {
-
+                    pin_3.set_low()?;
-            self.shift_register.decompose()[MS_4].set_low()?;
+                }
-            self.shift_register.decompose()[SENSOR_ON].set_high()?;
 
+                shift_register.decompose()[MS_4].set_low()?;
+                shift_register.decompose()[SENSOR_ON].set_high()?;
+            }
             let measurement = 100; //how long to measure and then extrapolate to hz
             let factor = 1000f32 / measurement as f32; //scale raw cound by this number to get hz
 
             //give some time to stabilize
-            self.esp.delay.delay_ms(10);
+            Timer::after_millis(10).await;
-            self.signal_counter.counter_resume()?;
+            self.signal_counter.resume();
-            self.esp.delay.delay_ms(measurement);
+            Timer::after_millis(measurement).await;
-            self.signal_counter.counter_pause()?;
+            self.signal_counter.pause();
-            self.shift_register.decompose()[MS_4].set_high()?;
+            {
-            self.shift_register.decompose()[SENSOR_ON].set_low()?;
+                let shift_register = self.shift_register.lock().await;
-            self.esp.delay.delay_ms(10);
+                shift_register.decompose()[MS_4].set_high()?;
-            let unscaled = self.signal_counter.get_counter_value()? as i32;
+                shift_register.decompose()[SENSOR_ON].set_low()?;
+            }
+            Timer::after_millis(10).await;
+            let unscaled = self.signal_counter.value();
             let hz = unscaled as f32 * factor;
             log(
                 LogMessage::RawMeasure,
@@ -371,66 +389,63 @@ impl<'a> BoardInteraction<'a> for V3<'a> {
         Ok(median)
     }
 
-    fn general_fault(&mut self, enable: bool) {
+    async fn general_fault(&mut self, enable: bool) {
-        unsafe { gpio_hold_dis(self.general_fault.pin()) };
+        hold_disable(6);
-        self.general_fault.set_state(enable.into()).unwrap();
+        if enable {
-        unsafe { gpio_hold_en(self.general_fault.pin()) };
+            self.general_fault.set_high();
+        } else {
+            self.general_fault.set_low();
+        }
+        hold_enable(6);
     }
 
-    fn test(&mut self) -> Result<()> {
+    async fn test(&mut self) -> Result<(), FatError> {
-        self.general_fault(true);
+        self.general_fault(true).await;
-        self.esp.delay.delay_ms(100);
+        Timer::after_millis(100).await;
-        self.general_fault(false);
+        self.general_fault(false).await;
-        self.esp.delay.delay_ms(100);
+        Timer::after_millis(100).await;
-        self.light(true)?;
+        self.light(true).await?;
-        self.esp.delay.delay_ms(500);
+        Timer::after_millis(500).await;
-        self.light(false)?;
+
-        self.esp.delay.delay_ms(500);
+        self.light(false).await?;
+        Timer::after_millis(500).await;
         for i in 0..PLANT_COUNT {
-            self.fault(i, true)?;
+            self.fault(i, true).await?;
-            self.esp.delay.delay_ms(500);
+            Timer::after_millis(500).await;
-            self.fault(i, false)?;
+            self.fault(i, false).await?;
-            self.esp.delay.delay_ms(500);
+            Timer::after_millis(500).await;
         }
         for i in 0..PLANT_COUNT {
-            self.pump(i, true)?;
+            self.pump(i, true).await?;
-            self.esp.delay.delay_ms(100);
+            Timer::after_millis(100).await;
-            self.pump(i, false)?;
+            self.pump(i, false).await?;
-            self.esp.delay.delay_ms(100);
+            Timer::after_millis(100).await;
         }
         for plant in 0..PLANT_COUNT {
-            let a = self.measure_moisture_hz(plant, Sensor::A);
+            let a = self.measure_moisture_hz(plant, Sensor::A).await;
-            let b = self.measure_moisture_hz(plant, Sensor::B);
+            let b = self.measure_moisture_hz(plant, Sensor::B).await;
             let aa = match a {
-                OkStd(a) => a as u32,
+                Ok(a) => a as u32,
                 Err(_) => u32::MAX,
             };
             let bb = match b {
-                OkStd(b) => b as u32,
+                Ok(b) => b as u32,
                 Err(_) => u32::MAX,
             };
             log(LogMessage::TestSensor, aa, bb, &plant.to_string(), "");
         }
-        self.esp.delay.delay_ms(10);
+        Timer::after_millis(10).await;
         Ok(())
     }
 
-    fn set_config(&mut self, config: PlantControllerConfig) -> Result<()> {
+    fn set_config(&mut self, config: PlantControllerConfig) {
         self.config = config;
-        self.esp.save_config(&self.config)?;
-        anyhow::Ok(())
     }
 
-    fn get_mptt_voltage(&mut self) -> Result<Voltage> {
+    async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError> {
-        //assuming module to work, these are the hardware set values
+        bail!("Not implemented in v3")
-        if self.is_day() {
-            Ok(Voltage::from_volts(15_f64))
-        } else {
-            Ok(Voltage::from_volts(0_f64))
-        }
     }
-
+    async fn get_mptt_current(&mut self) -> Result<Current, FatError> {
-    fn get_mptt_current(&mut self) -> Result<Current> {
+        bail!("Not implemented in v3")
-        bail!("Board does not have current sensor")
     }
 }

rust/src/hal/v3_shift_register.rs

@@ -1,12 +1,13 @@
 //! Serial-in parallel-out shift register
-
+#![allow(warnings)]
 use core::cell::RefCell;
+use core::convert::Infallible;
+use core::iter::Iterator;
 use core::mem::{self, MaybeUninit};
-use std::convert::Infallible;
+use core::result::{Result, Result::Ok};
+use embedded_hal::digital::OutputPin;
 
-use hal::digital::OutputPin;
+trait ShiftRegisterInternal: Send {
-
-trait ShiftRegisterInternal {
     fn update(&self, index: usize, command: bool) -> Result<(), ()>;
 }
 
@@ -46,9 +47,9 @@ macro_rules! ShiftRegisterBuilder {
         /// Serial-in parallel-out shift register
         pub struct $name<Pin1, Pin2, Pin3>
         where
-            Pin1: OutputPin,
+            Pin1: OutputPin + Send,
-            Pin2: OutputPin,
+            Pin2: OutputPin + Send,
-            Pin3: OutputPin,
+            Pin3: OutputPin + Send,
         {
             clock: RefCell<Pin1>,
             latch: RefCell<Pin2>,
@@ -58,9 +59,9 @@ macro_rules! ShiftRegisterBuilder {
 
         impl<Pin1, Pin2, Pin3> ShiftRegisterInternal for $name<Pin1, Pin2, Pin3>
         where
-            Pin1: OutputPin,
+            Pin1: OutputPin + Send,
-            Pin2: OutputPin,
+            Pin2: OutputPin + Send,
-            Pin3: OutputPin,
+            Pin3: OutputPin + Send,
         {
             /// Sets the value of the shift register output at `index` to value `command`
             fn update(&self, index: usize, command: bool) -> Result<(), ()> {
@@ -85,9 +86,9 @@ macro_rules! ShiftRegisterBuilder {
 
         impl<Pin1, Pin2, Pin3> $name<Pin1, Pin2, Pin3>
         where
-            Pin1: OutputPin,
+            Pin1: OutputPin + Send,
-            Pin2: OutputPin,
+            Pin2: OutputPin + Send,
-            Pin3: OutputPin,
+            Pin3: OutputPin + Send,
         {
             /// Creates a new SIPO shift register from clock, latch, and data output pins
             pub fn new(clock: Pin1, latch: Pin2, data: Pin3) -> Self {

rust/src/hal/v4_hal.rs

@@ -1,45 +1,81 @@
 use crate::config::PlantControllerConfig;
 use crate::hal::battery::BatteryInteraction;
-use crate::hal::esp::Esp;
+use crate::hal::esp::{hold_disable, hold_enable, Esp};
 use crate::hal::rtc::RTCModuleInteraction;
-use crate::hal::v4_sensor::SensorImpl;
-use crate::hal::v4_sensor::SensorInteraction;
 use crate::hal::water::TankSensor;
-use crate::hal::{
+use crate::hal::{BoardInteraction, FreePeripherals, Sensor, I2C_DRIVER, PLANT_COUNT};
-    deep_sleep, BoardInteraction, FreePeripherals, Sensor, I2C_DRIVER, PLANT_COUNT
+use alloc::boxed::Box;
-};
+use alloc::string::ToString;
-use crate::log::{log, LogMessage};
+use async_trait::async_trait;
-use anyhow::bail;
+use chrono::{DateTime, FixedOffset, Utc};
-use embedded_hal::digital::OutputPin;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
-use embedded_hal_bus::i2c::MutexDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
-use esp_idf_hal::gpio::{AnyInputPin, IOPin, InputOutput, Output, PinDriver, Pull};
+use embassy_time::Timer;
-use esp_idf_hal::i2c::{I2cDriver, I2cError};
+use esp_hal::{twai, Blocking};
-use esp_idf_hal::pcnt::{
+//use embedded_hal_bus::i2c::MutexDevice;
-    PcntChannel, PcntChannelConfig, PcntControlMode, PcntCountMode, PcntDriver, PinIndex,
+use crate::bail;
-};
+use crate::fat_error::{FatError, FatResult};
-use esp_idf_sys::{gpio_hold_dis, gpio_hold_en};
+use crate::hal::v4_sensor::{SensorImpl, SensorInteraction};
+use crate::log::{LogMessage, LOG_ACCESS};
+use esp_hal::gpio::{Flex, Input, InputConfig, Level, Output, OutputConfig, Pull};
+use esp_hal::i2c::master::I2c;
+use esp_hal::pcnt::channel::CtrlMode::Keep;
+use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
+use esp_hal::pcnt::Pcnt;
+use esp_hal::twai::{EspTwaiFrame, StandardId, TwaiMode};
+use esp_println::println;
 use ina219::address::{Address, Pin};
 use ina219::calibration::UnCalibrated;
-use ina219::configuration::{Configuration, OperatingMode};
+use ina219::configuration::{Configuration, OperatingMode, Resolution};
 use ina219::SyncIna219;
-use measurements::{Current, Resistance, Voltage};
+use measurements::Resistance;
-use pca9535::{ExpanderError, GPIOBank, Pca9535Immediate, StandardExpanderInterface};
+use measurements::{Current, Voltage};
-use std::result::Result::Ok as OkStd;
+use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
-use embedded_can::nb::Can;
+
-use embedded_can::Frame;
+const MPPT_CURRENT_SHUNT_OHMS: f64 = 0.05_f64;
-use embedded_can::StandardId;
+const TWAI_BAUDRATE: twai::BaudRate = twai::BaudRate::B125K;
-use esp_idf_hal::prelude::*;
-use esp_idf_hal::can;
 
 pub enum Charger<'a> {
     SolarMpptV1 {
-        mppt_ina: SyncIna219<MutexDevice<'a, I2cDriver<'a>>, UnCalibrated>,
+        mppt_ina: SyncIna219<
-        solar_is_day: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, esp_idf_hal::gpio::Input>,
+            I2cDevice<'a, CriticalSectionRawMutex, I2c<'static, Blocking>>,
-        charge_indicator: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+            UnCalibrated,
+        >,
+        solar_is_day: Input<'a>,
+        charge_indicator: Output<'a>,
     },
     ErrorInit {},
 }
 
+impl<'a> Charger<'a> {
+    pub(crate) fn get_mppt_current(&mut self) -> FatResult<Current> {
+        match self {
+            Charger::SolarMpptV1 { mppt_ina, .. } => {
+                let v = mppt_ina.shunt_voltage()?;
+                let shunt_voltage = Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
+                let shut_value = Resistance::from_ohms(MPPT_CURRENT_SHUNT_OHMS);
+                let current = shunt_voltage.as_volts() / shut_value.as_ohms();
+                Ok(Current::from_amperes(current))
+            }
+            Charger::ErrorInit { .. } => {
+                bail!("hardware error during init");
+            }
+        }
+    }
+
+    pub(crate) fn get_mptt_voltage(&mut self) -> FatResult<Voltage> {
+        match self {
+            Charger::SolarMpptV1 { mppt_ina, .. } => {
+                let v = mppt_ina.bus_voltage()?;
+                Ok(Voltage::from_millivolts(v.voltage_mv() as f64))
+            }
+            Charger::ErrorInit { .. } => {
+                bail!("hardware error during init");
+            }
+        }
+    }
+}
+
 impl Charger<'_> {
     pub(crate) fn power_save(&mut self) {
         match self {
@@ -54,7 +90,7 @@ impl Charger<'_> {
                         operating_mode: OperatingMode::PowerDown,
                     })
                     .map_err(|e| {
-                        println!(
+                        log::info!(
                     "Error setting ina mppt configuration during deep sleep preparation{:?}",
                     e
                 );
@@ -63,12 +99,12 @@ impl Charger<'_> {
             _ => {}
         }
     }
-    fn set_charge_indicator(&mut self, charging: bool) -> anyhow::Result<()> {
+    fn set_charge_indicator(&mut self, charging: bool) -> FatResult<()> {
         match self {
             Self::SolarMpptV1 {
                 charge_indicator, ..
             } => {
-                charge_indicator.set_state(charging.into())?;
+                charge_indicator.set_level(charging.into());
             }
             _ => {}
         }
@@ -77,37 +113,10 @@ impl Charger<'_> {
 
     fn is_day(&self) -> bool {
         match self {
-            Charger::SolarMpptV1 { solar_is_day, .. } => solar_is_day.get_level().into(),
+            Charger::SolarMpptV1 { solar_is_day, .. } => solar_is_day.is_high(),
             _ => true,
         }
     }
-
-    fn get_mptt_voltage(&mut self) -> anyhow::Result<Voltage> {
-        let voltage = match self {
-            Charger::SolarMpptV1 { mppt_ina, .. } => mppt_ina
-                .bus_voltage()
-                .map(|v| Voltage::from_millivolts(v.voltage_mv() as f64))?,
-            _ => {
-                bail!("hardware error during init")
-            }
-        };
-        Ok(voltage)
-    }
-
-    fn get_mptt_current(&mut self) -> anyhow::Result<Current> {
-        let current = match self {
-            Charger::SolarMpptV1 { mppt_ina, .. } => mppt_ina.shunt_voltage().map(|v| {
-                let shunt_voltage = Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
-                let shut_value = Resistance::from_ohms(0.05_f64);
-                let current = shunt_voltage.as_volts() / shut_value.as_ohms();
-                Current::from_amperes(current)
-            })?,
-            _ => {
-                bail!("hardware error during init")
-            }
-        };
-        Ok(current)
-    }
 }
 
 pub struct V4<'a> {
@@ -118,40 +127,41 @@ pub struct V4<'a> {
     battery_monitor: Box<dyn BatteryInteraction + Send>,
     config: PlantControllerConfig,
 
-    awake: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, Output>,
+    awake: Output<'a>,
-    light: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    light: Output<'a>,
-    general_fault: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, InputOutput>,
+    general_fault: Output<'a>,
-    pump_expander: Pca9535Immediate<MutexDevice<'a, I2cDriver<'a>>>,
+    pump_expander: Pca9535Immediate<I2cDevice<'a, CriticalSectionRawMutex, I2c<'static, Blocking>>>,
-    pump_ina: Option<SyncIna219<MutexDevice<'a, I2cDriver<'a>>, UnCalibrated>>,
+    pump_ina: Option<
-    sensor: SensorImpl<'a>,
+        SyncIna219<I2cDevice<'a, CriticalSectionRawMutex, I2c<'static, Blocking>>, UnCalibrated>,
-    extra1: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, Output>,
+    >,
-    extra2: PinDriver<'a, esp_idf_hal::gpio::AnyIOPin, Output>,
+    sensor: SensorImpl,
+    extra1: Output<'a>,
+    extra2: Output<'a>,
 }
 
-pub(crate) fn create_v4(
+pub(crate) async fn create_v4(
-    peripherals: FreePeripherals,
+    peripherals: FreePeripherals<'static>,
     esp: Esp<'static>,
     config: PlantControllerConfig,
     battery_monitor: Box<dyn BatteryInteraction + Send>,
     rtc_module: Box<dyn RTCModuleInteraction + Send>,
-) -> anyhow::Result<Box<dyn BoardInteraction<'static> + Send + 'static>> {
+) -> Result<Box<dyn BoardInteraction<'static> + Send + 'static>, FatError> {
-    println!("Start v4");
+    log::info!("Start v4");
-    let mut awake = PinDriver::output(peripherals.gpio21.downgrade())?;
+    let mut awake = Output::new(peripherals.gpio21, Level::High, OutputConfig::default());
-    awake.set_high()?;
+    awake.set_high();
 
-    let mut general_fault = PinDriver::input_output(peripherals.gpio23.downgrade())?;
+    let mut general_fault = Output::new(peripherals.gpio23, Level::Low, OutputConfig::default());
-    general_fault.set_pull(Pull::Floating)?;
+    general_fault.set_low();
-    general_fault.set_low()?;
 
-    let mut extra1 = PinDriver::output(peripherals.gpio6.downgrade())?;
+    let extra1 = Output::new(peripherals.gpio6, Level::Low, OutputConfig::default());
-    extra1.set_low()?;
+    let extra2 = Output::new(peripherals.gpio15, Level::Low, OutputConfig::default());
 
-    let mut extra2 = PinDriver::output(peripherals.gpio15.downgrade())?;
+    let one_wire_pin = Flex::new(peripherals.gpio18);
-    extra2.set_low()?;
+    let tank_power_pin = Output::new(peripherals.gpio11, Level::Low, OutputConfig::default());
-
+    let flow_sensor_pin = Input::new(
-    let one_wire_pin = peripherals.gpio18.downgrade();
+        peripherals.gpio4,
-    let tank_power_pin = peripherals.gpio11.downgrade();
+        InputConfig::default().with_pull(Pull::Up),
-    let flow_sensor_pin = peripherals.gpio4.downgrade();
+    );
 
     let tank_sensor = TankSensor::create(
         one_wire_pin,
@@ -162,32 +172,23 @@ pub(crate) fn create_v4(
         peripherals.pcnt1,
     )?;
 
-    let mut sensor_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 34);
+    let sensor_expander_device = I2cDevice::new(I2C_DRIVER.get().await);
-    let sensor = match  sensor_expander.pin_into_output(GPIOBank::Bank0, 0)  {
+    let mut sensor_expander = Pca9535Immediate::new(sensor_expander_device, 34);
+    let sensor = match sensor_expander.pin_into_output(GPIOBank::Bank0, 0) {
         Ok(_) => {
-            println!("SensorExpander answered");
+            log::info!("SensorExpander answered");
-            //pulse counter version
-            let mut signal_counter = PcntDriver::new(
-                peripherals.pcnt0,
-                Some(peripherals.gpio22),
-                Option::<AnyInputPin>::None,
-                Option::<AnyInputPin>::None,
-                Option::<AnyInputPin>::None,
-            )?;
 
-            signal_counter.channel_config(
+            let signal_counter = peripherals.pcnt0;
-                PcntChannel::Channel0,
+
-                PinIndex::Pin0,
+            signal_counter.set_low_limit(Some(0))?;
-                PinIndex::Pin1,
+            signal_counter.set_high_limit(Some(i16::MAX))?;
-                &PcntChannelConfig {
+
-                    lctrl_mode: PcntControlMode::Keep,
+            let ch0 = &signal_counter.channel0;
-                    hctrl_mode: PcntControlMode::Keep,
+            let edge_pin = Input::new(peripherals.gpio22, InputConfig::default());
-                    pos_mode: PcntCountMode::Increment,
+            ch0.set_edge_signal(edge_pin.peripheral_input());
-                    neg_mode: PcntCountMode::Hold,
+            ch0.set_input_mode(Hold, Increment);
-                    counter_h_lim: i16::MAX,
+            ch0.set_ctrl_mode(Keep, Keep);
-                    counter_l_lim: 0,
+            signal_counter.listen();
-                },
-            )?;
 
             for pin in 0..8 {
                 let _ = sensor_expander.pin_into_output(GPIOBank::Bank0, pin);
@@ -202,40 +203,33 @@ pub(crate) fn create_v4(
             }
         }
         Err(_) => {
-            println!("Can bus mode ");
+            log::info!("Can bus mode ");
-            let timing = can::config::Timing::B25K;
+            let twai_config = twai::TwaiConfiguration::new(
-            let config = can::config::Config::new().timing(timing);
+                peripherals.twai,
-            let mut can = can::CanDriver::new(peripherals.can, peripherals.gpio0, peripherals.gpio2, &config).unwrap();
+                peripherals.gpio0,
+                peripherals.gpio2,
+                TWAI_BAUDRATE,
+                TwaiMode::Normal,
+            );
 
+            let mut twai = twai_config.start();
+            let frame = EspTwaiFrame::new(StandardId::ZERO, &[1, 2, 3]).unwrap();
 
-            let frame = StandardId::new(0x042).unwrap();
+            twai.transmit(&frame).unwrap();
-            let tx_frame = Frame::new(frame, &[0, 1, 2, 3, 4, 5, 6, 7]).unwrap();
-            can.transmit(&tx_frame, 1000).unwrap();
 
-            if let Ok(rx_frame) = can.receive(1000) {
+            //            let frame = twai.receive().unwrap();
-                println!("rx {:}:", rx_frame);
+            println!("Received a frame: {frame:?}");
-            }
             //can bus version
-            SensorImpl::CanBus {
+            SensorImpl::CanBus { twai }
-                can
-            }
         }
     };
 
+    let solar_is_day = Input::new(peripherals.gpio7, InputConfig::default());
+    let light = Output::new(peripherals.gpio10, Level::Low, Default::default());
+    let charge_indicator = Output::new(peripherals.gpio3, Level::Low, Default::default());
 
-
+    let pump_device = I2cDevice::new(I2C_DRIVER.get().await);
-
+    let mut pump_expander = Pca9535Immediate::new(pump_device, 32);
-    let mut solar_is_day = PinDriver::input(peripherals.gpio7.downgrade())?;
-    solar_is_day.set_pull(Pull::Floating)?;
-
-    let mut light = PinDriver::input_output(peripherals.gpio10.downgrade())?;
-    light.set_pull(Pull::Floating)?;
-
-    let mut charge_indicator = PinDriver::input_output(peripherals.gpio3.downgrade())?;
-    charge_indicator.set_pull(Pull::Floating)?;
-    charge_indicator.set_low()?;
-
-    let mut pump_expander = Pca9535Immediate::new(MutexDevice::new(&I2C_DRIVER), 32);
     for pin in 0..8 {
         let _ = pump_expander.pin_into_output(GPIOBank::Bank0, pin);
         let _ = pump_expander.pin_into_output(GPIOBank::Bank1, pin);
@@ -243,15 +237,37 @@ pub(crate) fn create_v4(
         let _ = pump_expander.pin_set_low(GPIOBank::Bank1, pin);
     }
 
+    let mppt_current = I2cDevice::new(I2C_DRIVER.get().await);
+    let mppt_ina = match SyncIna219::new(mppt_current, Address::from_pins(Pin::Vcc, Pin::Gnd)) {
+        Ok(mut ina) => {
+            // Prefer higher averaging for more stable readings
+            let _ = ina.set_configuration(Configuration {
+                reset: Default::default(),
+                bus_voltage_range: Default::default(),
+                shunt_voltage_range: Default::default(),
+                bus_resolution: Default::default(),
+                shunt_resolution: Resolution::Avg128,
+                operating_mode: Default::default(),
+            });
+            Some(ina)
+        }
+        Err(err) => {
+            log::info!("Error creating mppt ina: {:?}", err);
+            None
+        }
+    };
 
-
+    let pump_current_dev = I2cDevice::new(I2C_DRIVER.get().await);
-    let mppt_ina = SyncIna219::new(
+    let pump_ina = match SyncIna219::new(pump_current_dev, Address::from_pins(Pin::Gnd, Pin::Sda)) {
-        MutexDevice::new(&I2C_DRIVER),
+        Ok(ina) => Some(ina),
-        Address::from_pins(Pin::Vcc, Pin::Gnd),
+        Err(err) => {
-    );
+            log::info!("Error creating pump ina: {:?}", err);
+            None
+        }
+    };
 
     let charger = match mppt_ina {
-        Ok(mut mppt_ina) => {
+        Some(mut mppt_ina) => {
             mppt_ina.set_configuration(Configuration {
                 reset: Default::default(),
                 bus_voltage_range: Default::default(),
@@ -267,18 +283,7 @@ pub(crate) fn create_v4(
                 charge_indicator,
             }
         }
-        Err(_) => Charger::ErrorInit {},
+        None => Charger::ErrorInit {},
-    };
-
-    let pump_ina = match SyncIna219::new(
-        MutexDevice::new(&I2C_DRIVER),
-        Address::from_pins(Pin::Gnd, Pin::Sda),
-    ) {
-        Ok(pump_ina) => Some(pump_ina),
-        Err(err) => {
-            println!("Error creating pump ina: {:?}", err);
-            None
-        }
     };
 
     let v = V4 {
@@ -288,10 +293,10 @@ pub(crate) fn create_v4(
         tank_sensor,
         light,
         general_fault,
-        pump_ina,
         pump_expander,
         config,
         battery_monitor,
+        pump_ina,
         charger,
         extra1,
         extra2,
@@ -300,9 +305,10 @@ pub(crate) fn create_v4(
     Ok(Box::new(v))
 }
 
+#[async_trait]
 impl<'a> BoardInteraction<'a> for V4<'a> {
-    fn get_tank_sensor(&mut self) -> Option<&mut TankSensor<'a>> {
+    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
-        Some(&mut self.tank_sensor)
+        Ok(&mut self.tank_sensor)
     }
 
     fn get_esp(&mut self) -> &mut Esp<'a> {
@@ -321,126 +327,144 @@ impl<'a> BoardInteraction<'a> for V4<'a> {
         &mut self.rtc_module
     }
 
-    fn set_charge_indicator(&mut self, charging: bool) -> anyhow::Result<()> {
+    async fn get_time(&mut self) -> DateTime<Utc> {
+        self.esp.get_time()
+    }
+
+    async fn set_time(&mut self, time: &DateTime<FixedOffset>) -> FatResult<()> {
+        self.rtc_module.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> {
         self.charger.set_charge_indicator(charging)
     }
 
-    fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
-        self.awake.set_low().unwrap();
+        self.awake.set_low();
         self.charger.power_save();
-        deep_sleep(duration_in_ms);
+        self.esp.deep_sleep_ms(duration_in_ms);
     }
 
     fn is_day(&self) -> bool {
         self.charger.is_day()
     }
 
-    fn light(&mut self, enable: bool) -> anyhow::Result<()> {
+    async fn light(&mut self, enable: bool) -> Result<(), FatError> {
-        unsafe { gpio_hold_dis(self.light.pin()) };
+        hold_disable(10);
-        self.light.set_state(enable.into())?;
+        self.light.set_level(enable.into());
-        unsafe { gpio_hold_en(self.light.pin()) };
+        hold_enable(10);
-        anyhow::Ok(())
+        Ok(())
     }
 
-    fn pump(&mut self, plant: usize, enable: bool) -> anyhow::Result<()> {
+    async fn pump(&mut self, plant: usize, enable: bool) -> FatResult<()> {
         if enable {
             self.pump_expander
-                .pin_set_high(GPIOBank::Bank0, plant.try_into()?)?;
+                .pin_set_high(GPIOBank::Bank0, plant as u8)?;
         } else {
             self.pump_expander
-                .pin_set_low(GPIOBank::Bank0, plant.try_into()?)?;
+                .pin_set_low(GPIOBank::Bank0, plant as u8)?;
         }
-        anyhow::Ok(())
+        Ok(())
     }
 
-    fn pump_current(&mut self, _plant: usize) -> anyhow::Result<Current> {
+    async fn pump_current(&mut self, _plant: usize) -> Result<Current, FatError> {
-        //sensore is shared for all pumps, ignore plant id
+        // sensor is shared for all pumps, ignore plant id
         match self.pump_ina.as_mut() {
             None => {
                 bail!("pump current sensor not available");
             }
             Some(pump_ina) => {
-                let v = pump_ina.shunt_voltage().map(|v| {
+                let v = pump_ina
-                    let shunt_voltage = Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
+                    .shunt_voltage()
-                    let shut_value = Resistance::from_ohms(0.05_f64);
+                    .map_err(|e| FatError::String {
-                    let current = shunt_voltage.as_volts() / shut_value.as_ohms();
+                        error: alloc::format!("{:?}", e),
-                    Current::from_amperes(current)
+                    })
-                })?;
+                    .map(|v| {
+                        let shunt_voltage =
+                            Voltage::from_microvolts(v.shunt_voltage_uv().abs() as f64);
+                        let shut_value = Resistance::from_ohms(0.05_f64);
+                        let current = shunt_voltage.as_volts() / shut_value.as_ohms();
+                        Current::from_amperes(current)
+                    })?;
                 Ok(v)
             }
         }
     }
 
-    fn fault(&mut self, plant: usize, enable: bool) -> anyhow::Result<()> {
+    async fn fault(&mut self, plant: usize, enable: bool) -> FatResult<()> {
         if enable {
             self.pump_expander
-                .pin_set_high(GPIOBank::Bank1, plant.try_into()?)?
+                .pin_set_high(GPIOBank::Bank1, plant as u8)?;
         } else {
             self.pump_expander
-                .pin_set_low(GPIOBank::Bank1, plant.try_into()?)?
+                .pin_set_low(GPIOBank::Bank1, plant as u8)?;
         }
-        anyhow::Ok(())
+        Ok(())
     }
 
-    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> anyhow::Result<f32> {
+    async fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> Result<f32, FatError> {
-        self.sensor.measure_moisture_hz(plant, sensor)
+        self.sensor.measure_moisture_hz(plant, sensor).await
     }
 
-    fn general_fault(&mut self, enable: bool) {
+    async fn general_fault(&mut self, enable: bool) {
-        unsafe { gpio_hold_dis(self.general_fault.pin()) };
+        hold_disable(23);
-        self.general_fault.set_state(enable.into()).unwrap();
+        self.general_fault.set_level(enable.into());
-        unsafe { gpio_hold_en(self.general_fault.pin()) };
+        hold_enable(23);
     }
 
-    fn test(&mut self) -> anyhow::Result<()> {
+    async fn test(&mut self) -> Result<(), FatError> {
-        self.general_fault(true);
+        self.general_fault(true).await;
-        self.esp.delay.delay_ms(100);
+        Timer::after_millis(100).await;
-        self.general_fault(false);
+        self.general_fault(false).await;
-        self.esp.delay.delay_ms(500);
+        Timer::after_millis(500).await;
-        self.light(true)?;
+        self.light(true).await?;
-        self.esp.delay.delay_ms(500);
+        Timer::after_millis(500).await;
-        self.light(false)?;
+        self.light(false).await?;
-        self.esp.delay.delay_ms(500);
+        Timer::after_millis(500).await;
         for i in 0..PLANT_COUNT {
-            self.fault(i, true)?;
+            self.fault(i, true).await?;
-            self.esp.delay.delay_ms(500);
+            Timer::after_millis(500).await;
-            self.fault(i, false)?;
+            self.fault(i, false).await?;
-            self.esp.delay.delay_ms(500);
+            Timer::after_millis(500).await;
         }
         for i in 0..PLANT_COUNT {
-            self.pump(i, true)?;
+            self.pump(i, true).await?;
-            self.esp.delay.delay_ms(100);
+            Timer::after_millis(100).await;
-            self.pump(i, false)?;
+            self.pump(i, false).await?;
-            self.esp.delay.delay_ms(100);
+            Timer::after_millis(100).await;
         }
         for plant in 0..PLANT_COUNT {
-            let a = self.measure_moisture_hz(plant, Sensor::A);
+            let a = self.measure_moisture_hz(plant, Sensor::A).await;
-            let b = self.measure_moisture_hz(plant, Sensor::B);
+            let b = self.measure_moisture_hz(plant, Sensor::B).await;
             let aa = match a {
-                OkStd(a) => a as u32,
+                Ok(a) => a as u32,
                 Err(_) => u32::MAX,
             };
             let bb = match b {
-                OkStd(b) => b as u32,
+                Ok(b) => b as u32,
                 Err(_) => u32::MAX,
             };
-            log(LogMessage::TestSensor, aa, bb, &plant.to_string(), "");
+            LOG_ACCESS
+                .lock()
+                .await
+                .log(LogMessage::TestSensor, aa, bb, &plant.to_string(), "")
+                .await;
         }
-        self.esp.delay.delay_ms(10);
+        Timer::after_millis(10).await;
-        anyhow::Ok(())
+        Ok(())
     }
 
-    fn set_config(&mut self, config: PlantControllerConfig) -> anyhow::Result<()> {
+    fn set_config(&mut self, config: PlantControllerConfig) {
         self.config = config;
-        self.esp.save_config(&self.config)?;
-        anyhow::Ok(())
     }
 
-    fn get_mptt_voltage(&mut self) -> anyhow::Result<Voltage> {
+    async fn get_mptt_voltage(&mut self) -> Result<Voltage, FatError> {
         self.charger.get_mptt_voltage()
     }
 
-    fn get_mptt_current(&mut self) -> anyhow::Result<Current> {
+    async fn get_mptt_current(&mut self) -> Result<Current, FatError> {
-        self.charger.get_mptt_current()
+        self.charger.get_mppt_current()
     }
 }

rust/src/hal/v4_sensor.rs

@@ -1,16 +1,24 @@
-use embedded_hal_bus::i2c::MutexDevice;
+use crate::fat_error::{FatError, FatResult};
-use esp_idf_hal::can::CanDriver;
+use crate::hal::Box;
-use esp_idf_hal::delay::Delay;
-use esp_idf_hal::i2c::I2cDriver;
-use esp_idf_hal::pcnt::PcntDriver;
-use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
 use crate::hal::Sensor;
-use crate::log::{log, LogMessage};
+use crate::log::{LogMessage, LOG_ACCESS};
+use alloc::format;
+use alloc::string::ToString;
+use async_trait::async_trait;
+use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_time::Timer;
+use esp_hal::i2c::master::I2c;
+use esp_hal::pcnt::unit::Unit;
+use esp_hal::twai::Twai;
+use esp_hal::Blocking;
+use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};
 
 const REPEAT_MOIST_MEASURE: usize = 10;
 
+#[async_trait]
 pub trait SensorInteraction {
-    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> anyhow::Result<f32>;
+    async fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> FatResult<f32>;
 }
 
 const MS0: u8 = 1_u8;
@@ -20,24 +28,30 @@ const MS3: u8 = 4_u8;
 const MS4: u8 = 2_u8;
 const SENSOR_ON: u8 = 5_u8;
 
-pub enum SensorImpl<'a> {
+pub enum SensorImpl {
-    PulseCounter{
+    PulseCounter {
-        signal_counter: PcntDriver<'a>,
+        signal_counter: Unit<'static, 0>,
-        sensor_expander: Pca9535Immediate<MutexDevice<'a, I2cDriver<'a>>>,
+        sensor_expander:
+            Pca9535Immediate<I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>>,
+    },
+    CanBus {
+        twai: Twai<'static, Blocking>,
     },
-    CanBus{
-        can: CanDriver<'a>
-    }
 }
 
-impl SensorInteraction for SensorImpl<'_> {
+#[async_trait]
-    fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> anyhow::Result<f32> {
+impl SensorInteraction for SensorImpl {
+    async fn measure_moisture_hz(&mut self, plant: usize, sensor: Sensor) -> FatResult<f32> {
         match self {
-            SensorImpl::PulseCounter { signal_counter, sensor_expander, .. } => {
+            SensorImpl::PulseCounter {
+                signal_counter,
+                sensor_expander,
+                ..
+            } => {
                 let mut results = [0_f32; REPEAT_MOIST_MEASURE];
                 for repeat in 0..REPEAT_MOIST_MEASURE {
-                    signal_counter.counter_pause()?;
+                    signal_counter.pause();
-                    signal_counter.counter_clear()?;
+                    signal_counter.clear();
 
                     //Disable all
                     sensor_expander.pin_set_high(GPIOBank::Bank0, MS4)?;
@@ -70,46 +84,47 @@ impl SensorInteraction for SensorImpl<'_> {
                     }
 
                     sensor_expander.pin_set_low(GPIOBank::Bank0, MS4)?;
-                    sensor_expander
+                    sensor_expander.pin_set_high(GPIOBank::Bank0, SENSOR_ON)?;
-                        .pin_set_high(GPIOBank::Bank0, SENSOR_ON)?;
 
-                    let delay = Delay::new_default();
                     let measurement = 100; // TODO what is this scaling factor? what is its purpose?
                     let factor = 1000f32 / measurement as f32;
 
                     //give some time to stabilize
-                    delay.delay_ms(10);
+                    Timer::after_millis(10).await;
-                    signal_counter.counter_resume()?;
+                    signal_counter.resume();
-                    delay.delay_ms(measurement);
+                    Timer::after_millis(measurement).await;
-                    signal_counter.counter_pause()?;
+                    signal_counter.pause();
                     sensor_expander.pin_set_high(GPIOBank::Bank0, MS4)?;
-                    sensor_expander
+                    sensor_expander.pin_set_low(GPIOBank::Bank0, SENSOR_ON)?;
-                        .pin_set_low(GPIOBank::Bank0, SENSOR_ON)?;
                     sensor_expander.pin_set_low(GPIOBank::Bank0, MS0)?;
                     sensor_expander.pin_set_low(GPIOBank::Bank0, MS1)?;
                     sensor_expander.pin_set_low(GPIOBank::Bank0, MS2)?;
                     sensor_expander.pin_set_low(GPIOBank::Bank0, MS3)?;
-                    delay.delay_ms(10);
+                    Timer::after_millis(10).await;
-                    let unscaled = signal_counter.get_counter_value()? as i32;
+                    let unscaled = 1337; //signal_counter.get_counter_value()? as i32;
                     let hz = unscaled as f32 * factor;
-                    log(
+                    LOG_ACCESS
-                        LogMessage::RawMeasure,
+                        .lock()
-                        unscaled as u32,
+                        .await
-                        hz as u32,
+                        .log(
-                        &plant.to_string(),
+                            LogMessage::RawMeasure,
-                        &format!("{sensor:?}"),
+                            unscaled as u32,
-                    );
+                            hz as u32,
+                            &plant.to_string(),
+                            &format!("{sensor:?}"),
+                        )
+                        .await;
                     results[repeat] = hz;
                 }
                 results.sort_by(|a, b| a.partial_cmp(b).unwrap()); // floats don't seem to implement total_ord
 
                 let mid = results.len() / 2;
                 let median = results[mid];
-                anyhow::Ok(median)
+                Ok(median)
-            }
-            SensorImpl::CanBus { .. } => {
-                todo!()
             }
+            SensorImpl::CanBus { twai } => Err(FatError::String {
+                error: "Not yet implemented".to_string(),
+            }),
         }
     }
 }

rust/src/hal/water.rs

@@ -1,171 +1,180 @@
-use crate::hal::TANK_MULTI_SAMPLE;
+use crate::bail;
-use anyhow::{anyhow, bail};
+use crate::fat_error::FatError;
-use ds18b20::Ds18b20;
+use crate::hal::{ADC1, TANK_MULTI_SAMPLE};
-use esp_idf_hal::adc::oneshot::config::AdcChannelConfig;
+use embassy_time::Timer;
-use esp_idf_hal::adc::oneshot::{AdcChannelDriver, AdcDriver};
+use esp_hal::analog::adc::{Adc, AdcCalLine, AdcConfig, AdcPin, Attenuation};
-use esp_idf_hal::adc::{attenuation, Resolution, ADC1};
+use esp_hal::delay::Delay;
-use esp_idf_hal::delay::Delay;
+use esp_hal::gpio::{DriveMode, Flex, Input, InputConfig, Output, OutputConfig, Pull};
-use esp_idf_hal::gpio::{AnyIOPin, AnyInputPin, Gpio5, InputOutput, PinDriver, Pull};
+use esp_hal::pcnt::channel::CtrlMode::Keep;
-use esp_idf_hal::pcnt::{
+use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
-    PcntChannel, PcntChannelConfig, PcntControlMode, PcntCountMode, PcntDriver, PinIndex, PCNT1,
+use esp_hal::pcnt::unit::Unit;
-};
+use esp_hal::peripherals::GPIO5;
-use esp_idf_sys::EspError;
+use esp_hal::Async;
-use one_wire_bus::OneWire;
+use esp_println::println;
+use onewire::{ds18b20, Device, DeviceSearch, OneWire, DS18B20};
+
+unsafe impl Send for TankSensor<'_> {}
 
 pub struct TankSensor<'a> {
-    one_wire_bus: OneWire<PinDriver<'a, AnyIOPin, InputOutput>>,
+    one_wire_bus: OneWire<Flex<'a>>,
-    tank_channel: AdcChannelDriver<'a, Gpio5, AdcDriver<'a, ADC1>>,
+    tank_channel: Adc<'a, ADC1<'a>, Async>,
-    tank_power: PinDriver<'a, AnyIOPin, InputOutput>,
+    tank_power: Output<'a>,
-    flow_counter: PcntDriver<'a>,
+    tank_pin: AdcPin<GPIO5<'a>, ADC1<'a>, AdcCalLine<ADC1<'a>>>,
-    delay: Delay,
+    flow_counter: Unit<'a, 1>,
 }
 
 impl<'a> TankSensor<'a> {
     pub(crate) fn create(
-        one_wire_pin: AnyIOPin,
+        mut one_wire_pin: Flex<'a>,
-        adc1: ADC1,
+        adc1: ADC1<'a>,
-        gpio5: Gpio5,
+        gpio5: GPIO5<'a>,
-        tank_power_pin: AnyIOPin,
+        tank_power: Output<'a>,
-        flow_sensor_pin: AnyIOPin,
+        flow_sensor: Input,
-        pcnt1: PCNT1,
+        pcnt1: Unit<'a, 1>,
-    ) -> anyhow::Result<TankSensor<'a>> {
+    ) -> Result<TankSensor<'a>, FatError> {
-        let mut one_wire_pin =
+        one_wire_pin.apply_output_config(
-            PinDriver::input_output_od(one_wire_pin).expect("Failed to configure pin");
+            &OutputConfig::default()
-        one_wire_pin
+                .with_drive_mode(DriveMode::OpenDrain)
-            .set_pull(Pull::Floating)
+                .with_pull(Pull::None),
-            .expect("Failed to set pull");
+        );
+        one_wire_pin.apply_input_config(&InputConfig::default().with_pull(Pull::None));
+        one_wire_pin.set_high();
+        one_wire_pin.set_input_enable(true);
+        one_wire_pin.set_output_enable(true);
 
-        let adc_config = AdcChannelConfig {
+        let mut adc1_config = AdcConfig::new();
-            attenuation: attenuation::DB_11,
+        let tank_pin =
-            resolution: Resolution::Resolution12Bit,
+            adc1_config.enable_pin_with_cal::<_, AdcCalLine<_>>(gpio5, Attenuation::_11dB);
-            calibration: esp_idf_hal::adc::oneshot::config::Calibration::Curve,
+        let tank_channel = Adc::new(adc1, adc1_config).into_async();
-        };
-        let tank_driver = AdcDriver::new(adc1).expect("Failed to configure ADC");
-        let tank_channel = AdcChannelDriver::new(tank_driver, gpio5, &adc_config)
-            .expect("Failed to configure ADC channel");
 
-        let mut tank_power =
+        let one_wire_bus = OneWire::new(one_wire_pin, false);
-            PinDriver::input_output(tank_power_pin).expect("Failed to configure pin");
-        tank_power
-            .set_pull(Pull::Floating)
-            .expect("Failed to set pull");
 
-        let one_wire_bus =
+        pcnt1.set_high_limit(Some(i16::MAX))?;
-            OneWire::new(one_wire_pin).expect("OneWire bus did not pull up after release");
 
-        let mut flow_counter = PcntDriver::new(
+        let ch0 = &pcnt1.channel0;
-            pcnt1,
+        ch0.set_edge_signal(flow_sensor.peripheral_input());
-            Some(flow_sensor_pin),
+        ch0.set_input_mode(Hold, Increment);
-            Option::<AnyInputPin>::None,
+        ch0.set_ctrl_mode(Keep, Keep);
-            Option::<AnyInputPin>::None,
+        pcnt1.listen();
-            Option::<AnyInputPin>::None,
-        )?;
-
-        flow_counter.channel_config(
-            PcntChannel::Channel1,
-            PinIndex::Pin0,
-            PinIndex::Pin1,
-            &PcntChannelConfig {
-                lctrl_mode: PcntControlMode::Keep,
-                hctrl_mode: PcntControlMode::Keep,
-                pos_mode: PcntCountMode::Increment,
-                neg_mode: PcntCountMode::Hold,
-                counter_h_lim: i16::MAX,
-                counter_l_lim: 0,
-            },
-        )?;
 
         Ok(TankSensor {
             one_wire_bus,
             tank_channel,
             tank_power,
-            flow_counter,
+            tank_pin,
-            delay: Default::default(),
+            flow_counter: pcnt1,
         })
     }
 
     pub fn reset_flow_meter(&mut self) {
-        self.flow_counter.counter_pause().unwrap();
+        self.flow_counter.pause();
-        self.flow_counter.counter_clear().unwrap();
+        self.flow_counter.clear();
     }
 
     pub fn start_flow_meter(&mut self) {
-        self.flow_counter.counter_resume().unwrap();
+        self.flow_counter.resume();
     }
 
     pub fn get_flow_meter_value(&mut self) -> i16 {
-        self.flow_counter.get_counter_value().unwrap()
+        self.flow_counter.value()
     }
 
     pub fn stop_flow_meter(&mut self) -> i16 {
-        self.flow_counter.counter_pause().unwrap();
+        self.flow_counter.pause();
         self.get_flow_meter_value()
     }
 
-    pub fn water_temperature_c(&mut self) -> anyhow::Result<f32> {
+    pub async fn water_temperature_c(&mut self) -> Result<f32, FatError> {
         //multisample should be moved to water_temperature_c
         let mut attempt = 1;
-        let water_temp: Result<f32, anyhow::Error> = loop {
+        let mut delay = Delay::new();
-            let temp = self.single_temperature_c();
+
-            match &temp {
+        let presence = self.one_wire_bus.reset(&mut delay)?;
-                Ok(res) => {
+        println!("OneWire: reset presence pulse = {}", presence);
-                    println!("Water temp is {}", res);
+        if !presence {
-                    break temp;
+            println!("OneWire: no device responded to reset — check pull-up resistor and wiring");
-                }
+        }
-                Err(err) => {
+
-                    println!("Could not get water temp {} attempt {}", err, attempt)
+        let mut search = DeviceSearch::new();
-                }
+        let mut water_temp_sensor: Option<Device> = None;
+        let mut devices_found = 0u8;
+        while let Some(device) = self.one_wire_bus.search_next(&mut search, &mut delay)? {
+            devices_found += 1;
+            println!(
+                "OneWire: found device #{} family=0x{:02X} addr={:02X?}",
+                devices_found, device.address[0], device.address
+            );
+            if device.address[0] == ds18b20::FAMILY_CODE {
+                water_temp_sensor = Some(device);
+                break;
+            } else {
+                println!("OneWire: skipping device — not a DS18B20 (family 0x{:02X} != 0x{:02X})", device.address[0], ds18b20::FAMILY_CODE);
             }
-            if attempt == 5 {
+        }
-                break temp;
+        if devices_found == 0 {
+            println!("OneWire: search found zero devices on the bus");
+        }
+
+        match water_temp_sensor {
+            Some(device) => {
+                println!("Found one wire device: {:?}", device);
+                let mut water_temp_sensor = DS18B20::new(device)?;
+
+                let water_temp: Result<f32, FatError> = loop {
+                    let temp = self
+                        .single_temperature_c(&mut water_temp_sensor, &mut delay)
+                        .await;
+                    match &temp {
+                        Ok(res) => {
+                            println!("Water temp is {}", res);
+                            break temp;
+                        }
+                        Err(err) => {
+                            println!("Could not get water temp {} attempt {}", err, attempt)
+                        }
+                    }
+                    if attempt == 5 {
+                        break temp;
+                    }
+                    attempt += 1;
+                };
+                water_temp
             }
-            attempt += 1;
+            None => {
-        };
+                bail!("Not found any one wire Ds18b20");
-        water_temp
+            }
+        }
     }
 
-    fn single_temperature_c(&mut self) -> anyhow::Result<f32> {
+    async fn single_temperature_c(
-        self.one_wire_bus
+        &mut self,
-            .reset(&mut self.delay)
+        sensor: &mut DS18B20,
-            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
+        delay: &mut Delay,
-        let first = self.one_wire_bus.devices(false, &mut self.delay).next();
+    ) -> Result<f32, FatError> {
-        if first.is_none() {
+        let resolution = sensor.measure_temperature(&mut self.one_wire_bus, delay)?;
-            bail!("Not found any one wire  Ds18b20");
+        Timer::after_millis(resolution.time_ms() as u64).await;
-        }
+        let temperature = sensor.read_temperature(&mut self.one_wire_bus, delay)? as f32;
-        let device_address = first
+        if temperature == 85_f32 {
-            .unwrap()
-            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
-
-        let water_temp_sensor = Ds18b20::new::<EspError>(device_address)
-            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
-
-        water_temp_sensor
-            .start_temp_measurement(&mut self.one_wire_bus, &mut self.delay)
-            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
-        ds18b20::Resolution::Bits12.delay_for_measurement_time(&mut self.delay);
-        let sensor_data = water_temp_sensor
-            .read_data(&mut self.one_wire_bus, &mut self.delay)
-            .map_err(|err| -> anyhow::Error { anyhow!("Missing attribute: {:?}", err) })?;
-        if sensor_data.temperature == 85_f32 {
             bail!("Ds18b20 dummy temperature returned");
         }
-        anyhow::Ok(sensor_data.temperature / 10_f32)
+        Ok(temperature / 10_f32)
     }
 
-    pub fn tank_sensor_voltage(&mut self) -> anyhow::Result<f32> {
+    pub async fn tank_sensor_voltage(&mut self) -> Result<f32, FatError> {
-        self.tank_power.set_high()?;
+        self.tank_power.set_high();
         //let stabilize
-        self.delay.delay_ms(100);
+        Timer::after_millis(100).await;
 
         let mut store = [0_u16; TANK_MULTI_SAMPLE];
-        for multisample in 0..TANK_MULTI_SAMPLE {
+        for sample in store.iter_mut() {
-            let value = self.tank_channel.read()?;
+            *sample = self.tank_channel.read_oneshot(&mut self.tank_pin).await;
-            store[multisample] = value;
+            //force yield between successful samples
+            Timer::after_millis(10).await;
         }
-        self.tank_power.set_low()?;
+        self.tank_power.set_low();
 
         store.sort();
-        let median_mv = store[6] as f32 / 1000_f32;
+        let median_mv = store[TANK_MULTI_SAMPLE / 2] as f32;
-        anyhow::Ok(median_mv)
+        Ok(median_mv / 1000.0)
     }
 }

rust/src/lib.rs

@@ -1,4 +0,0 @@
-#![allow(dead_code)]
-extern crate embedded_hal as hal;
-
-pub mod sipo;

rust/src/log/interceptor.rs

@@ -0,0 +1,108 @@
+use alloc::string::String;
+use alloc::vec::Vec;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::blocking_mutex::Mutex as BlockingMutex;
+use log::{LevelFilter, Log, Metadata, Record};
+
+const MAX_LIVE_LOG_ENTRIES: usize = 64;
+
+struct LiveLogBuffer {
+    entries: Vec<(u64, String)>,
+    next_seq: u64,
+}
+
+impl LiveLogBuffer {
+    const fn new() -> Self {
+        Self {
+            entries: Vec::new(),
+            next_seq: 0,
+        }
+    }
+
+    fn push(&mut self, text: String) {
+        if self.entries.len() >= MAX_LIVE_LOG_ENTRIES {
+            self.entries.remove(0);
+        }
+        self.entries.push((self.next_seq, text));
+        self.next_seq += 1;
+    }
+
+    fn get_after(&self, after: Option<u64>) -> (Vec<(u64, String)>, bool, u64) {
+        let next_seq = self.next_seq;
+        match after {
+            None => (self.entries.clone(), false, next_seq),
+            Some(after_seq) => {
+                let result: Vec<_> = self.entries
+                    .iter()
+                    .filter(|(seq, _)| *seq > after_seq)
+                    .cloned()
+                    .collect();
+
+                // Dropped if there are entries that should exist (seq > after_seq) but
+                // the oldest retained entry has a higher seq than after_seq + 1.
+                let dropped = if next_seq > after_seq.saturating_add(1) {
+                    if let Some((oldest_seq, _)) = self.entries.first() {
+                        *oldest_seq > after_seq.saturating_add(1)
+                    } else {
+                        // Buffer empty but entries were written — all dropped
+                        true
+                    }
+                } else {
+                    false
+                };
+
+                (result, dropped, next_seq)
+            }
+        }
+    }
+}
+
+pub struct InterceptorLogger {
+    live_log: BlockingMutex<CriticalSectionRawMutex, core::cell::RefCell<LiveLogBuffer>>,
+}
+
+impl InterceptorLogger {
+    pub const fn new() -> Self {
+        Self {
+            live_log: BlockingMutex::new(core::cell::RefCell::new(LiveLogBuffer::new())),
+        }
+    }
+
+    /// Returns (entries_after, dropped, next_seq).
+    /// Pass `after = None` to retrieve the entire current buffer.
+    /// Pass `after = Some(seq)` to retrieve only entries with seq > that value.
+    pub fn get_live_logs(&self, after: Option<u64>) -> (Vec<(u64, String)>, bool, u64) {
+        self.live_log.lock(|buf| buf.borrow().get_after(after))
+    }
+
+    pub fn init(&'static self) {
+        match log::set_logger(self).map(|()| log::set_max_level(LevelFilter::Info)) {
+            Ok(()) => {}
+            Err(_e) => {
+                esp_println::println!("ERROR: Logger already set");
+            }
+        }
+    }
+}
+
+impl Log for InterceptorLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() <= log::Level::Info
+    }
+
+    fn log(&self, record: &Record) {
+        if self.enabled(record.metadata()) {
+            let message = alloc::format!("{}: {}", record.level(), record.args());
+
+            // Print to serial
+            esp_println::println!("{}", message);
+
+            // Store in live log ring buffer
+            self.live_log.lock(|buf| {
+                buf.borrow_mut().push(message);
+            });
+        }
+    }
+
+    fn flush(&self) {}
+}

rust/src/log/mod.rs

@@ -1,73 +1,120 @@
+use crate::vec;
+use crate::BOARD_ACCESS;
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use bytemuck::{AnyBitPattern, Pod, Zeroable};
+use deranged::RangedU8;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::channel::Channel;
+use embassy_sync::mutex::Mutex;
+use esp_hal::Persistable;
+use log::{info, warn};
 use serde::Serialize;
-use std::{collections::HashMap, sync::Mutex};
-use strum::EnumIter;
 use strum_macros::IntoStaticStr;
-
-use esp_idf_svc::systime::EspSystemTime;
-use once_cell::sync::Lazy;
-use ringbuffer::{ConstGenericRingBuffer, RingBuffer};
-use text_template::Template;
 use unit_enum::UnitEnum;
 
+const LOG_ARRAY_SIZE: u8 = 220;
+const MAX_LOG_ARRAY_INDEX: u8 = LOG_ARRAY_SIZE - 1;
+#[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
+static mut LOG_ARRAY: LogArray = LogArray {
+    buffer: [LogEntryInner {
+        timestamp: 0,
+        message_id: 0,
+        a: 0,
+        b: 0,
+        txt_short: [0; TXT_SHORT_LENGTH],
+        txt_long: [0; TXT_LONG_LENGTH],
+    }; LOG_ARRAY_SIZE as usize],
+    head: 0,
+};
+
+// this is the only reference created for LOG_ARRAY and the only way to access it
+#[allow(static_mut_refs)]
+pub static LOG_ACCESS: Mutex<CriticalSectionRawMutex, &'static mut LogArray> =
+    unsafe { Mutex::new(&mut LOG_ARRAY) };
+
+mod interceptor;
+
+pub use interceptor::InterceptorLogger;
+
+pub static INTERCEPTOR: InterceptorLogger = InterceptorLogger::new();
+
+pub struct LogRequest {
+    pub message_key: LogMessage,
+    pub number_a: u32,
+    pub number_b: u32,
+    pub txt_short: heapless::String<TXT_SHORT_LENGTH>,
+    pub txt_long: heapless::String<TXT_LONG_LENGTH>,
+}
+
+static LOG_CHANNEL: Channel<CriticalSectionRawMutex, LogRequest, 16> = Channel::new();
+
+#[embassy_executor::task]
+pub async fn log_task() {
+    loop {
+        let request = LOG_CHANNEL.receive().await;
+        LOG_ACCESS
+            .lock()
+            .await
+            .log(
+                request.message_key,
+                request.number_a,
+                request.number_b,
+                request.txt_short.as_str(),
+                request.txt_long.as_str(),
+            )
+            .await;
+    }
+}
+
 const TXT_SHORT_LENGTH: usize = 8;
 const TXT_LONG_LENGTH: usize = 32;
 
-const BUFFER_SIZE: usize = 220;
+#[derive(Debug, Clone, Copy, AnyBitPattern)]
+#[repr(C)]
+pub struct LogArray {
+    buffer: [LogEntryInner; LOG_ARRAY_SIZE as usize],
+    head: u8,
+}
 
-#[link_section = ".rtc.data"]
+unsafe impl Persistable for LogArray {}
-static mut BUFFER: ConstGenericRingBuffer<LogEntry, BUFFER_SIZE> =
+unsafe impl Zeroable for LogEntryInner {}
-    ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>::new();
-#[allow(static_mut_refs)]
-static BUFFER_ACCESS: Lazy<Mutex<&mut ConstGenericRingBuffer<LogEntry, BUFFER_SIZE>>> =
-    Lazy::new(|| unsafe { Mutex::new(&mut BUFFER) });
 
-#[derive(Serialize, Debug, Clone)]
+unsafe impl Pod for LogEntryInner {}
+
+#[derive(Debug, Clone, Copy)]
+struct LogEntryInner {
+    pub timestamp: u64,
+    pub message_id: u16,
+    pub a: u32,
+    pub b: u32,
+    pub txt_short: [u8; TXT_SHORT_LENGTH],
+    pub txt_long: [u8; TXT_LONG_LENGTH],
+}
+
+#[derive(Serialize)]
 pub struct LogEntry {
     pub timestamp: u64,
     pub message_id: u16,
     pub a: u32,
     pub b: u32,
-    pub txt_short: heapless::String<TXT_SHORT_LENGTH>,
+    pub txt_short: alloc::string::String,
-    pub txt_long: heapless::String<TXT_LONG_LENGTH>,
+    pub txt_long: alloc::string::String,
 }
 
-pub fn init() {
+impl From<LogEntryInner> for LogEntry {
-    unsafe {
+    fn from(value: LogEntryInner) -> Self {
-        BUFFER = ConstGenericRingBuffer::<LogEntry, BUFFER_SIZE>::new();
+        LogEntry {
-    };
+            timestamp: value.timestamp,
-    let mut access = BUFFER_ACCESS.lock().unwrap();
+            message_id: value.message_id,
-    access.drain().for_each(|_| {});
+            a: value.a,
-}
+            b: value.b,
-
+            txt_short: alloc::string::String::from_utf8_lossy_owned(value.txt_short.to_vec()),
-fn limit_length<const LIMIT: usize>(input: &str, target: &mut heapless::String<LIMIT>) {
+            txt_long: alloc::string::String::from_utf8_lossy_owned(value.txt_long.to_vec()),
-    for char in input.chars() {
-        match target.push(char) {
-            Ok(_) => {} //continue adding chars
-            Err(_) => {
-                //clear space for two asci chars
-                while target.len() + 2 >= LIMIT {
-                    target.pop().unwrap();
-                }
-                //add .. to shortened strings
-                target.push('.').unwrap();
-                target.push('.').unwrap();
-                return;
-            }
         }
     }
 }
 
-pub fn get_log() -> Vec<LogEntry> {
-    let buffer = BUFFER_ACCESS.lock().unwrap();
-    let mut read_copy = Vec::new();
-    for entry in buffer.iter() {
-        let copy = entry.clone();
-        read_copy.push(copy);
-    }
-    drop(buffer);
-    read_copy
-}
-
 pub fn log(message_key: LogMessage, number_a: u32, number_b: u32, txt_short: &str, txt_long: &str) {
     let mut txt_short_stack: heapless::String<TXT_SHORT_LENGTH> = heapless::String::new();
     let mut txt_long_stack: heapless::String<TXT_LONG_LENGTH> = heapless::String::new();
@@ -75,59 +122,119 @@ pub fn log(message_key: LogMessage, number_a: u32, number_b: u32, txt_short: &st
     limit_length(txt_short, &mut txt_short_stack);
     limit_length(txt_long, &mut txt_long_stack);
 
-    let time = EspSystemTime {}.now().as_millis() as u64;
+    match LOG_CHANNEL.try_send(LogRequest {
-
+        message_key,
-    let ordinal = message_key.ordinal() as u16;
+        number_a,
-    let template_string: &str = message_key.into();
+        number_b,
-
-    let mut values: HashMap<&str, &str> = HashMap::new();
-    let number_a_str = number_a.to_string();
-    let number_b_str = number_b.to_string();
-
-    values.insert("number_a", &number_a_str);
-    values.insert("number_b", &number_b_str);
-    values.insert("txt_short", txt_short);
-    values.insert("txt_long", txt_long);
-
-    let template = Template::from(template_string);
-    let serial_entry = template.fill_in(&values);
-
-    println!("{serial_entry}");
-    //TODO push to mqtt?
-
-    let entry = LogEntry {
-        timestamp: time,
-        message_id: ordinal,
-        a: number_a,
-        b: number_b,
         txt_short: txt_short_stack,
         txt_long: txt_long_stack,
-    };
+    }) {
-
+        Ok(_) => {}
-    let mut buffer = BUFFER_ACCESS.lock().unwrap();
+        Err(_) => {
-    buffer.push(entry);
+            warn!("Log channel full, dropping log entry");
-}
+        }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn within_limit() {
-        let test = "12345678";
-
-        let mut txt_short_stack: heapless::String<TXT_SHORT_LENGTH> = heapless::String::new();
-        let mut txt_long_stack: heapless::String<TXT_LONG_LENGTH> = heapless::String::new();
-        limit_length(test, &mut txt_short_stack);
-        limit_length(test, &mut txt_long_stack);
-
-        assert_eq!(txt_short_stack.as_str(), test);
-        assert_eq!(txt_long_stack.as_str(), test);
     }
 }
 
-#[derive(IntoStaticStr, EnumIter, Serialize, PartialEq, Eq, PartialOrd, Ord, Clone, UnitEnum)]
+impl LogArray {
+    pub fn get(&mut self) -> Vec<LogEntry> {
+        let head: RangedU8<0, MAX_LOG_ARRAY_INDEX> =
+            RangedU8::new(self.head).unwrap_or(RangedU8::new_saturating(0));
+
+        let mut rv: Vec<LogEntry> = Vec::new();
+        let mut index = head.wrapping_sub(1);
+        for _ in 0..self.buffer.len() {
+            let entry = self.buffer[index.get() as usize];
+            if (entry.message_id as usize) != LogMessage::Empty.ordinal() {
+                rv.push(entry.into());
+            }
+            index = index.wrapping_sub(1);
+        }
+        rv
+    }
+
+    pub async fn log(
+        &mut self,
+        message_key: LogMessage,
+        number_a: u32,
+        number_b: u32,
+        txt_short: &str,
+        txt_long: &str,
+    ) {
+        let mut head: RangedU8<0, MAX_LOG_ARRAY_INDEX> =
+            RangedU8::new(self.head).unwrap_or(RangedU8::new_saturating(0));
+
+        let time = {
+            let mut guard = BOARD_ACCESS.get().await.lock().await;
+            guard.board_hal.get_esp().rtc.current_time_us()
+        } / 1000;
+
+        let ordinal = message_key.ordinal() as u16;
+        let template: &str = message_key.into();
+        let mut template_string = template.to_string();
+        template_string = template_string.replace("${number_a}", number_a.to_string().as_str());
+        template_string = template_string.replace("${number_b}", number_b.to_string().as_str());
+        template_string = template_string.replace("${txt_long}", txt_long);
+        template_string = template_string.replace("${txt_short}", txt_short);
+
+        info!("{template_string}");
+
+        let to_modify = &mut self.buffer[head.get() as usize];
+        to_modify.timestamp = time;
+        to_modify.message_id = ordinal;
+        to_modify.a = number_a;
+        to_modify.b = number_b;
+        to_modify.txt_short.clone_from_slice(txt_short.as_bytes());
+        to_modify.txt_long.clone_from_slice(txt_long.as_bytes());
+        head = head.wrapping_add(1);
+        self.head = head.get();
+    }
+}
+
+fn limit_length<const LIMIT: usize>(input: &str, target: &mut heapless::String<LIMIT>) {
+    for char in input.chars() {
+        match target.push(char) {
+            Ok(_) => {} //continue adding chars
+            Err(_) => {
+                //clear space for two asci chars
+                info!("pushing char {char} to limit {LIMIT} current value {target} input {input}");
+                while target.len() + 2 >= LIMIT {
+                    target.pop();
+                }
+                //add .. to shortened strings
+                match target.push('.') {
+                    Ok(_) => {}
+                    Err(_) => {
+                        warn!(
+                            "Error pushin . to limit {LIMIT} current value {target} input {input}"
+                        )
+                    }
+                }
+                match target.push('.') {
+                    Ok(_) => {}
+                    Err(_) => {
+                        warn!(
+                            "Error pushin . to limit {LIMIT} current value {target} input {input}"
+                        )
+                    }
+                }
+            }
+        }
+    }
+    while target.len() < LIMIT {
+        match target.push(' ') {
+            Ok(_) => {}
+            Err(_) => {
+                warn!("Error pushing space to limit {LIMIT} current value {target} input {input}")
+            }
+        }
+    }
+}
+
+#[derive(IntoStaticStr, Serialize, PartialEq, Eq, PartialOrd, Ord, Clone, UnitEnum)]
 pub enum LogMessage {
+    #[strum(serialize = "")]
+    Empty,
     #[strum(
         serialize = "Reset due to ${txt_long} requires rtc clear ${number_a} and force config mode ${number_b}"
     )]
@@ -160,7 +267,7 @@ pub enum LogMessage {
     StayAlive,
     #[strum(serialize = "Connecting mqtt ${txt_short} with id ${txt_long}")]
     MqttInfo,
-    #[strum(serialize = "Received stay alive with value ${txt_short}")]
+    #[strum(serialize = "Received stay alive with value ${number_a}")]
     MqttStayAliveRec,
     #[strum(serialize = "Unknown topic recieved ${txt_long}")]
     UnknownTopic,
@@ -204,6 +311,20 @@ pub enum LogMessage {
     PumpOpenLoopCurrent,
     #[strum(serialize = "Pump Open current sensor required but did not work: ${number_a}")]
     PumpMissingSensorCurrent,
+    #[strum(
+        serialize = "Fertilizer applied for ${number_a}s on plant ${number_b} (last application ${txt_short} minutes ago)"
+    )]
+    FertilizerApplied,
+    #[strum(serialize = "MPPT Current sensor could not be reached")]
+    MPPTError,
+    #[strum(
+        serialize = "Trace: a: ${number_a} b: ${number_b} txt_s ${txt_short} long ${txt_long}"
+    )]
+    Trace,
+    #[strum(serialize = "Parsing error reading message")]
+    UnknownMessage,
+    #[strum(serialize = "Going to deep sleep for ${number_a} minutes")]
+    DeepSleep,
 }
 
 #[derive(Serialize)]
@@ -222,9 +343,9 @@ impl From<&LogMessage> for MessageTranslation {
 }
 
 impl LogMessage {
-    pub fn to_log_localisation_config() -> Vec<MessageTranslation> {
+    pub fn log_localisation_config() -> Vec<MessageTranslation> {
         Vec::from_iter((0..LogMessage::len()).map(|i| {
-            let msg_type = LogMessage::from_ordinal(i).unwrap();
+            let msg_type = LogMessage::from_ordinal(i).unwrap_or(LogMessage::UnknownMessage);
             (&msg_type).into()
         }))
     }

rust/src/mcutie_3_0_0/Cargo.toml

@@ -0,0 +1,34 @@
+[package]
+name = "mcutie"
+version = "3.0.0"
+edition = "2021"
+
+[lib]
+path = "lib.rs"
+
+[features]
+default = []
+homeassistant = []
+serde = ["dep:serde", "heapless/serde"]
+defmt = []
+log = ["dep:log"]
+
+[dependencies]
+embassy-net = { version = "0.8.0", default-features = false, features = ["tcp", "dns", "proto-ipv4", "proto-ipv6", "medium-ethernet"] }
+embassy-sync = { version = "0.8.0", default-features = false }
+embassy-time = { version = "0.5.1", default-features = false }
+embassy-futures = { version = "0.1.2", default-features = false }
+embedded-io = { version = "0.7.1", default-features = false }
+embedded-io-async = { version = "0.7.0", default-features = false }
+heapless = { version = "0.7.17", default-features = false }
+mqttrs = { version = "0.4.1", default-features = false }
+once_cell = { version = "1.21.3", default-features = false, features = ["critical-section"] }
+pin-project = { version = "1.1.10", default-features = false }
+hex = { version = "0.4.3", default-features = false }
+serde = { version = "1.0.228", default-features = false, features = ["derive"], optional = true }
+log = { version = "0.4.28", default-features = false, optional = true }
+
+[dev-dependencies]
+futures-executor = "0.3.31"
+futures-timer = "3.0.3"
+futures-util = "0.3.31"

rust/src/mcutie_3_0_0/buffer.rs

@@ -0,0 +1,124 @@
+use core::{cmp, fmt, ops::Deref};
+
+use embedded_io::{SliceWriteError, Write};
+use mqttrs::{encode_slice, Packet};
+
+use crate::Error;
+
+/// A stack allocated buffer that can be written to and then read back from.
+/// Dereferencing as a [`u8`] slice allows access to previously written data.
+///
+/// Can be written to with [`write!`] and supports [`embedded_io::Write`] and
+/// [`embedded_io_async::Write`].
+pub struct Buffer<const N: usize> {
+    bytes: [u8; N],
+    cursor: usize,
+}
+
+impl<const N: usize> Default for Buffer<N> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<const N: usize> Buffer<N> {
+    /// Creates a new buffer.
+    pub(crate) const fn new() -> Self {
+        Self {
+            bytes: [0; N],
+            cursor: 0,
+        }
+    }
+
+    /// Creates a new buffer and writes the given data into it.
+    pub(crate) fn from(buf: &[u8]) -> Result<Self, Error> {
+        let mut buffer = Self::new();
+        match buffer.write_all(buf) {
+            Ok(()) => Ok(buffer),
+            Err(_) => Err(Error::TooLarge),
+        }
+    }
+
+    pub(crate) fn encode_packet(&mut self, packet: &Packet<'_>) -> Result<(), mqttrs::Error> {
+        let len = encode_slice(packet, &mut self.bytes[self.cursor..])?;
+        self.cursor += len;
+
+        Ok(())
+    }
+
+    #[cfg(feature = "serde")]
+    /// Serializes a value into this buffer using JSON.
+    pub(crate) fn serialize_json<T: serde::Serialize>(
+        &mut self,
+        value: &T,
+    ) -> Result<(), serde_json_core::ser::Error> {
+        let len = serde_json_core::to_slice(value, &mut self.bytes[self.cursor..])?;
+        self.cursor += len;
+
+        Ok(())
+    }
+
+    #[cfg(feature = "serde")]
+    /// Deserializes this buffer using JSON into the given type.
+    pub fn deserialize_json<'a, T: serde::Deserialize<'a>>(
+        &'a self,
+    ) -> Result<T, serde_json_core::de::Error> {
+        let (result, _) = serde_json_core::from_slice(self)?;
+
+        Ok(result)
+    }
+
+    /// The number of bytes available for writing into this buffer.
+    pub fn available(&self) -> usize {
+        N - self.cursor
+    }
+}
+
+impl<const N: usize> Deref for Buffer<N> {
+    type Target = [u8];
+
+    fn deref(&self) -> &Self::Target {
+        &self.bytes[0..self.cursor]
+    }
+}
+
+impl<const N: usize> fmt::Write for Buffer<N> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_all(s.as_bytes()).map_err(|_| fmt::Error)
+    }
+}
+
+impl<const N: usize> embedded_io::ErrorType for Buffer<N> {
+    type Error = SliceWriteError;
+}
+
+impl<const N: usize> embedded_io::Write for Buffer<N> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        if buf.is_empty() {
+            return Ok(0);
+        }
+
+        let writable = cmp::min(self.available(), buf.len());
+        if writable == 0 {
+            Err(SliceWriteError::Full)
+        } else {
+            self.bytes[self.cursor..self.cursor + writable].copy_from_slice(buf);
+            self.cursor += writable;
+            Ok(writable)
+        }
+    }
+
+    fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+impl<const N: usize> embedded_io_async::Write for Buffer<N> {
+    async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+        <Self as embedded_io::Write>::write(self, buf)
+    }
+
+    async fn flush(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}

rust/src/mcutie_3_0_0/fmt.rs

@@ -0,0 +1,80 @@
+#![macro_use]
+
+#[cfg(all(feature = "defmt", feature = "log"))]
+compile_error!("The `defmt` and `log` features cannot both be enabled at the same time.");
+
+#[cfg(not(feature = "defmt"))]
+use core::fmt;
+
+#[cfg(feature = "defmt")]
+pub(crate) use ::defmt::Debug2Format;
+
+#[cfg(not(feature = "defmt"))]
+pub(crate) struct Debug2Format<D: fmt::Debug>(pub(crate) D);
+
+#[cfg(feature = "log")]
+impl<D: fmt::Debug> fmt::Debug for Debug2Format<D> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! trace {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        #[cfg(feature = "defmt")]
+        ::defmt::trace!($s $(, $x)*);
+        #[cfg(feature = "log")]
+        ::log::trace!($s $(, $x)*);
+        #[cfg(not(any(feature="defmt", feature="log")))]
+        let _ = ($( & $x ),*);
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! debug {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        #[cfg(feature = "defmt")]
+        ::defmt::debug!($s $(, $x)*);
+        #[cfg(feature = "log")]
+        ::log::debug!($s $(, $x)*);
+        #[cfg(not(any(feature="defmt", feature="log")))]
+        let _ = ($( & $x ),*);
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! info {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        #[cfg(feature = "defmt")]
+        ::defmt::info!($s $(, $x)*);
+        #[cfg(feature = "log")]
+        ::log::info!($s $(, $x)*);
+        #[cfg(not(any(feature="defmt", feature="log")))]
+        let _ = ($( & $x ),*);
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! warn {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        #[cfg(feature = "defmt")]
+        ::defmt::warn!($s $(, $x)*);
+        #[cfg(feature = "log")]
+        ::log::warn!($s $(, $x)*);
+        #[cfg(not(any(feature="defmt", feature="log")))]
+        let _ = ($( & $x ),*);
+    };
+}
+
+#[collapse_debuginfo(yes)]
+macro_rules! error {
+    ($s:literal $(, $x:expr)* $(,)?) => {
+        #[cfg(feature = "defmt")]
+        ::defmt::error!($s $(, $x)*);
+        #[cfg(feature = "log")]
+        ::log::error!($s $(, $x)*);
+        #[cfg(not(any(feature="defmt", feature="log")))]
+        let _ = ($( & $x ),*);
+    };
+}

rust/src/mcutie_3_0_0/homeassistant/binary_sensor.rs

@@ -0,0 +1,120 @@
+//! Tools for publishing a [Home Assistant binary sensor](https://www.home-assistant.io/integrations/binary_sensor.mqtt/).
+use core::ops::Deref;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{homeassistant::Component, Error, Publishable, Topic};
+
+/// The state of the sensor. Can be easily converted to or from a [`bool`].
+#[derive(Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(from = "&str", into = "&'static str")]
+#[allow(missing_docs)]
+pub enum BinarySensorState {
+    On,
+    Off,
+}
+
+impl From<BinarySensorState> for &'static str {
+    fn from(state: BinarySensorState) -> Self {
+        match state {
+            BinarySensorState::On => "ON",
+            BinarySensorState::Off => "OFF",
+        }
+    }
+}
+
+impl<'a> From<&'a str> for BinarySensorState {
+    fn from(st: &'a str) -> Self {
+        if st == "ON" {
+            Self::On
+        } else {
+            Self::Off
+        }
+    }
+}
+
+impl From<bool> for BinarySensorState {
+    fn from(val: bool) -> Self {
+        if val {
+            BinarySensorState::On
+        } else {
+            BinarySensorState::Off
+        }
+    }
+}
+
+impl From<BinarySensorState> for bool {
+    fn from(val: BinarySensorState) -> Self {
+        match val {
+            BinarySensorState::On => true,
+            BinarySensorState::Off => true,
+        }
+    }
+}
+
+impl AsRef<[u8]> for BinarySensorState {
+    fn as_ref(&self) -> &'static [u8] {
+        match self {
+            Self::On => "ON".as_bytes(),
+            Self::Off => "OFF".as_bytes(),
+        }
+    }
+}
+
+/// The type of sensor.
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+#[allow(missing_docs)]
+pub enum BinarySensorClass {
+    Battery,
+    BatteryCharging,
+    CarbonMonoxide,
+    Cold,
+    Connectivity,
+    Door,
+    GarageDoor,
+    Gas,
+    Heat,
+    Light,
+    Lock,
+    Moisture,
+    Motion,
+    Moving,
+    Occupancy,
+    Opening,
+    Plug,
+    Power,
+    Presence,
+    Problem,
+    Running,
+    Safety,
+    Smoke,
+    Sound,
+    Tamper,
+    Update,
+    Vibration,
+    Window,
+}
+
+/// A binary sensor that can publish a [`BinarySensorState`] status.
+#[derive(Serialize)]
+pub struct BinarySensor {
+    /// The type of sensor
+    pub device_class: Option<BinarySensorClass>,
+}
+
+impl Component for BinarySensor {
+    type State = BinarySensorState;
+
+    fn platform() -> &'static str {
+        "binary_sensor"
+    }
+
+    async fn publish_state<T: Deref<Target = str>>(
+        &self,
+        topic: &Topic<T>,
+        state: Self::State,
+    ) -> Result<(), Error> {
+        topic.with_bytes(state).publish().await
+    }
+}

rust/src/mcutie_3_0_0/homeassistant/button.rs

@@ -0,0 +1,40 @@
+//! Tools for publishing a [Home Assistant button](https://www.home-assistant.io/integrations/button.mqtt/).
+use core::ops::Deref;
+
+use serde::Serialize;
+
+use crate::{homeassistant::Component, Error, Topic};
+
+/// The type of button.
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+#[allow(missing_docs)]
+pub enum ButtonClass {
+    Identify,
+    Restart,
+    Update,
+}
+
+/// A button that can be pressed.
+#[derive(Serialize)]
+pub struct Button {
+    /// The type of button.
+    pub device_class: Option<ButtonClass>,
+}
+
+impl Component for Button {
+    type State = ();
+
+    fn platform() -> &'static str {
+        "button"
+    }
+
+    async fn publish_state<T: Deref<Target = str>>(
+        &self,
+        _topic: &Topic<T>,
+        _state: Self::State,
+    ) -> Result<(), Error> {
+        // Buttons don't have a state
+        Err(Error::Invalid)
+    }
+}

rust/src/mcutie_3_0_0/homeassistant/light.rs

@@ -0,0 +1,384 @@
+//! Tools for publishing a [Home Assistant light](https://www.home-assistant.io/integrations/light.mqtt/).
+use core::{ops::Deref, str};
+
+use serde::{ser::SerializeStruct, Deserialize, Serialize, Serializer};
+
+use crate::{
+    fmt::Debug2Format,
+    homeassistant::{binary_sensor::BinarySensorState, ser::List, Component},
+    Error, Payload, Publishable, Topic,
+};
+
+#[derive(Serialize)]
+#[serde(rename_all = "lowercase")]
+#[allow(missing_docs)]
+pub enum SupportedColorMode {
+    OnOff,
+    Brightness,
+    #[serde(rename = "color_temp")]
+    ColorTemp,
+    Hs,
+    Xy,
+    Rgb,
+    Rgbw,
+    Rgbww,
+    White,
+}
+
+#[derive(Serialize, Deserialize, Default)]
+struct SerializedColor {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    h: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    s: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    x: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    y: Option<f32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    r: Option<u8>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    g: Option<u8>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    b: Option<u8>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    w: Option<u8>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    c: Option<u8>,
+}
+
+#[derive(Deserialize)]
+struct LedPayload<'a> {
+    state: BinarySensorState,
+    #[serde(default)]
+    brightness: Option<u8>,
+    #[serde(default)]
+    color_temp: Option<u32>,
+    #[serde(default)]
+    color: Option<SerializedColor>,
+    #[serde(default)]
+    effect: Option<&'a str>,
+}
+
+/// The color of the light in various forms.
+#[derive(Serialize)]
+#[serde(rename_all = "lowercase", tag = "color_mode", content = "color")]
+#[allow(missing_docs)]
+pub enum Color {
+    None,
+    Brightness(u8),
+    ColorTemp(u32),
+    Hs {
+        #[serde(rename = "h")]
+        hue: f32,
+        #[serde(rename = "s")]
+        saturation: f32,
+    },
+    Xy {
+        x: f32,
+        y: f32,
+    },
+    Rgb {
+        #[serde(rename = "r")]
+        red: u8,
+        #[serde(rename = "g")]
+        green: u8,
+        #[serde(rename = "b")]
+        blue: u8,
+    },
+    Rgbw {
+        #[serde(rename = "r")]
+        red: u8,
+        #[serde(rename = "g")]
+        green: u8,
+        #[serde(rename = "b")]
+        blue: u8,
+        #[serde(rename = "w")]
+        white: u8,
+    },
+    Rgbww {
+        #[serde(rename = "r")]
+        red: u8,
+        #[serde(rename = "g")]
+        green: u8,
+        #[serde(rename = "b")]
+        blue: u8,
+        #[serde(rename = "c")]
+        cool_white: u8,
+        #[serde(rename = "w")]
+        warm_white: u8,
+    },
+}
+
+/// The state of the light. This can be sent to the broker and received as a
+/// command from Home Assistant.
+pub struct LightState<'a> {
+    /// Whether the light is on or off.
+    pub state: BinarySensorState,
+    /// The color of the light.
+    pub color: Color,
+    /// Any effect that is applied.
+    pub effect: Option<&'a str>,
+}
+
+impl<'a> LightState<'a> {
+    /// Parses the state from a command payload.
+    pub fn from_payload(payload: &'a Payload) -> Result<Self, Error> {
+        let parsed: LedPayload<'a> = match payload.deserialize_json() {
+            Ok(p) => p,
+            Err(e) => {
+                warn!("Failed to deserialize packet: {:?}", Debug2Format(&e));
+                if let Ok(s) = str::from_utf8(payload) {
+                    trace!("{}", s);
+                }
+                return Err(Error::PacketError);
+            }
+        };
+
+        let color = if let Some(color) = parsed.color {
+            if let Some(x) = color.x {
+                Color::Xy {
+                    x,
+                    y: color.y.unwrap_or_default(),
+                }
+            } else if let Some(h) = color.h {
+                Color::Hs {
+                    hue: h,
+                    saturation: color.s.unwrap_or_default(),
+                }
+            } else if let Some(c) = color.c {
+                Color::Rgbww {
+                    red: color.r.unwrap_or_default(),
+                    green: color.g.unwrap_or_default(),
+                    blue: color.b.unwrap_or_default(),
+                    cool_white: c,
+                    warm_white: color.w.unwrap_or_default(),
+                }
+            } else if let Some(w) = color.w {
+                Color::Rgbw {
+                    red: color.r.unwrap_or_default(),
+                    green: color.g.unwrap_or_default(),
+                    blue: color.b.unwrap_or_default(),
+                    white: w,
+                }
+            } else {
+                Color::Rgb {
+                    red: color.r.unwrap_or_default(),
+                    green: color.g.unwrap_or_default(),
+                    blue: color.b.unwrap_or_default(),
+                }
+            }
+        } else if let Some(color_temp) = parsed.color_temp {
+            Color::ColorTemp(color_temp)
+        } else if let Some(brightness) = parsed.brightness {
+            Color::Brightness(brightness)
+        } else {
+            Color::None
+        };
+
+        Ok(LightState {
+            state: parsed.state,
+            color,
+            effect: parsed.effect,
+        })
+    }
+}
+
+impl Serialize for LightState<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut len = 1;
+
+        if self.effect.is_some() {
+            len += 1;
+        }
+
+        match self.color {
+            Color::None => {}
+            Color::Brightness(_) | Color::ColorTemp(_) => len += 1,
+            _ => len += 2,
+        }
+
+        let mut serializer = serializer.serialize_struct("LightState", len)?;
+
+        serializer.serialize_field("state", &self.state)?;
+
+        if let Some(effect) = self.effect {
+            serializer.serialize_field("effect", effect)?;
+        } else {
+            serializer.skip_field("effect")?;
+        }
+
+        match self.color {
+            Color::None => {
+                serializer.skip_field("brightness")?;
+                serializer.skip_field("color_temp")?;
+                serializer.skip_field("color")?;
+            }
+            Color::Brightness(b) => {
+                serializer.skip_field("color_temp")?;
+                serializer.skip_field("color")?;
+
+                serializer.serialize_field("brightness", &b)?
+            }
+            Color::ColorTemp(c) => {
+                serializer.skip_field("brightness")?;
+                serializer.skip_field("color")?;
+
+                serializer.serialize_field("color_temp", &c)?
+            }
+            Color::Hs { hue, saturation } => {
+                serializer.skip_field("brightness")?;
+                serializer.skip_field("color_temp")?;
+
+                serializer.serialize_field("color_mode", "hs")?;
+
+                let color = SerializedColor {
+                    h: Some(hue),
+                    s: Some(saturation),
+                    ..Default::default()
+                };
+
+                serializer.serialize_field("color", &color)?
+            }
+            Color::Xy { x, y } => {
+                serializer.skip_field("brightness")?;
+                serializer.skip_field("color_temp")?;
+
+                serializer.serialize_field("color_mode", "xy")?;
+
+                let color = SerializedColor {
+                    x: Some(x),
+                    y: Some(y),
+                    ..Default::default()
+                };
+
+                serializer.serialize_field("color", &color)?
+            }
+            Color::Rgb { red, green, blue } => {
+                serializer.skip_field("brightness")?;
+                serializer.skip_field("color_temp")?;
+
+                serializer.serialize_field("color_mode", "rgb")?;
+
+                let color = SerializedColor {
+                    r: Some(red),
+                    g: Some(green),
+                    b: Some(blue),
+                    ..Default::default()
+                };
+
+                serializer.serialize_field("color", &color)?
+            }
+            Color::Rgbw {
+                red,
+                green,
+                blue,
+                white,
+            } => {
+                serializer.skip_field("brightness")?;
+                serializer.skip_field("color_temp")?;
+
+                serializer.serialize_field("color_mode", "rgbw")?;
+
+                let color = SerializedColor {
+                    r: Some(red),
+                    g: Some(green),
+                    b: Some(blue),
+                    w: Some(white),
+                    ..Default::default()
+                };
+
+                serializer.serialize_field("color", &color)?
+            }
+            Color::Rgbww {
+                red,
+                green,
+                blue,
+                cool_white,
+                warm_white,
+            } => {
+                serializer.skip_field("brightness")?;
+                serializer.skip_field("color_temp")?;
+
+                serializer.serialize_field("color_mode", "rgbww")?;
+
+                let color = SerializedColor {
+                    r: Some(red),
+                    g: Some(green),
+                    b: Some(blue),
+                    c: Some(cool_white),
+                    w: Some(warm_white),
+                    ..Default::default()
+                };
+
+                serializer.serialize_field("color", &color)?
+            }
+        }
+
+        serializer.end()
+    }
+}
+
+/// A light entity
+pub struct Light<'a, const C: usize, const E: usize> {
+    /// The color modes supported by the light.
+    pub supported_color_modes: [SupportedColorMode; C],
+    /// Any effects that can be used.
+    pub effects: [&'a str; E],
+}
+
+impl<const C: usize, const E: usize> Serialize for Light<'_, C, E> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut len = 2;
+
+        if C > 0 {
+            len += 1;
+        }
+
+        if E > 0 {
+            len += 2;
+        }
+
+        let mut serializer = serializer.serialize_struct("Light", len)?;
+
+        serializer.serialize_field("schema", "json")?;
+
+        if C > 0 {
+            serializer.serialize_field("sup_clrm", &List::new(&self.supported_color_modes))?;
+        } else {
+            serializer.skip_field("sup_clrm")?;
+        }
+
+        if E > 0 {
+            serializer.serialize_field("effect", &true)?;
+            serializer.serialize_field("fx_list", &List::new(&self.effects))?;
+        } else {
+            serializer.skip_field("effect")?;
+            serializer.skip_field("fx_list")?;
+        }
+
+        serializer.end()
+    }
+}
+
+impl<const C: usize, const E: usize> Component for Light<'_, C, E> {
+    type State = LightState<'static>;
+
+    fn platform() -> &'static str {
+        "light"
+    }
+
+    async fn publish_state<T: Deref<Target = str>>(
+        &self,
+        topic: &Topic<T>,
+        state: Self::State,
+    ) -> Result<(), Error> {
+        topic.with_json(state).publish().await
+    }
+}

rust/src/mcutie_3_0_0/homeassistant/mod.rs

@@ -0,0 +1,295 @@
+//! Home Assistant auto-discovery and related messages.
+//!
+//! Normally you would declare your entities statically in your binary. It is
+//! then trivial to send out discovery messages or state changes.
+//!
+//! ```
+//! # use mcutie::{Publishable, Topic};
+//! # use mcutie::homeassistant::{Entity, Device, Origin, AvailabilityState, AvailabilityTopics};
+//! # use mcutie::homeassistant::binary_sensor::{BinarySensor, BinarySensorClass, BinarySensorState};
+//! const DEVICE_AVAILABILITY_TOPIC: Topic<&'static str> = Topic::Device("status");
+//! const MOTION_STATE_TOPIC: Topic<&'static str> = Topic::Device("motion/status");
+//!
+//! const DEVICE: Device<'static> = Device::new();
+//! const ORIGIN: Origin<'static> = Origin::new();
+//!
+//! const MOTION_SENSOR: Entity<'static, 1, BinarySensor> = Entity {
+//!     device: DEVICE,
+//!     origin: ORIGIN,
+//!     object_id: "motion",
+//!     unique_id: Some("motion"),
+//!     name: "Motion",
+//!     availability: AvailabilityTopics::All([DEVICE_AVAILABILITY_TOPIC]),
+//!     state_topic: Some(MOTION_STATE_TOPIC),
+//!     command_topic: None,
+//!     component: BinarySensor {
+//!         device_class: Some(BinarySensorClass::Motion),
+//!     },
+//! };
+//!
+//! async fn send_discovery_messages() {
+//!     MOTION_SENSOR.publish_discovery().await.unwrap();
+//!     DEVICE_AVAILABILITY_TOPIC.with_bytes(AvailabilityState::Online).publish().await.unwrap();
+//! }
+//!
+//! async fn send_state(state: BinarySensorState) {
+//!     MOTION_SENSOR.publish_state(state).await.unwrap();
+//! }
+//! ```
+use core::{future::Future, ops::Deref};
+
+use mqttrs::QoS;
+use serde::{
+    ser::{Error as _, SerializeStruct},
+    Serialize, Serializer,
+};
+
+use crate::{
+    device_id, device_type, homeassistant::ser::DiscoverySerializer, io::publish, Error,
+    McutieTask, MqttMessage, Payload, Publishable, Topic, TopicString, DATA_CHANNEL,
+};
+
+pub mod binary_sensor;
+pub mod button;
+pub mod light;
+pub mod sensor;
+mod ser;
+
+const HA_STATUS_TOPIC: Topic<&'static str> = Topic::General("homeassistant/status");
+const STATE_ONLINE: &str = "online";
+const STATE_OFFLINE: &str = "offline";
+
+/// A trait representing a specific type of entity in Home Assistant
+pub trait Component: Serialize {
+    /// The state to publish.
+    type State;
+
+    /// The platform identifier for this entity. Internal.
+    fn platform() -> &'static str;
+
+    /// Publishes this entity's state to the MQTT broker.
+    fn publish_state<T: Deref<Target = str>>(
+        &self,
+        topic: &Topic<T>,
+        state: Self::State,
+    ) -> impl Future<Output = Result<(), Error>>;
+}
+
+impl<'t, T, L, const S: usize> McutieTask<'t, T, L, S>
+where
+    T: Deref<Target = str> + 't,
+    L: Publishable + 't,
+{
+    pub(super) async fn ha_after_connected(&self) {
+        let _ = HA_STATUS_TOPIC.subscribe(false).await;
+    }
+
+    pub(super) async fn ha_handle_update(
+        &self,
+        topic: &Topic<TopicString>,
+        payload: &Payload,
+    ) -> bool {
+        if topic == &HA_STATUS_TOPIC {
+            if payload.as_ref() == STATE_ONLINE.as_bytes() {
+                DATA_CHANNEL.send(MqttMessage::HomeAssistantOnline).await;
+            }
+
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl<T: Deref<Target = str>> Serialize for Topic<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut topic = TopicString::new();
+        self.to_string(&mut topic)
+            .map_err(|_| S::Error::custom("topic was too large to serialize"))?;
+        serializer.serialize_str(&topic)
+    }
+}
+
+fn name_or_device<S>(name: &Option<&str>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_str(name.unwrap_or_else(|| device_type()))
+}
+
+/// Represents the device in Home Assistant.
+///
+/// Can just be the default in which case useful properties such as the ID are
+/// automatically included.
+#[derive(Clone, Copy, Default)]
+pub struct Device<'a> {
+    /// A name to identify the device. If not provided the default device type is
+    /// used.
+    pub name: Option<&'a str>,
+    /// An optional configuration URL for the device.
+    pub configuration_url: Option<&'a str>,
+}
+
+impl Device<'_> {
+    /// Creates a new default device.
+    pub const fn new() -> Self {
+        Self {
+            name: None,
+            configuration_url: None,
+        }
+    }
+}
+
+impl Serialize for Device<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut len = 2;
+        if self.configuration_url.is_some() {
+            len += 1;
+        }
+
+        let mut serializer = serializer.serialize_struct("Device", len)?;
+
+        serializer.serialize_field("name", self.name.unwrap_or_else(|| device_type()))?;
+        serializer.serialize_field("ids", device_id())?;
+
+        if let Some(cu) = self.configuration_url {
+            serializer.serialize_field("cu", cu)?;
+        } else {
+            serializer.skip_field("cu")?;
+        }
+
+        serializer.end()
+    }
+}
+
+/// Represents the device's origin in Home Assistant.
+///
+/// Can just be the default in which case useful properties are automatically
+/// included.
+#[derive(Clone, Copy, Default, Serialize)]
+pub struct Origin<'a> {
+    /// A name to identify the device's origin. If not provided the default
+    /// device type is used.
+    #[serde(serialize_with = "name_or_device")]
+    pub name: Option<&'a str>,
+}
+
+impl Origin<'_> {
+    /// Creates a new default origin.
+    pub const fn new() -> Self {
+        Self { name: None }
+    }
+}
+
+/// A single entity for Home Assistant.
+///
+/// Calling [`Entity::publish_discovery`] will publish the discovery message to
+/// allow Home Assistant to detect this entity. Read the
+/// [Home Assistant MQTT docs](https://www.home-assistant.io/integrations/mqtt/)
+/// for information on what some of these properties mean.
+pub struct Entity<'a, const A: usize, C: Component> {
+    /// The device this entity is a part of.
+    pub device: Device<'a>,
+    /// The origin of the device.
+    pub origin: Origin<'a>,
+    /// An object identifier to allow for entity ID customisation in Home Assistant.
+    pub object_id: &'a str,
+    /// An optional unique identifier for the entity.
+    pub unique_id: Option<&'a str>,
+    /// A friendly name for the entity.
+    pub name: &'a str,
+    /// Specifies the availability topics that Home Assistant will listen to to
+    /// determine this entity's availability.
+    pub availability: AvailabilityTopics<'a, A>,
+    /// The state topic that this entity's state is published to.
+    pub state_topic: Option<Topic<&'a str>>,
+    /// The command topic that this entity receives commands from.
+    pub command_topic: Option<Topic<&'a str>>,
+    /// The specific entity.
+    pub component: C,
+}
+
+impl<const A: usize, C: Component> Entity<'_, A, C> {
+    /// Publishes the discovery message for this entity to the broker.
+    pub async fn publish_discovery(&self) -> Result<(), Error> {
+        let mut topic = TopicString::new();
+        topic
+            .push_str(option_env!("HA_DISCOVERY_PREFIX").unwrap_or("homeassistant"))
+            .map_err(|_| Error::TooLarge)?;
+        topic.push('/').map_err(|_| Error::TooLarge)?;
+        topic.push_str(C::platform()).map_err(|_| Error::TooLarge)?;
+        topic.push('/').map_err(|_| Error::TooLarge)?;
+        topic
+            .push_str(self.object_id)
+            .map_err(|_| Error::TooLarge)?;
+        topic.push_str("/config").map_err(|_| Error::TooLarge)?;
+
+        let mut payload = Payload::new();
+        payload.serialize_json(self).map_err(|_| Error::TooLarge)?;
+
+        publish(&topic, &payload, QoS::AtMostOnce, false).await
+    }
+
+    /// Publishes this entity's state to the broker.
+    ///
+    /// # Errors
+    ///
+    /// - [`Error::Invalid`] if the entity doesn't have a state topic.
+    pub async fn publish_state(&self, state: C::State) -> Result<(), Error> {
+        if let Some(topic) = self.state_topic {
+            self.component.publish_state(&topic, state).await
+        } else {
+            Err(Error::Invalid)
+        }
+    }
+}
+
+/// A payload representing a device or entity's availability.
+#[allow(missing_docs)]
+pub enum AvailabilityState {
+    Online,
+    Offline,
+}
+
+impl AsRef<[u8]> for AvailabilityState {
+    fn as_ref(&self) -> &'static [u8] {
+        match self {
+            Self::Online => STATE_ONLINE.as_bytes(),
+            Self::Offline => STATE_OFFLINE.as_bytes(),
+        }
+    }
+}
+
+/// The availiabity topics that home assistant will use to determine an entity's
+/// availability.
+pub enum AvailabilityTopics<'a, const A: usize> {
+    /// The entity is always available.
+    None,
+    /// The entity is available if all of the topics are publishes as online.
+    All([Topic<&'a str>; A]),
+    /// The entity is available if any of the topics are publishes as online.
+    Any([Topic<&'a str>; A]),
+    /// The entity is available based on the most recent of the topics to
+    /// publish state.
+    Latest([Topic<&'a str>; A]),
+}
+
+impl<const A: usize, C: Component> Serialize for Entity<'_, A, C> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let outer = DiscoverySerializer {
+            discovery: self,
+            inner: serializer,
+        };
+
+        self.component.serialize(outer)
+    }
+}

rust/src/mcutie_3_0_0/homeassistant/sensor.rs

@@ -0,0 +1,103 @@
+//! Tools for publishing a [Home Assistant sensor](https://www.home-assistant.io/integrations/sensor.mqtt/).
+use core::ops::Deref;
+
+use serde::Serialize;
+
+use crate::{homeassistant::Component, Error, Publishable, Topic};
+
+/// The type of sensor.
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+#[allow(missing_docs)]
+pub enum SensorClass {
+    ApparentPower,
+    Aqi,
+    AtmosphericPressure,
+    Battery,
+    CarbonDioxide,
+    CarbonMonoxide,
+    Current,
+    DataRate,
+    DataSize,
+    Date,
+    Distance,
+    Duration,
+    Energy,
+    EnergyStorage,
+    Enum,
+    Frequency,
+    Gas,
+    Humidity,
+    Illuminance,
+    Irradiance,
+    Moisture,
+    Monetary,
+    NitrogenDioxide,
+    NitrogenMonoxide,
+    NitrousOxide,
+    Ozone,
+    Ph,
+    Pm1,
+    Pm25,
+    Pm10,
+    PowerFactor,
+    Power,
+    Precipitation,
+    PrecipitationIntensity,
+    Pressure,
+    ReactivePower,
+    SignalStrength,
+    SoundPressure,
+    Speed,
+    SulphurDioxide,
+    Temperature,
+    Timestamp,
+    VolatileOrganicCompounds,
+    VolatileOrganicCompoundsParts,
+    Voltage,
+    Volume,
+    VolumeFlowRate,
+    VolumeStorage,
+    Water,
+    Weight,
+    WindSpeed,
+}
+
+/// The type of measurement that this entity publishes.
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum SensorStateClass {
+    /// A measurement at a singe point in time.
+    Measurement,
+    /// A cumulative total that can increase or decrease over time.
+    Total,
+    /// A cumulative total that can only increase.
+    TotalIncreasing,
+}
+
+/// A binary sensor that can publish a [`f32`] value.
+#[derive(Serialize)]
+pub struct Sensor<'u> {
+    /// The type of sensor.
+    pub device_class: Option<SensorClass>,
+    /// The type of measurement that this sensor reports.
+    pub state_class: Option<SensorStateClass>,
+    /// The unit of measurement for this sensor.
+    pub unit_of_measurement: Option<&'u str>,
+}
+
+impl Component for Sensor<'_> {
+    type State = f32;
+
+    fn platform() -> &'static str {
+        "sensor"
+    }
+
+    async fn publish_state<T: Deref<Target = str>>(
+        &self,
+        topic: &Topic<T>,
+        state: Self::State,
+    ) -> Result<(), Error> {
+        topic.with_display(state).publish().await
+    }
+}

rust/src/mcutie_3_0_0/homeassistant/ser.rs

@@ -0,0 +1,333 @@
+use core::ops::Deref;
+
+use serde::{
+    ser::{SerializeSeq, SerializeStruct},
+    Serialize, Serializer,
+};
+
+use crate::{
+    homeassistant::{AvailabilityTopics, Component, Entity},
+    Topic,
+};
+
+#[derive(Serialize)]
+pub(super) struct AvailabilityTopicItem<'a> {
+    topic: Topic<&'a str>,
+}
+
+struct AvailabilityTopicList<'a, T: Deref<Target = str>, const N: usize> {
+    list: &'a [Topic<T>; N],
+}
+
+impl<'a, const N: usize, T: Deref<Target = str>> AvailabilityTopicList<'a, T, N> {
+    pub(super) fn new(list: &'a [Topic<T>; N]) -> Self {
+        Self { list }
+    }
+}
+
+impl<T: Deref<Target = str>, const N: usize> Serialize for AvailabilityTopicList<'_, T, N> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut serializer = serializer.serialize_seq(Some(N))?;
+
+        for topic in self.list {
+            serializer.serialize_element(&AvailabilityTopicItem {
+                topic: topic.as_ref(),
+            })?;
+        }
+
+        serializer.end()
+    }
+}
+
+pub(super) struct List<'a, T: Serialize, const N: usize> {
+    list: &'a [T; N],
+}
+
+impl<'a, T: Serialize, const N: usize> List<'a, T, N> {
+    pub(super) fn new(list: &'a [T; N]) -> Self {
+        Self { list }
+    }
+}
+
+impl<T: Serialize, const N: usize> Serialize for List<'_, T, N> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut serializer = serializer.serialize_seq(Some(N))?;
+
+        for item in self.list {
+            serializer.serialize_element(item)?;
+        }
+
+        serializer.end()
+    }
+}
+
+pub(super) struct DiscoverySerializer<'a, const A: usize, C: Component, S: Serializer> {
+    pub(super) discovery: &'a Entity<'a, A, C>,
+    pub(super) inner: S,
+}
+
+impl<const A: usize, C: Component, S: Serializer> Serializer for DiscoverySerializer<'_, A, C, S> {
+    type Ok = S::Ok;
+    type Error = S::Error;
+    type SerializeSeq = S::SerializeSeq;
+    type SerializeTuple = S::SerializeTuple;
+    type SerializeTupleStruct = S::SerializeTupleStruct;
+    type SerializeTupleVariant = S::SerializeTupleVariant;
+    type SerializeMap = S::SerializeMap;
+    type SerializeStruct = S::SerializeStruct;
+    type SerializeStructVariant = S::SerializeStructVariant;
+
+    fn serialize_struct(
+        self,
+        name: &'static str,
+        mut len: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        len += 5;
+        if self.discovery.state_topic.is_some() {
+            len += 1;
+        }
+        if self.discovery.command_topic.is_some() {
+            len += 1;
+        }
+        if self.discovery.unique_id.is_some() {
+            len += 1;
+        }
+        if !matches!(self.discovery.availability, AvailabilityTopics::None) {
+            len += 2;
+        }
+
+        let mut serializer = self.inner.serialize_struct(name, len)?;
+
+        serializer.serialize_field("dev", &self.discovery.device)?;
+        serializer.serialize_field("o", &self.discovery.origin)?;
+        serializer.serialize_field("p", C::platform())?;
+        serializer.serialize_field("obj_id", self.discovery.object_id)?;
+
+        serializer.serialize_field("name", self.discovery.name)?;
+
+        if let Some(t) = self.discovery.state_topic {
+            serializer.serialize_field("stat_t", &t)?;
+        } else {
+            serializer.skip_field("stat_t")?;
+        }
+
+        if let Some(t) = self.discovery.command_topic {
+            serializer.serialize_field("cmd_t", &t)?;
+        } else {
+            serializer.skip_field("cmd_t")?;
+        }
+
+        match &self.discovery.availability {
+            AvailabilityTopics::None => {
+                serializer.skip_field("avty")?;
+                serializer.skip_field("avty_mode")?;
+            }
+            AvailabilityTopics::All(topics) => {
+                serializer.serialize_field("avty_mode", "all")?;
+                serializer.serialize_field("avty", &AvailabilityTopicList::new(topics))?;
+            }
+            AvailabilityTopics::Any(topics) => {
+                serializer.serialize_field("avty_mode", "any")?;
+                serializer.serialize_field("avty", &AvailabilityTopicList::new(topics))?;
+            }
+            AvailabilityTopics::Latest(topics) => {
+                serializer.serialize_field("avty_mode", "latest")?;
+                serializer.serialize_field("avty", &AvailabilityTopicList::new(topics))?;
+            }
+        }
+
+        if let Some(v) = self.discovery.unique_id {
+            serializer.serialize_field("uniq_id", v)?;
+        } else {
+            serializer.skip_field("uniq_id")?;
+        }
+
+        Ok(serializer)
+    }
+
+    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        unimplemented!()
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_newtype_struct<T>(self, _: &'static str, _: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        unimplemented!()
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: ?Sized + Serialize,
+    {
+        unimplemented!()
+    }
+
+    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_i128(self, _: i128) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn serialize_u128(self, _: u128) -> Result<Self::Ok, Self::Error> {
+        unimplemented!()
+    }
+
+    fn collect_seq<I>(self, _: I) -> Result<Self::Ok, Self::Error>
+    where
+        I: IntoIterator,
+        <I as IntoIterator>::Item: Serialize,
+    {
+        unimplemented!()
+    }
+
+    fn collect_map<K, V, I>(self, _: I) -> Result<Self::Ok, Self::Error>
+    where
+        K: Serialize,
+        V: Serialize,
+        I: IntoIterator<Item = (K, V)>,
+    {
+        unimplemented!()
+    }
+
+    fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: ?Sized + core::fmt::Display,
+    {
+        unimplemented!()
+    }
+
+    fn is_human_readable(&self) -> bool {
+        unimplemented!()
+    }
+}

rust/src/mcutie_3_0_0/io.rs

@@ -0,0 +1,483 @@
+use core::ops::Deref;
+
+pub(crate) use atomic16::assign_pid;
+use embassy_futures::select::{select, select4, Either};
+use embassy_net::{
+    dns::DnsQueryType,
+    tcp::{TcpReader, TcpSocket, TcpWriter},
+    Stack,
+};
+use embassy_sync::{
+    blocking_mutex::raw::CriticalSectionRawMutex,
+    pubsub::{PubSubChannel, Subscriber, WaitResult},
+};
+use embassy_time::Timer;
+use embedded_io_async::Write;
+use mqttrs::{
+    decode_slice, Connect, ConnectReturnCode, LastWill, Packet, Pid, Protocol, Publish, QoS, QosPid,
+};
+
+use crate::{
+    device_id, fmt::Debug2Format, pipe::ConnectedPipe, ControlMessage, Error, MqttMessage, Payload,
+    Publishable, Topic, TopicString, CONFIRMATION_TIMEOUT, DATA_CHANNEL, DEFAULT_BACKOFF,
+    RESET_BACKOFF,
+};
+
+static SEND_QUEUE: ConnectedPipe<CriticalSectionRawMutex, Payload, 10> = ConnectedPipe::new();
+
+pub(crate) static CONTROL_CHANNEL: PubSubChannel<CriticalSectionRawMutex, ControlMessage, 2, 5, 0> =
+    PubSubChannel::new();
+
+type ControlSubscriber = Subscriber<'static, CriticalSectionRawMutex, ControlMessage, 2, 5, 0>;
+
+pub(crate) async fn subscribe() -> ControlSubscriber {
+    loop {
+        if let Ok(sub) = CONTROL_CHANNEL.subscriber() {
+            return sub;
+        }
+
+        Timer::after_millis(50).await;
+    }
+}
+
+#[cfg(target_has_atomic = "16")]
+mod atomic16 {
+    use core::sync::atomic::{AtomicU16, Ordering};
+
+    use mqttrs::Pid;
+
+    static PID: AtomicU16 = AtomicU16::new(0);
+
+    pub(crate) async fn assign_pid() -> Pid {
+        Pid::new() + PID.fetch_add(1, Ordering::SeqCst)
+    }
+}
+
+#[cfg(not(target_has_atomic = "16"))]
+mod atomic16 {
+    use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
+    use mqttrs::Pid;
+
+    static PID_MUTEX: Mutex<CriticalSectionRawMutex, u16> = Mutex::new(0);
+
+    pub(crate) async fn assign_pid() -> Pid {
+        let mut locked = PID_MUTEX.lock().await;
+        *locked += 1;
+
+        Pid::new() + *locked
+    }
+}
+
+pub(crate) async fn send_packet(packet: Packet<'_>) -> Result<(), Error> {
+    let mut buffer = Payload::new();
+
+    match buffer.encode_packet(&packet) {
+        Ok(()) => {
+            debug!(
+                "Sending packet to broker: {:?}",
+                Debug2Format(&packet.get_type())
+            );
+            SEND_QUEUE.push(buffer).await;
+            Ok(())
+        }
+        Err(_) => {
+            error!("Failed to send packet");
+            Err(Error::PacketError)
+        }
+    }
+}
+
+pub(crate) async fn wait_for_publish(
+    mut subscriber: ControlSubscriber,
+    expected_pid: Pid,
+) -> Result<(), Error> {
+    match select(
+        async {
+            loop {
+                match subscriber.next_message().await {
+                    WaitResult::Lagged(_) => {
+                        // Maybe we missed the message?
+                    }
+                    WaitResult::Message(ControlMessage::Published(published_pid)) => {
+                        if published_pid == expected_pid {
+                            return Ok(());
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        },
+        Timer::after_millis(CONFIRMATION_TIMEOUT),
+    )
+    .await
+    {
+        Either::First(r) => r,
+        Either::Second(_) => Err(Error::TimedOut),
+    }
+}
+
+pub(crate) async fn publish(
+    topic_name: &str,
+    payload: &[u8],
+    qos: QoS,
+    retain: bool,
+) -> Result<(), Error> {
+    let subscriber = subscribe().await;
+
+    let (qospid, pid) = match qos {
+        QoS::AtMostOnce => (QosPid::AtMostOnce, None),
+        QoS::AtLeastOnce => {
+            let pid = assign_pid().await;
+            (QosPid::AtLeastOnce(pid), Some(pid))
+        }
+        QoS::ExactlyOnce => {
+            let pid = assign_pid().await;
+            (QosPid::ExactlyOnce(pid), Some(pid))
+        }
+    };
+
+    let packet = Packet::Publish(Publish {
+        dup: false,
+        qospid,
+        retain,
+        topic_name,
+        payload,
+    });
+
+    send_packet(packet).await?;
+
+    if let Some(expected_pid) = pid {
+        wait_for_publish(subscriber, expected_pid).await
+    } else {
+        Ok(())
+    }
+}
+
+fn packet_size(buffer: &[u8]) -> Option<usize> {
+    let mut pos = 1;
+    let mut multiplier = 1;
+    let mut value = 0;
+
+    while pos < buffer.len() {
+        value += (buffer[pos] & 127) as usize * multiplier;
+        multiplier *= 128;
+
+        if (buffer[pos] & 128) == 0 {
+            return Some(value + pos + 1);
+        }
+
+        pos += 1;
+        if pos == 5 {
+            return Some(0);
+        }
+    }
+
+    None
+}
+
+/// The MQTT task that must be run in order for the stack to operate.
+pub struct McutieTask<'t, T, L, const S: usize>
+where
+    T: Deref<Target = str> + 't,
+    L: Publishable + 't,
+{
+    pub(crate) network: Stack<'t>,
+    pub(crate) broker: &'t str,
+    pub(crate) last_will: Option<L>,
+    pub(crate) username: Option<&'t str>,
+    pub(crate) password: Option<&'t str>,
+    pub(crate) subscriptions: [Topic<T>; S],
+    pub(crate) keep_alive: u16
+}
+
+impl<'t, T, L, const S: usize> McutieTask<'t, T, L, S>
+where
+    T: Deref<Target = str> + 't,
+    L: Publishable + 't,
+{
+    #[cfg(not(feature = "homeassistant"))]
+    async fn ha_handle_update(&self, _topic: &Topic<TopicString>, _payload: &Payload) -> bool {
+        false
+    }
+
+    async fn recv_loop(&self, mut reader: TcpReader<'_>) -> Result<(), Error> {
+        let mut buffer = [0_u8; 4096];
+        let mut cursor: usize = 0;
+
+        let controller = CONTROL_CHANNEL.immediate_publisher();
+
+        loop {
+            match reader.read(&mut buffer[cursor..]).await {
+                Ok(0) => {
+                    error!("Receive socket closed");
+                    return Ok(());
+                }
+                Ok(len) => {
+                    cursor += len;
+                }
+                Err(_) => {
+                    error!("I/O failure reading packet");
+                    return Err(Error::IOError);
+                }
+            }
+
+            let mut start_pos = 0;
+            loop {
+                let packet_length = match packet_size(&buffer[start_pos..cursor]) {
+                    Some(0) => {
+                        error!("Invalid MQTT packet");
+                        return Err(Error::PacketError);
+                    }
+                    Some(len) => len,
+                    None => {
+                        // None is returned when there is not yet enough data to decode a packet.
+                        if start_pos != 0 {
+                            // Adjust the buffer to reclaim any unused data
+                            buffer.copy_within(start_pos..cursor, 0);
+                            cursor -= start_pos;
+                        }
+                        break;
+                    }
+                };
+
+                let packet = match decode_slice(&buffer[start_pos..(start_pos + packet_length)]) {
+                    Ok(Some(p)) => p,
+                    Ok(None) => {
+                        error!("Packet length calculation failed.");
+                        return Err(Error::PacketError);
+                    }
+                    Err(_) => {
+                        error!("Invalid MQTT packet");
+                        return Err(Error::PacketError);
+                    }
+                };
+
+                debug!(
+                    "Received packet from broker: {:?}",
+                    Debug2Format(&packet.get_type())
+                );
+
+                match packet {
+                    Packet::Connack(connack) => match connack.code {
+                        ConnectReturnCode::Accepted => {
+                            #[cfg(feature = "homeassistant")]
+                            self.ha_after_connected().await;
+
+                            for topic in &self.subscriptions {
+                                let _ = topic.subscribe(false).await;
+                            }
+
+                            DATA_CHANNEL.send(MqttMessage::Connected).await;
+                        }
+                        _ => {
+                            error!("Connection request to broker was not accepted");
+                            return Err(Error::IOError);
+                        }
+                    },
+                    Packet::Pingresp => {}
+
+                    Packet::Publish(publish) => {
+                        match (
+                            Topic::from_str(publish.topic_name),
+                            Payload::from(publish.payload),
+                        ) {
+                            (Ok(topic), Ok(payload)) => {
+                                if !self.ha_handle_update(&topic, &payload).await {
+                                    DATA_CHANNEL
+                                        .send(MqttMessage::Publish(topic, payload))
+                                        .await;
+                                }
+                            }
+                            _ => {
+                                error!("Unable to process publish data as it was too large");
+                            }
+                        }
+
+                        match publish.qospid {
+                            mqttrs::QosPid::AtMostOnce => {}
+                            mqttrs::QosPid::AtLeastOnce(pid) => {
+                                send_packet(Packet::Puback(pid)).await?;
+                            }
+                            mqttrs::QosPid::ExactlyOnce(pid) => {
+                                send_packet(Packet::Pubrec(pid)).await?;
+                            }
+                        }
+                    }
+                    Packet::Puback(pid) => {
+                        controller.publish_immediate(ControlMessage::Published(pid));
+                    }
+                    Packet::Pubrec(pid) => {
+                        controller.publish_immediate(ControlMessage::Published(pid));
+                        send_packet(Packet::Pubrel(pid)).await?;
+                    }
+                    Packet::Pubrel(pid) => send_packet(Packet::Pubrel(pid)).await?,
+                    Packet::Pubcomp(_) => {}
+
+                    Packet::Suback(suback) => {
+                        if let Some(return_code) = suback.return_codes.first() {
+                            controller.publish_immediate(ControlMessage::Subscribed(
+                                suback.pid,
+                                *return_code,
+                            ));
+                        } else {
+                            warn!("Unexpected suback with no return codes");
+                        }
+                    }
+                    Packet::Unsuback(pid) => {
+                        controller.publish_immediate(ControlMessage::Unsubscribed(pid));
+                    }
+
+                    Packet::Connect(_)
+                    | Packet::Subscribe(_)
+                    | Packet::Pingreq
+                    | Packet::Unsubscribe(_)
+                    | Packet::Disconnect => {
+                        debug!(
+                            "Unexpected packet from broker: {:?}",
+                            Debug2Format(&packet.get_type())
+                        );
+                    }
+                }
+
+                start_pos += packet_length;
+                if start_pos == cursor {
+                    cursor = 0;
+                    break;
+                }
+            }
+        }
+    }
+
+    async fn write_loop(&self, mut writer: TcpWriter<'_>) {
+        let mut buffer = Payload::new();
+
+        let mut last_will_topic = TopicString::new();
+        let mut last_will_payload = Payload::new();
+
+        let last_will = self.last_will.as_ref().and_then(|p| {
+            if p.write_topic(&mut last_will_topic).is_ok()
+                && p.write_payload(&mut last_will_payload).is_ok()
+            {
+                Some(LastWill {
+                    topic: &last_will_topic,
+                    message: &last_will_payload,
+                    qos: p.qos(),
+                    retain: p.retain(),
+                })
+            } else {
+                None
+            }
+        });
+
+        // Send our connection request.
+        if buffer
+            .encode_packet(&Packet::Connect(Connect {
+                protocol: Protocol::MQTT311,
+                keep_alive: self.keep_alive,
+                client_id: device_id(),
+                clean_session: true,
+                last_will,
+                username: self.username,
+                password: self.password.map(|s| s.as_bytes()),
+            }))
+            .is_err()
+        {
+            error!("Failed to encode connection packet");
+            return;
+        }
+
+        if let Err(e) = writer.write(&buffer).await {
+            error!("Failed to send connection packet: {:?}", e);
+            return;
+        }
+
+        let reader = SEND_QUEUE.reader();
+
+        loop {
+            let buffer = reader.receive().await;
+
+            trace!("Writer sending packet");
+            if let Err(e) = writer.write(&buffer).await {
+                error!("Failed to send data: {:?}", e);
+                return;
+            }
+        }
+    }
+
+    /// Runs the MQTT stack. The future returned from this must be awaited for everything to work.
+    pub async fn run(self) {
+        let mut timeout: Option<u64> = None;
+
+        let mut rx_buffer = [0; 4096];
+        let mut tx_buffer = [0; 4096];
+
+        loop {
+            if let Some(millis) = timeout.replace(DEFAULT_BACKOFF) {
+                Timer::after_millis(millis).await;
+            }
+
+            if !self.network.is_config_up() {
+                debug!("Waiting for network to configure.");
+                self.network.wait_config_up().await;
+                debug!("Network configured.");
+            }
+
+            let ip_addrs = match self.network.dns_query(self.broker, DnsQueryType::A).await {
+                Ok(v) => v,
+                Err(e) => {
+                    error!("Failed to lookup '{}' for broker: {:?}", self.broker, e);
+                    continue;
+                }
+            };
+
+            let ip = match ip_addrs.first() {
+                Some(i) => *i,
+                None => {
+                    error!("No IP address found for broker '{}'", self.broker);
+                    continue;
+                }
+            };
+
+            debug!("Connecting to {}:1883", ip);
+
+            let mut socket = TcpSocket::new(self.network, &mut rx_buffer, &mut tx_buffer);
+            if let Err(e) = socket.connect((ip, 1883)).await {
+                error!("Failed to connect to {}:1883: {:?}", ip, e);
+                continue;
+            }
+
+            info!("Connected to {}", self.broker);
+            timeout = Some(RESET_BACKOFF);
+
+            let (reader, writer) = socket.split();
+
+            let recv_loop = self.recv_loop(reader);
+            let send_loop = self.write_loop(writer);
+
+            let ping_loop = async {
+                loop {
+                    Timer::after_secs(45).await;
+
+                    let _ = send_packet(Packet::Pingreq).await;
+                }
+            };
+
+            let link_down = async {
+                self.network.wait_link_down().await;
+                warn!("Network link lost");
+            };
+
+            let ip_down = async {
+                self.network.wait_config_down().await;
+                warn!("Network config lost");
+            };
+
+            select4(send_loop, ping_loop, recv_loop, select(link_down, ip_down)).await;
+
+            socket.close();
+
+            warn!("Lost connection with broker");
+            DATA_CHANNEL.send(MqttMessage::Disconnected).await;
+        }
+    }
+}

rust/src/mcutie_3_0_0/lib.rs

@@ -0,0 +1,227 @@
+#![no_std]
+#![deny(unreachable_pub)]
+#![warn(missing_docs)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+//! MQTT client support crate vendored into this repository.
+
+use core::{ops::Deref, str};
+
+pub use buffer::Buffer;
+use embassy_net::{HardwareAddress, Stack};
+use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel};
+use heapless::String;
+pub use io::McutieTask;
+pub use mqttrs::QoS;
+use mqttrs::{Pid, SubscribeReturnCodes};
+use once_cell::sync::OnceCell;
+pub use publish::*;
+pub use topic::Topic;
+
+// This must come first so the macros are visible
+pub(crate) mod fmt;
+
+mod buffer;
+#[cfg(feature = "homeassistant")]
+pub mod homeassistant;
+mod io;
+mod pipe;
+mod publish;
+mod topic;
+
+// This really needs to match that used by mqttrs.
+const TOPIC_LENGTH: usize = 256;
+const PAYLOAD_LENGTH: usize = 2048;
+
+/// A fixed length stack allocated string. The length is fixed by the mqttrs crate.
+pub type TopicString = String<TOPIC_LENGTH>;
+/// A fixed length buffer of 2048 bytes.
+pub type Payload = Buffer<PAYLOAD_LENGTH>;
+
+// By default in the event of an error connecting to the broker we will wait for 5s.
+const DEFAULT_BACKOFF: u64 = 5000;
+// If the connection dropped then re-connect more quickly.
+const RESET_BACKOFF: u64 = 200;
+// How long to wait for the broker to confirm actions.
+const CONFIRMATION_TIMEOUT: u64 = 2000;
+
+static DATA_CHANNEL: Channel<CriticalSectionRawMutex, MqttMessage, 10> = Channel::new();
+
+static DEVICE_TYPE: OnceCell<String<32>> = OnceCell::new();
+static DEVICE_ID: OnceCell<String<32>> = OnceCell::new();
+
+fn device_id() -> &'static str {
+    DEVICE_ID.get().unwrap()
+}
+
+fn device_type() -> &'static str {
+    DEVICE_TYPE.get().unwrap()
+}
+
+/// Various errors
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "defmt", derive(defmt::Format))]
+pub enum Error {
+    /// An IO error occured.
+    IOError,
+    /// The operation timed out.
+    TimedOut,
+    /// An attempt was made to encode something too large.
+    TooLarge,
+    /// A packet or payload could not be decoded or encoded.
+    PacketError,
+    /// An invalid or unsupported operation was attempted.
+    Invalid,
+    /// A value was rejected.
+    Rejected,
+}
+
+#[allow(clippy::large_enum_variant)]
+/// A message from the MQTT broker.
+pub enum MqttMessage {
+    /// The broker has been connected to successfully. Generally in response to this message a
+    /// device should subscribe to topics of interest and send out any device state.
+    Connected,
+    /// New data received from the broker.
+    Publish(Topic<TopicString>, Payload),
+    /// The connection to the broker has been dropped.
+    Disconnected,
+    /// Home Assistant has come online and you should send any discovery messages.
+    #[cfg(feature = "homeassistant")]
+    HomeAssistantOnline,
+}
+
+#[derive(Clone)]
+enum ControlMessage {
+    Published(Pid),
+    Subscribed(Pid, SubscribeReturnCodes),
+    Unsubscribed(Pid),
+}
+
+/// Receives messages from the broker.
+pub struct McutieReceiver;
+
+impl McutieReceiver {
+    /// Waits for the next message from the broker.
+    pub async fn receive(&self) -> MqttMessage {
+        DATA_CHANNEL.receive().await
+    }
+}
+
+/// A builder to configure the MQTT stack.
+pub struct McutieBuilder<'t, T, L, const S: usize>
+where
+    T: Deref<Target = str> + 't,
+    L: Publishable + 't,
+{
+    network: Stack<'t>,
+    device_type: &'t str,
+    device_id: Option<&'t str>,
+    broker: &'t str,
+    last_will: Option<L>,
+    username: Option<&'t str>,
+    password: Option<&'t str>,
+    subscriptions: [Topic<T>; S],
+}
+
+impl<'t, T: Deref<Target = str> + 't, L: Publishable + 't> McutieBuilder<'t, T, L, 0> {
+    /// Creates a new builder with the initial required configuration.
+    ///
+    /// `device_type` is expected to be the same for all devices of the same type.
+    /// `broker` may be an IP address or a DNS name for the broker to connect to.
+    pub fn new(network: Stack<'t>, device_type: &'t str, broker: &'t str) -> Self {
+        Self {
+            network,
+            device_type,
+            broker,
+            device_id: None,
+            last_will: None,
+            username: None,
+            password: None,
+            subscriptions: [],
+        }
+    }
+}
+
+impl<'t, T: Deref<Target = str> + 't, L: Publishable + 't, const S: usize>
+    McutieBuilder<'t, T, L, S>
+{
+    /// Add some default topics to subscribe to.
+    pub fn with_subscriptions<const N: usize>(
+        self,
+        subscriptions: [Topic<T>; N],
+    ) -> McutieBuilder<'t, T, L, N> {
+        McutieBuilder {
+            network: self.network,
+            device_type: self.device_type,
+            broker: self.broker,
+            device_id: self.device_id,
+            last_will: self.last_will,
+            username: self.username,
+            password: self.password,
+            subscriptions,
+        }
+    }
+}
+
+impl<'t, T: Deref<Target = str> + 't, L: Publishable + 't, const S: usize>
+    McutieBuilder<'t, T, L, S>
+{
+    /// Adds authentication for the broker.
+    pub fn with_authentication(self, username: &'t str, password: &'t str) -> Self {
+        Self {
+            username: Some(username),
+            password: Some(password),
+            ..self
+        }
+    }
+
+    /// Sets a last will message to be published in the event of disconnection.
+    pub fn with_last_will(self, last_will: L) -> Self {
+        Self {
+            last_will: Some(last_will),
+            ..self
+        }
+    }
+
+    /// Sets a custom unique device identifier. If none is set then the network
+    /// MAC address is used.
+    pub fn with_device_id(self, device_id: &'t str) -> Self {
+        Self {
+            device_id: Some(device_id),
+            ..self
+        }
+    }
+
+    /// Initialises the MQTT stack returning a receiver for listening to
+    /// messages from the broker and a future that must be run in order for the
+    /// stack to operate.
+    pub fn build(self, keep_alive: u16) -> (McutieReceiver, McutieTask<'t, T, L, S>) {
+        let mut dtype = String::<32>::new();
+        dtype.push_str(self.device_type).unwrap();
+        DEVICE_TYPE.set(dtype).unwrap();
+
+        let mut did = String::<32>::new();
+        if let Some(device_id) = self.device_id {
+            did.push_str(device_id).unwrap();
+        } else if let HardwareAddress::Ethernet(address) = self.network.hardware_address() {
+            let mut buffer = [0_u8; 12];
+            hex::encode_to_slice(address.as_bytes(), &mut buffer).unwrap();
+            did.push_str(str::from_utf8(&buffer).unwrap()).unwrap();
+        }
+
+        DEVICE_ID.set(did).unwrap();
+
+        (
+            McutieReceiver {},
+            McutieTask {
+                network: self.network,
+                broker: self.broker,
+                last_will: self.last_will,
+                username: self.username,
+                password: self.password,
+                subscriptions: self.subscriptions,
+                keep_alive
+            },
+        )
+    }
+}

rust/src/mcutie_3_0_0/pipe.rs

@@ -0,0 +1,267 @@
+use core::{
+    cell::RefCell,
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll, Waker},
+};
+
+use embassy_sync::blocking_mutex::{raw::RawMutex, Mutex};
+use pin_project::pin_project;
+
+struct PipeData<T, const N: usize> {
+    connect_count: usize,
+    receiver_waker: Option<Waker>,
+    sender_waker: Option<Waker>,
+    pending: Option<T>,
+}
+
+fn swap_wakers(waker: &mut Option<Waker>, new_waker: &Waker) {
+    if let Some(old_waker) = waker.take() {
+        if old_waker.will_wake(new_waker) {
+            *waker = Some(old_waker)
+        } else {
+            if !new_waker.will_wake(&old_waker) {
+                old_waker.wake();
+            }
+
+            *waker = Some(new_waker.clone());
+        }
+    } else {
+        *waker = Some(new_waker.clone())
+    }
+}
+
+pub(crate) struct ReceiveFuture<'a, M: RawMutex, T, const N: usize> {
+    pipe: &'a ConnectedPipe<M, T, N>,
+}
+
+impl<M: RawMutex, T, const N: usize> Future for ReceiveFuture<'_, M, T, N> {
+    type Output = T;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.pipe.inner.lock(|cell| {
+            let mut inner = cell.borrow_mut();
+
+            if let Some(waker) = inner.sender_waker.take() {
+                waker.wake();
+            }
+
+            if let Some(item) = inner.pending.take() {
+                if let Some(old_waker) = inner.receiver_waker.take() {
+                    old_waker.wake();
+                }
+
+                Poll::Ready(item)
+            } else {
+                swap_wakers(&mut inner.receiver_waker, cx.waker());
+                Poll::Pending
+            }
+        })
+    }
+}
+
+pub(crate) struct PipeReader<'a, M: RawMutex, T, const N: usize> {
+    pipe: &'a ConnectedPipe<M, T, N>,
+}
+
+impl<M: RawMutex, T, const N: usize> PipeReader<'_, M, T, N> {
+    #[must_use]
+    pub(crate) fn receive(&self) -> ReceiveFuture<'_, M, T, N> {
+        ReceiveFuture { pipe: self.pipe }
+    }
+}
+
+impl<M: RawMutex, T, const N: usize> Drop for PipeReader<'_, M, T, N> {
+    fn drop(&mut self) {
+        self.pipe.inner.lock(|cell| {
+            let mut inner = cell.borrow_mut();
+            inner.connect_count -= 1;
+
+            if inner.connect_count == 0 {
+                inner.pending = None;
+            }
+
+            if let Some(waker) = inner.sender_waker.take() {
+                waker.wake();
+            }
+        })
+    }
+}
+
+#[pin_project]
+pub(crate) struct PushFuture<'a, M: RawMutex, T, const N: usize> {
+    data: Option<T>,
+    pipe: &'a ConnectedPipe<M, T, N>,
+}
+
+impl<M: RawMutex, T, const N: usize> Future for PushFuture<'_, M, T, N> {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        self.pipe.inner.lock(|cell| {
+            let project = self.project();
+            let mut inner = cell.borrow_mut();
+
+            if let Some(receiver) = inner.receiver_waker.take() {
+                receiver.wake();
+            }
+
+            if project.data.is_none() || inner.connect_count == 0 {
+                trace!("Dropping packet");
+                Poll::Ready(())
+            } else if inner.pending.is_some() {
+                swap_wakers(&mut inner.sender_waker, cx.waker());
+                Poll::Pending
+            } else {
+                inner.pending = project.data.take();
+
+                Poll::Ready(())
+            }
+        })
+    }
+}
+
+/// A pipe that knows whether a receiver is connected. If so pushing to the
+/// queue waits until there is space in the queue, otherwise data is simply
+/// dropped.
+pub(crate) struct ConnectedPipe<M: RawMutex, T, const N: usize> {
+    inner: Mutex<M, RefCell<PipeData<T, N>>>,
+}
+
+impl<M: RawMutex, T, const N: usize> ConnectedPipe<M, T, N> {
+    pub(crate) const fn new() -> Self {
+        Self {
+            inner: Mutex::new(RefCell::new(PipeData {
+                connect_count: 0,
+                receiver_waker: None,
+                sender_waker: None,
+                pending: None,
+            })),
+        }
+    }
+
+    /// A future that waits for a new item to be available.
+    pub(crate) fn reader(&self) -> PipeReader<'_, M, T, N> {
+        self.inner.lock(|cell| {
+            let mut inner = cell.borrow_mut();
+            inner.connect_count += 1;
+
+            PipeReader { pipe: self }
+        })
+    }
+
+    /// Pushes an item to the reader, waiting for a slot to become available if
+    /// connected.
+    #[must_use]
+    pub(crate) fn push(&self, data: T) -> PushFuture<'_, M, T, N> {
+        PushFuture {
+            data: Some(data),
+            pipe: self,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use core::time::Duration;
+
+    use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+    use futures_executor::{LocalPool, ThreadPool};
+    use futures_timer::Delay;
+    use futures_util::{future::select, pin_mut, task::SpawnExt, FutureExt};
+
+    use super::ConnectedPipe;
+
+    async fn wait_milis(milis: u64) {
+        Delay::new(Duration::from_millis(milis)).await;
+    }
+
+    // #[futures_test::test]
+    #[test]
+    fn test_send_receive() {
+        let mut executor = LocalPool::new();
+        let spawner = executor.spawner();
+
+        static PIPE: ConnectedPipe<CriticalSectionRawMutex, usize, 5> = ConnectedPipe::new();
+
+        // Task that sends
+        spawner
+            .spawn(async {
+                wait_milis(10).await;
+
+                PIPE.push(23).await;
+                PIPE.push(56).await;
+                PIPE.push(67).await;
+            })
+            .unwrap();
+
+        // Task that receives
+        spawner
+            .spawn(async {
+                let reader = PIPE.reader();
+                let value = reader.receive().await;
+                assert_eq!(value, 23);
+                let value = reader.receive().await;
+                assert_eq!(value, 56);
+                let value = reader.receive().await;
+                assert_eq!(value, 67);
+            })
+            .unwrap();
+
+        executor.run();
+    }
+
+    #[futures_test::test]
+    async fn test_send_drop() {
+        static PIPE: ConnectedPipe<CriticalSectionRawMutex, usize, 5> = ConnectedPipe::new();
+
+        PIPE.push(23).await;
+        PIPE.push(56).await;
+        PIPE.push(67).await;
+
+        // Create a reader after sending
+        let reader = PIPE.reader();
+        let receive = reader.receive().fuse();
+        pin_mut!(receive);
+
+        let timeout = wait_milis(50).fuse();
+        pin_mut!(timeout);
+
+        let either = select(receive, timeout).await;
+
+        match either {
+            futures_util::future::Either::Left(_) => {
+                panic!("There should be nothing to receive!");
+            }
+            futures_util::future::Either::Right(_) => {}
+        }
+    }
+
+    #[futures_test::test]
+    async fn test_bulk_send_publish() {
+        static PIPE: ConnectedPipe<CriticalSectionRawMutex, usize, 5> = ConnectedPipe::new();
+
+        let executor = ThreadPool::new().unwrap();
+
+        executor
+            .spawn(async {
+                for i in 0..1000 {
+                    PIPE.push(i).await;
+                }
+            })
+            .unwrap();
+
+        executor
+            .spawn(async {
+                for i in 1000..2000 {
+                    PIPE.push(i).await;
+                }
+            })
+            .unwrap();
+
+        let reader = PIPE.reader();
+        for _ in 0..800 {
+            reader.receive().await;
+        }
+    }
+}

rust/src/mcutie_3_0_0/publish.rs

@@ -0,0 +1,173 @@
+use core::{fmt::Display, future::Future, ops::Deref};
+
+use embedded_io::Write;
+use mqttrs::QoS;
+
+use crate::{io::publish, Error, Payload, Topic, TopicString};
+
+/// A message that can be published to an MQTT broker.
+pub trait Publishable {
+    /// Write this message's topic into the supplied buffer.
+    fn write_topic(&self, buffer: &mut TopicString) -> Result<(), Error>;
+
+    /// Write this message's payload into the supplied buffer.
+    fn write_payload(&self, buffer: &mut Payload) -> Result<(), Error>;
+
+    /// Get this message's QoS level.
+    fn qos(&self) -> QoS {
+        QoS::AtMostOnce
+    }
+
+    /// Whether the broker should retain this message.
+    fn retain(&self) -> bool {
+        false
+    }
+
+    /// Publishes this message to the broker. If the stack has not yet been
+    /// initialized this is likely to panic.
+    fn publish(&self) -> impl Future<Output = Result<(), Error>> {
+        async {
+            let mut topic = TopicString::new();
+            self.write_topic(&mut topic)?;
+
+            let mut payload = Payload::new();
+            self.write_payload(&mut payload)?;
+
+            publish(&topic, &payload, self.qos(), self.retain()).await
+        }
+    }
+}
+
+/// A [`Publishable`] with a raw byte payload.
+pub struct PublishBytes<'a, T, B: AsRef<[u8]>> {
+    pub(crate) topic: &'a Topic<T>,
+    pub(crate) data: B,
+    pub(crate) qos: QoS,
+    pub(crate) retain: bool,
+}
+
+impl<T, B: AsRef<[u8]>> PublishBytes<'_, T, B> {
+    /// Sets the QoS level for this message.
+    pub fn qos(mut self, qos: QoS) -> Self {
+        self.qos = qos;
+        self
+    }
+
+    /// Sets whether the broker should retain this message.
+    pub fn retain(mut self, retain: bool) -> Self {
+        self.retain = retain;
+        self
+    }
+}
+
+impl<'a, T: Deref<Target = str> + 'a, B: AsRef<[u8]>> Publishable for PublishBytes<'a, T, B> {
+    fn write_topic(&self, buffer: &mut TopicString) -> Result<(), Error> {
+        self.topic.to_string(buffer)
+    }
+
+    fn write_payload(&self, buffer: &mut Payload) -> Result<(), Error> {
+        buffer
+            .write_all(self.data.as_ref())
+            .map_err(|_| Error::TooLarge)
+    }
+
+    fn qos(&self) -> QoS {
+        self.qos
+    }
+
+    fn retain(&self) -> bool {
+        self.retain
+    }
+
+    async fn publish(&self) -> Result<(), Error> {
+        let mut topic = TopicString::new();
+        self.write_topic(&mut topic)?;
+
+        publish(&topic, self.data.as_ref(), self.qos(), self.retain()).await
+    }
+}
+
+/// A [`Publishable`] with a payload that implements [`Display`].
+pub struct PublishDisplay<'a, T, D: Display> {
+    pub(crate) topic: &'a Topic<T>,
+    pub(crate) data: D,
+    pub(crate) qos: QoS,
+    pub(crate) retain: bool,
+}
+
+impl<T, D: Display> PublishDisplay<'_, T, D> {
+    /// Sets the QoS level for this message.
+    pub fn qos(mut self, qos: QoS) -> Self {
+        self.qos = qos;
+        self
+    }
+
+    /// Sets whether the broker should retain this message.
+    pub fn retain(mut self, retain: bool) -> Self {
+        self.retain = retain;
+        self
+    }
+}
+
+impl<'a, T: Deref<Target = str> + 'a, D: Display> Publishable for PublishDisplay<'a, T, D> {
+    fn write_topic(&self, buffer: &mut TopicString) -> Result<(), Error> {
+        self.topic.to_string(buffer)
+    }
+
+    fn write_payload(&self, buffer: &mut Payload) -> Result<(), Error> {
+        write!(buffer, "{}", self.data).map_err(|_| Error::TooLarge)
+    }
+
+    fn qos(&self) -> QoS {
+        self.qos
+    }
+
+    fn retain(&self) -> bool {
+        self.retain
+    }
+}
+
+#[cfg(feature = "serde")]
+/// A [`Publishable`] with that serializes a JSON payload.
+pub struct PublishJson<'a, T, D: serde::Serialize> {
+    pub(crate) topic: &'a Topic<T>,
+    pub(crate) data: D,
+    pub(crate) qos: QoS,
+    pub(crate) retain: bool,
+}
+
+#[cfg(feature = "serde")]
+impl<T, D: serde::Serialize> PublishJson<'_, T, D> {
+    /// Sets the QoS level for this message.
+    pub fn qos(mut self, qos: QoS) -> Self {
+        self.qos = qos;
+        self
+    }
+
+    /// Sets whether the broker should retain this message.
+    pub fn retain(mut self, retain: bool) -> Self {
+        self.retain = retain;
+        self
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'a, T: Deref<Target = str> + 'a, D: serde::Serialize> Publishable for PublishJson<'a, T, D> {
+    fn write_topic(&self, buffer: &mut TopicString) -> Result<(), Error> {
+        self.topic.to_string(buffer)
+    }
+
+    fn write_payload(&self, buffer: &mut Payload) -> Result<(), Error> {
+        buffer
+            .serialize_json(&self.data)
+            .map_err(|_| Error::TooLarge)
+    }
+
+    fn qos(&self) -> QoS {
+        self.qos
+    }
+
+    fn retain(&self) -> bool {
+        self.retain
+    }
+}

rust/src/mcutie_3_0_0/topic.rs

@@ -0,0 +1,284 @@
+use core::{fmt::Display, ops::Deref};
+
+use embassy_futures::select::{select, Either};
+use embassy_sync::pubsub::WaitResult;
+use embassy_time::Timer;
+use heapless::{String, Vec};
+use mqttrs::{Packet, QoS, Subscribe, SubscribeReturnCodes, SubscribeTopic, Unsubscribe};
+
+#[cfg(feature = "serde")]
+use crate::publish::PublishJson;
+use crate::{
+    device_id, device_type,
+    io::{assign_pid, send_packet, subscribe},
+    publish::{PublishBytes, PublishDisplay},
+    ControlMessage, Error, TopicString, CONFIRMATION_TIMEOUT,
+};
+
+/// An MQTT topic that is optionally prefixed with the device type and unique ID.
+/// Normally you will define all your application's topics as consts with static
+/// lifetimes.
+///
+/// A [`Topic`] is the main entry to publishing messages to the broker.
+///
+/// ```
+/// # use mcutie::{Publishable, Topic};
+/// const DEVICE_AVAILABILITY: Topic<&'static str> = Topic::Device("state");
+///
+/// async fn send_status(status: &'static str) {
+///   let _ = DEVICE_AVAILABILITY.with_bytes(status.as_bytes()).publish().await;
+/// }
+/// ```
+#[derive(Clone, Copy)]
+pub enum Topic<T> {
+    /// A topic that is prefixed with the device type.
+    DeviceType(T),
+    /// A topic that is prefixed with the device type and unique ID.
+    Device(T),
+    /// Any topic.
+    General(T),
+}
+
+impl<A, B> PartialEq<Topic<A>> for Topic<B>
+where
+    B: PartialEq<A>,
+{
+    fn eq(&self, other: &Topic<A>) -> bool {
+        match (self, other) {
+            (Topic::DeviceType(l0), Topic::DeviceType(r0)) => l0 == r0,
+            (Topic::Device(l0), Topic::Device(r0)) => l0 == r0,
+            (Topic::General(l0), Topic::General(r0)) => l0 == r0,
+            _ => false,
+        }
+    }
+}
+
+impl<T> Topic<T> {
+    /// Creates a publishable message with something that can return a reference
+    /// to the payload in bytes.
+    ///
+    /// Defaults to non-retained with QoS of 0 (AtMostOnce).
+    pub fn with_bytes<B: AsRef<[u8]>>(&self, data: B) -> PublishBytes<'_, T, B> {
+        PublishBytes {
+            topic: self,
+            data,
+            qos: QoS::AtMostOnce,
+            retain: false,
+        }
+    }
+
+    /// Creates a publishable message with something that implements [`Display`].
+    ///
+    /// Defaults to non-retained with QoS of 0 (AtMostOnce).
+    pub fn with_display<D: Display>(&self, data: D) -> PublishDisplay<'_, T, D> {
+        PublishDisplay {
+            topic: self,
+            data,
+            qos: QoS::AtMostOnce,
+            retain: false,
+        }
+    }
+
+    #[cfg(feature = "serde")]
+    /// Creates a publishable message with something that can be serialized to
+    /// JSON.
+    ///
+    /// Defaults to non-retained with QoS of 0 (AtMostOnce).
+    pub fn with_json<D: serde::Serialize>(&self, data: D) -> PublishJson<'_, T, D> {
+        PublishJson {
+            topic: self,
+            data,
+            qos: QoS::AtMostOnce,
+            retain: false,
+        }
+    }
+}
+
+impl Topic<TopicString> {
+    pub(crate) fn from_str(mut st: &str) -> Result<Self, Error> {
+        let mut strip_prefix = |pr: &str| -> bool {
+            if st.starts_with(pr) && st.len() > pr.len() && &st[pr.len()..pr.len() + 1] == "/" {
+                st = &st[pr.len() + 1..];
+                true
+            } else {
+                false
+            }
+        };
+
+        if strip_prefix(device_type()) {
+            if strip_prefix(device_id()) {
+                let mut topic = TopicString::new();
+                topic.push_str(st).map_err(|_| Error::TooLarge)?;
+                Ok(Topic::Device(topic))
+            } else {
+                let mut topic = TopicString::new();
+                topic.push_str(st).map_err(|_| Error::TooLarge)?;
+                Ok(Topic::DeviceType(topic))
+            }
+        } else {
+            let mut topic = TopicString::new();
+            topic.push_str(st).map_err(|_| Error::TooLarge)?;
+            Ok(Topic::General(topic))
+        }
+    }
+}
+
+impl<T: Deref<Target = str>> Topic<T> {
+    pub(crate) fn to_string<const N: usize>(&self, result: &mut String<N>) -> Result<(), Error> {
+        match self {
+            Topic::Device(st) => {
+                result
+                    .push_str(device_type())
+                    .map_err(|_| Error::TooLarge)?;
+                result.push_str("/").map_err(|_| Error::TooLarge)?;
+                result.push_str(device_id()).map_err(|_| Error::TooLarge)?;
+                result.push_str("/").map_err(|_| Error::TooLarge)?;
+                result.push_str(st.as_ref()).map_err(|_| Error::TooLarge)?;
+            }
+            Topic::DeviceType(st) => {
+                result
+                    .push_str(device_type())
+                    .map_err(|_| Error::TooLarge)?;
+                result.push_str("/").map_err(|_| Error::TooLarge)?;
+                result.push_str(st.as_ref()).map_err(|_| Error::TooLarge)?;
+            }
+            Topic::General(st) => {
+                result.push_str(st.as_ref()).map_err(|_| Error::TooLarge)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Converts to a topic containing an [`str`]. Particularly useful for converting from an owned
+    /// string for match patterns.
+    pub fn as_ref(&self) -> Topic<&str> {
+        match self {
+            Topic::DeviceType(st) => Topic::DeviceType(st.as_ref()),
+            Topic::Device(st) => Topic::Device(st.as_ref()),
+            Topic::General(st) => Topic::General(st.as_ref()),
+        }
+    }
+
+    /// Subscribes to this topic. If `wait_for_ack` is true then this will wait until confirmation
+    /// is received from the broker before returning.
+    pub async fn subscribe(&self, wait_for_ack: bool) -> Result<(), Error> {
+        let mut subscriber = subscribe().await;
+
+        let mut topic_path = TopicString::new();
+        if self.to_string(&mut topic_path).is_err() {
+            return Err(Error::TooLarge);
+        }
+
+        let pid = assign_pid().await;
+
+        let mut subscribe_topic_path = String::<256>::new();
+        subscribe_topic_path
+            .push_str(topic_path.as_str())
+            .map_err(|_| Error::TooLarge)?;
+        let subscribe_topic = SubscribeTopic {
+            topic_path: subscribe_topic_path,
+            qos: QoS::AtLeastOnce,
+        };
+
+        // The size of this vec must match that used by mqttrs.
+        let topics = match Vec::<SubscribeTopic, 5>::from_slice(&[subscribe_topic]) {
+            Ok(t) => t,
+            Err(_) => return Err(Error::TooLarge),
+        };
+
+        let packet = Packet::Subscribe(Subscribe { pid, topics });
+
+        send_packet(packet).await?;
+
+        if wait_for_ack {
+            match select(
+                async {
+                    loop {
+                        match subscriber.next_message().await {
+                            WaitResult::Lagged(_) => {
+                                // Maybe we missed the message?
+                            }
+                            WaitResult::Message(ControlMessage::Subscribed(
+                                subscribed_pid,
+                                return_code,
+                            )) => {
+                                if subscribed_pid == pid {
+                                    if matches!(return_code, SubscribeReturnCodes::Success(_)) {
+                                        return Ok(());
+                                    } else {
+                                        return Err(Error::IOError);
+                                    }
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                },
+                Timer::after_millis(CONFIRMATION_TIMEOUT),
+            )
+            .await
+            {
+                Either::First(r) => r,
+                Either::Second(_) => Err(Error::TimedOut),
+            }
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Unsubscribes from a topic. If `wait_for_ack` is true then this will wait until confirmation is
+    /// received from the broker before returning.
+    pub async fn unsubscribe(&self, wait_for_ack: bool) -> Result<(), Error> {
+        let mut subscriber = subscribe().await;
+
+        let mut topic_path = TopicString::new();
+        if self.to_string(&mut topic_path).is_err() {
+            return Err(Error::TooLarge);
+        }
+
+        let pid = assign_pid().await;
+
+        // The size of this vec must match that used by mqttrs.
+        let mut unsubscribe_topic_path = String::<256>::new();
+        unsubscribe_topic_path
+            .push_str(topic_path.as_str())
+            .map_err(|_| Error::TooLarge)?;
+        let topics = match Vec::<String<256>, 5>::from_slice(&[unsubscribe_topic_path]) {
+            Ok(t) => t,
+            Err(_) => return Err(Error::TooLarge),
+        };
+
+        let packet = Packet::Unsubscribe(Unsubscribe { pid, topics });
+
+        send_packet(packet).await?;
+
+        if wait_for_ack {
+            match select(
+                async {
+                    loop {
+                        match subscriber.next_message().await {
+                            WaitResult::Lagged(_) => {
+                                // Maybe we missed the message?
+                            }
+                            WaitResult::Message(ControlMessage::Unsubscribed(subscribed_pid)) => {
+                                if subscribed_pid == pid {
+                                    return Ok(());
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                },
+                Timer::after_millis(CONFIRMATION_TIMEOUT),
+            )
+            .await
+            {
+                Either::First(r) => r,
+                Either::Second(_) => Err(Error::TimedOut),
+            }
+        } else {
+            Ok(())
+        }
+    }
+}

rust/src/mqtt.rs

@@ -0,0 +1,398 @@
+use crate::config::NetworkConfig;
+use crate::fat_error::{ContextExt, FatError, FatResult};
+use crate::hal::battery::{BatteryError, BatteryInfo, BatteryState};
+use crate::hal::{PlantHal, HAL};
+use crate::log::{log, LogMessage};
+use crate::plant_state::PlantState;
+use crate::tank::TankState;
+use crate::{bail, VersionInfo};
+use alloc::string::String;
+use alloc::{format, string::ToString};
+use chrono::DateTime;
+use chrono_tz::Tz;
+use core::sync::atomic::Ordering;
+use embassy_executor::Spawner;
+use embassy_net::Stack;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::MutexGuard;
+use embassy_sync::once_lock::OnceLock;
+use embassy_time::{Duration, Timer, WithTimeout};
+use log::{info, warn};
+use mcutie::{
+    Error, McutieBuilder, McutieReceiver, McutieTask, MqttMessage, PublishDisplay, Publishable,
+    QoS, Topic,
+};
+use portable_atomic::AtomicBool;
+use serde::{Deserialize, Serialize};
+
+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();
+
+pub fn is_stay_alive() -> bool {
+    MQTT_STAY_ALIVE.load(Ordering::Relaxed)
+}
+
+pub async fn publish(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 publish_inner(subtopic, message).await {
+        Ok(()) => {}
+        Err(err) => {
+            info!(
+                "Error during mqtt send on topic {subtopic} with message {message:#?} error is {err:?}"
+            );
+        }
+    };
+}
+
+async fn publish_inner(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,
+                    Error::Rejected => 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;
+            }
+        }
+    }
+}
+
+use crate::util::mk_static;
+
+pub async fn mqtt_init(
+    network_config: &'static NetworkConfig,
+    stack: Stack<'static>,
+    spawner: Spawner,
+) -> 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!("{base_topic}/state");
+    let round_trip_topic = format!("{base_topic}/internal/roundtrip");
+    let stay_alive_topic = format!("{base_topic}/stay_alive");
+
+    let mut builder: McutieBuilder<'_, String, PublishDisplay<String, &str>, 0> =
+        McutieBuilder::new(stack, "plant ctrl", mqtt_url);
+    if let (Some(mqtt_user), Some(mqtt_password)) = (
+        network_config.mqtt_user.as_ref(),
+        network_config.mqtt_password.as_ref(),
+    ) {
+        builder = builder.with_authentication(mqtt_user, mqtt_password);
+        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);
+
+    spawner.spawn(mqtt_incoming_task(
+        receiver,
+        round_trip_topic.clone(),
+        stay_alive_topic.clone(),
+    )?);
+    spawner.spawn(mqtt_runner(task)?);
+
+    log(LogMessage::StayAlive, 0, 0, "", &stay_alive_topic);
+
+    log(LogMessage::MqttInfo, 0, 0, "", mqtt_url);
+
+    let mqtt_timeout = 15000;
+    let res = async {
+        while !MQTT_CONNECTED_EVENT_RECEIVED.load(Ordering::Relaxed) {
+            PlantHal::feed_watchdog();
+            Timer::after(Duration::from_millis(100)).await;
+        }
+        Ok::<(), FatError>(())
+    }
+    .with_timeout(Duration::from_millis(mqtt_timeout as u64))
+    .await;
+
+    if res.is_err() {
+        bail!("Timeout waiting MQTT connect event")
+    }
+
+    let _ = Topic::General(round_trip_topic.clone())
+        .with_display("online_text")
+        .publish()
+        .await;
+
+    let res = async {
+        while !MQTT_ROUND_TRIP_RECEIVED.load(Ordering::Relaxed) {
+            PlantHal::feed_watchdog();
+            Timer::after(Duration::from_millis(100)).await;
+        }
+        Ok::<(), FatError>(())
+    }
+    .with_timeout(Duration::from_millis(mqtt_timeout as u64))
+    .await;
+
+    if res.is_err() {
+        MQTT_CONNECTED_EVENT_RECEIVED.store(false, Ordering::Relaxed);
+        bail!("Timeout waiting MQTT roundtrip")
+    }
+    Ok(())
+}
+
+#[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(LogMessage::MqttStayAliveRec, a, 0, "", "");
+                        MQTT_STAY_ALIVE.store(value, Ordering::Relaxed);
+                    } else {
+                        log(LogMessage::UnknownTopic, 0, 0, "", &topic);
+                    }
+                }
+            },
+            MqttMessage::Disconnected => {
+                MQTT_CONNECTED_EVENT_RECEIVED.store(false, Ordering::Relaxed);
+                info!("Mqtt disconnected");
+            }
+        }
+    }
+}
+
+pub async fn publish_tank_state(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+    tank_state: &TankState,
+    water_temp: FatResult<f32>,
+) {
+    let state = serde_json::to_string(
+        &tank_state.as_mqtt_info(&board.board_hal.get_config().tank, &water_temp),
+    )
+    .unwrap();
+    let _ = publish("/water", &*state).await;
+}
+
+pub async fn publish_plant_states(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+    timezone_time: &DateTime<Tz>,
+    plantstate: &[PlantState; 8],
+) {
+    for (plant_id, (plant_state, plant_conf)) in plantstate
+        .iter()
+        .zip(&board.board_hal.get_config().plants.clone())
+        .enumerate()
+    {
+        let state =
+            serde_json::to_string(&plant_state.to_mqtt_info(plant_conf, timezone_time)).unwrap();
+        let plant_topic = format!("/plant{}", plant_id + 1);
+        let _ = publish(&plant_topic, &state).await;
+    }
+}
+
+pub async fn publish_firmware_info(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+    version: VersionInfo,
+    ip_address: &str,
+    timezone_time: &str,
+) {
+    publish("/firmware/address", ip_address).await;
+    publish("/firmware/state", &serde_json::to_string(&version).unwrap()).await;
+    publish("/firmware/last_online", timezone_time).await;
+    publish("/state", "online").await;
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
+struct PumpInfo {
+    pub enabled: bool,
+    pub pump_ineffective: bool,
+    pub median_current_ma: u16,
+    pub max_current_ma: u16,
+    pub min_current_ma: u16,
+}
+
+pub async fn pump_info(
+    plant_id: usize,
+    pump_active: bool,
+    pump_ineffective: bool,
+    median_current_ma: u16,
+    max_current_ma: u16,
+    min_current_ma: u16,
+    _error: bool,
+) {
+    let pump_info = PumpInfo {
+        enabled: pump_active,
+        pump_ineffective,
+        median_current_ma,
+        max_current_ma,
+        min_current_ma,
+    };
+    let pump_topic = format!("/pump{}", plant_id + 1);
+
+    match serde_json::to_string(&pump_info) {
+        Ok(state) => {
+            let _ = publish(&pump_topic, &state).await;
+        }
+        Err(err) => {
+            warn!("Error publishing pump state {}", err);
+        }
+    };
+}
+
+#[derive(Serialize, Debug, PartialEq)]
+pub struct Solar {
+    pub current_ma: u32,
+    pub voltage_ma: u32,
+}
+
+pub async fn publish_mppt_state(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+) -> FatResult<()> {
+    let current = board.board_hal.get_mptt_current().await?;
+    let voltage = board.board_hal.get_mptt_voltage().await?;
+    let solar_state = Solar {
+        current_ma: current.as_milliamperes() as u32,
+        voltage_ma: voltage.as_millivolts() as u32,
+    };
+    if let Ok(serialized_solar_state_bytes) = serde_json::to_string(&solar_state) {
+        let _ = publish("/mppt", &serialized_solar_state_bytes).await;
+    }
+    Ok(())
+}
+
+pub async fn publish_battery_state(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+) -> () {
+    let telemetry = match board
+        .board_hal
+        .get_battery_monitor()
+        .get_battery_state()
+        .await
+    {
+        Ok(BatteryState::Info(info)) => info,
+        Ok(BatteryState::Unknown) => BatteryInfo {
+            voltage_mv: None,
+            avg_current_ma: None,
+            soc_pct: None,
+            soh_pct: None,
+            temperature_c: None,
+            cycle_count: None,
+            remaining_mah: None,
+            design_mah: None,
+            error: Some(BatteryError::NoBatteryMonitor),
+        },
+        Err(e) => BatteryInfo {
+            voltage_mv: None,
+            avg_current_ma: None,
+            soc_pct: None,
+            soh_pct: None,
+            temperature_c: None,
+            cycle_count: None,
+            remaining_mah: None,
+            design_mah: None,
+            error: Some(BatteryError::CommunicationError {
+                message: alloc::format!("{:?}", e),
+            }),
+        },
+    };
+    if let Ok(json) = serde_json::to_string(&telemetry) {
+        let _ = publish("/battery", &json).await;
+    }
+}

rust/src/network.rs

@@ -0,0 +1,419 @@
+use crate::bail;
+use crate::config::NetworkConfig;
+use crate::fat_error::{ContextExt, FatError, FatResult};
+use crate::hal::{PlantHal, HAL};
+use crate::mqtt;
+use crate::util::mk_static;
+use alloc::string::{String, ToString};
+use alloc::sync::Arc;
+use chrono::{DateTime, Utc};
+use core::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
+use embassy_executor::Spawner;
+use embassy_net::dns::DnsQueryType;
+use embassy_net::udp::{PacketMetadata, UdpSocket};
+use embassy_net::{DhcpConfig, Runner, Stack, StackResources, StaticConfigV4};
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::{Mutex, MutexGuard};
+use embassy_time::{Duration, Timer, WithTimeout};
+use option_lock::OptionLock;
+use edge_dhcp::{
+    io::{self, DEFAULT_SERVER_PORT},
+    server::{Server, ServerOptions},
+};
+use edge_nal::UdpBind;
+use edge_nal_embassy::{Udp, UdpBuffers};
+use esp_hal::rng::Rng;
+use esp_println::println;
+use esp_radio::wifi::ap::AccessPointConfig;
+use esp_radio::wifi::sta::StationConfig;
+use esp_radio::wifi::{AuthenticationMethod, Config, Interface};
+use log::{info, warn, error};
+use serde::Serialize;
+use sntpc::{NtpContext, NtpTimestampGenerator, NtpUdpSocket, get_time};
+
+const NTP_SERVER: &str = "pool.ntp.org";
+
+#[derive(Copy, Clone, Default)]
+struct Timestamp {
+    stamp: DateTime<Utc>,
+}
+
+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()
+    }
+}
+
+struct EmbassyNtpSocket<'a, 'b> {
+    socket: &'a UdpSocket<'b>,
+}
+
+impl<'a, 'b> EmbassyNtpSocket<'a, 'b> {
+    fn new(socket: &'a UdpSocket<'b>) -> Self {
+        Self { socket }
+    }
+}
+
+impl NtpUdpSocket for EmbassyNtpSocket<'_, '_> {
+    async fn send_to(&self, buf: &[u8], addr: SocketAddr) -> sntpc::Result<usize> {
+        self.socket
+            .send_to(buf, addr)
+            .await
+            .map_err(|_| sntpc::Error::Network)?;
+        Ok(buf.len())
+    }
+
+    async fn recv_from(&self, buf: &mut [u8]) -> sntpc::Result<(usize, SocketAddr)> {
+        let (len, metadata) = self
+            .socket
+            .recv_from(buf)
+            .await
+            .map_err(|_| sntpc::Error::Network)?;
+        let addr = match metadata.endpoint.addr {
+            embassy_net::IpAddress::Ipv4(ip) => IpAddr::V4(ip),
+            embassy_net::IpAddress::Ipv6(ip) => IpAddr::V6(ip),
+        };
+        Ok((len, SocketAddr::new(addr, metadata.endpoint.port)))
+    }
+}
+
+pub async fn sntp(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).context("Could not bind UDP socket")?;
+
+    let context = NtpContext::new(Timestamp::default());
+    let ntp_socket = EmbassyNtpSocket::new(&socket);
+
+    let ntp_addrs = stack
+        .dns_query(NTP_SERVER, DnsQueryType::A)
+        .await
+        .context("Failed to resolve DNS")?;
+
+    if ntp_addrs.is_empty() {
+        bail!("No IP addresses found for NTP server");
+    }
+    let ntp = ntp_addrs[0];
+    info!("NTP server: {ntp:?}");
+
+    let mut counter = 0;
+    loop {
+        let addr: IpAddr = ntp.into();
+        let timeout = get_time(SocketAddr::from((addr, 123)), &ntp_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;
+            }
+        }
+    }
+}
+
+#[derive(Serialize, Debug, PartialEq)]
+pub enum SntpMode {
+    OFFLINE,
+    SYNC { current: DateTime<Utc> },
+}
+
+#[derive(Serialize, Debug, PartialEq)]
+pub enum NetworkMode {
+    WIFI {
+        sntp: SntpMode,
+        mqtt: bool,
+        ip_address: String,
+    },
+    OFFLINE,
+}
+
+#[embassy_executor::task(pool_size = 2)]
+pub(crate) async fn net_task(mut runner: Runner<'static, Interface<'static>>) {
+    runner.run().await;
+}
+
+#[embassy_executor::task]
+pub(crate) async fn run_dhcp(stack: Stack<'static>, ip: Ipv4Addr) {
+    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 = match unbound_socket
+        .bind(SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::UNSPECIFIED,
+            DEFAULT_SERVER_PORT,
+        )))
+        .await
+    {
+        Ok(s) => s,
+        Err(e) => {
+            error!("dhcp task failed to bind socket: {:?}", e);
+            return;
+        }
+    };
+
+    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| warn!("DHCP server error: {e:?}"));
+        Timer::after(Duration::from_millis(500)).await;
+    }
+}
+
+pub async fn wifi_ap(
+    ssid: String,
+    interface_ap: Interface<'static>,
+    controller: &Arc<Mutex<CriticalSectionRawMutex, esp_radio::wifi::WifiController<'static>>>,
+    rng: &mut Rng,
+    spawner: Spawner,
+) -> FatResult<Stack<'static>> {
+    let gw_ip_addr = Ipv4Addr::new(192, 168, 71, 1);
+
+    let config = embassy_net::Config::ipv4_static(StaticConfigV4 {
+        address: embassy_net::Ipv4Cidr::new(gw_ip_addr, 24),
+        gateway: Some(gw_ip_addr),
+        dns_servers: Default::default(),
+    });
+
+    let seed = (rng.random() as u64) << 32 | rng.random() as u64;
+
+    println!("init secondary stack");
+    let (stack, runner) = embassy_net::new(
+        interface_ap,
+        config,
+        mk_static!(StackResources<4>, StackResources::<4>::new()),
+        seed,
+    );
+    let stack = mk_static!(Stack, stack);
+
+    let client_config =
+        Config::AccessPoint(AccessPointConfig::default().with_ssid(ssid.clone()));
+    controller.lock().await.set_config(&client_config)?;
+
+    println!("start net task");
+    spawner.spawn(net_task(runner)?);
+    println!("run dhcp");
+    spawner.spawn(run_dhcp(*stack, gw_ip_addr)?);
+
+    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}/");
+    stack
+        .config_v4()
+        .inspect(|c| println!("ipv4 config: {c:?}"));
+
+    Ok(*stack)
+}
+
+pub async fn wifi(
+    network_config: &NetworkConfig,
+    interface_sta: Interface<'static>,
+    controller: &Arc<Mutex<CriticalSectionRawMutex, esp_radio::wifi::WifiController<'static>>>,
+    rng: &mut Rng,
+    spawner: Spawner,
+) -> FatResult<Stack<'static>> {
+    esp_radio::wifi_set_log_verbose();
+    let ssid = match &network_config.ssid {
+        Some(ssid) => {
+            if ssid.is_empty() {
+                bail!("Wifi ssid was empty")
+            }
+            ssid.as_str().to_string()
+        }
+        None => {
+            bail!("Wifi ssid was empty")
+        }
+    };
+    info!("attempting to connect wifi {ssid}");
+    let password = match network_config.password {
+        Some(ref password) => password.as_str().to_string(),
+        None => "".to_string(),
+    };
+    let max_wait = network_config.max_wait;
+
+    let config = embassy_net::Config::dhcpv4(DhcpConfig::default());
+
+    let seed = (rng.random() as u64) << 32 | rng.random() as u64;
+
+    let (stack, runner) = embassy_net::new(
+        interface_sta,
+        config,
+        mk_static!(StackResources<8>, StackResources::<8>::new()),
+        seed,
+    );
+    let stack = mk_static!(Stack, stack);
+
+    let auth_method = if password.is_empty() {
+        AuthenticationMethod::None
+    } else {
+        AuthenticationMethod::Wpa2Personal
+    };
+    let client_config = StationConfig::default()
+        .with_ssid(ssid)
+        .with_auth_method(auth_method)
+        .with_scan_method(esp_radio::wifi::sta::ScanMethod::AllChannels)
+        .with_listen_interval(10)
+        .with_beacon_timeout(10)
+        .with_failure_retry_cnt(3)
+        .with_password(password);
+
+    controller
+        .lock()
+        .await
+        .set_config(&Config::Station(client_config))?;
+    spawner.spawn(net_task(runner)?);
+    controller
+        .lock()
+        .await
+        .connect_async()
+        .with_timeout(Duration::from_millis(max_wait as u64 * 1000))
+        .await
+        .context("Timeout waiting for wifi sta connected")??;
+
+    let res = async {
+        while !stack.is_link_up() {
+            Timer::after(Duration::from_millis(500)).await;
+        }
+        Ok::<(), FatError>(())
+    }
+    .with_timeout(Duration::from_millis(max_wait as u64 * 1000))
+    .await;
+
+    if res.is_err() {
+        bail!("Timeout waiting for wifi link up")
+    }
+
+    let res = async {
+        while !stack.is_config_up() {
+            Timer::after(Duration::from_millis(100)).await
+        }
+        Ok::<(), FatError>(())
+    }
+    .with_timeout(Duration::from_millis(max_wait as u64 * 1000))
+    .await;
+
+    if res.is_err() {
+        bail!("Timeout waiting for wifi config up")
+    }
+
+    info!("Connected WIFI, dhcp: {:?}", stack.config_v4());
+    Ok(*stack)
+}
+
+pub async fn try_connect_wifi_sntp_mqtt(
+    board: &mut MutexGuard<'static, CriticalSectionRawMutex, HAL<'static>>,
+    stack_store: &mut OptionLock<Stack<'static>>,
+    spawner: Spawner,
+) -> NetworkMode {
+    let nw_conf = &board.board_hal.get_config().network.clone();
+    let esp = board.board_hal.get_esp();
+    let device = match esp.interface_sta.take() {
+        Some(d) => d,
+        None => {
+            info!("Offline mode due to STA interface already taken");
+            board.board_hal.general_fault(true).await;
+            return NetworkMode::OFFLINE;
+        }
+    };
+    match wifi(nw_conf, device, &esp.controller, &mut esp.rng, spawner).await {
+        Ok(stack) => {
+            stack_store.replace(stack);
+
+            let sntp_mode: SntpMode = match sntp(1000 * 10, stack).await {
+                Ok(new_time) => {
+                    info!("Using time from sntp {}", new_time.to_rfc3339());
+                    let _ = board
+                        .board_hal
+                        .get_rtc_module()
+                        .set_rtc_time(&new_time)
+                        .await;
+                    SntpMode::SYNC { current: new_time }
+                }
+                Err(err) => {
+                    warn!("sntp error: {err}");
+                    board.board_hal.general_fault(true).await;
+                    SntpMode::OFFLINE
+                }
+            };
+
+            let mqtt_connected = if board.board_hal.get_config().network.mqtt_url.is_some() {
+                let nw_config = board.board_hal.get_config().network.clone();
+                let nw_config = mk_static!(NetworkConfig, nw_config);
+                match mqtt::mqtt_init(nw_config, stack, spawner).await {
+                    Ok(_) => {
+                        info!("Mqtt connection ready");
+                        true
+                    }
+                    Err(err) => {
+                        warn!("Could not connect mqtt due to {err}");
+                        false
+                    }
+                }
+            } else {
+                false
+            };
+
+            let ip = match stack.config_v4() {
+                Some(config) => config.address.address().to_string(),
+                None => match stack.config_v6() {
+                    Some(config) => config.address.address().to_string(),
+                    None => String::from("No IP"),
+                },
+            };
+            NetworkMode::WIFI {
+                sntp: sntp_mode,
+                mqtt: mqtt_connected,
+                ip_address: ip,
+            }
+        }
+        Err(err) => {
+            info!("Offline mode due to {err}");
+            board.board_hal.general_fault(true).await;
+            NetworkMode::OFFLINE
+        }
+    }
+}

rust/src/plant_state.rs

@@ -3,6 +3,7 @@ use crate::{
     hal::{Sensor, HAL},
     in_time_range,
 };
+use alloc::string::{String, ToString};
 use chrono::{DateTime, TimeDelta, Utc};
 use chrono_tz::Tz;
 use serde::{Deserialize, Serialize};
@@ -10,11 +11,12 @@ use serde::{Deserialize, Serialize};
 const MOIST_SENSOR_MAX_FREQUENCY: f32 = 7500.; // 60kHz (500Hz margin)
 const MOIST_SENSOR_MIN_FREQUENCY: f32 = 150.; // this is really, really dry, think like cactus levels
 
-#[derive(Debug, PartialEq, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize)]
+#[serde(tag = "kind")]
 pub enum MoistureSensorError {
     ShortCircuit { hz: f32, max: f32 },
     OpenLoop { hz: f32, min: f32 },
-    BoardError(String),
+    BoardError { message: String },
 }
 
 #[derive(Debug, PartialEq, Serialize)]
@@ -48,6 +50,14 @@ impl MoistureSensorState {
 impl MoistureSensorState {}
 
 #[derive(Debug, PartialEq, Serialize)]
+pub struct SensorTelemetry {
+    pub moisture_pct: Option<f32>,
+    pub raw_hz: Option<f32>,
+    pub error: Option<MoistureSensorError>,
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+#[serde(tag = "kind")]
 pub enum PumpError {
     PumpNotWorking {
         failed_attempts: usize,
@@ -115,9 +125,13 @@ fn map_range_moisture(
 }
 
 impl PlantState {
-    pub fn read_hardware_state(plant_id: usize, board: &mut HAL) -> Self {
+    pub async fn read_hardware_state(plant_id: usize, board: &mut HAL<'_>) -> Self {
         let sensor_a = if board.board_hal.get_config().plants[plant_id].sensor_a {
-            match board.board_hal.measure_moisture_hz(plant_id, Sensor::A) {
+            match board
+                .board_hal
+                .measure_moisture_hz(plant_id, Sensor::A)
+                .await
+            {
                 Ok(raw) => match map_range_moisture(
                     raw,
                     board.board_hal.get_config().plants[plant_id].moisture_sensor_min_frequency,
@@ -129,16 +143,20 @@ impl PlantState {
                     },
                     Err(err) => MoistureSensorState::SensorError(err),
                 },
-                Err(err) => MoistureSensorState::SensorError(MoistureSensorError::BoardError(
+                Err(err) => MoistureSensorState::SensorError(MoistureSensorError::BoardError {
-                    err.to_string(),
+                    message: err.to_string(),
-                )),
+                })
             }
         } else {
             MoistureSensorState::Disabled
         };
 
         let sensor_b = if board.board_hal.get_config().plants[plant_id].sensor_b {
-            match board.board_hal.measure_moisture_hz(plant_id, Sensor::B) {
+            match board
+                .board_hal
+                .measure_moisture_hz(plant_id, Sensor::B)
+                .await
+            {
                 Ok(raw) => match map_range_moisture(
                     raw,
                     board.board_hal.get_config().plants[plant_id].moisture_sensor_min_frequency,
@@ -150,9 +168,9 @@ impl PlantState {
                     },
                     Err(err) => MoistureSensorState::SensorError(err),
                 },
-                Err(err) => MoistureSensorState::SensorError(MoistureSensorError::BoardError(
+                Err(err) => MoistureSensorState::SensorError(MoistureSensorError::BoardError {
-                    err.to_string(),
+                    message: err.to_string(),
-                )),
+                })
             }
         } else {
             MoistureSensorState::Disabled
@@ -238,7 +256,7 @@ impl PlantState {
             }
             PlantWateringMode::MinMoisture => {
                 let (moisture_percent, _) = self.plant_moisture();
-                if let Some(moisture_percent) = moisture_percent {
+                if let Some(_moisture_percent) = moisture_percent {
                     if self.pump_in_timeout(plant_conf, current_time) {
                         false
                     } else if !in_time_range(
@@ -247,10 +265,10 @@ impl PlantState {
                         plant_conf.pump_hour_end,
                     ) {
                         false
-                    } else if (true) {
+                    } else if true {
                         //if not cooldown min and below max
                         true
-                    } else if (true) {
+                    } else if true {
                         //if below min disable cooldown min
                         true
                     } else {
@@ -268,19 +286,21 @@ impl PlantState {
         &self,
         plant_conf: &PlantConfig,
         current_time: &DateTime<Tz>,
-    ) -> PlantInfo<'_> {
+    ) -> PlantInfo {
+        let (moisture_pct, _) = self.plant_moisture();
         PlantInfo {
-            sensor_a: &self.sensor_a,
+            moisture_pct,
-            sensor_b: &self.sensor_b,
+            sensor_a: Self::sensor_to_telemetry(&self.sensor_a),
+            sensor_b: Self::sensor_to_telemetry(&self.sensor_b),
             mode: plant_conf.mode,
             do_water: self.needs_to_be_watered(plant_conf, current_time),
-            dry: if let Some(moisture_percent) = self.plant_moisture().0 {
+            dry: if let Some(moisture_percent) = moisture_pct {
                 moisture_percent < plant_conf.target_moisture
             } else {
                 false
             },
             cooldown: self.pump_in_timeout(plant_conf, current_time),
-            out_of_work_hour: in_time_range(
+            out_of_work_hour: !in_time_range(
                 current_time,
                 plant_conf.pump_hour_start,
                 plant_conf.pump_hour_end,
@@ -307,15 +327,40 @@ impl PlantState {
             },
         }
     }
+
+    fn sensor_to_telemetry(sensor: &MoistureSensorState) -> SensorTelemetry {
+        match sensor {
+            MoistureSensorState::Disabled => SensorTelemetry {
+                moisture_pct: None,
+                raw_hz: None,
+                error: None,
+            },
+            MoistureSensorState::MoistureValue {
+                raw_hz,
+                moisture_percent,
+            } => SensorTelemetry {
+                moisture_pct: Some(*moisture_percent),
+                raw_hz: Some(*raw_hz),
+                error: None,
+            },
+            MoistureSensorState::SensorError(err) => SensorTelemetry {
+                moisture_pct: None,
+                raw_hz: None,
+                error: Some(err.clone()),
+            },
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Serialize)]
 /// State of a single plant to be tracked
-pub struct PlantInfo<'a> {
+pub struct PlantInfo {
+    /// combined plant moisture from available sensors
+    moisture_pct: Option<f32>,
     /// state of humidity sensor on bank a
-    sensor_a: &'a MoistureSensorState,
+    sensor_a: SensorTelemetry,
     /// state of humidity sensor on bank b
-    sensor_b: &'a MoistureSensorState,
+    sensor_b: SensorTelemetry,
     /// configured plant watering mode
     mode: PlantWateringMode,
     /// the plant needs to be watered

rust/src/tank.rs

@@ -1,16 +1,21 @@
-use crate::{config::TankConfig, hal::HAL};
+use crate::alloc::string::{String, ToString};
-use anyhow::Context;
+use crate::config::TankConfig;
+use crate::hal::HAL;
+use crate::fat_error::FatResult;
+use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
+use embassy_sync::mutex::MutexGuard;
 use serde::Serialize;
 
 const OPEN_TANK_VOLTAGE: f32 = 3.0;
 pub const WATER_FROZEN_THRESH: f32 = 4.0;
 
 #[derive(Debug, Clone, Serialize)]
+#[serde(tag = "kind")]
 pub enum TankError {
     SensorDisabled,
-    SensorMissing(f32),
+    SensorMissing { raw_mv: f32 },
     SensorValueError { value: f32, min: f32, max: f32 },
-    BoardError(String),
+    BoardError { message: String },
 }
 
 pub enum TankState {
@@ -21,7 +26,7 @@ pub enum TankState {
 
 fn raw_voltage_to_divider_percent(raw_value_mv: f32) -> Result<f32, TankError> {
     if raw_value_mv > OPEN_TANK_VOLTAGE {
-        return Err(TankError::SensorMissing(raw_value_mv));
+        return Err(TankError::SensorMissing { raw_mv: raw_value_mv });
     }
 
     let r2 = raw_value_mv * 50.0 / (3.3 - raw_value_mv);
@@ -113,7 +118,7 @@ impl TankState {
         }
     }
 
-    pub fn as_mqtt_info(&self, config: &TankConfig, water_temp: &anyhow::Result<f32>) -> TankInfo {
+    pub fn as_mqtt_info(&self, config: &TankConfig, water_temp: &FatResult<f32>) -> TankInfo {
         let mut tank_err: Option<TankError> = None;
         let left_ml = match self.left_ml(config) {
             Err(err) => {
@@ -137,29 +142,30 @@ impl TankState {
         TankInfo {
             enough_water,
             warn_level,
-            left_ml,
+            volume_ml: left_ml,
             sensor_error: tank_err,
-            raw,
+            fill_raw_v: raw,
             water_frozen: water_temp
                 .as_ref()
                 .is_ok_and(|temp| *temp < WATER_FROZEN_THRESH),
-            water_temp: water_temp.as_ref().copied().ok(),
+            water_temp_c: water_temp.as_ref().copied().ok(),
             temp_sensor_error: water_temp.as_ref().err().map(|err| err.to_string()),
-            percent,
+            fill_pct: percent,
         }
     }
 }
 
-pub fn determine_tank_state(board: &mut std::sync::MutexGuard<'_, HAL<'_>>) -> TankState {
+pub async fn determine_tank_state(
+    board: &mut MutexGuard<'static, CriticalSectionRawMutex, HAL<'static>>,
+) -> TankState {
     if board.board_hal.get_config().tank.tank_sensor_enabled {
         match board
             .board_hal
             .get_tank_sensor()
-            .context("no sensor")
+            .and_then(|f| core::prelude::v1::Ok(f.tank_sensor_voltage()))
-            .and_then(|f| f.tank_sensor_voltage())
         {
-            Ok(raw_sensor_value_mv) => TankState::Present(raw_sensor_value_mv),
+            Ok(raw_sensor_value_mv) => TankState::Present(raw_sensor_value_mv.await.unwrap()),
-            Err(err) => TankState::Error(TankError::BoardError(err.to_string())),
+            Err(err) => TankState::Error(TankError::BoardError { message: err.to_string() }),
         }
     } else {
         TankState::Disabled
@@ -170,20 +176,20 @@ pub fn determine_tank_state(board: &mut std::sync::MutexGuard<'_, HAL<'_>>) -> T
 /// Information structure send to mqtt for monitoring purposes
 pub struct TankInfo {
     /// there is enough water in the tank
-    enough_water: bool,
+    pub(crate) enough_water: bool,
     /// warning that water needs to be refilled soon
-    warn_level: bool,
+    pub(crate) warn_level: bool,
     /// estimation how many ml are still in the tank
-    left_ml: Option<f32>,
+    pub(crate) volume_ml: Option<f32>,
     /// if there is an issue with the water level sensor
-    sensor_error: Option<TankError>,
+    pub(crate) sensor_error: Option<TankError>,
     /// raw water sensor value
-    raw: Option<f32>,
+    pub(crate) fill_raw_v: Option<f32>,
     /// percent value
-    percent: Option<f32>,
+    pub(crate) fill_pct: Option<f32>,
     /// water in the tank might be frozen
-    water_frozen: bool,
+    pub(crate) water_frozen: bool,
     /// water temperature
-    water_temp: Option<f32>,
+    pub(crate) water_temp_c: Option<f32>,
-    temp_sensor_error: Option<String>,
+    pub(crate) temp_sensor_error: Option<String>,
 }

rust/src/util.rs

@@ -0,0 +1,10 @@
+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
+    }};
+}
+
+pub(crate) use mk_static;

rust/src/webserver/backup_manager.rs

@@ -0,0 +1,191 @@
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::rtc::X25;
+use crate::BOARD_ACCESS;
+use alloc::borrow::ToOwned;
+use alloc::format;
+use alloc::string::{String, ToString};
+use chrono::DateTime;
+use edge_http::io::server::Connection;
+use edge_nal::io::{Read, Write};
+use log::info;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+pub struct WebBackupHeader {
+    timestamp: String,
+    size: u16,
+}
+pub(crate) async fn get_backup_config<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> FatResult<Option<u32>>
+where
+    T: Read + Write,
+{
+    // First pass: verify checksum without sending data
+    let mut checksum = X25.digest();
+    let mut chunk = 0_usize;
+    loop {
+        let mut board = BOARD_ACCESS.get().await.lock().await;
+        board.board_hal.progress(chunk as u32).await;
+        let (buf, len, expected_crc) = board
+            .board_hal
+            .get_rtc_module()
+            .get_backup_config(chunk)
+            .await?;
+
+        // Update checksum with the actual data bytes of this chunk
+        checksum.update(&buf[..len]);
+
+        let is_last = len == 0 || len < buf.len();
+        if is_last {
+            let actual_crc = checksum.finalize();
+            if actual_crc != expected_crc {
+                BOARD_ACCESS
+                    .get()
+                    .await
+                    .lock()
+                    .await
+                    .board_hal
+                    .clear_progress()
+                    .await;
+                conn.initiate_response(
+                    409,
+                    Some(
+                        format!(
+                            "Checksum mismatch expected {} got {}",
+                            expected_crc, actual_crc
+                        )
+                        .as_str(),
+                    ),
+                    &[],
+                )
+                .await?;
+                return Ok(Some(409));
+            }
+            break;
+        }
+        chunk += 1;
+    }
+    // Second pass: stream data
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Access-Control-Allow-Origin", "*"),
+            ("Access-Control-Allow-Headers", "*"),
+            ("Access-Control-Allow-Methods", "*"),
+        ],
+    )
+    .await?;
+
+    let mut chunk = 0_usize;
+    loop {
+        let mut board = BOARD_ACCESS.get().await.lock().await;
+        board.board_hal.progress(chunk as u32).await;
+        let (buf, len, _expected_crc) = board
+            .board_hal
+            .get_rtc_module()
+            .get_backup_config(chunk)
+            .await?;
+
+        if len == 0 {
+            break;
+        }
+
+        conn.write_all(&buf[..len]).await?;
+
+        if len < buf.len() {
+            break;
+        }
+        chunk += 1;
+    }
+    BOARD_ACCESS
+        .get()
+        .await
+        .lock()
+        .await
+        .board_hal
+        .clear_progress()
+        .await;
+    Ok(Some(200))
+}
+
+pub(crate) async fn backup_config<T, const N: usize>(
+    conn: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let mut offset = 0_usize;
+    let mut buf = [0_u8; 32];
+
+    let mut checksum = X25.digest();
+
+    let mut counter = 0;
+    loop {
+        let to_write = conn.read(&mut buf).await?;
+        if to_write == 0 {
+            info!("backup finished");
+            break;
+        } else {
+            let mut board = BOARD_ACCESS.get().await.lock().await;
+            board.board_hal.progress(counter).await;
+
+            counter = counter + 1;
+            board
+                .board_hal
+                .get_rtc_module()
+                .backup_config(offset, &buf[0..to_write])
+                .await?;
+            checksum.update(&buf[0..to_write]);
+        }
+        offset = offset + to_write;
+    }
+
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board
+        .board_hal
+        .get_rtc_module()
+        .backup_config_finalize(checksum.finalize(), offset)
+        .await?;
+    board.board_hal.clear_progress().await;
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Access-Control-Allow-Origin", "*"),
+            ("Access-Control-Allow-Headers", "*"),
+            ("Access-Control-Allow-Methods", "*"),
+        ],
+    )
+    .await?;
+    Ok(Some("saved".to_owned()))
+}
+
+pub(crate) async fn backup_info<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> Result<Option<String>, FatError>
+where
+    T: Read + Write,
+{
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let header = board.board_hal.get_rtc_module().get_backup_info().await;
+    let json = match header {
+        Ok(h) => {
+            let timestamp = DateTime::from_timestamp_millis(h.timestamp).unwrap();
+            let wbh = WebBackupHeader {
+                timestamp: timestamp.to_rfc3339(),
+                size: h.size,
+            };
+            serde_json::to_string(&wbh)?
+        }
+        Err(err) => {
+            let wbh = WebBackupHeader {
+                timestamp: err.to_string(),
+                size: 0,
+            };
+            serde_json::to_string(&wbh)?
+        }
+    };
+    Ok(Some(json))
+}

rust/src/webserver/file_manager.rs

@@ -0,0 +1,160 @@
+use crate::fat_error::{FatError, FatResult};
+use crate::BOARD_ACCESS;
+use alloc::borrow::ToOwned;
+use alloc::format;
+use alloc::string::String;
+use edge_http::io::server::Connection;
+use edge_http::Method;
+use edge_nal::io::{Read, Write};
+use log::info;
+
+pub(crate) async fn list_files<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let result = board.board_hal.get_esp().list_files().await?;
+    let file_list_json = serde_json::to_string(&result)?;
+    Ok(Some(file_list_json))
+}
+pub(crate) async fn file_operations<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+    method: Method,
+    path: &&str,
+    prefix: &&str,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    let filename = &path[prefix.len()..];
+    info!("file request for {} with method {}", filename, method);
+    Ok(match method {
+        Method::Delete => {
+            let mut board = BOARD_ACCESS.get().await.lock().await;
+            board
+                .board_hal
+                .get_esp()
+                .delete_file(filename.to_owned())
+                .await?;
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            Some(200)
+        }
+        Method::Get => {
+            let disposition = format!("attachment; filename=\"{filename}\"");
+            let size = {
+                let mut board = BOARD_ACCESS.get().await.lock().await;
+                board
+                    .board_hal
+                    .get_esp()
+                    .get_size(filename.to_owned())
+                    .await?
+            };
+
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Content-Type", "application/octet-stream"),
+                    ("Content-Disposition", disposition.as_str()),
+                    ("Content-Length", &format!("{}", size)),
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+
+            let mut chunk = 0;
+            loop {
+                let mut board = BOARD_ACCESS.get().await.lock().await;
+                board.board_hal.progress(chunk).await;
+                let read_chunk = board
+                    .board_hal
+                    .get_esp()
+                    .get_file(filename.to_owned(), chunk)
+                    .await?;
+                let length = read_chunk.1;
+                if length == 0 {
+                    info!("file request for {} finished", filename);
+                    break;
+                }
+                let data = &read_chunk.0[0..length];
+                conn.write_all(data).await?;
+                if length < read_chunk.0.len() {
+                    info!("file request for {} finished", filename);
+                    break;
+                }
+                chunk = chunk + 1;
+            }
+            BOARD_ACCESS
+                .get()
+                .await
+                .lock()
+                .await
+                .board_hal
+                .clear_progress()
+                .await;
+            Some(200)
+        }
+        Method::Post => {
+            {
+                let mut board = BOARD_ACCESS.get().await.lock().await;
+                //ensure the file is deleted first; otherwise we would need to truncate the file which will not work with streaming
+                let _ = board
+                    .board_hal
+                    .get_esp()
+                    .delete_file(filename.to_owned())
+                    .await;
+            }
+
+            let mut offset = 0_usize;
+            let mut chunk = 0;
+            loop {
+                let mut buf = [0_u8; 1024];
+                let to_write = conn.read(&mut buf).await?;
+                if to_write == 0 {
+                    info!("file request for {} finished", filename);
+                    break;
+                } else {
+                    let mut board = BOARD_ACCESS.get().await.lock().await;
+                    board.board_hal.progress(chunk as u32).await;
+                    board
+                        .board_hal
+                        .get_esp()
+                        .write_file(filename.to_owned(), offset as u32, &buf[0..to_write])
+                        .await?;
+                }
+                offset = offset + to_write;
+                chunk = chunk + 1;
+            }
+            BOARD_ACCESS
+                .get()
+                .await
+                .lock()
+                .await
+                .board_hal
+                .clear_progress()
+                .await;
+            conn.initiate_response(
+                200,
+                Some("OK"),
+                &[
+                    ("Access-Control-Allow-Origin", "*"),
+                    ("Access-Control-Allow-Headers", "*"),
+                    ("Access-Control-Allow-Methods", "*"),
+                ],
+            )
+            .await?;
+            Some(200)
+        }
+        _ => None,
+    })
+}

rust/src/webserver/get_json.rs

@@ -0,0 +1,184 @@
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::PLANT_COUNT;
+use crate::log::LogMessage;
+use crate::plant_state::{MoistureSensorState, PlantState};
+use crate::tank::determine_tank_state;
+use crate::{get_version, BOARD_ACCESS};
+use alloc::format;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use chrono_tz::Tz;
+use core::str::FromStr;
+use edge_http::io::server::Connection;
+use edge_nal::io::{Read, Write};
+use log::info;
+use serde::Serialize;
+
+#[derive(Serialize, Debug)]
+struct LoadData<'a> {
+    rtc: &'a str,
+    native: &'a str,
+}
+#[derive(Serialize, Debug)]
+struct Moistures {
+    moisture_a: Vec<String>,
+    moisture_b: Vec<String>,
+}
+#[derive(Serialize, Debug)]
+struct SolarState {
+    mppt_voltage: f32,
+    mppt_current: f32,
+    is_day: bool,
+}
+pub(crate) async fn get_live_moisture<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let mut plant_state = Vec::new();
+    for i in 0..PLANT_COUNT {
+        plant_state.push(PlantState::read_hardware_state(i, &mut board).await);
+    }
+    let a = Vec::from_iter(plant_state.iter().map(|s| match &s.sensor_a {
+        MoistureSensorState::Disabled => "disabled".to_string(),
+        MoistureSensorState::MoistureValue {
+            raw_hz,
+            moisture_percent,
+        } => {
+            format!("{moisture_percent:.2}% {raw_hz}hz",)
+        }
+        MoistureSensorState::SensorError(err) => format!("{err:?}"),
+    }));
+    let b = Vec::from_iter(plant_state.iter().map(|s| match &s.sensor_b {
+        MoistureSensorState::Disabled => "disabled".to_string(),
+        MoistureSensorState::MoistureValue {
+            raw_hz,
+            moisture_percent,
+        } => {
+            format!("{moisture_percent:.2}% {raw_hz}hz",)
+        }
+        MoistureSensorState::SensorError(err) => format!("{err:?}"),
+    }));
+
+    let data = Moistures {
+        moisture_a: a,
+        moisture_b: b,
+    };
+    let json = serde_json::to_string(&data)?;
+
+    Ok(Some(json))
+}
+
+pub(crate) async fn tank_info<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> Result<Option<String>, FatError>
+where
+    T: Read + Write,
+{
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let tank_state = determine_tank_state(&mut board).await;
+    //should be multisampled
+    let sensor = board.board_hal.get_tank_sensor()?;
+
+    let water_temp: FatResult<f32> = sensor.water_temperature_c().await;
+    Ok(Some(serde_json::to_string(&tank_state.as_mqtt_info(
+        &board.board_hal.get_config().tank,
+        &water_temp,
+    ))?))
+}
+
+pub(crate) async fn get_timezones() -> FatResult<Option<String>> {
+    // Get all timezones compiled into the binary from chrono-tz
+    let timezones: Vec<&'static str> = chrono_tz::TZ_VARIANTS.iter().map(|tz| tz.name()).collect();
+    let json = serde_json::to_string(&timezones)?;
+    Ok(Some(json))
+}
+
+pub(crate) async fn get_solar_state<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let state = SolarState {
+        mppt_voltage: board.board_hal.get_mptt_voltage().await?.as_millivolts() as f32,
+        mppt_current: board.board_hal.get_mptt_current().await?.as_milliamperes() as f32,
+        is_day: board.board_hal.is_day(),
+    };
+    Ok(Some(serde_json::to_string(&state)?))
+}
+
+pub(crate) async fn get_version_web<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    Ok(Some(serde_json::to_string(&get_version(&mut board).await)?))
+}
+
+pub(crate) async fn get_config<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let json = serde_json::to_string(&board.board_hal.get_config())?;
+    Ok(Some(json))
+}
+
+pub(crate) async fn get_battery_state<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let battery_state = board
+        .board_hal
+        .get_battery_monitor()
+        .get_battery_state()
+        .await?;
+    Ok(Some(serde_json::to_string(&battery_state)?))
+}
+
+pub(crate) async fn get_time<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let conf = board.board_hal.get_config();
+
+    let tz: Tz = match conf.timezone.as_ref() {
+        None => Tz::UTC,
+        Some(tz_string) => match Tz::from_str(tz_string) {
+            Ok(tz) => tz,
+            Err(err) => {
+                info!("failed parsing timezone {err}");
+                Tz::UTC
+            }
+        },
+    };
+
+    let native = board
+        .board_hal
+        .get_time()
+        .await
+        .with_timezone(&tz)
+        .to_rfc3339();
+
+    let rtc = match board.board_hal.get_rtc_module().get_rtc_time().await {
+        Ok(time) => time.with_timezone(&tz).to_rfc3339(),
+        Err(err) => {
+            format!("Error getting time: {err}")
+        }
+    };
+
+    let data = LoadData {
+        rtc: rtc.as_str(),
+        native: native.as_str(),
+    };
+    let json = serde_json::to_string(&data)?;
+
+    Ok(Some(json))
+}
+
+pub(crate) async fn get_log_localization_config<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    Ok(Some(serde_json::to_string(
+        &LogMessage::log_localisation_config(),
+    )?))
+}

rust/src/webserver/get_log.rs

@@ -0,0 +1,36 @@
+use crate::fat_error::FatResult;
+use crate::log::LOG_ACCESS;
+use edge_http::io::server::Connection;
+use edge_nal::io::{Read, Write};
+
+pub(crate) async fn get_log<T, const N: usize>(
+    conn: &mut Connection<'_, T, N>,
+) -> FatResult<Option<u32>>
+where
+    T: Read + Write,
+{
+    let log = LOG_ACCESS.lock().await.get();
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Content-Type", "text/javascript"),
+            ("Access-Control-Allow-Origin", "*"),
+            ("Access-Control-Allow-Headers", "*"),
+            ("Access-Control-Allow-Methods", "*"),
+        ],
+    )
+    .await?;
+    conn.write_all("[".as_bytes()).await?;
+    let mut append = false;
+    for entry in log {
+        if append {
+            conn.write_all(",".as_bytes()).await?;
+        }
+        append = true;
+        let json = serde_json::to_string(&entry)?;
+        conn.write_all(json.as_bytes()).await?;
+    }
+    conn.write_all("]".as_bytes()).await?;
+    Ok(Some(200))
+}

rust/src/webserver/get_static.rs

@@ -0,0 +1,50 @@
+use crate::fat_error::FatError;
+use edge_http::io::server::Connection;
+use edge_nal::io::{Read, Write};
+
+pub(crate) async fn serve_favicon<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    conn.initiate_response(200, Some("OK"), &[("Content-Type", "image/x-icon")])
+        .await?;
+    conn.write_all(include_bytes!("favicon.ico")).await?;
+    Ok(Some(200))
+}
+
+pub(crate) async fn serve_index<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[("Content-Type", "text/html"), ("Content-Encoding", "gzip")],
+    )
+    .await?;
+    conn.write_all(include_bytes!("index.html.gz")).await?;
+    Ok(Some(200))
+}
+
+pub(crate) async fn serve_bundle<T, const N: usize>(
+    conn: &mut Connection<'_, T, { N }>,
+) -> Result<Option<u32>, FatError>
+where
+    T: Read + Write,
+{
+    conn.initiate_response(
+        200,
+        Some("OK"),
+        &[
+            ("Content-Type", "text/javascript"),
+            ("Content-Encoding", "gzip"),
+        ],
+    )
+    .await?;
+    conn.write_all(include_bytes!("bundle.js.gz")).await?;
+    Ok(Some(200))
+}

rust/src/webserver/post_json.rs

@@ -0,0 +1,114 @@
+use crate::config::PlantControllerConfig;
+use crate::fat_error::FatResult;
+use crate::webserver::read_up_to_bytes_from_request;
+use crate::{do_secure_pump, BOARD_ACCESS};
+use alloc::borrow::ToOwned;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use chrono::DateTime;
+use edge_http::io::server::Connection;
+use edge_nal::io::{Read, Write};
+use esp_radio::wifi::ap::AccessPointInfo;
+use log::info;
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+pub struct NightLampCommand {
+    active: bool,
+}
+#[derive(Serialize, Debug)]
+struct SSIDList {
+    ssids: Vec<String>,
+}
+#[derive(Deserialize, Debug)]
+struct SetTime<'a> {
+    time: &'a str,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+pub struct TestPump {
+    pump: usize,
+}
+
+pub(crate) async fn wifi_scan<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    info!("start wifi scan");
+    let mut ssids: Vec<String> = Vec::new();
+    let scan_result: Vec<AccessPointInfo> = board.board_hal.get_esp().wifi_scan().await?;
+    scan_result
+        .iter()
+        .for_each(|s| ssids.push(s.ssid.as_str().to_owned()));
+    let ssid_json = serde_json::to_string(&SSIDList { ssids })?;
+    info!("Sending ssid list {}", &ssid_json);
+    Ok(Some(ssid_json))
+}
+
+pub(crate) async fn board_test() -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.test().await?;
+    Ok(None)
+}
+
+pub(crate) async fn pump_test<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let actual_data = read_up_to_bytes_from_request(request, None).await?;
+    let pump_test: TestPump = serde_json::from_slice(&actual_data)?;
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+
+    let config = &board.board_hal.get_config().plants[pump_test.pump].clone();
+    let pump_result = do_secure_pump(&mut board, pump_test.pump, config, false).await;
+    //ensure it is disabled before unwrapping
+    board.board_hal.pump(pump_test.pump, false).await?;
+
+    Ok(Some(serde_json::to_string(&pump_result?)?))
+}
+
+pub(crate) async fn night_lamp_test<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let actual_data = read_up_to_bytes_from_request(request, None).await?;
+    let light_command: NightLampCommand = serde_json::from_slice(&actual_data)?;
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.light(light_command.active).await?;
+    Ok(None)
+}
+
+pub(crate) async fn write_time<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let actual_data = read_up_to_bytes_from_request(request, None).await?;
+    let time: SetTime = serde_json::from_slice(&actual_data)?;
+    let parsed = DateTime::parse_from_rfc3339(time.time)?;
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.set_time(&parsed).await?;
+    Ok(None)
+}
+
+pub(crate) async fn set_config<T, const N: usize>(
+    request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>>
+where
+    T: Read + Write,
+{
+    let all = read_up_to_bytes_from_request(request, Some(4096)).await?;
+    let length = all.len();
+    let config: PlantControllerConfig = serde_json::from_slice(&all)?;
+
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.get_esp().save_config(all).await?;
+    info!("Wrote config config {:?} with size {}", config, length);
+    board.board_hal.set_config(config);
+    Ok(Some("saved".to_string()))
+}

rust/src_webpack/package.json

@@ -1,5 +1,6 @@
 {
   "devDependencies": {
+    "compression-webpack-plugin": "^11.1.0",
     "html-webpack-harddisk-plugin": "^2.0.0",
     "html-webpack-plugin": "^5.6.3",
     "raw-loader": "^4.0.2",

rust/src_webpack/src/api.ts

@@ -157,7 +157,13 @@ export interface Moistures {
 export interface VersionInfo {
     git_hash: string,
     build_time: string,
-    partition: string
+    current: string,
+    slot0_state: string,
+    slot1_state: string,
+    heap_total: number,
+    heap_used: number,
+    heap_free: number,
+    heap_max_used: number,
 }
 
 export interface BatteryState {
@@ -189,4 +195,4 @@ export interface TankInfo {
     /// water temperature
     water_temp: number | null,
     temp_sensor_error: string | null
-}
+}

rust/src_webpack/src/main.ts

@@ -31,6 +31,7 @@ import {
     FileList, SolarState, PumpTestResult
 } from "./api";
 import {SolarView} from "./solarview";
+import {toast} from "./toast";
 
 export class Controller {
     loadTankInfo(): Promise<void> {
@@ -69,45 +70,44 @@ export class Controller {
             });
     }
 
-    getBackupInfo(): Promise<void> {
+    async getBackupInfo(): Promise<void> {
-        return fetch(PUBLIC_URL + "/backup_info")
+        try {
-            .then(response => response.json())
+            const response = await fetch(PUBLIC_URL + "/backup_info");
-            .then(json => json as BackupHeader)
+            const json = await response.json();
-            .then(header => {
+            const header = json as BackupHeader;
-                controller.submitView.setBackupInfo(header)
+            controller.submitView.setBackupInfo(header);
-            })
+        } catch (error) {
-            .catch(error => {
+            console.log(error);
-                console.log(error);
+        }
-            });
     }
 
-    populateTimezones(): Promise<void> {
+    async populateTimezones(): Promise<void> {
-        return fetch(PUBLIC_URL + '/timezones')
+        try {
-            .then(response => response.json())
+            const response = await fetch(PUBLIC_URL + '/timezones');
-            .then(json => json as string[])
+            const json = await response.json();
-            .then(timezones => {
+            const timezones = json as string[];
-                controller.timeView.timezones(timezones)
+            controller.timeView.timezones(timezones);
-            })
+        } catch (error) {
-            .catch(error => console.error('Error fetching timezones:', error));
+            return console.error('Error fetching timezones:', error);
+        }
     }
 
-    updateFileList(): Promise<void> {
+    async updateFileList(): Promise<void> {
-        return fetch(PUBLIC_URL + "/files")
+        try {
-            .then(response => response.json())
+            const response = await fetch(PUBLIC_URL + "/files");
-            .then(json => json as FileList)
+            const json = await response.json();
-            .then(filelist => {
+            const filelist = json as FileList;
-                controller.fileview.setFileList(filelist, PUBLIC_URL)
+            controller.fileview.setFileList(filelist, PUBLIC_URL);
-            })
+        } catch (error) {
-            .catch(error => {
+            console.log(error);
-                console.log(error);
+        }
-            });
     }
 
     uploadFile(file: File, name: string) {
-        var current = 0;
+        let current = 0;
-        var max = 100;
+        let max = 100;
         controller.progressview.addProgress("file_upload", (current / max) * 100, "Uploading File " + name + "(" + current + "/" + max + ")")
-        var ajax = new XMLHttpRequest();
+        const ajax = new XMLHttpRequest();
         ajax.upload.addEventListener("progress", event => {
             current = event.loaded / 1000;
             max = event.total / 1000;
@@ -133,7 +133,7 @@ export class Controller {
 
     deleteFile(name: string) {
         controller.progressview.addIndeterminate("file_delete", "Deleting " + name);
-        var ajax = new XMLHttpRequest();
+        const ajax = new XMLHttpRequest();
         ajax.open("DELETE", PUBLIC_URL + "/file?filename=" + name);
         ajax.send();
         ajax.addEventListener("error", () => {
@@ -153,50 +153,47 @@ export class Controller {
         controller.updateFileList()
     }
 
-    updateRTCData(): Promise<void> {
+    async updateRTCData(): Promise<void> {
-        return fetch(PUBLIC_URL + "/time")
+        try {
-            .then(response => response.json())
+            const response = await fetch(PUBLIC_URL + "/time");
-            .then(json => json as GetTime)
+            const json = await response.json();
-            .then(time => {
+            const time = json as GetTime;
-                controller.timeView.update(time.native, time.rtc)
+            controller.timeView.update(time.native, time.rtc);
-            })
+        } catch (error) {
-            .catch(error => {
+            controller.timeView.update("n/a", "n/a");
-                controller.timeView.update("n/a", "n/a")
+            console.log(error);
-                console.log(error);
+        }
-            });
     }
 
-    updateBatteryData(): Promise<void> {
+    async updateBatteryData(): Promise<void> {
-        return fetch(PUBLIC_URL + "/battery")
+        try {
-            .then(response => response.json())
+            const response = await fetch(PUBLIC_URL + "/battery");
-            .then(json => json as BatteryState)
+            const json = await response.json();
-            .then(battery => {
+            const battery = json as BatteryState;
-                controller.batteryView.update(battery)
+            controller.batteryView.update(battery);
-            })
+        } catch (error) {
-            .catch(error => {
+            controller.batteryView.update(null);
-                controller.batteryView.update(null)
+            console.log(error);
-                console.log(error);
+        }
-            })
     }
 
-    updateSolarData(): Promise<void> {
+    async updateSolarData(): Promise<void> {
-        return fetch(PUBLIC_URL + "/solar")
+        try {
-            .then(response => response.json())
+            const response = await fetch(PUBLIC_URL + "/solar");
-            .then(json => json as SolarState)
+            const json = await response.json();
-            .then(solar => {
+            const solar = json as SolarState;
-                controller.solarView.update(solar)
+            controller.solarView.update(solar);
-            })
+        } catch (error) {
-            .catch(error => {
+            controller.solarView.update(null);
-                controller.solarView.update(null)
+            console.log(error);
-                console.log(error);
+        }
-            })
     }
 
     uploadNewFirmware(file: File) {
-        var current = 0;
+        let current = 0;
-        var max = 100;
+        let max = 100;
         controller.progressview.addProgress("ota_upload", (current / max) * 100, "Uploading firmeware (" + current + "/" + max + ")")
-        var ajax = new XMLHttpRequest();
+        const ajax = new XMLHttpRequest();
         ajax.upload.addEventListener("progress", event => {
             current = event.loaded / 1000;
             max = event.total / 1000;
@@ -204,29 +201,34 @@ export class Controller {
         }, false);
         ajax.addEventListener("load", () => {
             controller.progressview.removeProgress("ota_upload")
-            controller.reboot();
+            const status = ajax.status;
+            if (status >= 200 && status < 300) {
+                controller.reboot();
+            } else {
+                const statusText = ajax.statusText || "";
+                const body = ajax.responseText || "";
+                toast.error(`OTA update error (${status}${statusText ? ' ' + statusText : ''}): ${body}`);
+            }
         }, false);
         ajax.addEventListener("error", () => {
-            alert("Error ota")
             controller.progressview.removeProgress("ota_upload")
+            toast.error("OTA upload failed due to a network error.");
         }, false);
         ajax.addEventListener("abort", () => {
-            alert("abort ota")
             controller.progressview.removeProgress("ota_upload")
+            toast.error("OTA upload was aborted.");
         }, false);
         ajax.open("POST", PUBLIC_URL + "/ota");
         ajax.send(file);
     }
 
-    version(): Promise<void> {
+    async version(): Promise<void> {
         controller.progressview.addIndeterminate("version", "Getting buildVersion")
-        return fetch(PUBLIC_URL + "/version")
+        const response = await fetch(PUBLIC_URL + "/version");
-            .then(response => response.json())
+        const json = await response.json();
-            .then(json => json as VersionInfo)
+        const versionInfo = json as VersionInfo;
-            .then(versionInfo => {
+        controller.progressview.removeProgress("version");
-                controller.progressview.removeProgress("version")
+        controller.firmWareView.setVersion(versionInfo);
-                controller.firmWareView.setVersion(versionInfo);
-            })
     }
 
     getBackupConfig() {
@@ -243,7 +245,7 @@ export class Controller {
         controller.progressview.addIndeterminate("get_config", "Downloading Config")
         const response = await fetch(PUBLIC_URL + "/get_config");
         const loaded = await response.json();
-        var currentConfig = loaded as PlantControllerConfig;
+        const currentConfig = loaded as PlantControllerConfig;
         controller.setInitialConfig(currentConfig);
         controller.setConfig(currentConfig);
         //sync json view initially
@@ -261,19 +263,20 @@ export class Controller {
             method: "POST",
             body: json,
         })
-            .then(response => response.text())
+          .then(response => response.text())
-            .then(text => statusCallback(text))
+          .then(text => statusCallback(text))
-        controller.progressview.removeProgress("set_config")
+          .then( _ => {
-        //load from remote to be clean
+            controller.progressview.removeProgress("set_config");
-        controller.downloadConfig()
+            setTimeout(() => { controller.downloadConfig() }, 250)
+          })
     }
 
-    backupConfig(json: string): Promise<string> {
+    async backupConfig(json: string): Promise<string> {
-        return fetch(PUBLIC_URL + "/backup_config", {
+        const response = await fetch(PUBLIC_URL + "/backup_config", {
             method: "POST",
             body: json,
-        })
+        });
-            .then(response => response.text());
+        return await response.text();
     }
 
     syncRTCFromBrowser() {
@@ -310,9 +313,9 @@ export class Controller {
     }
 
     testNightLamp(active: boolean) {
-        var body: NightLampCommand = {
+        const body: NightLampCommand = {
             active: active
-        }
+        };
         var pretty = JSON.stringify(body, undefined, 1);
         fetch(PUBLIC_URL + "/lamptest", {
             method: "POST",
@@ -574,4 +577,4 @@ window.addEventListener("beforeunload", (event) => {
         event.returnValue = confirmationMessage; // This will trigger the browser's default dialog
         return confirmationMessage;
     }
-});
+});

rust/src_webpack/src/ota.html

@@ -1,23 +1,27 @@
 <style>
-  .otakey{
+    .otakey {
-    min-width: 100px;
+        min-width: 100px;
-  }
+    }
-  .otavalue{
+
-    flex-grow: 1;
+    .otavalue {
-  }
+        flex-grow: 1;
-  .otaform {
+    }
-    min-width: 100px;
+
-    flex-grow: 1;
+    .otaform {
-  }
+        min-width: 100px;
-  .otachooser {
+        flex-grow: 1;
-    min-width: 100px;
+    }
-    width: 100%;
+
-  }
+    .otachooser {
+        min-width: 100px;
+        width: 100%;
+    }
 </style>
 <div class="flexcontainer">
     <div class="subtitle">
         Current Firmware
     </div>
+    <button style="margin-left: auto;" type="button" id="refresh_firmware_info">Refresh</button>
 </div>
 <div class="flexcontainer">
     <span class="otakey">Buildtime:</span>
@@ -28,14 +32,46 @@
     <span class="otavalue" id="firmware_githash"></span>
 </div>
 <div class="flexcontainer">
-  <span class="otakey">Partition:</span>
+    <span class="otakey">Partition:</span>
-  <span class="otavalue" id="firmware_partition"></span>
+    <span class="otavalue" id="firmware_partition"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">State0:</span>
+    <span class="otavalue" id="firmware_state0"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">State1:</span>
+    <span class="otavalue" id="firmware_state1"></span>
 </div>
 <div class="flexcontainer">
     <form class="otaform" id="upload_form" method="post">
         <input class="otachooser" type="file" name="file1" id="firmware_file"><br>
     </form>
 </div>
+<div class="flexcontainer">
+    <div class="subtitle">
+        Heap Memory
+    </div>
+    <div></div>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Free:</span>
+    <span class="otavalue" id="heap_free"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Used:</span>
+    <span class="otavalue" id="heap_used"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Total:</span>
+    <span class="otavalue" id="heap_total"></span>
+</div>
+<div class="flexcontainer">
+    <span class="otakey">Peak used:</span>
+    <span class="otavalue" id="heap_max_used"></span>
+</div>
+
+
 <div class="display:flex">
     <button style="margin-left: 16px; margin-top: 8px;" class="col-6" type="button" id="test">Self-Test</button>
-</div>
+</div>

rust/src_webpack/src/ota.ts

@@ -1,22 +1,38 @@
-import { Controller } from "./main";
+import {Controller} from "./main";
 import {VersionInfo} from "./api";
 
+function fmtBytes(n: number): string {
+    return `${n} B (${(n / 1024).toFixed(1)} KiB)`;
+}
+
 export class OTAView {
     readonly file1Upload: HTMLInputElement;
     readonly firmware_buildtime: HTMLDivElement;
     readonly firmware_githash: HTMLDivElement;
     readonly firmware_partition: HTMLDivElement;
+    readonly firmware_state0: HTMLDivElement;
+    readonly firmware_state1: HTMLDivElement;
+    readonly heap_free: HTMLDivElement;
+    readonly heap_used: HTMLDivElement;
+    readonly heap_total: HTMLDivElement;
+    readonly heap_max_used: HTMLDivElement;
 
     constructor(controller: Controller) {
         (document.getElementById("firmwareview") as HTMLElement).innerHTML = require("./ota.html")
 
-        let test  = document.getElementById("test") as HTMLButtonElement;
+        let test = document.getElementById("test") as HTMLButtonElement;
+        let refresh = document.getElementById("refresh_firmware_info") as HTMLButtonElement;
 
         this.firmware_buildtime = document.getElementById("firmware_buildtime") as HTMLDivElement;
         this.firmware_githash = document.getElementById("firmware_githash") as HTMLDivElement;
         this.firmware_partition = document.getElementById("firmware_partition") as HTMLDivElement;
+        this.firmware_state0 = document.getElementById("firmware_state0") as HTMLDivElement;
+        this.firmware_state1 = document.getElementById("firmware_state1") as HTMLDivElement;
+        this.heap_free = document.getElementById("heap_free") as HTMLDivElement;
+        this.heap_used = document.getElementById("heap_used") as HTMLDivElement;
+        this.heap_total = document.getElementById("heap_total") as HTMLDivElement;
+        this.heap_max_used = document.getElementById("heap_max_used") as HTMLDivElement;
 
-        
         const file = document.getElementById("firmware_file") as HTMLInputElement;
         this.file1Upload = file
         this.file1Upload.onchange = () => {
@@ -31,11 +47,21 @@ export class OTAView {
         test.onclick = () => {
             controller.selfTest();
         }
+
+        refresh.onclick = () => {
+            controller.version();
+        }
     }
 
     setVersion(versionInfo: VersionInfo) {
         this.firmware_buildtime.innerText = versionInfo.build_time;
         this.firmware_githash.innerText = versionInfo.git_hash;
-        this.firmware_partition.innerText = versionInfo.partition;
+        this.firmware_partition.innerText = versionInfo.current;
+        this.firmware_state0.innerText = versionInfo.slot0_state;
+        this.firmware_state1.innerText = versionInfo.slot1_state;
+        this.heap_free.innerText = fmtBytes(versionInfo.heap_free);
+        this.heap_used.innerText = fmtBytes(versionInfo.heap_used);
+        this.heap_total.innerText = fmtBytes(versionInfo.heap_total);
+        this.heap_max_used.innerText = fmtBytes(versionInfo.heap_max_used);
     }
-}
+}

rust/src_webpack/src/toast.ts

@@ -0,0 +1,94 @@
+class ToastService {
+  private container: HTMLElement;
+  private stylesInjected = false;
+
+  constructor() {
+    this.container = this.ensureContainer();
+    this.injectStyles();
+  }
+
+  info(message: string, timeoutMs: number = 5000) {
+    const el = this.createToast(message, 'info');
+    this.container.appendChild(el);
+    // Auto-dismiss after timeout
+    const timer = window.setTimeout(() => this.dismiss(el), timeoutMs);
+    // Dismiss on click immediately
+    el.addEventListener('click', () => {
+      window.clearTimeout(timer);
+      this.dismiss(el);
+    });
+  }
+
+  error(message: string) {
+    console.error(message);
+    const el = this.createToast(message, 'error');
+    this.container.appendChild(el);
+    // Only dismiss on click
+    el.addEventListener('click', () => this.dismiss(el));
+  }
+
+  private dismiss(el: HTMLElement) {
+    if (!el.parentElement) return;
+    el.parentElement.removeChild(el);
+  }
+
+  private createToast(message: string, type: 'info' | 'error'): HTMLElement {
+    const div = document.createElement('div');
+    div.className = `toast ${type}`;
+    div.textContent = message;
+    div.setAttribute('role', 'status');
+    div.setAttribute('aria-live', 'polite');
+    return div;
+  }
+
+  private ensureContainer(): HTMLElement {
+    let container = document.getElementById('toast-container');
+    if (!container) {
+      container = document.createElement('div');
+      container.id = 'toast-container';
+      document.body.appendChild(container);
+    }
+    return container;
+  }
+
+  private injectStyles() {
+    if (this.stylesInjected) return;
+    const style = document.createElement('style');
+    style.textContent = `
+#toast-container {
+  position: fixed;
+  top: 12px;
+  right: 12px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  z-index: 9999;
+}
+.toast {
+  max-width: 320px;
+  padding: 10px 12px;
+  border-radius: 6px;
+  box-shadow: 0 2px 6px rgba(0,0,0,0.2);
+  cursor: pointer;
+  user-select: none;
+  font-family: sans-serif;
+  font-size: 14px;
+  line-height: 1.3;
+}
+.toast.info {
+  background-color: #d4edda; /* green-ish */
+  color: #155724;
+  border-left: 4px solid #28a745;
+}
+.toast.error {
+  background-color: #f8d7da; /* red-ish */
+  color: #721c24;
+  border-left: 4px solid #dc3545;
+}
+`;
+    document.head.appendChild(style);
+    this.stylesInjected = true;
+  }
+}
+
+export const toast = new ToastService();

rust/src_webpack/webpack.config.js

@@ -3,54 +3,60 @@ const path = require('path');
 const HtmlWebpackPlugin = require('html-webpack-plugin');
 const HtmlWebpackHarddiskPlugin = require('html-webpack-harddisk-plugin');
 const CopyPlugin = require("copy-webpack-plugin");
+const CompressionPlugin = require("compression-webpack-plugin");
 
 const isDevServer = process.env.WEBPACK_SERVE;
 console.log("Dev server is " + isDevServer);
 var host;
-if (isDevServer){
+if (isDevServer) {
-  //ensure no trailing /
+    //ensure no trailing /
-  host = 'http://10.23.44.186';
+    host = 'http://10.23.44.186';
 } else {
-  host = '';
+    host = '';
 }
 
 module.exports = {
-  mode: "development",
+    mode: "development",
-  entry: ['./src/main.ts'],
+    entry: ['./src/main.ts'],
-  devtool: 'inline-source-map',
+    devtool: 'inline-source-map',
-  plugins: [
+    plugins: [
-    new webpack.DefinePlugin({
+        new webpack.DefinePlugin({
-      PUBLIC_URL: JSON.stringify(host),
+            PUBLIC_URL: JSON.stringify(host),
-    }),
+        }),
-    new webpack.EnvironmentPlugin({
+        new webpack.EnvironmentPlugin({
-      redirect: 'true'
+            redirect: 'true'
-    }),
+        }),
-    new HtmlWebpackPlugin({
+        new HtmlWebpackPlugin({
-      alwaysWriteToDisk: true,
+            alwaysWriteToDisk: true,
-      title: "PlantCtrl",
+            title: "PlantCtrl",
-    }),
+        }),
-    new HtmlWebpackHarddiskPlugin(),
+        new HtmlWebpackHarddiskPlugin(),
-  ],
+        new CompressionPlugin({
-  module: {
+            algorithm: "gzip",
-    rules: [
+            test: /\.js$|\.css$|\.html$/,
-      {
+            threshold: 0,
-      test: /\.html$/,
+            minRatio: 0.8
-      type: 'asset/source',
+        })
-      },
+    ],
-      {
+    module: {
-        test: /\.tsx?$/,
+        rules: [
-        use: 'ts-loader',
+            {
-        exclude: /node_modules/,
+                test: /\.html$/,
-      }
+                type: 'asset/source',
-    ]
+            },
-  },
+            {
-  resolve: {
+                test: /\.tsx?$/,
-    extensions: ['.tsx', '.ts', '.js', '.html'],
+                use: 'ts-loader',
-  },
+                exclude: /node_modules/,
-  output: {
+            }
-    filename: 'bundle.js',
+        ]
-    path: path.resolve(__dirname, '.'),
+    },
-  },
+    resolve: {
-  devServer: {
+        extensions: ['.tsx', '.ts', '.js', '.html'],
-  }
+    },
+    output: {
+        filename: 'bundle.js',
+        path: path.resolve(__dirname, '.'),
+    },
+    devServer: {}
 };