Add missing Box import in battery module

clippy fixed
Refactor formatting and remove unused imports in mqtt and plant_state modules
2026-05-30 21:01:29 +02:00 · 2026-05-30 20:59:58 +02:00 · 2026-05-30 20:57:39 +02:00 · 2026-05-30 20:57:31 +02:00 · 2026-05-30 20:55:51 +02:00 · 2026-05-29 11:22:12 +02:00
94 changed files with 39988 additions and 5240 deletions
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -0,0 +1,62 @@
+# AGENTS.md
+
+## Scope
+These instructions apply to the entire repository unless a deeper `AGENTS.md` overrides them.
+
+## Repository Overview
+`PlantCtrl` is a mixed-discipline repository with embedded firmware, shared Rust crates, hardware design files, and a Hugo-based website.
+
+Top-level layout:
+- `Software/MainBoard/rust`: main embedded Rust firmware for the controller board (`plant-ctrl2`).
+- `Software/CAN_Sensor`: embedded Rust firmware for the CAN sensor / BMS board.
+- `Software/Shared/canapi`: shared Rust crate used by firmware projects.
+- `Hardware`: PCB, case, and related hardware design assets.
+- `DataSheets`: reference material; treat as source data, not generated output.
+- `website`: Hugo site based on the Blowfish theme.
+- `bin`: helper scripts and local tooling, if present.
+
+## Working Rules
+- Keep changes tightly scoped to the user request; this repo spans hardware, firmware, and website code.
+- Prefer fixing the underlying cause instead of applying cosmetic workarounds.
+- Preserve existing file structure and naming unless the user explicitly asks for restructuring.
+- Avoid mass formatting or opportunistic cleanup in KiCad files, lockfiles, generated assets, or vendored dependencies.
+- Do not edit dependency directories such as `website/themes` or `Software/MainBoard/rust/src_webpack/node_modules` unless the user explicitly asks for vendor changes.
+- When touching firmware code, keep resource usage and target constraints in mind; avoid unnecessary allocations or feature creep.
+
+## Firmware Guidance
+- Shared protocol or serialization changes must be checked for impact across both `Software/MainBoard/rust` and `Software/CAN_Sensor`.
+- Prefer small, explicit changes in embedded code paths; do not introduce heavyweight abstractions without a clear payoff.
+- Keep `no_std`/embedded assumptions intact unless the code clearly opts into something else.
+- Be careful with feature flags, target-specific dependencies, and boot/runtime configuration in Cargo manifests.
+
+## Hardware Guidance
+- Treat hardware directories as design artifacts, not generic text files.
+- Do not reorder, normalize, or bulk-edit PCB / CAD files unless the user specifically requests those changes.
+- If a software change depends on hardware assumptions, call that out clearly in the final handoff.
+
+## Website Guidance
+- The site in `website` uses Hugo with the Blowfish theme.
+- Prefer editing site content, config, or custom assets over modifying vendored theme internals.
+- Keep frontend changes consistent with the existing site structure unless the user asks for a redesign.
+
+## Validation
+Use the narrowest relevant check first.
+
+Useful commands:
+- `cargo check --manifest-path Software/Shared/canapi/Cargo.toml`
+- `cargo check --manifest-path Software/CAN_Sensor/Cargo.toml`
+- `cargo check --manifest-path Software/MainBoard/rust/Cargo.toml`
+- `npm run dev` from `website` for local Hugo development if the environment has the required tools installed.
+
+Validation notes:
+- Embedded firmware may require target-specific toolchains or hardware-adjacent tooling that is not always available.
+- If you cannot run a meaningful validation step, say so explicitly and describe the likely prerequisite.
+
+## File Hygiene
+- Read large files in chunks.
+- Prefer targeted searches (`rg`, or `find` if unavailable) over broad scans.
+- Do not commit build outputs, generated binaries, or local IDE metadata unless the user explicitly requests it.
+
+## Handoff Expectations
+- Summarize what changed, where it changed, and any validation performed.
+- Call out follow-up work when a change likely affects both firmware targets, hardware assumptions, or the website.
--- a/Hardware/Controller/MPPT/MPPT.kicad_prl
+++ b/Hardware/Controller/MPPT/MPPT.kicad_prl
@@ -15,6 +15,7 @@
      "vias": 1.0,
      "zones": 0.6
    },
+    "prototype_zone_fills": false,
    "selection_filter": {
      "dimensions": true,
      "footprints": true,
@@ -53,6 +54,7 @@
    "zone_display_mode": 1
  },
  "git": {
+    "integration_disabled": false,
    "repo_type": "",
    "repo_username": "",
    "ssh_key": ""
@@ -105,6 +107,7 @@
    "filter_text": "",
    "group_by_constraint": false,
    "group_by_netclass": false,
+    "show_time_domain_details": false,
    "show_unconnected_nets": false,
    "show_zero_pad_nets": false,
    "sort_ascending": true,
@@ -115,6 +118,7 @@
    "files": []
  },
  "schematic": {
+    "hierarchy_collapsed": [],
    "selection_filter": {
      "graphics": true,
      "images": true,
@@ -122,6 +126,7 @@
      "lockedItems": false,
      "otherItems": true,
      "pins": true,
+      "ruleAreas": true,
      "symbols": true,
      "text": true,
      "wires": true
--- a/Hardware/Controller/MPPT/MPPT.kicad_pro
+++ b/Hardware/Controller/MPPT/MPPT.kicad_pro
@@ -3,6 +3,8 @@
    "3dviewports": [],
    "design_settings": {
      "defaults": {
+        "apply_defaults_to_fp_barcodes": false,
+        "apply_defaults_to_fp_dimensions": false,
        "apply_defaults_to_fp_fields": false,
        "apply_defaults_to_fp_shapes": false,
        "apply_defaults_to_fp_text": false,
@@ -82,6 +84,7 @@
        "extra_footprint": "warning",
        "footprint": "error",
        "footprint_filters_mismatch": "ignore",
+        "footprint_symbol_field_mismatch": "warning",
        "footprint_symbol_mismatch": "warning",
        "footprint_type_mismatch": "ignore",
        "hole_clearance": "error",
@@ -99,6 +102,7 @@
        "mirrored_text_on_front_layer": "warning",
        "missing_courtyard": "ignore",
        "missing_footprint": "warning",
+        "missing_tuning_profile": "warning",
        "net_conflict": "warning",
        "nonmirrored_text_on_back_layer": "warning",
        "npth_inside_courtyard": "ignore",
@@ -118,9 +122,12 @@
        "too_many_vias": "error",
        "track_angle": "error",
        "track_dangling": "warning",
+        "track_not_centered_on_via": "ignore",
+        "track_on_post_machined_layer": "error",
        "track_segment_length": "error",
        "track_width": "error",
        "tracks_crossing": "error",
+        "tuning_profile_track_geometries": "ignore",
        "unconnected_items": "error",
        "unresolved_variable": "error",
        "via_dangling": "warning",
@@ -235,17 +242,28 @@
      "zones_allow_external_fillets": false
    },
    "ipc2581": {
+      "bom_rev": "",
      "dist": "",
      "distpn": "",
      "internal_id": "",
      "mfg": "",
-      "mpn": ""
+      "mpn": "",
+      "sch_revision": ""
    },
    "layer_pairs": [],
    "layer_presets": [],
    "viewports": []
  },
  "boards": [],
+  "component_class_settings": {
+    "assignments": [],
+    "meta": {
+      "version": 0
+    },
+    "sheet_component_classes": {
+      "enabled": false
+    }
+  },
  "cvpcb": {
    "equivalence_files": []
  },
@@ -494,13 +512,14 @@
        "priority": 2147483647,
        "schematic_color": "rgba(0, 0, 0, 0.000)",
        "track_width": 0.2,
+        "tuning_profile": "",
        "via_diameter": 0.6,
        "via_drill": 0.3,
        "wire_width": 6
      }
    ],
    "meta": {
-      "version": 4
+      "version": 5
    },
    "net_colors": null,
    "netclass_assignments": null,
@@ -683,6 +702,7 @@
      "sort_asc": true,
      "sort_field": "Reference"
    },
+    "bus_aliases": {},
    "connection_grid_size": 50.0,
    "drawing": {
      "dashed_lines_dash_length_ratio": 12.0,
@@ -721,7 +741,14 @@
    "spice_save_all_dissipations": false,
    "spice_save_all_voltages": false,
    "subpart_first_id": 65,
-    "subpart_id_separator": 0
+    "subpart_id_separator": 0,
+    "top_level_sheets": [
+      {
+        "filename": "MPPT.kicad_sch",
+        "name": "MPPT",
+        "uuid": "00000000-0000-0000-0000-000000000000"
+      }
+    ]
  },
  "sheets": [
    [
@@ -729,5 +756,11 @@
      "Root"
    ]
  ],
-  "text_variables": {}
+  "text_variables": {},
+  "tuning_profiles": {
+    "meta": {
+      "version": 0
+    },
+    "tuning_profiles_impedance_geometric": []
+  }
 }
--- a/Hardware/Controller/MainBoard/PlantCtrlESP32.kicad_prl
+++ b/Hardware/Controller/MainBoard/PlantCtrlESP32.kicad_prl
@@ -15,6 +15,7 @@
      "vias": 1.0,
      "zones": 0.6
    },
+    "prototype_zone_fills": false,
    "ratsnest_display_mode": 0,
    "selection_filter": {
      "dimensions": true,
@@ -54,6 +55,7 @@
    "zone_display_mode": 1
  },
  "git": {
+    "integration_disabled": false,
    "repo_password": "",
    "repo_type": "",
    "repo_username": "",
@@ -113,6 +115,7 @@
    "filter_text": "",
    "group_by_constraint": false,
    "group_by_netclass": false,
+    "show_time_domain_details": false,
    "show_unconnected_nets": false,
    "show_zero_pad_nets": false,
    "sort_ascending": true,
@@ -123,6 +126,7 @@
    "files": []
  },
  "schematic": {
+    "hierarchy_collapsed": [],
    "selection_filter": {
      "graphics": true,
      "images": true,
@@ -130,6 +134,7 @@
      "lockedItems": false,
      "otherItems": true,
      "pins": true,
+      "ruleAreas": true,
      "symbols": true,
      "text": true,
      "wires": true
--- a/Hardware/Controller/MainBoard/PlantCtrlESP32.kicad_pro
+++ b/Hardware/Controller/MainBoard/PlantCtrlESP32.kicad_pro
@@ -3,6 +3,8 @@
    "3dviewports": [],
    "design_settings": {
      "defaults": {
+        "apply_defaults_to_fp_barcodes": false,
+        "apply_defaults_to_fp_dimensions": false,
        "apply_defaults_to_fp_fields": false,
        "apply_defaults_to_fp_shapes": false,
        "apply_defaults_to_fp_text": false,
@@ -78,6 +80,7 @@
        "extra_footprint": "warning",
        "footprint": "error",
        "footprint_filters_mismatch": "ignore",
+        "footprint_symbol_field_mismatch": "warning",
        "footprint_symbol_mismatch": "warning",
        "footprint_type_mismatch": "warning",
        "hole_clearance": "error",
@@ -96,6 +99,7 @@
        "mirrored_text_on_front_layer": "warning",
        "missing_courtyard": "ignore",
        "missing_footprint": "warning",
+        "missing_tuning_profile": "warning",
        "net_conflict": "warning",
        "nonmirrored_text_on_back_layer": "warning",
        "npth_inside_courtyard": "ignore",
@@ -115,9 +119,12 @@
        "too_many_vias": "error",
        "track_angle": "error",
        "track_dangling": "warning",
+        "track_not_centered_on_via": "ignore",
+        "track_on_post_machined_layer": "error",
        "track_segment_length": "error",
        "track_width": "error",
        "tracks_crossing": "error",
+        "tuning_profile_track_geometries": "ignore",
        "unconnected_items": "error",
        "unresolved_variable": "error",
        "via_dangling": "warning",
@@ -242,17 +249,28 @@
      "zones_use_no_outline": true
    },
    "ipc2581": {
+      "bom_rev": "",
      "dist": "",
      "distpn": "",
      "internal_id": "",
      "mfg": "",
-      "mpn": ""
+      "mpn": "",
+      "sch_revision": ""
    },
    "layer_pairs": [],
    "layer_presets": [],
    "viewports": []
  },
  "boards": [],
+  "component_class_settings": {
+    "assignments": [],
+    "meta": {
+      "version": 0
+    },
+    "sheet_component_classes": {
+      "enabled": false
+    }
+  },
  "cvpcb": {
    "equivalence_files": []
  },
@@ -443,11 +461,14 @@
      "duplicate_sheet_names": "error",
      "endpoint_off_grid": "ignore",
      "extra_units": "error",
+      "field_name_whitespace": "warning",
      "footprint_filter": "ignore",
      "footprint_link_issues": "warning",
      "four_way_junction": "ignore",
      "global_label_dangling": "warning",
+      "ground_pin_not_ground": "warning",
      "hier_label_mismatch": "error",
+      "isolated_pin_label": "warning",
      "label_dangling": "error",
      "label_multiple_wires": "warning",
      "lib_symbol_issues": "warning",
@@ -470,6 +491,7 @@
      "similar_power": "warning",
      "simulation_model_issue": "ignore",
      "single_global_label": "warning",
+      "stacked_pin_name": "warning",
      "unannotated": "error",
      "unconnected_wire_endpoint": "warning",
      "undefined_netclass": "error",
@@ -502,6 +524,7 @@
        "priority": 2147483647,
        "schematic_color": "rgba(0, 0, 0, 0.000)",
        "track_width": 1.2,
+        "tuning_profile": "",
        "via_diameter": 0.8,
        "via_drill": 0.4,
        "wire_width": 6
@@ -520,6 +543,7 @@
        "priority": 0,
        "schematic_color": "rgb(255, 4, 6)",
        "track_width": 1.0,
+        "tuning_profile": "",
        "via_diameter": 0.8,
        "via_drill": 0.4,
        "wire_width": 12
@@ -538,6 +562,7 @@
        "priority": 1,
        "schematic_color": "rgb(255, 153, 0)",
        "track_width": 0.2,
+        "tuning_profile": "",
        "via_diameter": 0.8,
        "via_drill": 0.4,
        "wire_width": 12
@@ -556,6 +581,7 @@
        "priority": 2,
        "schematic_color": "rgb(81, 255, 3)",
        "track_width": 1.2,
+        "tuning_profile": "",
        "via_diameter": 0.8,
        "via_drill": 0.4,
        "wire_width": 12
@@ -574,6 +600,7 @@
        "priority": 3,
        "schematic_color": "rgb(130, 130, 130)",
        "track_width": 1.2,
+        "tuning_profile": "",
        "via_diameter": 0.8,
        "via_drill": 0.4,
        "wire_width": 12
@@ -592,13 +619,14 @@
        "priority": 4,
        "schematic_color": "rgb(0, 0, 0)",
        "track_width": 0.5,
+        "tuning_profile": "",
        "via_diameter": 0.8,
        "via_drill": 0.4,
        "wire_width": 12
      }
    ],
    "meta": {
-      "version": 4
+      "version": 5
    },
    "net_colors": null,
    "netclass_assignments": null,
@@ -1077,6 +1105,10 @@
  },
  "schematic": {
    "annotate_start_num": 0,
+    "annotation": {
+      "method": 0,
+      "sort_order": 0
+    },
    "bom_export_filename": "PlantCtrlESP32.csv",
    "bom_fmt_presets": [],
    "bom_fmt_settings": {
@@ -1256,6 +1288,7 @@
      "sort_asc": true,
      "sort_field": "LCSC_PART_NUMBER"
    },
+    "bus_aliases": {},
    "connection_grid_size": 50.0,
    "drawing": {
      "dashed_lines_dash_length_ratio": 12.0,
@@ -1263,6 +1296,7 @@
      "default_line_thickness": 6.0,
      "default_text_size": 50.0,
      "field_names": [],
+      "hop_over_size_choice": 0,
      "intersheets_ref_own_page": false,
      "intersheets_ref_prefix": "",
      "intersheets_ref_short": false,
@@ -1295,6 +1329,7 @@
    },
    "page_layout_descr_file": "",
    "plot_directory": "/tmp/",
+    "reuse_designators": true,
    "space_save_all_events": true,
    "spice_adjust_passive_values": false,
    "spice_current_sheet_as_root": false,
@@ -1304,7 +1339,16 @@
    "spice_save_all_dissipations": false,
    "spice_save_all_voltages": false,
    "subpart_first_id": 65,
-    "subpart_id_separator": 0
+    "subpart_id_separator": 0,
+    "top_level_sheets": [
+      {
+        "filename": "PlantCtrlESP32.kicad_sch",
+        "name": "PlantCtrlESP32",
+        "uuid": "00000000-0000-0000-0000-000000000000"
+      }
+    ],
+    "used_designators": "",
+    "variants": []
  },
  "sheets": [
    [
@@ -1312,5 +1356,11 @@
      "Root"
    ]
  ],
-  "text_variables": {}
+  "text_variables": {},
+  "tuning_profiles": {
+    "meta": {
+      "version": 0
+    },
+    "tuning_profiles_impedance_geometric": []
+  }
 }
--- a/Hardware/Controller/PumpOutput/PumpOutput.kicad_prl
+++ b/Hardware/Controller/PumpOutput/PumpOutput.kicad_prl
@@ -15,6 +15,7 @@
      "vias": 1.0,
      "zones": 0.6
    },
+    "prototype_zone_fills": false,
    "selection_filter": {
      "dimensions": true,
      "footprints": true,
@@ -53,6 +54,7 @@
    "zone_display_mode": 0
  },
  "git": {
+    "integration_disabled": false,
    "repo_type": "",
    "repo_username": "",
    "ssh_key": ""
@@ -105,6 +107,7 @@
    "filter_text": "",
    "group_by_constraint": false,
    "group_by_netclass": false,
+    "show_time_domain_details": false,
    "show_unconnected_nets": false,
    "show_zero_pad_nets": false,
    "sort_ascending": true,
@@ -115,6 +118,7 @@
    "files": []
  },
  "schematic": {
+    "hierarchy_collapsed": [],
    "selection_filter": {
      "graphics": true,
      "images": true,
@@ -122,6 +126,7 @@
      "lockedItems": false,
      "otherItems": true,
      "pins": true,
+      "ruleAreas": true,
      "symbols": true,
      "text": true,
      "wires": true
--- a/Hardware/Controller/PumpOutput/PumpOutput.kicad_pro
+++ b/Hardware/Controller/PumpOutput/PumpOutput.kicad_pro
@@ -3,6 +3,8 @@
    "3dviewports": [],
    "design_settings": {
      "defaults": {
+        "apply_defaults_to_fp_barcodes": false,
+        "apply_defaults_to_fp_dimensions": false,
        "apply_defaults_to_fp_fields": false,
        "apply_defaults_to_fp_shapes": false,
        "apply_defaults_to_fp_text": false,
@@ -82,6 +84,7 @@
        "extra_footprint": "warning",
        "footprint": "error",
        "footprint_filters_mismatch": "ignore",
+        "footprint_symbol_field_mismatch": "warning",
        "footprint_symbol_mismatch": "warning",
        "footprint_type_mismatch": "warning",
        "hole_clearance": "error",
@@ -99,6 +102,7 @@
        "mirrored_text_on_front_layer": "warning",
        "missing_courtyard": "ignore",
        "missing_footprint": "warning",
+        "missing_tuning_profile": "warning",
        "net_conflict": "warning",
        "nonmirrored_text_on_back_layer": "warning",
        "npth_inside_courtyard": "ignore",
@@ -118,9 +122,12 @@
        "too_many_vias": "error",
        "track_angle": "error",
        "track_dangling": "warning",
+        "track_not_centered_on_via": "ignore",
+        "track_on_post_machined_layer": "error",
        "track_segment_length": "error",
        "track_width": "error",
        "tracks_crossing": "error",
+        "tuning_profile_track_geometries": "ignore",
        "unconnected_items": "error",
        "unresolved_variable": "error",
        "via_dangling": "warning",
@@ -236,17 +243,28 @@
      "zones_allow_external_fillets": false
    },
    "ipc2581": {
+      "bom_rev": "",
      "dist": "",
      "distpn": "",
      "internal_id": "",
      "mfg": "",
-      "mpn": ""
+      "mpn": "",
+      "sch_revision": ""
    },
    "layer_pairs": [],
    "layer_presets": [],
    "viewports": []
  },
  "boards": [],
+  "component_class_settings": {
+    "assignments": [],
+    "meta": {
+      "version": 0
+    },
+    "sheet_component_classes": {
+      "enabled": false
+    }
+  },
  "cvpcb": {
    "equivalence_files": []
  },
@@ -495,13 +513,14 @@
        "priority": 2147483647,
        "schematic_color": "rgba(0, 0, 0, 0.000)",
        "track_width": 0.2,
+        "tuning_profile": "",
        "via_diameter": 0.6,
        "via_drill": 0.3,
        "wire_width": 6
      }
    ],
    "meta": {
-      "version": 4
+      "version": 5
    },
    "net_colors": null,
    "netclass_assignments": null,
@@ -629,6 +648,7 @@
      "sort_asc": true,
      "sort_field": "Reference"
    },
+    "bus_aliases": {},
    "connection_grid_size": 50.0,
    "drawing": {
      "dashed_lines_dash_length_ratio": 12.0,
@@ -667,7 +687,14 @@
    "spice_save_all_dissipations": false,
    "spice_save_all_voltages": false,
    "subpart_first_id": 65,
-    "subpart_id_separator": 0
+    "subpart_id_separator": 0,
+    "top_level_sheets": [
+      {
+        "filename": "PumpOutput.kicad_sch",
+        "name": "PumpOutput",
+        "uuid": "00000000-0000-0000-0000-000000000000"
+      }
+    ]
  },
  "sheets": [
    [
@@ -675,5 +702,11 @@
      "Root"
    ]
  ],
-  "text_variables": {}
+  "text_variables": {},
+  "tuning_profiles": {
+    "meta": {
+      "version": 0
+    },
+    "tuning_profiles_impedance_geometric": []
+  }
 }
--- a/Hardware/Controller_Case/flap_v2.3mf
+++ b/Hardware/Controller_Case/flap_v2.3mf
--- a/Hardware/Sensor/sensor.kicad_prl
+++ b/Hardware/Sensor/sensor.kicad_prl
@@ -15,6 +15,7 @@
      "vias": 1.0,
      "zones": 0.6
    },
+    "prototype_zone_fills": false,
    "selection_filter": {
      "dimensions": true,
      "footprints": true,
@@ -54,6 +55,7 @@
    "zone_display_mode": 0
  },
  "git": {
+    "integration_disabled": false,
    "repo_type": "",
    "repo_username": "",
    "ssh_key": ""
@@ -106,6 +108,7 @@
    "filter_text": "",
    "group_by_constraint": false,
    "group_by_netclass": false,
+    "show_time_domain_details": false,
    "show_unconnected_nets": false,
    "show_zero_pad_nets": false,
    "sort_ascending": true,
@@ -116,6 +119,7 @@
    "files": []
  },
  "schematic": {
+    "hierarchy_collapsed": [],
    "selection_filter": {
      "graphics": true,
      "images": true,
@@ -123,6 +127,7 @@
      "lockedItems": false,
      "otherItems": true,
      "pins": true,
+      "ruleAreas": true,
      "symbols": true,
      "text": true,
      "wires": true
--- a/Hardware/Sensor/sensor.kicad_pro
+++ b/Hardware/Sensor/sensor.kicad_pro
@@ -3,6 +3,8 @@
    "3dviewports": [],
    "design_settings": {
      "defaults": {
+        "apply_defaults_to_fp_barcodes": false,
+        "apply_defaults_to_fp_dimensions": false,
        "apply_defaults_to_fp_fields": false,
        "apply_defaults_to_fp_shapes": false,
        "apply_defaults_to_fp_text": false,
@@ -77,6 +79,7 @@
        "extra_footprint": "warning",
        "footprint": "error",
        "footprint_filters_mismatch": "warning",
+        "footprint_symbol_field_mismatch": "warning",
        "footprint_symbol_mismatch": "warning",
        "footprint_type_mismatch": "warning",
        "hole_clearance": "error",
@@ -94,6 +97,7 @@
        "mirrored_text_on_front_layer": "warning",
        "missing_courtyard": "warning",
        "missing_footprint": "warning",
+        "missing_tuning_profile": "warning",
        "net_conflict": "warning",
        "nonmirrored_text_on_back_layer": "warning",
        "npth_inside_courtyard": "warning",
@@ -113,9 +117,12 @@
        "too_many_vias": "error",
        "track_angle": "error",
        "track_dangling": "warning",
+        "track_not_centered_on_via": "ignore",
+        "track_on_post_machined_layer": "error",
        "track_segment_length": "error",
        "track_width": "error",
        "tracks_crossing": "error",
+        "tuning_profile_track_geometries": "ignore",
        "unconnected_items": "error",
        "unresolved_variable": "error",
        "via_dangling": "warning",
@@ -227,17 +234,28 @@
      "zones_allow_external_fillets": false
    },
    "ipc2581": {
+      "bom_rev": "",
      "dist": "",
      "distpn": "",
      "internal_id": "",
      "mfg": "",
-      "mpn": ""
+      "mpn": "",
+      "sch_revision": ""
    },
    "layer_pairs": [],
    "layer_presets": [],
    "viewports": []
  },
  "boards": [],
+  "component_class_settings": {
+    "assignments": [],
+    "meta": {
+      "version": 0
+    },
+    "sheet_component_classes": {
+      "enabled": false
+    }
+  },
  "cvpcb": {
    "equivalence_files": []
  },
@@ -486,13 +504,14 @@
        "priority": 2147483647,
        "schematic_color": "rgba(0, 0, 0, 0.000)",
        "track_width": 0.2,
+        "tuning_profile": "",
        "via_diameter": 0.6,
        "via_drill": 0.3,
        "wire_width": 6
      }
    ],
    "meta": {
-      "version": 4
+      "version": 5
    },
    "net_colors": null,
    "netclass_assignments": null,
@@ -861,6 +880,7 @@
      "sort_asc": true,
      "sort_field": "Reference"
    },
+    "bus_aliases": {},
    "connection_grid_size": 50.0,
    "drawing": {
      "dashed_lines_dash_length_ratio": 12.0,
@@ -899,7 +919,14 @@
    "spice_save_all_dissipations": false,
    "spice_save_all_voltages": false,
    "subpart_first_id": 65,
-    "subpart_id_separator": 0
+    "subpart_id_separator": 0,
+    "top_level_sheets": [
+      {
+        "filename": "sensor.kicad_sch",
+        "name": "sensor",
+        "uuid": "00000000-0000-0000-0000-000000000000"
+      }
+    ]
  },
  "sheets": [
    [
@@ -907,5 +934,11 @@
      "Root"
    ]
  ],
-  "text_variables": {}
+  "text_variables": {},
+  "tuning_profiles": {
+    "meta": {
+      "version": 0
+    },
+    "tuning_profiles_impedance_geometric": []
+  }
 }
--- a/Hardware/open-bms/bms/bms.kicad_pcb
+++ b/Hardware/open-bms/bms/bms.kicad_pcb
--- a/Hardware/open-bms/bms/bms.kicad_prl
+++ b/Hardware/open-bms/bms/bms.kicad_prl
@@ -2,7 +2,7 @@
  "board": {
    "active_layer": 0,
    "active_layer_preset": "",
-    "auto_track_width": true,
+    "auto_track_width": false,
    "hidden_netclasses": [],
    "hidden_nets": [],
    "high_contrast_mode": 0,
@@ -15,6 +15,7 @@
      "vias": 1.0,
      "zones": 0.6
    },
+    "prototype_zone_fills": false,
    "selection_filter": {
      "dimensions": true,
      "footprints": true,
@@ -54,6 +55,7 @@
    "zone_display_mode": 0
  },
  "git": {
+    "integration_disabled": false,
    "repo_type": "",
    "repo_username": "",
    "ssh_key": ""
@@ -63,8 +65,30 @@
    "version": 5
  },
  "net_inspector_panel": {
-    "col_hidden": [],
-    "col_order": [],
+    "col_hidden": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ],
+    "col_order": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9
+    ],
    "col_widths": [],
    "custom_group_rules": [],
    "expanded_rows": [],
@@ -73,6 +97,7 @@
    "filter_text": "",
    "group_by_constraint": false,
    "group_by_netclass": false,
+    "show_time_domain_details": false,
    "show_unconnected_nets": false,
    "show_zero_pad_nets": false,
    "sort_ascending": true,
@@ -83,6 +108,7 @@
    "files": []
  },
  "schematic": {
+    "hierarchy_collapsed": [],
    "selection_filter": {
      "graphics": true,
      "images": true,
@@ -90,6 +116,7 @@
      "lockedItems": false,
      "otherItems": true,
      "pins": true,
+      "ruleAreas": true,
      "symbols": true,
      "text": true,
      "wires": true
--- a/Hardware/open-bms/bms/bms.kicad_pro
+++ b/Hardware/open-bms/bms/bms.kicad_pro
@@ -2,25 +2,278 @@
  "board": {
    "3dviewports": [],
    "design_settings": {
-      "defaults": {},
-      "diff_pair_dimensions": [],
+      "defaults": {
+        "apply_defaults_to_fp_barcodes": false,
+        "apply_defaults_to_fp_dimensions": false,
+        "apply_defaults_to_fp_fields": false,
+        "apply_defaults_to_fp_shapes": false,
+        "apply_defaults_to_fp_text": false,
+        "board_outline_line_width": 0.05,
+        "copper_line_width": 0.2,
+        "copper_text_italic": false,
+        "copper_text_size_h": 1.5,
+        "copper_text_size_v": 1.5,
+        "copper_text_thickness": 0.3,
+        "copper_text_upright": false,
+        "courtyard_line_width": 0.05,
+        "dimension_precision": 4,
+        "dimension_units": 3,
+        "dimensions": {
+          "arrow_length": 1270000,
+          "extension_offset": 500000,
+          "keep_text_aligned": true,
+          "suppress_zeroes": true,
+          "text_position": 0,
+          "units_format": 0
+        },
+        "fab_line_width": 0.1,
+        "fab_text_italic": false,
+        "fab_text_size_h": 1.0,
+        "fab_text_size_v": 1.0,
+        "fab_text_thickness": 0.15,
+        "fab_text_upright": false,
+        "other_line_width": 0.1,
+        "other_text_italic": false,
+        "other_text_size_h": 1.0,
+        "other_text_size_v": 1.0,
+        "other_text_thickness": 0.15,
+        "other_text_upright": false,
+        "pads": {
+          "drill": 0.8,
+          "height": 1.27,
+          "width": 2.54
+        },
+        "silk_line_width": 0.1,
+        "silk_text_italic": false,
+        "silk_text_size_h": 1.0,
+        "silk_text_size_v": 1.0,
+        "silk_text_thickness": 0.1,
+        "silk_text_upright": false,
+        "zones": {
+          "border_display_style": 2,
+          "border_hatch_pitch": 0.5,
+          "corner_radius": 0.0,
+          "corner_smoothing": 0,
+          "fill_mode": 0,
+          "hatch_gap": 1.5,
+          "hatch_orientation": 0.0,
+          "hatch_smoothing_level": 0,
+          "hatch_smoothing_value": 0.1,
+          "hatch_thickness": 1.0,
+          "min_clearance": 0.5,
+          "min_island_area": 10.0,
+          "min_thickness": 0.25,
+          "pad_connection": 1,
+          "remove_islands": 0,
+          "thermal_relief_gap": 0.5,
+          "thermal_relief_spoke_width": 0.5
+        }
+      },
+      "diff_pair_dimensions": [
+        {
+          "gap": 0.0,
+          "via_gap": 0.0,
+          "width": 0.0
+        }
+      ],
      "drc_exclusions": [],
-      "rules": {},
-      "track_widths": [],
-      "via_dimensions": []
+      "meta": {
+        "version": 2
+      },
+      "rule_severities": {
+        "annular_width": "error",
+        "clearance": "error",
+        "connection_width": "warning",
+        "copper_edge_clearance": "error",
+        "copper_sliver": "warning",
+        "courtyards_overlap": "error",
+        "creepage": "error",
+        "diff_pair_gap_out_of_range": "error",
+        "diff_pair_uncoupled_length_too_long": "error",
+        "drill_out_of_range": "error",
+        "duplicate_footprints": "warning",
+        "extra_footprint": "warning",
+        "footprint": "error",
+        "footprint_filters_mismatch": "ignore",
+        "footprint_symbol_field_mismatch": "warning",
+        "footprint_symbol_mismatch": "warning",
+        "footprint_type_mismatch": "ignore",
+        "hole_clearance": "error",
+        "hole_to_hole": "warning",
+        "holes_co_located": "warning",
+        "invalid_outline": "error",
+        "isolated_copper": "warning",
+        "item_on_disabled_layer": "error",
+        "items_not_allowed": "error",
+        "length_out_of_range": "error",
+        "lib_footprint_issues": "warning",
+        "lib_footprint_mismatch": "warning",
+        "malformed_courtyard": "error",
+        "microvia_drill_out_of_range": "error",
+        "mirrored_text_on_front_layer": "warning",
+        "missing_courtyard": "ignore",
+        "missing_footprint": "warning",
+        "missing_tuning_profile": "warning",
+        "net_conflict": "warning",
+        "nonmirrored_text_on_back_layer": "warning",
+        "npth_inside_courtyard": "error",
+        "padstack": "warning",
+        "pth_inside_courtyard": "error",
+        "shorting_items": "error",
+        "silk_edge_clearance": "ignore",
+        "silk_over_copper": "warning",
+        "silk_overlap": "warning",
+        "skew_out_of_range": "error",
+        "solder_mask_bridge": "error",
+        "starved_thermal": "error",
+        "text_height": "warning",
+        "text_on_edge_cuts": "error",
+        "text_thickness": "warning",
+        "through_hole_pad_without_hole": "error",
+        "too_many_vias": "error",
+        "track_angle": "error",
+        "track_dangling": "warning",
+        "track_not_centered_on_via": "ignore",
+        "track_on_post_machined_layer": "error",
+        "track_segment_length": "error",
+        "track_width": "error",
+        "tracks_crossing": "error",
+        "tuning_profile_track_geometries": "ignore",
+        "unconnected_items": "error",
+        "unresolved_variable": "error",
+        "via_dangling": "warning",
+        "zones_intersect": "error"
+      },
+      "rules": {
+        "max_error": 0.005,
+        "min_clearance": 0.0,
+        "min_connection": 0.0,
+        "min_copper_edge_clearance": 0.5,
+        "min_groove_width": 0.0,
+        "min_hole_clearance": 0.25,
+        "min_hole_to_hole": 0.25,
+        "min_microvia_diameter": 0.2,
+        "min_microvia_drill": 0.1,
+        "min_resolved_spokes": 2,
+        "min_silk_clearance": 0.0,
+        "min_text_height": 0.8,
+        "min_text_thickness": 0.08,
+        "min_through_hole_diameter": 0.3,
+        "min_track_width": 0.2,
+        "min_via_annular_width": 0.1,
+        "min_via_diameter": 0.5,
+        "solder_mask_to_copper_clearance": 0.005,
+        "use_height_for_length_calcs": true
+      },
+      "teardrop_options": [
+        {
+          "td_onpthpad": true,
+          "td_onroundshapesonly": false,
+          "td_onsmdpad": true,
+          "td_ontrackend": false,
+          "td_onvia": true
+        }
+      ],
+      "teardrop_parameters": [
+        {
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 0,
+          "td_height_ratio": 1.0,
+          "td_length_ratio": 0.5,
+          "td_maxheight": 2.0,
+          "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
+          "td_target_name": "td_round_shape",
+          "td_width_to_size_filter_ratio": 0.9
+        },
+        {
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 0,
+          "td_height_ratio": 1.0,
+          "td_length_ratio": 0.5,
+          "td_maxheight": 2.0,
+          "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
+          "td_target_name": "td_rect_shape",
+          "td_width_to_size_filter_ratio": 0.9
+        },
+        {
+          "td_allow_use_two_tracks": true,
+          "td_curve_segcount": 0,
+          "td_height_ratio": 1.0,
+          "td_length_ratio": 0.5,
+          "td_maxheight": 2.0,
+          "td_maxlen": 1.0,
+          "td_on_pad_in_zone": false,
+          "td_target_name": "td_track_end",
+          "td_width_to_size_filter_ratio": 0.9
+        }
+      ],
+      "track_widths": [
+        0.0,
+        0.2,
+        0.5,
+        1.0,
+        2.0,
+        5.0
+      ],
+      "tuning_pattern_settings": {
+        "diff_pair_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 1.0
+        },
+        "diff_pair_skew_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 0.6
+        },
+        "single_track_defaults": {
+          "corner_radius_percentage": 80,
+          "corner_style": 1,
+          "max_amplitude": 1.0,
+          "min_amplitude": 0.2,
+          "single_sided": false,
+          "spacing": 0.6
+        }
+      },
+      "via_dimensions": [
+        {
+          "diameter": 0.0,
+          "drill": 0.0
+        }
+      ],
+      "zones_allow_external_fillets": false
    },
    "ipc2581": {
+      "bom_rev": "",
      "dist": "",
      "distpn": "",
      "internal_id": "",
      "mfg": "",
-      "mpn": ""
+      "mpn": "",
+      "sch_revision": ""
    },
    "layer_pairs": [],
    "layer_presets": [],
    "viewports": []
  },
  "boards": [],
+  "component_class_settings": {
+    "assignments": [],
+    "meta": {
+      "version": 0
+    },
+    "sheet_component_classes": {
+      "enabled": false
+    }
+  },
  "cvpcb": {
    "equivalence_files": []
  },
@@ -210,11 +463,14 @@
      "duplicate_sheet_names": "error",
      "endpoint_off_grid": "warning",
      "extra_units": "error",
+      "field_name_whitespace": "warning",
      "footprint_filter": "ignore",
      "footprint_link_issues": "warning",
      "four_way_junction": "ignore",
      "global_label_dangling": "warning",
+      "ground_pin_not_ground": "warning",
      "hier_label_mismatch": "error",
+      "isolated_pin_label": "warning",
      "label_dangling": "error",
      "label_multiple_wires": "warning",
      "lib_symbol_issues": "warning",
@@ -237,6 +493,7 @@
      "similar_power": "warning",
      "simulation_model_issue": "ignore",
      "single_global_label": "ignore",
+      "stacked_pin_name": "warning",
      "unannotated": "error",
      "unconnected_wire_endpoint": "warning",
      "undefined_netclass": "error",
@@ -269,13 +526,14 @@
        "priority": 2147483647,
        "schematic_color": "rgba(0, 0, 0, 0.000)",
        "track_width": 0.2,
+        "tuning_profile": "",
        "via_diameter": 0.6,
        "via_drill": 0.3,
        "wire_width": 6
      }
    ],
    "meta": {
-      "version": 4
+      "version": 5
    },
    "net_colors": null,
    "netclass_assignments": null,
@@ -297,6 +555,10 @@
  },
  "schematic": {
    "annotate_start_num": 0,
+    "annotation": {
+      "method": 0,
+      "sort_order": 0
+    },
    "bom_export_filename": "${PROJECTNAME}.csv",
    "bom_fmt_presets": [],
    "bom_fmt_settings": {
@@ -359,15 +621,298 @@
          "label": "Datasheet",
          "name": "Datasheet",
          "show": true
+        },
+        {
+          "group_by": false,
+          "label": "Actuator/Cap Color",
+          "name": "Actuator/Cap Color",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Attrition Qty",
+          "name": "Attrition Qty",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Capacitance",
+          "name": "Capacitance",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Category",
+          "name": "Category",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Circuit",
+          "name": "Circuit",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Class",
+          "name": "Class",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Contact Current",
+          "name": "Contact Current",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Diode Configuration",
+          "name": "Diode Configuration",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Field5",
+          "name": "Field5",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Forward Voltage (Vf@If)",
+          "name": "Forward Voltage (Vf@If)",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Insulation Resistance",
+          "name": "Insulation Resistance",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "LCSC",
+          "name": "LCSC",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "LCSC_PART_NUMBER",
+          "name": "LCSC_PART_NUMBER",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Manufacturer",
+          "name": "Manufacturer",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Mechanical Life",
+          "name": "Mechanical Life",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Minimum Qty",
+          "name": "Minimum Qty",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Mounting Style",
+          "name": "Mounting Style",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Operating Force",
+          "name": "Operating Force",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Operating Temperature",
+          "name": "Operating Temperature",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Operating Temperature Range",
+          "name": "Operating Temperature Range",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Overload Voltage (Max)",
+          "name": "Overload Voltage (Max)",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Part",
+          "name": "Part",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Pin Style",
+          "name": "Pin Style",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Power(Watts)",
+          "name": "Power(Watts)",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Price",
+          "name": "Price",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Process",
+          "name": "Process",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Rectified Current",
+          "name": "Rectified Current",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Resistance",
+          "name": "Resistance",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Reverse Leakage Current",
+          "name": "Reverse Leakage Current",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Reverse Voltage (Vr)",
+          "name": "Reverse Voltage (Vr)",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Sim.Device",
+          "name": "Sim.Device",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Sim.Pins",
+          "name": "Sim.Pins",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Sim.Type",
+          "name": "Sim.Type",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Stock",
+          "name": "Stock",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Strike Gundam",
+          "name": "Strike Gundam",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Switch Height",
+          "name": "Switch Height",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Switch Length",
+          "name": "Switch Length",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Switch Width",
+          "name": "Switch Width",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Temperature Coefficient",
+          "name": "Temperature Coefficient",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Tolerance",
+          "name": "Tolerance",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Type",
+          "name": "Type",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Voltage Rated",
+          "name": "Voltage Rated",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Voltage Rating (Dc)",
+          "name": "Voltage Rating (Dc)",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "With Lamp",
+          "name": "With Lamp",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Actuator Style",
+          "name": "Actuator Style",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "Description",
+          "name": "Description",
+          "show": false
+        },
+        {
+          "group_by": false,
+          "label": "#",
+          "name": "${ITEM_NUMBER}",
+          "show": false
        }
      ],
      "filter_string": "",
      "group_symbols": true,
      "include_excluded_from_bom": true,
-      "name": "Default Editing",
+      "name": "",
      "sort_asc": true,
      "sort_field": "Reference"
    },
+    "bus_aliases": {},
    "connection_grid_size": 50.0,
    "drawing": {
      "dashed_lines_dash_length_ratio": 12.0,
@@ -375,6 +920,7 @@
      "default_line_thickness": 6.0,
      "default_text_size": 50.0,
      "field_names": [],
+      "hop_over_size_choice": 0,
      "intersheets_ref_own_page": false,
      "intersheets_ref_prefix": "",
      "intersheets_ref_short": false,
@@ -398,6 +944,7 @@
    "net_format_name": "",
    "page_layout_descr_file": "",
    "plot_directory": "",
+    "reuse_designators": true,
    "space_save_all_events": true,
    "spice_current_sheet_as_root": false,
    "spice_external_command": "spice \"%I\"",
@@ -406,13 +953,28 @@
    "spice_save_all_dissipations": false,
    "spice_save_all_voltages": false,
    "subpart_first_id": 65,
-    "subpart_id_separator": 0
+    "subpart_id_separator": 0,
+    "top_level_sheets": [
+      {
+        "filename": "bms.kicad_sch",
+        "name": "bms",
+        "uuid": "7972d0e7-2611-420d-b298-ef8307db6186"
+      }
+    ],
+    "used_designators": "",
+    "variants": []
  },
  "sheets": [
    [
      "7972d0e7-2611-420d-b298-ef8307db6186",
-      "Root"
+      "bms"
    ]
  ],
-  "text_variables": {}
+  "text_variables": {},
+  "tuning_profiles": {
+    "meta": {
+      "version": 0
+    },
+    "tuning_profiles_impedance_geometric": []
+  }
 }
--- a/Hardware/open-bms/bms/bms.kicad_sch
+++ b/Hardware/open-bms/bms/bms.kicad_sch
--- a/Hardware/open-bms/bms/fabrication-toolkit-options.json
+++ b/Hardware/open-bms/bms/fabrication-toolkit-options.json
@@ -0,0 +1 @@
+{"ARCHIVE_NAME": "", "EXTRA_LAYERS": "", "ALL_ACTIVE_LAYERS": false, "EXTEND_EDGE_CUT": false, "ALTERNATIVE_EDGE_CUT": false, "AUTO TRANSLATE": true, "AUTO FILL": true, "EXCLUDE DNP": false, "OPEN BROWSER": true, "NO_BACKUP_OPT": false}
--- a/Hardware/open-bms/bms/footprints/amass/AMASS_XT30UPB+DATA-M_1x02_P5.0mm_Vertical.kicad_mod
+++ b/Hardware/open-bms/bms/footprints/amass/AMASS_XT30UPB+DATA-M_1x02_P5.0mm_Vertical.kicad_mod
@@ -0,0 +1,337 @@
+(footprint "AMASS_XT30UPB+DATA-M_1x02_P5.0mm_Vertical"
+	(version 20240108)
+	(generator "pcbnew")
+	(generator_version "8.0")
+	(layer "F.Cu")
+	(descr "Connector XT30 Vertical PCB Male, https://www.tme.eu/en/Document/4acc913878197f8c2e30d4b8cdc47230/XT30UPB%20SPEC.pdf")
+	(tags "RC Connector XT30")
+	(property "Reference" "REF**"
+		(at 2.5 -4 0)
+		(layer "F.SilkS")
+		(uuid "f7510d54-dcb1-4c3b-b842-cd250a98370c")
+		(effects
+			(font
+				(size 1 1)
+				(thickness 0.15)
+			)
+		)
+	)
+	(property "Value" "AMASS_XT30UPB+DATA-M_1x02_P5.0mm_Vertical"
+		(at 2.5 4 0)
+		(layer "F.Fab")
+		(uuid "c5a8a60c-4ea1-4401-a30c-34d36be61c07")
+		(effects
+			(font
+				(size 1 1)
+				(thickness 0.15)
+			)
+		)
+	)
+	(property "Footprint" ""
+		(at 0 0 0)
+		(unlocked yes)
+		(layer "F.Fab")
+		(hide yes)
+		(uuid "8fb27306-c085-4316-b554-4ba9be794054")
+		(effects
+			(font
+				(size 1.27 1.27)
+				(thickness 0.15)
+			)
+		)
+	)
+	(property "Datasheet" ""
+		(at 0 0 0)
+		(unlocked yes)
+		(layer "F.Fab")
+		(hide yes)
+		(uuid "74b71861-05d2-4229-8e81-25952aaaef7e")
+		(effects
+			(font
+				(size 1.27 1.27)
+				(thickness 0.15)
+			)
+		)
+	)
+	(property "Description" ""
+		(at 0 0 0)
+		(unlocked yes)
+		(layer "F.Fab")
+		(hide yes)
+		(uuid "a1d16ecc-7e64-48c4-b772-a9255380960d")
+		(effects
+			(font
+				(size 1.27 1.27)
+				(thickness 0.15)
+			)
+		)
+	)
+	(attr through_hole)
+	(fp_line
+		(start -2.71 -1.41)
+		(end -2.71 1.41)
+		(stroke
+			(width 0.12)
+			(type solid)
+		)
+		(layer "F.SilkS")
+		(uuid "e96c6ad2-9ca6-4df1-b35b-76e090d7ff4e")
+	)
+	(fp_line
+		(start -2.71 -1.41)
+		(end -1.01 -2.71)
+		(stroke
+			(width 0.12)
+			(type solid)
+		)
+		(layer "F.SilkS")
+		(uuid "0784d204-0a48-4a2b-8085-50e1ff7a1493")
+	)
+	(fp_line
+		(start -2.71 1.41)
+		(end -1.01 2.71)
+		(stroke
+			(width 0.12)
+			(type solid)
+		)
+		(layer "F.SilkS")
+		(uuid "db750970-e424-4a8e-a882-20a90baabffc")
+	)
+	(fp_line
+		(start -1.01 -2.71)
+		(end 7.71 -2.71)
+		(stroke
+			(width 0.12)
+			(type solid)
+		)
+		(layer "F.SilkS")
+		(uuid "9f23420e-db87-438c-a708-676a0616966e")
+	)
+	(fp_line
+		(start -1.01 2.71)
+		(end 7.71 2.71)
+		(stroke
+			(width 0.12)
+			(type solid)
+		)
+		(layer "F.SilkS")
+		(uuid "2ba574e3-9de5-4d7d-9777-e19e6fa702e7")
+	)
+	(fp_line
+		(start 7.71 -2.71)
+		(end 7.71 2.71)
+		(stroke
+			(width 0.12)
+			(type solid)
+		)
+		(layer "F.SilkS")
+		(uuid "2018cc6b-6115-4763-8b7c-54b60affbda7")
+	)
+	(fp_rect
+		(start -6.3 -2.71)
+		(end 7.71 2.7)
+		(stroke
+			(width 0.1)
+			(type default)
+		)
+		(fill none)
+		(layer "F.SilkS")
+		(uuid "11aac399-c862-4b67-9828-087abeea5b1b")
+	)
+	(fp_line
+		(start -3.1 -1.8)
+		(end -3.1 1.8)
+		(stroke
+			(width 0.05)
+			(type solid)
+		)
+		(layer "F.CrtYd")
+		(uuid "06ae69d8-1372-4524-8b1a-27a2f062f1c5")
+	)
+	(fp_line
+		(start -3.1 -1.8)
+		(end -1.4 -3.1)
+		(stroke
+			(width 0.05)
+			(type solid)
+		)
+		(layer "F.CrtYd")
+		(uuid "ae869a92-c688-4f2b-82ca-0578106a035a")
+	)
+	(fp_line
+		(start -3.1 1.8)
+		(end -1.4 3.1)
+		(stroke
+			(width 0.05)
+			(type solid)
+		)
+		(layer "F.CrtYd")
+		(uuid "cac6d927-6ba1-4095-825b-f94ee0d7abe9")
+	)
+	(fp_line
+		(start -1.4 -3.1)
+		(end 8.1 -3.1)
+		(stroke
+			(width 0.05)
+			(type solid)
+		)
+		(layer "F.CrtYd")
+		(uuid "fb4fa373-5492-4717-a9fe-7b69f4c53ba0")
+	)
+	(fp_line
+		(start -1.4 3.1)
+		(end 8.1 3.1)
+		(stroke
+			(width 0.05)
+			(type solid)
+		)
+		(layer "F.CrtYd")
+		(uuid "70296c77-546d-44a2-b5d3-e6dc58cf713b")
+	)
+	(fp_line
+		(start 8.1 -3.1)
+		(end 8.1 3.1)
+		(stroke
+			(width 0.05)
+			(type solid)
+		)
+		(layer "F.CrtYd")
+		(uuid "64764a09-de32-4f35-b54a-17e44810370f")
+	)
+	(fp_line
+		(start -2.6 -1.3)
+		(end -2.6 1.3)
+		(stroke
+			(width 0.1)
+			(type solid)
+		)
+		(layer "F.Fab")
+		(uuid "8d7ee7cb-5dda-453f-aa9a-6420c87f1b8e")
+	)
+	(fp_line
+		(start -2.6 -1.3)
+		(end -0.9 -2.6)
+		(stroke
+			(width 0.1)
+			(type solid)
+		)
+		(layer "F.Fab")
+		(uuid "2fa3ad90-36bb-4374-95ed-e44e50c7e385")
+	)
+	(fp_line
+		(start -2.6 1.3)
+		(end -0.9 2.6)
+		(stroke
+			(width 0.1)
+			(type solid)
+		)
+		(layer "F.Fab")
+		(uuid "2e4f8556-ffc2-4791-91da-e68c3513337e")
+	)
+	(fp_line
+		(start -0.9 -2.6)
+		(end 7.6 -2.6)
+		(stroke
+			(width 0.1)
+			(type solid)
+		)
+		(layer "F.Fab")
+		(uuid "cb9cd8af-1997-41db-b9fe-8982960ac6db")
+	)
+	(fp_line
+		(start -0.9 2.6)
+		(end 7.6 2.6)
+		(stroke
+			(width 0.1)
+			(type solid)
+		)
+		(layer "F.Fab")
+		(uuid "ea8a6c02-e974-4677-a854-a0891c323245")
+	)
+	(fp_line
+		(start 7.6 -2.6)
+		(end 7.6 2.6)
+		(stroke
+			(width 0.1)
+			(type solid)
+		)
+		(layer "F.Fab")
+		(uuid "c66f305c-0d56-4591-bc02-23252ad20321")
+	)
+	(fp_text user "-"
+		(at -4 0 0)
+		(layer "F.SilkS")
+		(uuid "c119570a-6846-48dc-9422-0b5665ab2df6")
+		(effects
+			(font
+				(size 1.5 1.5)
+				(thickness 0.15)
+			)
+		)
+	)
+	(fp_text user "+"
+		(at 9 0 0)
+		(layer "F.SilkS")
+		(uuid "d6ab678c-47f7-47e0-869b-ef3b9dbd1ba9")
+		(effects
+			(font
+				(size 1.5 1.5)
+				(thickness 0.15)
+			)
+		)
+	)
+	(fp_text user "${REFERENCE}"
+		(at 2.5 0 0)
+		(layer "F.Fab")
+		(uuid "a70efd12-1491-4664-ae98-5b2b7f52a502")
+		(effects
+			(font
+				(size 1 1)
+				(thickness 0.15)
+			)
+		)
+	)
+	(pad "1" thru_hole rect
+		(at 0 0)
+		(size 3 3)
+		(drill 1.8)
+		(layers "*.Cu" "*.Mask")
+		(remove_unused_layers no)
+		(uuid "3a0f3b23-814b-4df9-a02c-3d9fed9e23c9")
+	)
+	(pad "2" thru_hole circle
+		(at 5 0)
+		(size 3 3)
+		(drill 1.8)
+		(layers "*.Cu" "*.Mask")
+		(remove_unused_layers no)
+		(uuid "d897d74a-a13b-47cf-9806-eb8a75fe8d08")
+	)
+	(pad "3" thru_hole circle
+		(at -3.9 -1)
+		(size 1.524 1.524)
+		(drill 1)
+		(layers "*.Cu" "*.Mask")
+		(remove_unused_layers no)
+		(uuid "02a8c3fc-d75c-47a4-a907-f9191ff19e2c")
+	)
+	(pad "4" thru_hole circle
+		(at -3.9 1)
+		(size 1.524 1.524)
+		(drill 1)
+		(layers "*.Cu" "*.Mask")
+		(remove_unused_layers no)
+		(uuid "2000b5b8-f7c9-40a8-9010-65c16d2aefce")
+	)
+	(model "${KICAD8_3DMODEL_DIR}/Connector_AMASS.3dshapes/AMASS_XT30UPB-M_1x02_P5.0mm_Vertical.wrl"
+		(offset
+			(xyz 0 0 0)
+		)
+		(scale
+			(xyz 1 1 1)
+		)
+		(rotate
+			(xyz 0 0 0)
+		)
+	)
+)
--- a/Hardware/open-bms/bms/fp-lib-table
+++ b/Hardware/open-bms/bms/fp-lib-table
@@ -0,0 +1,4 @@
+(fp_lib_table
+	(version 7)
+	(lib (name "amass") (type "KiCad") (uri "${KIPRJMOD}/footprints/amass") (options "") (descr ""))
+)
--- a/Software/CAN_Sensor/build.rs
+++ b/Software/CAN_Sensor/build.rs
@@ -8,4 +8,15 @@ fn main() {
    std::fs::write(out_dir.join("memory.x"), include_bytes!("memory.x")).unwrap();
    println!("cargo:rustc-link-search={}", out_dir.display());
    println!("cargo:rerun-if-changed=memory.x");
+
+    // Embed firmware build timestamp as minutes since Unix epoch (4 bytes, big-endian).
+    // Dropping sub-minute precision keeps it in 4 bytes for many years.
+    let build_seconds = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .expect("System time before UNIX_EPOCH")
+        .as_secs();
+    let build_minutes = (build_seconds / 60) as u32;
+    let bytes = build_minutes.to_be_bytes();
+    std::fs::write(out_dir.join("build_minutes.bin"), bytes).unwrap();
+    println!("cargo:rerun-if-changed=build.rs");
 }
--- a/Software/CAN_Sensor/src/main.rs
+++ b/Software/CAN_Sensor/src/main.rs
@@ -3,7 +3,7 @@
 extern crate alloc;

 use crate::hal::peripherals::CAN1;
-use canapi::id::{plant_id, IDENTIFY_CMD_OFFSET, MOISTURE_DATA_OFFSET};
+use canapi::id::{plant_id, FIRMWARE_BUILD_OFFSET, IDENTIFY_CMD_OFFSET, MOISTURE_DATA_OFFSET};
 use canapi::SensorSlot;
 use ch32_hal::adc::{Adc, SampleTime, ADC_MAX};
 use ch32_hal::{pac};
@@ -47,6 +47,10 @@ static CAN_TX_CH: Channel<CriticalSectionRawMutex, CanFrame, 4> = Channel::new()

 static BEACON: AtomicBool = AtomicBool::new(false);

+/// Firmware build timestamp in minutes since Unix epoch, embedded at compile time.
+const FIRMWARE_BUILD_MINUTES: u32 =
+    u32::from_be_bytes(*include_bytes!(concat!(env!("OUT_DIR"), "/build_minutes.bin")));
+
 #[embassy_executor::main(entry = "qingke_rt::entry")]
 async fn main(spawner: Spawner) {
    ch32_hal::pac::AFIO.pcfr1().write(|w| w.set_can1_rm(2));
@@ -111,6 +115,7 @@ async fn main(spawner: Spawner) {
    }
    let moisture_id = plant_id(MOISTURE_DATA_OFFSET, slot, addr as u16);
    let identify_id = plant_id(IDENTIFY_CMD_OFFSET, slot, addr as u16);
+    let firmware_build_id = plant_id(FIRMWARE_BUILD_OFFSET, slot, addr as u16);
    let standard_identify_id = StandardId::new(identify_id).unwrap();

    //is any floating, or invalid addr (only 1-8 are valid)
@@ -241,19 +246,37 @@ async fn main(spawner: Spawner) {
            p.PB9,
            CanFifo::Fifo0,
            CanMode::Normal,
-            125_000,
+            20_000,
            config,
        )
        .expect("Valid");
        ch32_hal::pac::AFIO.pcfr1().write(|w| w.set_can1_rm(2));

        can.add_filter(CanFilter::accept_all());
+        
+        // Improve CAN robustness for longer cables:
+        // 1. Enable Automatic Bus-Off Management (ABOM)
+        // 2. Enable Automatic Retransmission (NART) to recover from transient errors
+        // 3. Enable Receive FIFO Overwrite Mode (RFLM = 0, default)
+        // 4. Increase Resync Jump Width (SJW) if possible by patching BTIMR
+        hal::pac::CAN1.ctlr().modify(|w| {
+            w.set_abom(false);
+            w.set_nart(false); 
+        });
+        
+        // SJW is bits 24-25 of BTIMR. HAL sets it to 0 (SJW=1). 
+        // Let's try to set it to 3 (SJW=4) for better jitter tolerance.
+        hal::pac::CAN1.btimr().modify(|w| {
+            w.set_sjw(3); // 3 means 4TQ
+        });
+
       // let mut filter = CanFilter::new_id_list();
       // filter.get(0).unwrap().set(Id::Standard(standard_identify_id), Default::default());
       // can.add_filter(filter);
        let standard_moisture_id = StandardId::new(moisture_id).unwrap();
+        let standard_firmware_build_id = StandardId::new(firmware_build_id).unwrap();
        spawner
-            .spawn(can_task(can,info, warn, standard_identify_id, standard_moisture_id))
+            .spawn(can_task(can, info, warn, standard_identify_id, standard_moisture_id, standard_firmware_build_id))
            .unwrap();

        // move Q output, LED, ADC and analog input into worker task
@@ -265,6 +288,8 @@ async fn main(spawner: Spawner) {
                ain,
                standard_moisture_id,
                standard_identify_id,
+                standard_firmware_build_id,
+                slot,
            ))
            .unwrap();
    }
@@ -345,6 +370,7 @@ async fn can_task(
    warn: &'static mut Output<'static>,
    identify_id: StandardId,
    moisture_id: StandardId,
+    _firmware_build_id: StandardId,
 ) {
    // Non-blocking beacon blink timing.
    // We keep this inside the CAN task so it can't stall other tasks (like `worker`) with `await`s.
@@ -389,7 +415,7 @@ async fn can_task(
                    Timer::after_millis(100).await;
                }
                let mut msg: heapless::String<128> = heapless::String::new();
-                let _ = write!(&mut msg, "rx err {:?}", err);
+                let _ = write!(&mut msg, "rx err {:?} \r\n", err);
                log(msg);
            }
        }
@@ -403,9 +429,25 @@ async fn can_task(
            }
        }

+
+
        while let Ok(mut frame) = CAN_TX_CH.try_receive() {
            match can.transmit(&mut frame) {
-                Ok(..) => {
+                Ok(_ok) => {
+                    let status = hal::pac::CAN1.errsr().read();
+
+                    // Check CAN error status register for bus-off condition
+                    if status.boff() || status.ewgf() || status.epvf() {
+                        let mut msg: heapless::String<128> = heapless::String::new();
+                        let _ = write!(&mut msg, "canbus status {} {} {} \r\n", status.boff(), status.ewgf(), status.epvf());
+                        log(msg);
+                        for _ in 0..2 {
+                            warn.set_high();
+                            Timer::after_millis(100).await;
+                            warn.set_low();
+                            Timer::after_millis(100).await;
+                        }
+                    }
                }
                Err(nb::Error::WouldBlock) => {
                    for _ in 0..2 {
@@ -415,7 +457,7 @@ async fn can_task(
                        Timer::after_millis(100).await;
                    }
                    let mut msg: heapless::String<128> = heapless::String::new();
-                    let _ = write!(&mut msg, "canbus out buffer full");
+                    let _ = write!(&mut msg, "canbus out buffer full  \r\n");
                    log(msg);
                }
                Err(nb::Error::Other(err)) => {
@@ -426,7 +468,7 @@ async fn can_task(
                        Timer::after_millis(100).await;
                    }
                    let mut msg: heapless::String<128> = heapless::String::new();
-                    let _ = write!(&mut msg, "tx err {:?}", err);
+                    let _ = write!(&mut msg, "tx err {:?}  \r\n", err);
                    log(msg);
                }
            }
@@ -443,72 +485,130 @@ async fn worker(
    mut ain: hal::peripherals::PA1,
    moisture_id: StandardId,
    identify_id: StandardId,
+    firmware_build_id: StandardId,
+    slot: SensorSlot,
 ) {
    // 555 emulation state: Q initially Low
    let mut q_high = false;
    let low_th: u16 = (ADC_MAX as u16) / 3; // ~1/3 Vref
    let high_th: u16 = ((ADC_MAX as u32 * 2) / 3) as u16; // ~2/3 Vref

-    loop {
-        // Count rising edges of Q in a 100 ms window
-        let start = Instant::now();
-        let mut pulses: u32 = 0;
-        let mut last_q = q_high;
+    const AVG_WINDOWS: u32 = 4;
+    const YIELD_EVERY: u32 = 64;
+    let probe_duration = Duration::from_millis(100);
+    let measurement_time = probe_duration.as_millis() * AVG_WINDOWS as u64; // 400ms
+    let interleaving_gap = Duration::from_millis(50);

-        probe_gnd.set_as_output(Speed::Low);
-        probe_gnd.set_low();
-        let probe_duration = Duration::from_millis(100);
-        while Instant::now()
-            .checked_duration_since(start)
-            .unwrap_or(Duration::from_millis(0))
-            < probe_duration
-        {
-            // Sample the analog input (Threshold/Trigger on A1)
-            let val: u16 = adc.convert(&mut ain, SampleTime::CYCLES28_5);
+    // Interleaving timing to ensure A and B never overlap:
+    // - Sensor A: measures for 400ms
+    // - Gap: 50ms
+    // - Sensor B: measures for 400ms
+    // - Gap: 50ms
+    // Total cycle: 900ms, so each sensor measures every 900ms (~1.1 measurements/second)
+    //
+    // Timeline:
+    // 0-400ms:   A measures, B idle
+    // 400-450ms: both idle (gap)
+    // 450-850ms: B measures, A idle
+    // 850-900ms: both idle (gap)
+    // Then repeat from 0ms

-            // 555 core behavior:
-            // - If input <= 1/3 Vref => set Q high (trigger)
-            // - If input >= 2/3 Vref => set Q low (threshold)
-            // - Otherwise keep previous Q state (hysteresis)
-            if val <= low_th {
-                q_high = true;
-            } else if val >= high_th {
-                q_high = false;
-            }
-
-            // Drive output pin accordingly
-            if q_high {
-                q.set_high();
-            } else {
-                q.set_low();
-            }
-
-            // Count rising edges
-            if !last_q && q_high {
-                pulses = pulses.saturating_add(1);
-            }
-            last_q = q_high;
-
-            // Yield to allow USB and other tasks to run
-            yield_now().await;
+    // Initial offset: B waits for A's measurement time + one gap
+    match slot {
+        SensorSlot::A => {
+            // A sensors start measuring immediately
        }
-        probe_gnd.set_as_input(Pull::None);
+        SensorSlot::B => {
+            // B sensors wait for A to finish measuring + gap
+            Timer::after(Duration::from_millis(measurement_time + interleaving_gap.as_millis())).await;
+        }
+    }

-        let freq_hz: u32 = pulses * (1000 / probe_duration.as_millis()) as u32; // pulses per 0.1s => Hz
+    loop {
+        let mut total_pulses: u32 = 0;
+
+        for _window in 0..AVG_WINDOWS {
+            // Count rising edges of Q in a 100 ms window
+            let start = Instant::now();
+            let mut pulses: u32 = 0;
+            let mut last_q = q_high;
+            let mut iter_count: u32 = 0;
+
+            probe_gnd.set_as_output(Speed::Low);
+            probe_gnd.set_low();
+            while Instant::now()
+                .checked_duration_since(start)
+                .unwrap_or(Duration::from_millis(0))
+                < probe_duration
+            {
+                // Sample the analog input (Threshold/Trigger on A1)
+                let val: u16 = adc.convert(&mut ain, SampleTime::CYCLES28_5);
+
+                // 555 core behavior:
+                // - If input <= 1/3 Vref => set Q high (trigger)
+                // - If input >= 2/3 Vref => set Q low (threshold)
+                // - Otherwise keep previous Q state (hysteresis)
+                if val <= low_th {
+                    q_high = true;
+                } else if val >= high_th {
+                    q_high = false;
+                }
+
+                // Drive output pin accordingly
+                if q_high {
+                    q.set_high();
+                } else {
+                    q.set_low();
+                }
+
+                // Count rising edges
+                if !last_q && q_high {
+                    pulses = pulses.saturating_add(1);
+                }
+                last_q = q_high;
+
+                // Yield every YIELD_EVERY samples to keep USB alive without
+                // disrupting per-sample timing
+                iter_count += 1;
+                if iter_count % YIELD_EVERY == 0 {
+                    yield_now().await;
+                }
+            }
+            probe_gnd.set_as_input(Pull::None);
+            total_pulses = total_pulses.saturating_add(pulses);
+        }
+
+        let avg_pulses = total_pulses / AVG_WINDOWS;
+        let freq_hz: u32 = avg_pulses * (1000 / probe_duration.as_millis()) as u32;

        let mut msg: heapless::String<128> = heapless::String::new();
        let _ = write!(
            &mut msg,
-            "555 window={}ms pulses={} freq={} Hz (A1->Q on PB0) id={:?}\r\n",
-            probe_duration.as_millis(),
-            pulses,
+            "555 window={}ms avg_pulses={} freq={} Hz (A1->Q on PB0) id={:?}\r\n",
+            probe_duration.as_millis() * AVG_WINDOWS as u64,
+            avg_pulses,
            freq_hz,
            identify_id.as_raw()
        );
        log(msg);

        let moisture = CanFrame::new(moisture_id, &(freq_hz as u32).to_be_bytes()).unwrap();
+        let delay_ms = moisture_id.as_raw() as u64 % 50;
+        Timer::after(Duration::from_millis(delay_ms)).await;
        CAN_TX_CH.send(moisture).await;
+
+        // Send firmware build timestamp after each measurement so the controller
+        // always has up-to-date build info without requiring an identify request.
+        let firmware = CanFrame::new(firmware_build_id, &FIRMWARE_BUILD_MINUTES.to_be_bytes()).unwrap();
+        let delay_ms = firmware_build_id.as_raw() as u64 % 50;
+        Timer::after(Duration::from_millis(delay_ms)).await;
+        CAN_TX_CH.send(firmware).await;
+
+        // Wait for the other slot to measure, plus gaps to ensure no overlap
+        // After A finishes measuring: wait 50ms (gap) + 400ms (B measures) + 50ms (gap) = 500ms
+        // After B finishes measuring: wait 50ms (gap) + 400ms (A measures) + 50ms (gap) = 500ms
+        // This ensures the full 900ms cycle is maintained and A/B never overlap
+        Timer::after(Duration::from_millis(interleaving_gap.as_millis() + measurement_time + interleaving_gap.as_millis())).await;
    }
 }

--- a/Software/MainBoard/rust/.cargo/config.toml
+++ b/Software/MainBoard/rust/.cargo/config.toml
@@ -23,8 +23,6 @@ target = "riscv32imac-unknown-none-elf"
 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 }
 ESP_LOG = "info"
-PATH = { value = "../../../bin:/usr/bin:/usr/local/bin", force = true, relative = true }
-


 [unstable]
--- a/Software/MainBoard/rust/.idea/vcs.xml
+++ b/Software/MainBoard/rust/.idea/vcs.xml
@@ -2,5 +2,6 @@
 <project version="4">
  <component name="VcsDirectoryMappings">
    <mapping directory="$PROJECT_DIR$/../../.." vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/../../../website/themes/blowfish" vcs="Git" />
  </component>
 </project>
--- a/Software/MainBoard/rust/Cargo.lock
+++ b/Software/MainBoard/rust/Cargo.lock
--- a/Software/MainBoard/rust/Cargo.toml
+++ b/Software/MainBoard/rust/Cargo.toml
@@ -46,57 +46,34 @@ canapi = { path = "../../Shared/canapi" }

 # Platform and ESP-specific runtime/boot/runtime utilities
 log = "0.4.28"
-esp-bootloader-esp-idf = { version = "0.4.0", features = ["esp32c6", "log-04"] }
-esp-hal = { version = "1.0.0", features = ["esp32c6", "log-04"] }
-esp-rtos = { version = "0.2.0", features = ["esp32c6", "embassy", "esp-radio"] }
-esp-backtrace = { version = "0.18.1", features = ["esp32c6", "panic-handler", "println", "colors", "custom-halt"] }
-esp-println = { version = "0.16.1", features = ["esp32c6", "log-04", "auto"] }
-esp-storage = { version = "0.8.1", features = ["esp32c6"] }
-esp-radio = { version = "0.17.0", features = ["esp32c6", "log-04", "smoltcp", "wifi", "unstable"] }
-esp-alloc = { version = "0.9.0", features = ["esp32c6", "internal-heap-stats"] }
+esp-bootloader-esp-idf = { version = "0.5.0", features = ["esp32c6", "log-04"] }
+esp-hal = { version = "1.1.0", features = ["esp32c6", "log-04"] }
+esp-rtos = { version = "0.3.0", features = ["esp32c6", "embassy", "esp-radio"] }
+esp-backtrace = { version = "0.19.0", features = ["esp32c6", "panic-handler", "println", "colors", "custom-halt"] }
+esp-println = { version = "0.17.0", features = ["esp32c6", "log-04", "auto"] }
+esp-storage = { version = "0.9.0", features = ["esp32c6"] }
+esp-radio = { version = "0.18.0", features = ["esp32c6", "log-04", "wifi", "unstable"] }
+esp-alloc = { version = "0.10.0", features = ["esp32c6", "internal-heap-stats"] }

 # Async runtime (Embassy core)
-embassy-executor = { version = "0.9.1", features = ["log", "nightly"] }
-embassy-time = { version = "0.5.0", features = ["log"], default-features = false }
-embassy-sync = { version = "0.7.2", features = ["log"] }
+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.7.1", features = [
-    "dhcpv4",
-    "log",
-    "medium-ethernet",
-    "tcp",
-    "udp",
-    "proto-ipv4",
-    "dns"
-] }
-smoltcp = { version = "0.12.0", default-features = false, features = [
-    "alloc",
-    "log",
-    "medium-ethernet",
-    "multicast",
-    "proto-dhcpv4",
-    "proto-ipv6",
-    "proto-dns",
-    "proto-ipv4",
-    "socket-dns",
-    "socket-icmp",
-    "socket-raw",
-    "socket-tcp",
-    "socket-udp",
-] }
+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.6.0"
-edge-nal = "0.5.0"
-edge-nal-embassy = "0.6.0"
-edge-http = { version = "0.6.1", features = ["log"] }
+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.22.0" }
+esp32c6 = { version = "0.23.2" }

 # Hardware abstraction traits and HAL adapters
 embedded-hal = "1.0.0"
 embedded-storage = "0.3.1"
-embassy-embedded-hal = "0.5.0"
+embassy-embedded-hal = "0.6.0"
 embedded-can = "0.4.1"
 nb = "1.1.0"

@@ -109,13 +86,12 @@ pca9535 = { version = "2.0.0" }
 ina219 = { version = "0.2.0" }

 # Storage and filesystem
-littlefs2 = { version = "0.6.1", features = ["c-stubs", "alloc"] }
-littlefs2-core = "0.1.2"
+embedded-savegame = { version = "0.3.0" }

 # Serialization / codecs
 serde = { version = "1.0.228", features = ["derive", "alloc"], default-features = false }
 serde_json = { version = "1.0.145", default-features = false, features = ["alloc"] }
-bincode = { version = "2.0.1", default-features = false, features = ["derive"] }
+postcard = { version = "1.1.3", default-features = false, features = ["alloc"] }

 # Time and time zones
 chrono = { version = "0.4.42", default-features = false, features = ["iana-time-zone", "alloc", "serde"] }
@@ -125,6 +101,7 @@ chrono-tz = { version = "0.10.4", default-features = false, features = ["filter-
 heapless = { version = "0.7.17", features = ["serde"] } # stay in sync with mcutie version
 static_cell = "2.1.1"
 portable-atomic = "1.11.1"
+critical-section = "1"
 crc = "3.3.0"
 bytemuck = { version = "1.24.0", features = ["derive", "min_const_generics", "pod_saturating", "extern_crate_alloc"] }
 deranged = "0.5.5"
@@ -133,12 +110,8 @@ unit-enum = "1.4.3"
 async-trait = "0.1.89"
 option-lock = { version = "0.3.1", default-features = false }
 measurements = "0.11.1"
+mcutie = { path = "src/mcutie_3_0_0", features = ["log"] }

-# Project-specific
-mcutie = { version = "0.3.0", default-features = false, features = ["log", "homeassistant"] }
-
-[patch.crates-io]
-mcutie = { git = 'https://github.com/empirephoenix/mcutie.git' }
 #bq34z100 = { path = "../../bq34z100_rust" }

 [build-dependencies]
--- a/Software/MainBoard/rust/TODO
+++ b/Software/MainBoard/rust/TODO
@@ -0,0 +1,3 @@
+One Wire does not seem to work.
+Flow Sensor does not seem to work.
+PlantProfiles with a dry out phase needs to be implemented + Memory for this
--- a/Software/MainBoard/rust/build.rs
+++ b/Software/MainBoard/rust/build.rs
@@ -49,5 +49,8 @@ fn linker_be_nice() {

 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();
 }
--- a/Software/MainBoard/rust/clippy.toml
+++ b/Software/MainBoard/rust/clippy.toml
@@ -0,0 +1,2 @@
+# This file is used for clippy configuration. 
+# It shouldn't contain the deny attributes, which belong to the crate root.
--- a/Software/MainBoard/rust/espflash.toml
+++ b/Software/MainBoard/rust/espflash.toml
@@ -1,8 +1,6 @@
-[connection]
+format = "EspIdf"

-[[usb_device]]
-vid = "303a"
-pid = "1001"
+[idf_format_args]

 [flash]
 size = "16MB"
--- a/Software/MainBoard/rust/src/config.rs
+++ b/Software/MainBoard/rust/src/config.rs
@@ -1,25 +1,25 @@
 use crate::hal::PLANT_COUNT;
 use crate::plant_state::PlantWateringMode;
-use alloc::string::String;
-use core::str::FromStr;
+use alloc::string::{String, ToString};
 use serde::{Deserialize, Serialize};

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(default)]
 pub struct NetworkConfig {
-    pub ap_ssid: heapless::String<32>,
-    pub ssid: Option<heapless::String<32>>,
-    pub password: Option<heapless::String<64>>,
+    pub ap_ssid: String,
+    pub ssid: Option<String>,
+    pub password: Option<String>,
    pub mqtt_url: Option<String>,
-    pub base_topic: Option<heapless::String<64>>,
+    pub base_topic: Option<String>,
    pub mqtt_user: Option<String>,
    pub mqtt_password: Option<String>,
    pub max_wait: u32,
+    pub retry_count: u32,
 }
 impl Default for NetworkConfig {
    fn default() -> Self {
        Self {
-            ap_ssid: heapless::String::from_str("PlantCtrl Init").unwrap(),
+            ap_ssid: "PlantCtrl Init".to_string(),
            ssid: None,
            password: None,
            mqtt_url: None,
@@ -27,6 +27,7 @@ impl Default for NetworkConfig {
            mqtt_user: None,
            mqtt_password: None,
            max_wait: 10000,
+            retry_count: 3,
        }
    }
 }
@@ -96,6 +97,8 @@ pub enum BoardVersion {
 pub struct BoardHardware {
    pub board: BoardVersion,
    pub battery: BatteryBoardVersion,
+    #[serde(default)]
+    pub pump_corrosion_protection: bool,
 }

 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
@@ -109,6 +112,14 @@ pub struct PlantControllerConfig {
    pub timezone: Option<String>,
 }

+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
+pub enum SensorCombineMode {
+    Min,
+    Max,
+    #[default]
+    Avg,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(default)]
 pub struct PlantConfig {
@@ -128,6 +139,9 @@ pub struct PlantConfig {
    pub min_pump_current_ma: u16,
    pub max_pump_current_ma: u16,
    pub ignore_current_error: bool,
+    pub fertilizer_s: u16,
+    pub fertilizer_cooldown_min: u16,
+    pub sensor_combine_mode: SensorCombineMode,
 }

 impl Default for PlantConfig {
@@ -149,6 +163,9 @@ impl Default for PlantConfig {
            min_pump_current_ma: 10,
            max_pump_current_ma: 3000,
            ignore_current_error: true,
+            fertilizer_s: 0,
+            fertilizer_cooldown_min: 1440, // 1 day default
+            sensor_combine_mode: SensorCombineMode::Avg,
        }
    }
 }
--- a/Software/MainBoard/rust/src/fat_error.rs
+++ b/Software/MainBoard/rust/src/fat_error.rs
@@ -1,5 +1,7 @@
 use alloc::format;
 use alloc::string::{String, ToString};
+use chrono::format::ParseErrorKind;
+use chrono_tz::ParseError;
 use core::convert::Infallible;
 use core::fmt;
 use core::fmt::Debug;
@@ -14,28 +16,18 @@ use esp_hal::twai::EspTwaiError;
 use esp_radio::wifi::WifiError;
 use ina219::errors::{BusVoltageReadError, ShuntVoltageReadError};
 use lib_bms_protocol::BmsProtocolError;
-use littlefs2_core::PathError;
 use onewire::Error;
 use pca9535::ExpanderError;

 //All error superconstruct
 #[derive(Debug)]
 pub enum FatError {
-    BMSError {
-        error: String,
-    },
    OneWireError {
        error: Error<Infallible>,
    },
    String {
        error: String,
    },
-    LittleFSError {
-        error: littlefs2_core::Error,
-    },
-    PathError {
-        error: PathError,
-    },
    TryLockError {
        error: TryLockError,
    },
@@ -86,8 +78,6 @@ impl fmt::Display for FatError {
            }
            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:?}"),
@@ -106,7 +96,6 @@ impl fmt::Display for FatError {
                write!(f, "CanBusError {error:?}")
            }
            FatError::SNTPError { error } => write!(f, "SNTPError {error:?}"),
-            FatError::BMSError { error } => write!(f, "BMSError, {error}"),
            FatError::OTAError => {
                write!(f, "OTA missing partition")
            }
@@ -149,23 +138,28 @@ impl<T> ContextExt<T> for Option<T> {
    }
 }

+impl<T, E> ContextExt<T> for Result<T, E>
+where
+    E: fmt::Debug,
+{
+    fn context<C>(self, context: C) -> Result<T, FatError>
+    where
+        C: AsRef<str>,
+    {
+        match self {
+            Ok(value) => Ok(value),
+            Err(err) => Err(FatError::String {
+                error: format!("{}: {:?}", context.as_ref(), err),
+            }),
+        }
+    }
+}
+
 impl From<Error<Infallible>> for FatError {
    fn from(error: Error<Infallible>) -> Self {
        FatError::OneWireError { error }
    }
 }
-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 }
@@ -236,16 +230,8 @@ impl<E: fmt::Debug> From<ExpanderError<I2cDeviceError<E>>> for FatError {
    }
 }

-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 {
+impl From<postcard::Error> for FatError {
+    fn from(value: postcard::Error) -> Self {
        FatError::Eeprom24x {
            error: format!("{value:?}"),
        }
@@ -283,7 +269,7 @@ impl<E: fmt::Debug> From<ShuntVoltageReadError<I2cDeviceError<E>>> for FatError

 impl From<Infallible> for FatError {
    fn from(value: Infallible) -> Self {
-        panic!("Infallible error: {:?}", value)
+        match value {}
    }
 }

@@ -333,6 +319,33 @@ impl From<BmsProtocolError> for FatError {
            BmsProtocolError::I2cCommunicationError => FatError::String {
                error: "I2C communication error".to_string(),
            },
+            BmsProtocolError::ChecksumError => FatError::String {
+                error: "BMS checksum error".to_string(),
+            },
+        }
+    }
+}
+
+impl From<ParseError> for FatError {
+    fn from(value: ParseError) -> Self {
+        FatError::String {
+            error: format!("Parsing error: {value:?}"),
+        }
+    }
+}
+
+impl From<ParseErrorKind> for FatError {
+    fn from(value: ParseErrorKind) -> Self {
+        FatError::String {
+            error: format!("Parsing error: {value:?}"),
+        }
+    }
+}
+
+impl From<chrono::format::ParseError> for FatError {
+    fn from(value: chrono::format::ParseError) -> Self {
+        FatError::String {
+            error: format!("Parsing error: {value:?}"),
        }
    }
 }
--- a/Software/MainBoard/rust/src/hal/battery.rs
+++ b/Software/MainBoard/rust/src/hal/battery.rs
@@ -1,5 +1,6 @@
-use crate::fat_error::{FatError, FatResult};
 use crate::hal::Box;
+use crate::fat_error::{FatError, FatResult};
+use alloc::string::String;
 use async_trait::async_trait;
 use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
@@ -18,15 +19,23 @@ pub trait BatteryInteraction {
    async fn reset(&mut self) -> FatResult<()>;
 }

-#[derive(Debug, Serialize, Copy, Clone)]
+#[derive(Debug, Serialize, Clone)]
 pub struct BatteryInfo {
-    pub voltage_milli_volt: u32,
-    pub average_current_milli_ampere: i32,
-    pub design_milli_ampere_hour: u32,
-    pub remaining_milli_ampere_hour: u32,
-    pub state_of_charge: u8,
-    pub state_of_health: u32,
-    pub temperature: i32,
+    pub voltage_mv: Option<u32>,
+    pub avg_current_ma: Option<i32>,
+    pub design_mah: Option<u32>,
+    pub remaining_mah: Option<u32>,
+    pub soc_pct: Option<f32>,
+    pub soh_pct: Option<f32>,
+    pub temperature_c: Option<i32>,
+    pub error: Option<BatteryError>,
+}
+
+#[derive(Debug, Serialize, Clone)]
+#[serde(tag = "kind")]
+pub enum BatteryError {
+    NoBatteryMonitor,
+    CommunicationError { message: String },
 }

 #[derive(Debug, Serialize)]
@@ -71,17 +80,19 @@ impl BatteryInteraction for WCHI2CSlave<'_> {
        let config = Config::read_from_i2c(&mut self.i2c)?;

        let state_of_charge =
-            (state.remaining_capacity_mah * 100 / state.lifetime_capacity_mah) as u8;
-        let state_of_health = state.lifetime_capacity_mah / config.capacity_mah * 100;
+            state.remaining_capacity_mah as f32 * 100. / state.lifetime_capacity_mah as f32;
+        let state_of_health =
+            state.lifetime_capacity_mah as f32 / config.capacity_mah as f32 * 100.;

        Ok(BatteryState::Info(BatteryInfo {
-            voltage_milli_volt: state.current_mv,
-            average_current_milli_ampere: 1337,
-            design_milli_ampere_hour: config.capacity_mah,
-            remaining_milli_ampere_hour: state.remaining_capacity_mah,
-            state_of_charge,
-            state_of_health,
-            temperature: state.temperature_celcius,
+            voltage_mv: Some(state.current_mv),
+            avg_current_ma: Some(1337),
+            design_mah: Some(config.capacity_mah),
+            remaining_mah: Some(state.remaining_capacity_mah),
+            soc_pct: Some(state_of_charge),
+            soh_pct: Some(state_of_health),
+            temperature_c: Some(state.temperature_celcius),
+            error: None,
        }))
    }

--- a/Software/MainBoard/rust/src/hal/esp.rs
+++ b/Software/MainBoard/rust/src/hal/esp.rs
--- a/Software/MainBoard/rust/src/hal/little_fs2storage_adapter.rs
+++ b/Software/MainBoard/rust/src/hal/little_fs2storage_adapter.rs
@@ -1,88 +0,0 @@
-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)
-            }
-        }
-    }
-}
--- a/Software/MainBoard/rust/src/hal/mod.rs
+++ b/Software/MainBoard/rust/src/hal/mod.rs
@@ -3,14 +3,14 @@ use lib_bms_protocol::BmsReadable;
 pub(crate) mod battery;
 // mod can_api; // replaced by external canapi crate
 pub mod esp;
-mod little_fs2storage_adapter;
 pub(crate) mod rtc;
+pub(crate) mod savegame_manager;
 mod shared_flash;
 mod v4_hal;
 mod water;

 use crate::alloc::string::ToString;
-use crate::hal::rtc::{DS3231Module, RTCModuleInteraction};
+use crate::hal::rtc::{BackupHeader, DS3231Module, RTCModuleInteraction};
 use esp_hal::peripherals::Peripherals;
 use esp_hal::peripherals::ADC1;
 use esp_hal::peripherals::GPIO0;
@@ -44,14 +44,13 @@ use crate::{
        battery::{BatteryInteraction, NoBatteryMonitor},
        esp::Esp,
    },
+    log::log,
    log::LogMessage,
-    BOARD_ACCESS,
 };
 use alloc::boxed::Box;
 use alloc::format;
 use alloc::sync::Arc;
 use async_trait::async_trait;
-use bincode::{Decode, Encode};
 use canapi::SensorSlot;
 use chrono::{DateTime, FixedOffset, Utc};
 use core::cell::RefCell;
@@ -75,9 +74,8 @@ use measurements::{Current, Voltage};

 use crate::fat_error::{ContextExt, FatError, FatResult};
 use crate::hal::battery::WCHI2CSlave;
-use crate::hal::little_fs2storage_adapter::LittleFs2Filesystem;
+use crate::hal::savegame_manager::SavegameManager;
 use crate::hal::water::TankSensor;
-use crate::log::LOG_ACCESS;
 use embassy_sync::mutex::Mutex;
 use embassy_sync::once_lock::OnceLock;
 use embedded_storage::nor_flash::RmwNorFlashStorage;
@@ -86,39 +84,40 @@ use esp_alloc as _;
 use esp_backtrace as _;
 use esp_bootloader_esp_idf::ota::{Ota, OtaImageState};
 use esp_hal::delay::Delay;
-use esp_hal::i2c::master::{BusTimeout, Config, I2c};
+use esp_hal::i2c::master::{BusTimeout, Config, FsmTimeout, I2c};
 use esp_hal::interrupt::software::SoftwareInterruptControl;
 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;
+use esp_hal::timer::timg::{MwdtStage, TimerGroup, Wdt};
 use esp_hal::uart::Uart;
 use esp_hal::Blocking;
-use esp_radio::{init, Controller};
 use esp_storage::FlashStorage;
-use littlefs2::fs::{Allocation, Filesystem as lfs2Filesystem};
-use littlefs2::object_safe::DynStorage;
-use log::{error, info, warn};
+use log::{info, warn};
 use portable_atomic::AtomicBool;
 use serde::{Deserialize, Serialize};
 use shared_flash::MutexFlashStorage;

-pub static TIME_ACCESS: OnceLock<Mutex<CriticalSectionRawMutex, Rtc>> = OnceLock::new();
-
 //Only support for 8 right now!
 pub const PLANT_COUNT: usize = 8;

 pub static PROGRESS_ACTIVE: AtomicBool = AtomicBool::new(false);

+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<
    embassy_sync::blocking_mutex::Mutex<CriticalSectionRawMutex, RefCell<I2c<Blocking>>>,
 > = OnceLock::new();

-#[derive(Debug, PartialEq, Clone, Copy, Encode, Decode)]
+#[derive(Debug, PartialEq, Clone, Copy, Serialize, Deserialize)]
 pub enum Sensor {
    A,
    B,
@@ -142,13 +141,15 @@ pub struct HAL<'a> {

 #[async_trait(?Send)]
 pub trait BoardInteraction<'a> {
-    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError>;
+    fn get_tank_sensor(&mut self) -> &mut TankSensor<'a>;
    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>;
+    async fn get_time(&mut self) -> DateTime<Utc>;
+    async fn set_time(&mut self, time: &DateTime<FixedOffset>) -> FatResult<()>;
    async fn set_charge_indicator(&mut self, charging: bool) -> Result<(), FatError>;
-    async fn deep_sleep(&mut self, duration_in_ms: u64) -> !;
+    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> !;

    fn is_day(&self) -> bool;
    //should be multsampled
@@ -163,16 +164,29 @@ pub trait BoardInteraction<'a> {
    async fn get_mptt_voltage(&mut self) -> FatResult<Voltage>;
    async fn get_mptt_current(&mut self) -> FatResult<Current>;
    async fn can_power(&mut self, state: bool) -> FatResult<()>;
+    async fn fertilizer_pump(&mut self, enable: bool) -> FatResult<()>;
+
+    async fn backup_config(&mut self, config: &PlantControllerConfig) -> FatResult<()>;
+    async fn read_backup(&mut self) -> FatResult<PlantControllerConfig>;
+    async fn backup_info(&mut self) -> FatResult<BackupHeader>;

    // Return JSON string with autodetected sensors per plant. Default: not supported.
-    async fn detect_sensors(&mut self, _request: Detection) -> FatResult<Detection> {
+    async fn detect_sensors(&mut self, _request: DetectionRequest) -> FatResult<Detection> {
        bail!("Autodetection is only available on v4 HAL with CAN bus");
    }

+    /// Return the last known firmware build timestamps per sensor, set during detect_sensors.
+    fn get_sensor_build_minutes(&self) -> ([Option<u32>; PLANT_COUNT], [Option<u32>; PLANT_COUNT]) {
+        ([None; PLANT_COUNT], [None; PLANT_COUNT])
+    }
+
    async fn progress(&mut self, counter: u32) {
        // Indicate progress is active to suppress default wait_infinity blinking
        PROGRESS_ACTIVE.store(true, core::sync::atomic::Ordering::Relaxed);

+        // Feed watchdog during long-running webserver operations
+        PlantHal::feed_watchdog();
+
        let current = counter % PLANT_COUNT as u32;
        for led in 0..PLANT_COUNT {
            if let Err(err) = self.fault(led, current == led as u32).await {
@@ -227,14 +241,7 @@ pub struct FreePeripherals<'a> {
    pub adc1: ADC1<'a>,
 }

-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
-    }};
-}
+use crate::util::mk_static;

 impl PlantHal {
    pub async fn create() -> Result<Mutex<CriticalSectionRawMutex, HAL<'static>>, FatError> {
@@ -244,17 +251,23 @@ impl PlantHal {
        esp_alloc::heap_allocator!(size: 64 * 1024);
        esp_alloc::heap_allocator!(#[link_section = ".dram2_uninit"] size: 64000);

-        let rtc: Rtc = Rtc::new(peripherals.LPWR);
-        TIME_ACCESS
-            .init(Mutex::new(rtc))
-            .map_err(|_| FatError::String {
-                error: "Init error rct".to_string(),
-            })?;
+        let mut rtc_peripheral: Rtc = Rtc::new(peripherals.LPWR);
+        rtc_peripheral.rwdt.disable();

        let timg0 = TimerGroup::new(peripherals.TIMG0);
        let sw_int = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
        esp_rtos::start(timg0.timer0, sw_int.software_interrupt0);

+        // Initialize and enable the watchdog with 30 second timeout
+        let mut wdt = timg0.wdt;
+        wdt.set_timeout(MwdtStage::Stage0, esp_hal::time::Duration::from_secs(30));
+        wdt.enable();
+        WATCHDOG
+            .init(embassy_sync::blocking_mutex::Mutex::new(RefCell::new(wdt)))
+            .map_err(|_| FatError::String {
+                error: "Watchdog already initialized".to_string(),
+            })?;
+
        let boot_button = Input::new(
            peripherals.GPIO9,
            InputConfig::default().with_pull(Pull::None),
@@ -264,16 +277,14 @@ impl PlantHal {
        let wake_gpio1 = peripherals.GPIO1;

        let rng = Rng::new();
-        let esp_wifi_ctrl = &*mk_static!(
-            Controller<'static>,
-            init().expect("Could not init wifi controller")
-        );

-        let (controller, interfaces) =
-            esp_radio::wifi::new(esp_wifi_ctrl, peripherals.WIFI, Default::default())
-                .expect("Could not init wifi");
+        let (controller, interfaces) = esp_radio::wifi::new(peripherals.WIFI, Default::default())
+            .map_err(|e| FatError::String {
+            error: format!("Could not init wifi: {:?}", e),
+        })?;

-        let pcnt_module = Pcnt::new(peripherals.PCNT);
+        let mut pcnt_module = Pcnt::new(peripherals.PCNT);
+        pcnt_module.set_interrupt_handler(water::flow_interrupt_handler);

        let free_pins = FreePeripherals {
            gpio0: peripherals.GPIO0,
@@ -325,19 +336,16 @@ impl PlantHal {
            pt.find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
                DataPartitionSubType::Ota,
            ))?
-            .expect("No OTA data partition found")
+            .context("No OTA data partition found")?
        );

-        let ota_data = mk_static!(
-            FlashRegion<RmwNorFlashStorage<&mut MutexFlashStorage>>,
-            ota_data.as_embedded_storage(mk_static!(
-                RmwNorFlashStorage<&mut MutexFlashStorage>,
-                RmwNorFlashStorage::new(flash_storage_2, mk_static!([u8; 4096], [0_u8; 4096]))
-            ))
-        );
+        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, ota_data);
-        let state_1 = ota_state(AppPartitionSubType::Ota1, ota_data);
+        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)?;
@@ -370,42 +378,30 @@ impl PlantHal {
            .find_partition(esp_bootloader_esp_idf::partitions::PartitionType::Data(
                DataPartitionSubType::LittleFs,
            ))?
-            .expect("Data partition with littlefs not found");
+            .context("Storage data partition not found")?;
        let data_partition = mk_static!(PartitionEntry, data_partition);

        let data = mk_static!(
-            FlashRegion<MutexFlashStorage>,
+            FlashRegion<'static, 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 savegame = SavegameManager::new(data);
+        info!(
+            "Savegame storage initialized ({} slots × {} KB)",
+            savegame_manager::SAVEGAME_SLOT_COUNT,
+            savegame_manager::SAVEGAME_SLOT_SIZE / 1024
+        );

        let uart0 =
            Uart::new(peripherals.UART0, UartConfig::default()).map_err(|_| FatError::String {
                error: "Uart creation failed".to_string(),
            })?;

-        let ap = interfaces.ap;
-        let sta = interfaces.sta;
+        let ap = interfaces.access_point;
+        let sta = interfaces.station;
        let mut esp = Esp {
-            fs,
+            savegame,
            rng,
            controller: Arc::new(Mutex::new(controller)),
            interface_sta: Some(sta),
@@ -418,6 +414,7 @@ impl PlantHal {
            slot0_state: state_0,
            slot1_state: state_1,
            uart0,
+            rtc: rtc_peripheral,
        };

        //init,reset rtc memory depending on cause
@@ -453,17 +450,13 @@ impl PlantHal {
                SocResetReason::Cpu0JtagCpu => "cpu0 jtag cpu",
            },
        };
-        LOG_ACCESS
-            .lock()
-            .await
-            .log(
-                LogMessage::ResetReason,
-                init_rtc_store as u32,
-                to_config_mode as u32,
-                "",
-                &format!("{reasons:?}"),
-            )
-            .await;
+        log(
+            LogMessage::ResetReason,
+            init_rtc_store as u32,
+            to_config_mode as u32,
+            "",
+            &format!("{reasons:?}"),
+        );

        esp.init_rtc_deepsleep_memory(init_rtc_store, to_config_mode)
            .await;
@@ -475,11 +468,16 @@ impl PlantHal {
        let sda = peripherals.GPIO20;
        let scl = peripherals.GPIO19;

+        // Configure I2C with 1-second timeout
+        // At 100 Hz I2C clock, one bus cycle = 10ms
+        // For 1 second timeout: 100 bus cycles
        let i2c = I2c::new(
            peripherals.I2C0,
            Config::default()
-                .with_frequency(Rate::from_hz(100))
-                .with_timeout(BusTimeout::Maximum),
+                //.with_frequency(Rate::from_hz(100))
+                //1s at 100khz
+                .with_timeout(BusTimeout::BusCycles(100_000))
+                .with_scl_main_st_timeout(FsmTimeout::new(21)?),
        )?
        .with_scl(scl)
        .with_sda(sda);
@@ -488,7 +486,9 @@ impl PlantHal {
            RefCell<I2c<Blocking>>,
        > = CriticalSectionMutex::new(RefCell::new(i2c));

-        I2C_DRIVER.init(i2c_bus).expect("Could not init i2c driver");
+        I2C_DRIVER.init(i2c_bus).map_err(|_| FatError::String {
+            error: "Could not init i2c driver".to_string(),
+        })?;

        let i2c_bus = I2C_DRIVER.get().await;
        let rtc_device = I2cDevice::new(i2c_bus);
@@ -555,17 +555,13 @@ impl PlantHal {
                HAL { board_hal }
            }
            Err(err) => {
-                LOG_ACCESS
-                    .lock()
-                    .await
-                    .log(
-                        LogMessage::ConfigModeMissingConfig,
-                        0,
-                        0,
-                        "",
-                        &err.to_string(),
-                    )
-                    .await;
+                log(
+                    LogMessage::ConfigModeMissingConfig,
+                    0,
+                    0,
+                    "",
+                    &err.to_string(),
+                );
                HAL {
                    board_hal: v4_hal::create_v4(
                        free_pins,
@@ -581,6 +577,15 @@ impl PlantHal {

        Ok(Mutex::new(hal))
    }
+
+    /// Feed the watchdog timer to prevent system reset
+    pub fn feed_watchdog() {
+        if let Some(wdt_mutex) = WATCHDOG.try_get() {
+            wdt_mutex.lock(|cell| {
+                cell.borrow_mut().feed();
+            });
+        }
+    }
 }

 fn ota_state(
@@ -648,39 +653,38 @@ pub fn next_partition(current: AppPartitionSubType) -> FatResult<AppPartitionSub
    Ok(next)
 }

-pub async fn esp_time() -> DateTime<Utc> {
-    let guard = TIME_ACCESS.get().await.lock().await;
-    DateTime::from_timestamp_micros(guard.current_time_us() as i64).unwrap()
-}
-
-pub async fn esp_set_time(time: DateTime<FixedOffset>) -> FatResult<()> {
-    {
-        let guard = TIME_ACCESS.get().await.lock().await;
-        guard.set_current_time_us(time.timestamp_micros() as u64);
-    }
-    BOARD_ACCESS
-        .get()
-        .await
-        .lock()
-        .await
-        .board_hal
-        .get_rtc_module()
-        .set_rtc_time(&time.to_utc())
-        .await
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Default, Serialize)]
 pub struct Moistures {
    pub sensor_a_hz: [Option<f32>; PLANT_COUNT],
    pub sensor_b_hz: [Option<f32>; PLANT_COUNT],
+    pub sensor_a_build_minutes: [Option<u32>; PLANT_COUNT],
+    pub sensor_b_build_minutes: [Option<u32>; PLANT_COUNT],
 }

+/// Request: which sensors to send IDENTIFY_CMD to.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct DetectionRequest {
+    pub plant: [SensorRequest; PLANT_COUNT],
+}
+
+/// Per-sensor portion of a detection request.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct SensorRequest {
+    pub sensor_a: bool,
+    pub sensor_b: bool,
+}
+
+/// Response: detection result per plant.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct Detection {
-    plant: [DetectionSensorResult; PLANT_COUNT],
+    pub plant: [DetectionSensorResult; PLANT_COUNT],
 }
+
+/// Per-sensor detection result.
+/// `Some(build_minutes)` = sensor responded; value is its firmware build timestamp
+/// (minutes since Unix epoch, or 0 if not reported). `None` = not detected.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
 pub struct DetectionSensorResult {
-    sensor_a: bool,
-    sensor_b: bool,
+    pub sensor_a: Option<u32>,
+    pub sensor_b: Option<u32>,
 }
--- a/Software/MainBoard/rust/src/hal/rtc.rs
+++ b/Software/MainBoard/rust/src/hal/rtc.rs
@@ -1,8 +1,6 @@
 use crate::fat_error::FatResult;
 use crate::hal::Box;
 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;
@@ -19,24 +17,21 @@ use esp_hal::Blocking;
 use serde::{Deserialize, Serialize};

 pub const X25: crc::Crc<u16> = crc::Crc::<u16>::new(&crc::CRC_16_IBM_SDLC);
-const CONFIG: Configuration = config::standard();
+pub const EEPROM_PAGE: usize = 32;
 //
 #[async_trait(?Send)]
 pub trait RTCModuleInteraction {
-    async fn get_backup_info(&mut self) -> FatResult<BackupHeader>;
-    async fn get_backup_config(&mut self, chunk: usize) -> FatResult<([u8; 32], usize, u16)>;
-    async fn backup_config(&mut self, offset: usize, bytes: &[u8]) -> FatResult<()>;
-    async fn backup_config_finalize(&mut self, crc: u16, length: usize) -> FatResult<()>;
    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)]
+    fn write(&mut self, offset: u32, data: &[u8]) -> FatResult<()>;
+    fn read(&mut self, offset: u32, data: &mut [u8]) -> FatResult<()>;
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Debug, Default)]
 pub struct BackupHeader {
    pub timestamp: i64,
-    crc16: u16,
+    pub(crate) crc16: u16,
    pub size: u16,
 }
 //
@@ -46,7 +41,7 @@ pub struct DS3231Module {
        DS3231,
    >,

-    pub(crate) storage: eeprom24x::Storage<
+    pub storage: eeprom24x::Storage<
        I2cDevice<'static, CriticalSectionRawMutex, I2c<'static, Blocking>>,
        B32,
        TwoBytes,
@@ -57,67 +52,6 @@ pub struct DS3231Module {

 #[async_trait(?Send)]
 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.read(0, &mut header_page_buffer)?;
-
-        let (header, len): (BackupHeader, usize) =
-            bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
-
-        log::info!("Raw header is {header_page_buffer:?} with size {len}");
-        Ok(header)
-    }
-
-    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.read(0, &mut header_page_buffer)?;
-        let (header, _header_size): (BackupHeader, usize) =
-            bincode::decode_from_slice(&header_page_buffer[..], CONFIG)?;
-
-        let mut buf = [0_u8; 32];
-        let offset = chunk * buf.len() + BACKUP_HEADER_MAX_SIZE;
-
-        let end: usize = header.size as usize + BACKUP_HEADER_MAX_SIZE;
-        let current_end = offset + buf.len();
-        let chunk_size = if current_end > end {
-            end - offset
-        } else {
-            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))
-        }
-    }
-    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().await?.timestamp_millis();
-        let header = BackupHeader {
-            crc16: crc,
-            timestamp: time,
-            size: length as u16,
-        };
-        let config = config::standard();
-        let encoded = bincode::encode_into_slice(&header, &mut header_page_buffer, config)?;
-        log::info!("Raw header is {header_page_buffer:?} with size {encoded}");
-        self.storage.write(0, &header_page_buffer)?;
-        Ok(())
-    }
-
    async fn get_rtc_time(&mut self) -> FatResult<DateTime<Utc>> {
        Ok(self.rtc.datetime()?.and_utc())
    }
@@ -126,4 +60,14 @@ impl RTCModuleInteraction for DS3231Module {
        let naive_time = time.naive_utc();
        Ok(self.rtc.set_datetime(&naive_time)?)
    }
+
+    fn write(&mut self, offset: u32, data: &[u8]) -> FatResult<()> {
+        self.storage.write(offset, data)?;
+        Ok(())
+    }
+
+    fn read(&mut self, offset: u32, data: &mut [u8]) -> FatResult<()> {
+        self.storage.read(offset, data)?;
+        Ok(())
+    }
 }
--- a/Software/MainBoard/rust/src/hal/savegame_manager.rs
+++ b/Software/MainBoard/rust/src/hal/savegame_manager.rs
@@ -0,0 +1,265 @@
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use embedded_savegame::storage::{Flash, Storage};
+use embedded_storage::nor_flash::{NorFlash, ReadNorFlash};
+use esp_bootloader_esp_idf::partitions::{Error as PartitionError, FlashRegion};
+use log::{error, info};
+use serde::Serialize;
+
+use crate::fat_error::{FatError, FatResult};
+use crate::hal::shared_flash::MutexFlashStorage;
+
+/// Size of each save slot in bytes (16 KB).
+pub const SAVEGAME_SLOT_SIZE: usize = 16384;
+//keep a little of space at the end due to partition table offsets
+const SAFETY: usize = 5;
+/// Number of slots in the 8 MB storage partition.
+pub const SAVEGAME_SLOT_COUNT: usize = (8 * 1024 * 1024) / SAVEGAME_SLOT_SIZE - SAFETY; // 507
+
+/// Metadata about a single existing save slot, returned by [`SavegameManager::list_saves`].
+#[derive(Serialize, Debug, Clone)]
+pub struct SaveInfo {
+    pub idx: usize,
+    pub len: u32,
+    /// UTC timestamp in RFC3339 format when the save was created
+    pub created_at: Option<alloc::string::String>,
+}
+
+const SAVE_MAGIC: [u8; 4] = *b"SGM1";
+const SAVE_HEADER_LEN: usize = 6; // magic (4) + timestamp_len (u16)
+
+struct ParsedSave<'a> {
+    created_at: &'a str,
+    data: &'a [u8],
+}
+
+fn strip_padding(data: &[u8]) -> &[u8] {
+    let mut end = data.len();
+    while end > 0 {
+        let b = data[end - 1];
+        if b == 0x00 || b == 0xFF {
+            end -= 1;
+        } else {
+            break;
+        }
+    }
+    &data[..end]
+}
+
+fn parse_save(data: &[u8]) -> FatResult<ParsedSave<'_>> {
+    if data.len() < SAVE_HEADER_LEN {
+        return Err(FatError::String {
+            error: "Save payload too short".into(),
+        });
+    }
+    if data[..4] != SAVE_MAGIC {
+        return Err(FatError::String {
+            error: "Save payload has invalid magic".into(),
+        });
+    }
+
+    let timestamp_len = u16::from_le_bytes([data[4], data[5]]) as usize;
+    let timestamp_end = SAVE_HEADER_LEN + timestamp_len;
+    if timestamp_end > data.len() {
+        return Err(FatError::String {
+            error: "Save payload timestamp length exceeds data".into(),
+        });
+    }
+
+    let created_at = core::str::from_utf8(&data[SAVE_HEADER_LEN..timestamp_end]).map_err(|e| {
+        FatError::String {
+            error: alloc::format!("Save payload contains invalid timestamp UTF-8: {e:?}"),
+        }
+    })?;
+
+    Ok(ParsedSave {
+        created_at,
+        data: strip_padding(&data[timestamp_end..]),
+    })
+}
+
+// ── Flash adapter ──────────────────────────────────────────────────────────────
+
+/// Newtype wrapper around a [`PartitionError`] so we can implement the
+/// [`core::fmt::Debug`] bound required by [`embedded_savegame::storage::Flash`].
+#[derive(Debug)]
+pub struct SavegameFlashError(#[allow(dead_code)] PartitionError);
+
+/// Adapts a `&mut FlashRegion<'static, MutexFlashStorage>` to the
+/// [`embedded_savegame::storage::Flash`] trait.
+///
+/// `erase(addr)` erases exactly one slot (`SAVEGAME_SLOT_SIZE` bytes) starting
+/// at `addr`, which is what embedded-savegame expects for NOR flash.
+pub struct SavegameFlashAdapter<'a> {
+    region: &'a mut FlashRegion<'static, MutexFlashStorage>,
+}
+
+impl Flash for SavegameFlashAdapter<'_> {
+    type Error = SavegameFlashError;
+
+    fn read(&mut self, addr: u32, buf: &mut [u8]) -> Result<(), Self::Error> {
+        ReadNorFlash::read(self.region, addr, buf).map_err(SavegameFlashError)
+    }
+
+    fn write(&mut self, addr: u32, data: &mut [u8]) -> Result<(), Self::Error> {
+        info!(
+            "Relative writing to flash at 0x{:x} with length {}",
+            addr,
+            data.len()
+        );
+        let error = NorFlash::write(self.region, addr, data);
+        if let Err(err) = error {
+            error!("error {:?}", err);
+        }
+        error.map_err(SavegameFlashError)
+    }
+
+    /// Erase one full slot at `addr`.
+    /// embedded-savegame calls this before writing to a slot, so we erase
+    /// the entire `SAVEGAME_SLOT_SIZE` bytes so subsequent writes land on
+    /// pre-erased (0xFF) pages.
+    /// Ensures addresses are aligned to ERASE_SIZE (4KB) boundaries.
+    fn erase(&mut self, addr: u32) -> Result<(), Self::Error> {
+        const ERASE_SIZE: u32 = 4096;
+        // Align start address down to erase boundary
+        let aligned_start = (addr / ERASE_SIZE) * ERASE_SIZE;
+        // Align end address up to erase boundary
+        let end = addr + SAVEGAME_SLOT_SIZE as u32;
+        let aligned_end = end.div_ceil(ERASE_SIZE) * ERASE_SIZE;
+
+        info!(
+            "Relative erasing flash at 0x{:x} (aligned to 0x{:x}-0x{:x})",
+            addr, aligned_start, aligned_end
+        );
+
+        if aligned_start != addr || aligned_end != end {
+            log::warn!("Flash erase address not aligned: addr=0x{:x}, slot_size=0x{:x}. Aligned to 0x{:x}-0x{:x}", addr, SAVEGAME_SLOT_SIZE, aligned_start, aligned_end);
+        }
+
+        match NorFlash::erase(self.region, aligned_start, aligned_end) {
+            Ok(_) => Ok(()),
+            Err(err) => {
+                error!(
+                    "Flash erase failed: {:?}. 0x{:x}-0x{:x}",
+                    err, aligned_start, aligned_end
+                );
+                Err(SavegameFlashError(err))
+            }
+        }
+    }
+}
+
+impl From<SavegameFlashError> for FatError {
+    fn from(e: SavegameFlashError) -> Self {
+        FatError::String {
+            error: alloc::format!("Savegame flash error: {:?}", e),
+        }
+    }
+}
+
+// ── SavegameManager ────────────────────────────────────────────────────────────
+
+/// High-level save-game manager that stores JSON config blobs on the storage
+/// partition using [`embedded_savegame`] for wear leveling and power-fail safety.
+pub struct SavegameManager {
+    storage: Storage<SavegameFlashAdapter<'static>, SAVEGAME_SLOT_SIZE, SAVEGAME_SLOT_COUNT>,
+}
+
+impl SavegameManager {
+    pub fn new(region: &'static mut FlashRegion<'static, MutexFlashStorage>) -> Self {
+        Self {
+            storage: Storage::new(SavegameFlashAdapter { region }),
+        }
+    }
+
+    /// Persist `data` (JSON bytes) to the next available slot with a UTC timestamp.
+    ///
+    /// `scan()` advances the internal wear-leveling pointer to the latest valid
+    /// slot before `append()` writes to the next free one.
+    /// Both operations are performed atomically on the same Storage instance.
+    pub fn save(&mut self, data: &[u8], timestamp: &str) -> FatResult<()> {
+        let timestamp_bytes = timestamp.as_bytes();
+        let timestamp_len: u16 =
+            timestamp_bytes
+                .len()
+                .try_into()
+                .map_err(|_| FatError::String {
+                    error: "Timestamp too long for save header".into(),
+                })?;
+
+        let mut serialized =
+            Vec::with_capacity(SAVE_HEADER_LEN + timestamp_bytes.len() + data.len());
+        serialized.extend_from_slice(&SAVE_MAGIC);
+        serialized.extend_from_slice(&timestamp_len.to_le_bytes());
+        serialized.extend_from_slice(timestamp_bytes);
+        serialized.extend_from_slice(data);
+
+        // Flash storage often requires length to be a multiple of 4.
+        let padding = (4 - (serialized.len() % 4)) % 4;
+        if padding > 0 {
+            serialized.extend_from_slice(&[0u8; 4][..padding]);
+        }
+
+        info!("Serialized config with size {} (padded)", serialized.len());
+        self.storage.append(&mut serialized)?;
+        Ok(())
+    }
+
+    /// Load the most recently saved data.  Returns `None` if no valid save exists.
+    /// Unwraps the SaveWrapper and returns only the config data.
+    pub fn load_latest(&mut self) -> FatResult<Option<Vec<u8>>> {
+        let slot = self.storage.scan()?;
+        match slot {
+            None => Ok(None),
+            Some(slot) => self.load_slot(slot.idx),
+        }
+    }
+
+    /// Load a specific save by slot index.  Returns `None` if the slot is
+    /// empty or contains an invalid checksum.
+    /// Unwraps the SaveWrapper and returns only the config data.
+    pub fn load_slot(&mut self, idx: usize) -> FatResult<Option<Vec<u8>>> {
+        let mut buf = alloc::vec![0u8; SAVEGAME_SLOT_SIZE];
+        match self.storage.read(idx, &mut buf)? {
+            None => Ok(None),
+            Some(data) => {
+                let parsed = parse_save(data)?;
+                Ok(Some(parsed.data.to_vec()))
+            }
+        }
+    }
+
+    /// Erase a specific slot by index, effectively deleting it.
+    pub fn delete_slot(&mut self, idx: usize) -> FatResult<()> {
+        self.storage.erase(idx).map_err(Into::into)
+    }
+
+    /// Iterate all slots and return metadata for every slot that contains a
+    /// valid save, using the Storage read API to avoid assuming internal slot structure.
+    /// Extracts timestamps from SaveWrapper if available.
+    pub fn list_saves(&mut self) -> FatResult<Vec<SaveInfo>> {
+        let mut saves = Vec::new();
+        let mut buf = alloc::vec![0u8; SAVEGAME_SLOT_SIZE];
+        for idx in 0..SAVEGAME_SLOT_COUNT {
+            if let Some(data) = self.storage.read(idx, &mut buf)? {
+                match parse_save(data) {
+                    Ok(save) => {
+                        saves.push(SaveInfo {
+                            idx,
+                            len: save.data.len() as u32,
+                            created_at: Some(alloc::string::String::from(save.created_at)),
+                        });
+                    }
+                    Err(err) => {
+                        saves.push(SaveInfo {
+                            idx,
+                            len: 0,
+                            created_at: Some(err.to_string()),
+                        });
+                    }
+                }
+            }
+        }
+        Ok(saves)
+    }
+}
--- a/Software/MainBoard/rust/src/hal/v4_hal.rs
+++ b/Software/MainBoard/rust/src/hal/v4_hal.rs
@@ -3,18 +3,20 @@ use crate::config::PlantControllerConfig;
 use crate::fat_error::{ContextExt, FatError, FatResult};
 use crate::hal::battery::BatteryInteraction;
 use crate::hal::esp::{hold_disable, hold_enable, Esp};
-use crate::hal::rtc::RTCModuleInteraction;
+use crate::hal::rtc::{BackupHeader, RTCModuleInteraction, EEPROM_PAGE, X25};
 use crate::hal::water::TankSensor;
 use crate::hal::{
-    BoardInteraction, Detection, FreePeripherals, Moistures, Sensor, I2C_DRIVER, PLANT_COUNT,
-    TIME_ACCESS,
+    BoardInteraction, Detection, DetectionRequest, FreePeripherals, Moistures, Sensor, I2C_DRIVER,
+    PLANT_COUNT,
 };
-use crate::log::{LogMessage, LOG_ACCESS};
+use crate::log::{log, LogMessage};
 use alloc::boxed::Box;
 use alloc::string::ToString;
 use async_trait::async_trait;
 use canapi::id::{classify, plant_id, MessageKind, IDENTIFY_CMD_OFFSET};
 use canapi::SensorSlot;
+use chrono::{DateTime, FixedOffset, Utc};
+use core::cmp::min;
 use embassy_embedded_hal::shared_bus::blocking::i2c::I2cDevice;
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_time::{Duration, Timer, WithTimeout};
@@ -30,10 +32,19 @@ use ina219::SyncIna219;
 use log::{error, info, warn};
 use measurements::Resistance;
 use measurements::{Current, Voltage};
+// use no_panic::no_panic;
 use pca9535::{GPIOBank, Pca9535Immediate, StandardExpanderInterface};

+pub const BACKUP_HEADER_MAX_SIZE: usize = 64;
+
 const MPPT_CURRENT_SHUNT_OHMS: f64 = 0.05_f64;
-const TWAI_BAUDRATE: twai::BaudRate = twai::BaudRate::B125K;
+const TWAI_BAUDRATE: twai::BaudRate = twai::BaudRate::Custom(twai::TimingConfig {
+    baud_rate_prescaler: 200, // 40MHz / 200 * 2 = 100 on C6, 100 * 20 = 2000 divisor, 40MHz / 2000 = 20kHz
+    sync_jump_width: 3,       // 4 TQ
+    tseg_1: 15,
+    tseg_2: 4,
+    triple_sample: true,
+});

 pub enum Charger<'a> {
    SolarMpptV1 {
@@ -133,6 +144,11 @@ pub struct V4<'a> {
    extra1: Output<'a>,
    extra2: Output<'a>,
    twai_config: Option<TwaiConfiguration<'static, Blocking>>,
+
+    /// Last known firmware build timestamps per sensor (minutes since Unix epoch).
+    /// Updated during detect_sensors; preserved across normal measurement cycles.
+    sensor_a_build_minutes: [Option<u32>; PLANT_COUNT],
+    sensor_b_build_minutes: [Option<u32>; PLANT_COUNT],
 }

 pub(crate) async fn create_v4(
@@ -145,9 +161,11 @@ pub(crate) async fn create_v4(
    info!("Start v4");
    let mut awake = Output::new(peripherals.gpio21, Level::High, OutputConfig::default());
    awake.set_high();
+    info!("v4: gpio21 awake ok");

    let mut general_fault = Output::new(peripherals.gpio23, Level::Low, OutputConfig::default());
    general_fault.set_low();
+    info!("v4: gpio23 general_fault ok");

    let twai_config = Some(TwaiConfiguration::new(
        peripherals.twai,
@@ -156,17 +174,24 @@ pub(crate) async fn create_v4(
        TWAI_BAUDRATE,
        TwaiMode::Normal,
    ));
+    info!("v4: twai config ok");

    let extra1 = Output::new(peripherals.gpio6, Level::Low, OutputConfig::default());
+    info!("v4: gpio6 extra1 ok");
    let extra2 = Output::new(peripherals.gpio15, Level::Low, OutputConfig::default());
+    info!("v4: gpio15 extra2 ok");

    let one_wire_pin = Flex::new(peripherals.gpio18);
+    info!("v4: gpio18 one_wire ok");
    let tank_power_pin = Output::new(peripherals.gpio11, Level::Low, OutputConfig::default());
+    info!("v4: gpio11 tank_power ok");
    let flow_sensor_pin = Input::new(
        peripherals.gpio4,
        InputConfig::default().with_pull(Pull::Up),
    );
+    info!("v4: gpio4 flow_sensor ok");

+    info!("v4: creating tank sensor");
    let tank_sensor = TankSensor::create(
        one_wire_pin,
        peripherals.adc1,
@@ -175,12 +200,17 @@ pub(crate) async fn create_v4(
        flow_sensor_pin,
        peripherals.pcnt1,
    )?;
+    info!("v4: tank sensor ok");

    let can_power = Output::new(peripherals.gpio22, Level::Low, OutputConfig::default());
+    info!("v4: gpio22 can_power ok");

    let solar_is_day = Input::new(peripherals.gpio7, InputConfig::default());
+    info!("v4: gpio7 solar_is_day ok");
    let light = Output::new(peripherals.gpio10, Level::Low, Default::default());
+    info!("v4: gpio10 light ok");
    let charge_indicator = Output::new(peripherals.gpio3, Level::Low, Default::default());
+    info!("v4: gpio3 charge_indicator ok");

    info!("Start pump expander");
    let pump_device = I2cDevice::new(I2C_DRIVER.get().await);
@@ -262,14 +292,16 @@ pub(crate) async fn create_v4(
        extra2,
        can_power,
        twai_config,
+        sensor_a_build_minutes: [None; PLANT_COUNT],
+        sensor_b_build_minutes: [None; PLANT_COUNT],
    };
    Ok(Box::new(v))
 }

 #[async_trait(?Send)]
 impl<'a> BoardInteraction<'a> for V4<'a> {
-    fn get_tank_sensor(&mut self) -> Result<&mut TankSensor<'a>, FatError> {
-        Ok(&mut self.tank_sensor)
+    fn get_tank_sensor(&mut self) -> &mut TankSensor<'a> {
+        &mut self.tank_sensor
    }

    fn get_esp(&mut self) -> &mut Esp<'a> {
@@ -288,15 +320,24 @@ impl<'a> BoardInteraction<'a> for V4<'a> {
        &mut self.rtc_module
    }

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

-    async fn deep_sleep(&mut self, duration_in_ms: u64) -> ! {
+    async fn deep_sleep_ms(&mut self, duration_in_ms: u64) -> ! {
        self.awake.set_low();
        self.charger.power_save();
-        let rtc = TIME_ACCESS.get().await.lock().await;
-        self.esp.deep_sleep(duration_in_ms, rtc);
+        self.esp.deep_sleep(duration_in_ms);
    }

    fn is_day(&self) -> bool {
@@ -328,19 +369,11 @@ impl<'a> BoardInteraction<'a> for V4<'a> {
                bail!("pump current sensor not available");
            }
            Some(pump_ina) => {
-                let v = pump_ina
-                    .shunt_voltage()
-                    .map_err(|e| FatError::String {
-                        error: alloc::format!("{e:?}"),
-                    })
-                    .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)
+                let raw = pump_ina.shunt_voltage()?;
+                let shunt_voltage = Voltage::from_microvolts(raw.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();
+                Ok(Current::from_amperes(current))
            }
        }
    }
@@ -358,89 +391,45 @@ impl<'a> BoardInteraction<'a> for V4<'a> {
    async fn measure_moisture_hz(&mut self) -> FatResult<Moistures> {
        self.can_power.set_high();
        Timer::after_millis(500).await;
-        let config = self.twai_config.take().expect("twai config not set");
+        let config = self.twai_config.take().context("twai config not set")?;
        let mut twai = config.into_async().start();

-        Timer::after_millis(10).await;
+        if twai.is_bus_off() {
+            info!("Bus offline after start, attempting recovery");
+            // Re-start to initiate recovery
+            twai = twai.stop().start();
+        }

-        let mut moistures = Moistures::default();
-        let _ = wait_for_can_measurements(&mut twai, &mut moistures)
-            .with_timeout(Duration::from_millis(1000))
-            .await;
+        let res = (async {
+            Timer::after_millis(10).await;
+
+            let mut moistures = Moistures::default();
+            let _ = wait_for_can_measurements(&mut twai, &mut moistures)
+                .with_timeout(Duration::from_millis(5000))
+                .await;
+            Ok(moistures)
+        })
+        .await;

        let config = twai.stop().into_blocking();
        self.twai_config.replace(config);
-
        self.can_power.set_low();
-        Ok(moistures)
-    }

-    async fn detect_sensors(&mut self, request: Detection) -> FatResult<Detection> {
-        self.can_power.set_high();
-        Timer::after_millis(500).await;
-        let config = self.twai_config.take().expect("twai config not set");
-        let mut twai = config.into_async().start();
-
-        Timer::after_millis(1000).await;
-        info!("Sending info messages now");
-        // Send a few test messages per potential sensor node
-        for plant in 0..PLANT_COUNT {
-            for sensor in [Sensor::A, Sensor::B] {
-                let detect = if sensor == Sensor::A {
-                    request.plant[plant].sensor_a
-                } else {
-                    request.plant[plant].sensor_b
-                };
-                if !detect {
-                    continue;
+        // Persist any firmware build timestamps received alongside moisture data.
+        if let Ok(ref moistures) = res {
+            for (i, v) in moistures.sensor_a_build_minutes.iter().enumerate() {
+                if v.is_some() {
+                    self.sensor_a_build_minutes[i] = *v;
                }
-                let target = StandardId::new(plant_id(
-                    IDENTIFY_CMD_OFFSET,
-                    sensor.into(),
-                    (plant + 1) as u16,
-                ))
-                .context(">> Could not create address for sensor! (plant: {}) <<")?;
-                let can_buffer = [0_u8; 0];
-                info!(
-                    "Sending test message to plant {} sensor {sensor:?} with id {}",
-                    plant + 1,
-                    target.as_raw()
-                );
-                if let Some(frame) = EspTwaiFrame::new(target, &can_buffer) {
-                    // Try a few times; we intentionally ignore rx here and rely on stub logic
-                    let resu = twai
-                        .transmit_async(&frame)
-                        .with_timeout(Duration::from_millis(500))
-                        .await;
-                    match resu {
-                        Ok(_) => {}
-                        Err(err) => {
-                            info!(
-                                "Error sending test message to plant {} sensor {sensor:?}: {err:?}",
-                                plant + 1
-                            );
-                        }
-                    }
-                } else {
-                    info!("Error building CAN frame");
+            }
+            for (i, v) in moistures.sensor_b_build_minutes.iter().enumerate() {
+                if v.is_some() {
+                    self.sensor_b_build_minutes[i] = *v;
                }
            }
        }

-        let mut moistures = Moistures::default();
-        let _ = wait_for_can_measurements(&mut twai, &mut moistures)
-            .with_timeout(Duration::from_millis(3000))
-            .await;
-
-        let config = twai.stop().into_blocking();
-        self.twai_config.replace(config);
-
-        self.can_power.set_low();
-
-        let result = moistures.into();
-
-        info!("Autodetection result: {result:?}");
-        Ok(result)
+        res
    }

    async fn general_fault(&mut self, enable: bool) {
@@ -482,11 +471,7 @@ impl<'a> BoardInteraction<'a> for V4<'a> {
        for plant in 0..PLANT_COUNT {
            let a = moisture.sensor_a_hz[plant].unwrap_or(0.0) as u32;
            let b = moisture.sensor_b_hz[plant].unwrap_or(0.0) as u32;
-            LOG_ACCESS
-                .lock()
-                .await
-                .log(LogMessage::TestSensor, a, b, &(plant + 1).to_string(), "")
-                .await;
+            log(LogMessage::TestSensor, a, b, &(plant + 1).to_string(), "");
        }
        Timer::after_millis(10).await;
        Ok(())
@@ -512,6 +497,178 @@ impl<'a> BoardInteraction<'a> for V4<'a> {
        }
        Ok(())
    }
+
+    async fn fertilizer_pump(&mut self, enable: bool) -> FatResult<()> {
+        if enable {
+            self.extra2.set_high();
+        } else {
+            self.extra2.set_low();
+        }
+        Ok(())
+    }
+
+    async fn backup_config(&mut self, controller_config: &PlantControllerConfig) -> FatResult<()> {
+        let mut buffer: [u8; 4096 - BACKUP_HEADER_MAX_SIZE] = [0; 4096 - BACKUP_HEADER_MAX_SIZE];
+        let length = postcard::to_slice(controller_config, &mut buffer)?.len();
+        info!("Writing backup config of size {}", length);
+        let mut checksum = X25.digest();
+        checksum.update(&buffer[..length]);
+        let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
+
+        let time = self.rtc_module.get_rtc_time().await?.timestamp_millis();
+        let header = BackupHeader {
+            crc16: checksum.finalize(),
+            timestamp: time,
+            size: length as u16,
+        };
+        info!("Header is {:?}", header);
+        postcard::to_slice(&header, &mut header_page_buffer)?;
+        info!("Header is serialized");
+        self.get_rtc_module().write(0, &header_page_buffer)?;
+        info!("Header written");
+        let mut to_write = length;
+        let mut chunk: usize = 0;
+
+        while to_write > 0 {
+            self.progress(chunk as u32).await;
+            let start = chunk * EEPROM_PAGE;
+            let end = start + min(EEPROM_PAGE, to_write);
+            let part = &buffer[start..end];
+            info!(
+                "Writing chunk {} of size {} to offset {}",
+                chunk,
+                part.len(),
+                start
+            );
+            to_write -= part.len();
+            self.get_rtc_module()
+                .write((BACKUP_HEADER_MAX_SIZE + chunk * EEPROM_PAGE) as u32, part)?;
+            chunk += 1;
+        }
+        info!("Backup complete");
+        self.clear_progress().await;
+        Ok(())
+    }
+    async fn read_backup(&mut self) -> FatResult<PlantControllerConfig> {
+        let info = self.backup_info().await?;
+        let mut store = alloc::vec![0_u8; info.size as usize];
+        self.rtc_module
+            .read(BACKUP_HEADER_MAX_SIZE as u32, store.as_mut_slice())?;
+        info!("Read backup data of size {}", store.len());
+        let mut checksum = X25.digest();
+        info!("Calculating CRC");
+        checksum.update(&store[..]);
+        let crc = checksum.finalize();
+        info!("CRC is {:04x}", crc);
+        if crc != info.crc16 {
+            warn!("CRC mismatch in backup data");
+            bail!("CRC mismatch in backup data")
+        }
+        info!("CRC is correct");
+        let decoded = postcard::from_bytes(&store[..])?;
+        info!("Backup data decoded");
+        Ok(decoded)
+    }
+
+    async fn backup_info(&mut self) -> FatResult<BackupHeader> {
+        let mut header_page_buffer = [0_u8; BACKUP_HEADER_MAX_SIZE];
+        self.get_rtc_module().read(0, &mut header_page_buffer)?;
+        info!("Read header page");
+        let info = postcard::take_from_bytes::<BackupHeader>(&header_page_buffer[..]);
+        info!("decoding header: {:?}", info);
+        let (header, _) = info.context("Could not read backup header")?;
+        Ok(header)
+    }
+
+    async fn detect_sensors(&mut self, request: DetectionRequest) -> FatResult<Detection> {
+        self.can_power.set_high();
+        Timer::after_millis(500).await;
+        let config = self.twai_config.take().context("twai config not set")?;
+        let mut twai = config.into_async().start();
+
+        if twai.is_bus_off() {
+            info!("Bus offline after start, attempting recovery");
+            // Re-start to initiate recovery
+            twai = twai.stop().start();
+        }
+
+        let res = (async {
+            Timer::after_millis(1000).await;
+            info!("Sending info messages now");
+            // Send a few test messages per potential sensor node
+            for plant in 0..PLANT_COUNT {
+                for sensor in [Sensor::A, Sensor::B] {
+                    let detect = if sensor == Sensor::A {
+                        request.plant[plant].sensor_a
+                    } else {
+                        request.plant[plant].sensor_b
+                    };
+
+                    if !detect {
+                        continue;
+                    }
+                    let target = StandardId::new(plant_id(
+                        IDENTIFY_CMD_OFFSET,
+                        sensor.into(),
+                        (plant + 1) as u16,
+                    ))
+                    .context(">> Could not create address for sensor! (plant: {}) <<")?;
+                    let can_buffer = [0_u8; 0];
+                    info!(
+                        "Sending test message to plant {} sensor {sensor:?} with id {}",
+                        plant + 1,
+                        target.as_raw()
+                    );
+                    if let Some(frame) = EspTwaiFrame::new(target, &can_buffer) {
+                        // Try a few times; we intentionally ignore rx here and rely on stub logic
+                        let resu = twai
+                            .transmit_async(&frame)
+                            .with_timeout(Duration::from_millis(500))
+                            .await;
+                        match resu {
+                            Ok(_) => {}
+                            Err(err) => {
+                                info!(
+                                    "Error sending test message to plant {} sensor {sensor:?}: {err:?}",
+                                    plant + 1
+                                );
+                            }
+                        }
+                    } else {
+                        info!("Error building CAN frame");
+                    }
+                }
+            }
+
+            let mut moistures = Moistures::default();
+            let _ = wait_for_can_measurements(&mut twai, &mut moistures)
+                .with_timeout(Duration::from_millis(3000))
+                .await;
+
+            let result: Detection = moistures.into();
+
+            info!("Autodetection result: {result:?}");
+            Ok((result, moistures.sensor_a_build_minutes, moistures.sensor_b_build_minutes))
+        })
+        .await;
+
+        let config = twai.stop().into_blocking();
+        self.twai_config.replace(config);
+        self.can_power.set_low();
+
+        match res {
+            Ok((detection, a_builds, b_builds)) => {
+                self.sensor_a_build_minutes = a_builds;
+                self.sensor_b_build_minutes = b_builds;
+                Ok(detection)
+            }
+            Err(e) => Err(e),
+        }
+    }
+
+    fn get_sensor_build_minutes(&self) -> ([Option<u32>; PLANT_COUNT], [Option<u32>; PLANT_COUNT]) {
+        (self.sensor_a_build_minutes, self.sensor_b_build_minutes)
+    }
 }

 async fn wait_for_can_measurements(
@@ -531,10 +688,10 @@ async fn wait_for_can_measurements(
                                "received message of kind {:?} (plant: {}, sensor: {:?})",
                                msg.0, msg.1, msg.2
                            );
+                            let plant = msg.1 as usize;
+                            let sensor = msg.2;
+                            let data = can_frame.data();
                            if msg.0 == MessageKind::MoistureData {
-                                let plant = msg.1 as usize;
-                                let sensor = msg.2;
-                                let data = can_frame.data();
                                info!("Received moisture data: {:?}", data);
                                if let Ok(bytes) = data.try_into() {
                                    let frequency = u32::from_be_bytes(bytes);
@@ -551,6 +708,23 @@ async fn wait_for_can_measurements(
                                } else {
                                    error!("Received moisture data with invalid length: {} (expected 4)", data.len());
                                }
+                            } else if msg.0 == MessageKind::FirmwareBuild {
+                                info!("Received firmware build data: {:?}", data);
+                                if let Ok(bytes) = data.try_into() {
+                                    let build_minutes = u32::from_be_bytes(bytes);
+                                    match sensor {
+                                        SensorSlot::A => {
+                                            moistures.sensor_a_build_minutes[plant - 1] =
+                                                Some(build_minutes);
+                                        }
+                                        SensorSlot::B => {
+                                            moistures.sensor_b_build_minutes[plant - 1] =
+                                                Some(build_minutes);
+                                        }
+                                    }
+                                } else {
+                                    error!("Received firmware build data with invalid length: {} (expected 4)", data.len());
+                                }
                            }
                        }
                    }
@@ -577,10 +751,17 @@ impl From<Moistures> for Detection {
    fn from(value: Moistures) -> Self {
        let mut result = Detection::default();
        for (plant, sensor) in value.sensor_a_hz.iter().enumerate() {
-            result.plant[plant].sensor_a = sensor.is_some();
+            if sensor.is_some() {
+                // Sensor responded; include build timestamp (0 = timestamp not reported)
+                result.plant[plant].sensor_a =
+                    Some(value.sensor_a_build_minutes[plant].unwrap_or(0));
+            }
        }
        for (plant, sensor) in value.sensor_b_hz.iter().enumerate() {
-            result.plant[plant].sensor_b = sensor.is_some();
+            if sensor.is_some() {
+                result.plant[plant].sensor_b =
+                    Some(value.sensor_b_build_minutes[plant].unwrap_or(0));
+            }
        }
        result
    }
--- a/Software/MainBoard/rust/src/hal/water.rs
+++ b/Software/MainBoard/rust/src/hal/water.rs
@@ -2,23 +2,28 @@ use crate::bail;
 use crate::fat_error::FatError;
 use crate::hal::{ADC1, TANK_MULTI_SAMPLE};
 use embassy_time::Timer;
-use esp_hal::analog::adc::{Adc, AdcConfig, AdcPin, Attenuation};
+use esp_hal::analog::adc::{Adc, AdcCalLine, AdcConfig, AdcPin, Attenuation};
 use esp_hal::delay::Delay;
-use esp_hal::gpio::{Flex, Input, Output, OutputConfig, Pull};
+use esp_hal::gpio::{DriveMode, Flex, Input, InputConfig, Output, OutputConfig, Pull};
 use esp_hal::pcnt::channel::CtrlMode::Keep;
 use esp_hal::pcnt::channel::EdgeMode::{Hold, Increment};
 use esp_hal::pcnt::unit::Unit;
 use esp_hal::peripherals::GPIO5;
-use esp_hal::Blocking;
-use esp_println::println;
+use esp_hal::Async;
+use log::{error, info};
 use onewire::{ds18b20, Device, DeviceSearch, OneWire, DS18B20};
+use portable_atomic::{AtomicUsize, Ordering};
+
+unsafe impl Send for TankSensor<'_> {}
+
+static FLOW_OVERFLOW_COUNTER: AtomicUsize = AtomicUsize::new(0);

 pub struct TankSensor<'a> {
    one_wire_bus: OneWire<Flex<'a>>,
-    tank_channel: Adc<'a, ADC1<'a>, Blocking>,
+    tank_channel: Adc<'a, ADC1<'a>, Async>,
    tank_power: Output<'a>,
-    tank_pin: AdcPin<GPIO5<'a>, ADC1<'a>>,
-    flow_counter: Unit<'a, 1>,
+    tank_pin: AdcPin<GPIO5<'a>, ADC1<'a>, AdcCalLine<ADC1<'a>>>,
+    flow_unit: Unit<'static, 1>,
 }

 impl<'a> TankSensor<'a> {
@@ -28,67 +33,132 @@ impl<'a> TankSensor<'a> {
        gpio5: GPIO5<'a>,
        tank_power: Output<'a>,
        flow_sensor: Input,
-        pcnt1: Unit<'a, 1>,
+        pcnt1: Unit<'static, 1>,
    ) -> Result<TankSensor<'a>, FatError> {
-        one_wire_pin.apply_output_config(&OutputConfig::default().with_pull(Pull::None));
+        one_wire_pin.apply_output_config(
+            &OutputConfig::default()
+                .with_drive_mode(DriveMode::OpenDrain)
+                .with_pull(Pull::None),
+        );
+        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);
+        info!("tank: one_wire pin config ok");

        let mut adc1_config = AdcConfig::new();
-        let tank_pin = adc1_config.enable_pin(gpio5, Attenuation::_11dB);
-        let tank_channel = Adc::new(adc1, adc1_config);
+        info!("tank: adc config created");
+        let tank_pin =
+            adc1_config.enable_pin_with_cal::<_, AdcCalLine<_>>(gpio5, Attenuation::_11dB);
+        info!("tank: adc pin cal ok");
+        let tank_channel = Adc::new(adc1, adc1_config).into_async();
+        info!("tank: adc channel ok");

        let one_wire_bus = OneWire::new(one_wire_pin, false);
+        info!("tank: one_wire bus ok");

        pcnt1.set_high_limit(Some(i16::MAX))?;
+        info!("tank: pcnt high limit ok");
+        // Reject pulses shorter than ~12.8 µs (1023 APB cycles @ 80 MHz) to suppress EMI noise
+        // on the sensor cable. Real flow pulses are in the millisecond range.
+        match pcnt1.set_filter(Some(1023)) {
+            Ok(_) => {}
+            Err(err) => {
+                error!("tank: failed to set pcnt filter: {:?}", err);
+            }
+        }

        let ch0 = &pcnt1.channel0;
        ch0.set_edge_signal(flow_sensor.peripheral_input());
+        info!("tank: pcnt edge signal ok");
        ch0.set_input_mode(Hold, Increment);
        ch0.set_ctrl_mode(Keep, Keep);
+        info!("tank: pcnt input/ctrl mode ok");
+
        pcnt1.listen();
+        info!("tank: pcnt listen ok");

        Ok(TankSensor {
            one_wire_bus,
            tank_channel,
            tank_power,
            tank_pin,
-            flow_counter: pcnt1,
+            flow_unit: pcnt1,
        })
    }

    pub fn reset_flow_meter(&mut self) {
-        self.flow_counter.pause();
-        self.flow_counter.clear();
+        // Pause, clear counter, clear any pending interrupt, then reset the overflow counter —
+        // all inside a single critical section to prevent a race where the interrupt fires
+        // between the overflow reset and the pause.
+        critical_section::with(|_| {
+            self.flow_unit.pause();
+            self.flow_unit.clear();
+            self.flow_unit.reset_interrupt();
+            FLOW_OVERFLOW_COUNTER.store(0, Ordering::SeqCst);
+        });
    }

    pub fn start_flow_meter(&mut self) {
-        self.flow_counter.resume();
-    }
-
-    pub fn get_flow_meter_value(&mut self) -> i16 {
-        self.flow_counter.value()
+        self.flow_unit.resume();
    }

    pub fn stop_flow_meter(&mut self) -> i16 {
-        self.flow_counter.pause();
-        self.get_flow_meter_value()
+        critical_section::with(|_| {
+            let val = self.flow_unit.value();
+            self.flow_unit.pause();
+            val
+        })
+    }
+
+    pub fn get_full_flow_count(&self) -> u32 {
+        // Read both values inside a single critical section so an overflow interrupt cannot
+        // fire between the two reads and produce an inconsistent result.
+        critical_section::with(|_| {
+            let overflowed = FLOW_OVERFLOW_COUNTER.load(Ordering::SeqCst) as u32;
+            let current = self.flow_unit.value() as u32;
+            overflowed * (i16::MAX as u32 + 1) + current
+        })
    }

    pub async fn water_temperature_c(&mut self) -> Result<f32, FatError> {
        //multisample should be moved to water_temperature_c
        let mut attempt = 1;
        let mut delay = Delay::new();
-        self.one_wire_bus.reset(&mut delay)?;
+
+        let presence = self.one_wire_bus.reset(&mut delay)?;
+        info!("OneWire: reset presence pulse = {}", presence);
+        if !presence {
+            info!("OneWire: no device responded to reset — check pull-up resistor and wiring");
+        }
+
        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;
+            info!(
+                "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 {
+                info!(
+                    "OneWire: skipping device — not a DS18B20 (family 0x{:02X} != 0x{:02X})",
+                    device.address[0],
+                    ds18b20::FAMILY_CODE
+                );
            }
        }
+        if devices_found == 0 {
+            info!("OneWire: search found zero devices on the bus");
+        }
+
        match water_temp_sensor {
            Some(device) => {
-                println!("Found one wire device: {:?}", device);
+                info!("Found one wire device: {:?}", device);
                let mut water_temp_sensor = DS18B20::new(device)?;

                let water_temp: Result<f32, FatError> = loop {
@@ -97,11 +167,11 @@ impl<'a> TankSensor<'a> {
                        .await;
                    match &temp {
                        Ok(res) => {
-                            println!("Water temp is {}", res);
+                            info!("Water temp is {}", res);
                            break temp;
                        }
                        Err(err) => {
-                            println!("Could not get water temp {} attempt {}", err, attempt)
+                            info!("Could not get water temp {} attempt {}", err, attempt)
                        }
                    }
                    if attempt == 5 {
@@ -138,16 +208,26 @@ impl<'a> TankSensor<'a> {

        let mut store = [0_u16; TANK_MULTI_SAMPLE];
        for sample in store.iter_mut() {
-            let value = self.tank_channel.read_oneshot(&mut self.tank_pin);
-            //force yield
+            *sample = self.tank_channel.read_oneshot(&mut self.tank_pin).await;
+            //force yield between successful samples
            Timer::after_millis(10).await;
-            *sample = value.unwrap();
        }
        self.tank_power.set_low();

        store.sort();
-        //TODO probably wrong? check!
-        let median_mv = store[6] as f32 * 3300_f32 / 4096_f32;
-        Ok(median_mv)
+        let median_mv = store[TANK_MULTI_SAMPLE / 2] as f32;
+        Ok(median_mv / 1000.0)
+    }
+}
+
+#[esp_hal::handler]
+pub fn flow_interrupt_handler() {
+    use esp_hal::peripherals::PCNT;
+    let pcnt = PCNT::regs();
+    if pcnt.int_raw().read().cnt_thr_event_u(1).bit() {
+        if pcnt.u_status(1).read().h_lim().bit() {
+            FLOW_OVERFLOW_COUNTER.fetch_add(1, Ordering::SeqCst);
+        }
+        pcnt.int_clr().write(|w| w.cnt_thr_event_u(1).set_bit());
    }
 }
--- a/Software/MainBoard/rust/src/log/interceptor.rs
+++ b/Software/MainBoard/rust/src/log/interceptor.rs
@@ -0,0 +1,109 @@
+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 = 128;
+
+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) {}
+}
--- a/Software/MainBoard/rust/src/log/mod.rs
+++ b/Software/MainBoard/rust/src/log/mod.rs
@@ -1,10 +1,11 @@
-use crate::hal::TIME_ACCESS;
 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};
@@ -32,6 +33,40 @@ static mut LOG_ARRAY: LogArray = LogArray {
 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;

@@ -80,24 +115,31 @@ impl From<LogEntryInner> for LogEntry {
    }
 }

-pub async fn log(
-    message_key: LogMessage,
-    number_a: u32,
-    number_b: u32,
-    txt_short: &str,
-    txt_long: &str,
-) {
-    LOG_ACCESS
-        .lock()
-        .await
-        .log(message_key, number_a, number_b, txt_short, txt_long)
-        .await
+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();
+
+    limit_length(txt_short, &mut txt_short_stack);
+    limit_length(txt_long, &mut txt_long_stack);
+
+    match LOG_CHANNEL.try_send(LogRequest {
+        message_key,
+        number_a,
+        number_b,
+        txt_short: txt_short_stack,
+        txt_long: txt_long_stack,
+    }) {
+        Ok(_) => {}
+        Err(_) => {
+            warn!("Log channel full, dropping log entry");
+        }
+    }
 }

 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(0).unwrap());
+            RangedU8::new(self.head).unwrap_or(RangedU8::new_saturating(0));

        let mut rv: Vec<LogEntry> = Vec::new();
        let mut index = head.wrapping_sub(1);
@@ -120,17 +162,11 @@ impl LogArray {
        txt_long: &str,
    ) {
        let mut head: RangedU8<0, MAX_LOG_ARRAY_INDEX> =
-            RangedU8::new(self.head).unwrap_or(RangedU8::new(0).unwrap());
-
-        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(txt_short, &mut txt_short_stack);
-        limit_length(txt_long, &mut txt_long_stack);
+            RangedU8::new(self.head).unwrap_or(RangedU8::new_saturating(0));

        let time = {
-            let guard = TIME_ACCESS.get().await.lock().await;
-            guard.current_time_us()
+            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;
@@ -148,12 +184,8 @@ impl LogArray {
        to_modify.message_id = ordinal;
        to_modify.a = number_a;
        to_modify.b = number_b;
-        to_modify
-            .txt_short
-            .clone_from_slice(txt_short_stack.as_bytes());
-        to_modify
-            .txt_long
-            .clone_from_slice(txt_long_stack.as_bytes());
+        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();
    }
@@ -279,8 +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)]
@@ -301,7 +345,7 @@ impl From<&LogMessage> for MessageTranslation {
 impl LogMessage {
    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()
        }))
    }
--- a/Software/MainBoard/rust/src/main.rs
+++ b/Software/MainBoard/rust/src/main.rs
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/Cargo.toml
+++ b/Software/MainBoard/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"
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/buffer.rs
+++ b/Software/MainBoard/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(())
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/fmt.rs
+++ b/Software/MainBoard/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 ),*);
+    };
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/homeassistant/binary_sensor.rs
+++ b/Software/MainBoard/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
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/homeassistant/button.rs
+++ b/Software/MainBoard/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)
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/homeassistant/light.rs
+++ b/Software/MainBoard/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
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/homeassistant/mod.rs
+++ b/Software/MainBoard/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)
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/homeassistant/sensor.rs
+++ b/Software/MainBoard/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
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/homeassistant/ser.rs
+++ b/Software/MainBoard/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!()
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/io.rs
+++ b/Software/MainBoard/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_all(&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_all(&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;
+        }
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/lib.rs
+++ b/Software/MainBoard/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,
+            },
+        )
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/pipe.rs
+++ b/Software/MainBoard/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;
+        }
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/publish.rs
+++ b/Software/MainBoard/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
+    }
+}
--- a/Software/MainBoard/rust/src/mcutie_3_0_0/topic.rs
+++ b/Software/MainBoard/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(())
+        }
+    }
+}
--- a/Software/MainBoard/rust/src/mqtt.rs
+++ b/Software/MainBoard/rust/src/mqtt.rs
@@ -0,0 +1,438 @@
+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::format;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+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::{error, 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>,
+) -> FatResult<()> {
+    let state = serde_json::to_string(
+        &tank_state.as_mqtt_info(&board.board_hal.get_config().tank, &water_temp),
+    )?;
+    let _ = publish("/water", &state).await;
+    Ok(())
+}
+
+pub async fn publish_plant_states(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+    timezone_time: &DateTime<Tz>,
+    plantstate: &[PlantState; 8],
+) -> FatResult<()> {
+    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))?;
+        let plant_topic = format!("/plant{}", plant_id + 1);
+        let _ = publish(&plant_topic, &state).await;
+    }
+    Ok(())
+}
+
+pub async fn publish_firmware_info(version: VersionInfo, ip_address: &str, timezone_time: &str) {
+    publish("/firmware/address", ip_address).await;
+    let version = &serde_json::to_string(&version);
+    match version {
+        Ok(version_str) => publish("/firmware/state", version_str).await,
+        Err(e) => error!("Failed to serialize version info: {}", e),
+    }
+    publish("/firmware/last_online", timezone_time).await;
+    publish("/state", "online").await;
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq, Default)]
+///mqtt struct to track pump activities
+pub 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 error: String,
+    pub flow_raw: u32,
+    pub flow_ml: f32,
+}
+
+#[allow(clippy::too_many_arguments)]
+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: String,
+    flow_raw: u32,
+    flow_ml: f32,
+) {
+    let pump_info = PumpInfo {
+        enabled: pump_active,
+        pump_ineffective,
+        median_current_ma,
+        max_current_ma,
+        min_current_ma,
+        error,
+        flow_raw,
+        flow_ml,
+    };
+    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}");
+        }
+    };
+}
+
+/// Wi-Fi scan result details for MQTT
+#[derive(Serialize, Debug, PartialEq)]
+pub struct WifiScanResult {
+    pub ssid: String,
+    pub bssid: String,
+    pub rssi: i32,
+    pub channel: u8,
+    pub auth_method: String,
+}
+
+#[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>>,
+) -> FatResult<()> {
+    let telemetry = match board.board_hal.get_battery_monitor().get_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,
+            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,
+            remaining_mah: None,
+            design_mah: None,
+            error: Some(BatteryError::CommunicationError {
+                message: alloc::format!("{:?}", e),
+            }),
+        },
+    };
+    let json = serde_json::to_string(&telemetry)?;
+    publish("/battery", &json).await;
+    Ok(())
+}
+
+/// Publish Wi-Fi scan details to MQTT
+pub async fn publish_wifi_scan(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+) -> FatResult<()> {
+    let mut wifi_details = board.board_hal.get_esp().wifi_scan_details().await?;
+
+    // Sort by RSSI in descending order (strongest first)
+    wifi_details.sort_by(|a, b| b.rssi.cmp(&a.rssi));
+
+    // Take only the strongest 10 results
+    let wifi_results: Vec<WifiScanResult> = wifi_details
+        .iter()
+        .take(10)
+        .map(|d| WifiScanResult {
+            ssid: d.ssid.clone(),
+            bssid: d.bssid.clone(),
+            rssi: d.rssi,
+            channel: d.channel,
+            auth_method: d.auth_method.clone(),
+        })
+        .collect();
+
+    let json = serde_json::to_string(&wifi_results)?;
+    publish("/wifi_scan", &json).await;
+    Ok(())
+}
--- a/Software/MainBoard/rust/src/network.rs
+++ b/Software/MainBoard/rust/src/network.rs
@@ -0,0 +1,463 @@
+use crate::bail;
+use crate::config::NetworkConfig;
+use crate::fat_error::{ContextExt, FatError, FatResult};
+use crate::hal::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 edge_dhcp::{
+    io::{self, DEFAULT_SERVER_PORT},
+    server::{Server, ServerOptions},
+};
+use edge_nal::UdpBind;
+use edge_nal_embassy::{Udp, UdpBuffers};
+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 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::{error, info, warn};
+use option_lock::OptionLock;
+use serde::Serialize;
+use sntpc::{get_time, NtpContext, NtpTimestampGenerator, NtpUdpSocket};
+
+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)]
+#[allow(clippy::upper_case_acronyms)]
+pub enum SntpMode {
+    OFFLINE,
+    SYNC { current: DateTime<Utc> },
+}
+
+#[derive(Serialize, Debug, PartialEq)]
+#[allow(clippy::upper_case_acronyms)]
+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")
+        }
+    };
+    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 retry_count = network_config.retry_count;
+
+    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
+    };
+
+    // Spawn the network task once
+    spawner.spawn(net_task(runner)?);
+
+    let mut attempts = 0;
+
+    while attempts <= retry_count {
+        if attempts > 0 {
+            info!("WiFi connection retry {}/{}", attempts, retry_count);
+        } else {
+            info!("attempting to connect wifi {}", ssid);
+        }
+
+        let client_config = StationConfig::default()
+            .with_ssid(ssid.clone())
+            .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.clone());
+
+        // Set config and attempt connection
+        controller
+            .lock()
+            .await
+            .set_config(&Config::Station(client_config))?;
+
+        match controller
+            .lock()
+            .await
+            .connect_async()
+            .with_timeout(Duration::from_millis(max_wait as u64 * 1000))
+            .await
+        {
+            Ok(result) => {
+                result?;
+            }
+            Err(e) => {
+                let disconnect_info = controller.lock().await.disconnect_async().await;
+                warn!("Wifi disconnect info {:?}", disconnect_info);
+                warn!("WiFi connection attempt {} failed: Timeout waiting for wifi sta connected: {:?}", attempts + 1, e);
+                attempts += 1;
+                Timer::after(Duration::from_millis(500)).await;
+                continue;
+            }
+        }
+
+        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() {
+            warn!(
+                "WiFi connection attempt {} failed: link up timeout",
+                attempts + 1
+            );
+            attempts += 1;
+            Timer::after(Duration::from_millis(500)).await;
+            continue;
+        }
+
+        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() {
+            warn!(
+                "WiFi connection attempt {} failed: config up timeout",
+                attempts + 1
+            );
+            attempts += 1;
+            Timer::after(Duration::from_millis(500)).await;
+            continue;
+        }
+
+        // Success!
+        info!("Connected WIFI, dhcp: {:?}", stack.config_v4());
+        return Ok(*stack);
+    }
+
+    // All retries exhausted
+    bail!("WiFi connection failed after all retries");
+}
+
+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
+        }
+    }
+}
--- a/Software/MainBoard/rust/src/plant_state.rs
+++ b/Software/MainBoard/rust/src/plant_state.rs
@@ -1,22 +1,27 @@
+use crate::config::SensorCombineMode;
 use crate::hal::Moistures;
+use crate::plant_state::PlantWateringMode::TargetMoisture;
 use crate::{config::PlantConfig, hal::HAL, in_time_range};
 use chrono::{DateTime, TimeDelta, Utc};
 use chrono_tz::Tz;
 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
+const MOIST_SENSOR_MAX_FREQUENCY: f32 = 160000.; // 160kHz -> very wet
+const MOIST_SENSOR_MIN_FREQUENCY: f32 = 400.; // this is really, really dry, think like cactus levels

-#[derive(Debug, PartialEq, Serialize)]
+#[derive(Debug, PartialEq, Clone, Serialize)]
+#[serde(tag = "kind")]
 pub enum MoistureSensorError {
-    NoMessage,
+    MissingMessage,
+    NotExpectedMessage { hz: f32 },
    ShortCircuit { hz: f32, max: f32 },
    OpenLoop { hz: f32, min: f32 },
 }

 #[derive(Debug, PartialEq, Serialize)]
 pub enum MoistureSensorState {
-    MoistureValue { raw_hz: f32, moisture_percent: f32 },
+    MoistureValue { hz: f32, moisture_percent: f32 },
+    NoMessage,
    SensorError(MoistureSensorError),
 }

@@ -30,7 +35,7 @@ impl MoistureSensorState {

    pub fn moisture_percent(&self) -> Option<f32> {
        if let MoistureSensorState::MoistureValue {
-            raw_hz: _,
+            hz: _,
            moisture_percent,
        } = self
        {
@@ -44,21 +49,40 @@ 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,
        max_allowed_failures: usize,
    },
+    OverCurrent {
+        current_ma: u16,
+        max_allowed_ma: u16,
+    },
 }

 #[derive(Debug, Serialize)]
 pub struct PumpState {
    consecutive_pump_count: u32,
    previous_pump: Option<DateTime<Utc>>,
+    pub overcurrent_error: Option<u16>,
 }

 impl PumpState {
    fn is_err(&self, plant_config: &PlantConfig) -> Option<PumpError> {
+        if let Some(current_ma) = self.overcurrent_error {
+            return Some(PumpError::OverCurrent {
+                current_ma,
+                max_allowed_ma: plant_config.max_pump_current_ma,
+            });
+        }
        if self.consecutive_pump_count > plant_config.max_consecutive_pump_count as u32 {
            Some(PumpError::PumpNotWorking {
                failed_attempts: self.consecutive_pump_count as usize,
@@ -82,8 +106,36 @@ pub struct PlantState {
    pub sensor_a: MoistureSensorState,
    pub sensor_b: MoistureSensorState,
    pub pump: PumpState,
+    /// Last known firmware build timestamp for sensor A (minutes since Unix epoch).
+    /// Set during sensor detection; None if detection has not been run yet.
+    pub sensor_a_firmware_build_minutes: Option<u32>,
+    /// Last known firmware build timestamp for sensor B.
+    pub sensor_b_firmware_build_minutes: Option<u32>,
+    /// Last time fertilizer was applied.
+    pub last_fertilizer_time: Option<DateTime<Utc>>,
 }

+/// Map sensor frequency to moisture percentage using inverse power-law scaling (quadratic).
+///
+/// For resistive probes with 555 timer oscillator:
+/// - Dry soil has high resistance → low oscillation frequency
+/// - Wet soil has low resistance → high oscillation frequency
+///
+/// The relationship is non-linear: most frequency change occurs in the wet range.
+/// Using inverse power-law to give better discrimination at high moisture levels.
+///
+/// Formula: moisture = (1 - (f_max - f) / (f_max - f_min))^2 * 100
+///          = ((f - f_min) / (f_max - f_min))^2 * 100
+///
+/// But with k=0.5 (square root) for better high-end discrimination:
+/// Formula: moisture = sqrt((f - f_min) / (f_max - f_min)) * 100
+///
+/// Examples with default range (400-160000 Hz) using k=0.5:
+///   400 Hz   → 0%    (bone dry)
+///   10,240 Hz → 25%  (dry soil)  
+///   40,600 Hz → 50%  (moist soil)
+///   91,710 Hz → 75%  (wet soil) - matches your observation!
+///   160,000 Hz → 100% (saturated)
 fn map_range_moisture(
    s: f32,
    min_frequency: Option<f32>,
@@ -105,82 +157,107 @@ fn map_range_moisture(
            max: max_freq,
        });
    }
-    let moisture_percent = (s - min_freq) * 100.0 / (max_freq - min_freq);

-    Ok(moisture_percent)
+    // Normalize to 0-1 range
+    let t = (s - min_freq) / (max_freq - min_freq);
+
+    // Apply power-law mapping with k=0.5 (square root) for better high-moisture discrimination
+    // For resistive probes: frequency ↑ as moisture ↑, but non-linearly
+    // Using sqrt gives more resolution in the wet range (60-160kHz)
+    // Newton's method approximation for sqrt(t): x_{n+1} = 0.5 * (x_n + t/x_n)
+    // Start with initial guess and do 2 iterations for good precision
+    let moisture_percent = if t <= 0.0 {
+        0.0
+    } else if t >= 1.0 {
+        100.0
+    } else {
+        // Newton's method for sqrt(t)
+        let mut x = t; // Initial guess
+        x = 0.5 * (x + t / x); // First iteration
+        x = 0.5 * (x + t / x); // Second iteration for better precision
+        x * 100.0
+    };
+
+    Ok(moisture_percent.clamp(0.0, 100.0))
 }

 impl PlantState {
-    pub async fn read_hardware_state(
+    pub async fn interpret_raw_values(
        moistures: Moistures,
        plant_id: usize,
        board: &mut HAL<'_>,
    ) -> Self {
-        let sensor_a = {
-            //if board.board_hal.get_config().plants[plant_id].sensor_a {
-            let raw = moistures.sensor_a_hz[plant_id];
-            match raw {
-                None => MoistureSensorState::SensorError(MoistureSensorError::NoMessage),
-                Some(raw) => {
-                    match map_range_moisture(
-                        raw,
-                        board.board_hal.get_config().plants[plant_id]
-                            .moisture_sensor_min_frequency
-                            .map(|a| a as f32),
-                        board.board_hal.get_config().plants[plant_id]
-                            .moisture_sensor_max_frequency
-                            .map(|b| b as f32),
-                    ) {
-                        Ok(moisture_percent) => MoistureSensorState::MoistureValue {
-                            raw_hz: raw,
-                            moisture_percent,
-                        },
-                        Err(err) => MoistureSensorState::SensorError(err),
-                    }
-                }
-            }
-        }; // else {
-           //    MoistureSensorState::Disabled
-           //};
+        let min = board.board_hal.get_config().plants[plant_id].moisture_sensor_min_frequency;
+        let max = board.board_hal.get_config().plants[plant_id].moisture_sensor_max_frequency;

-        let sensor_b = {
-            //if board.board_hal.get_config().plants[plant_id].sensor_b {
-            let raw = moistures.sensor_b_hz[plant_id];
+        let raw_to_value = |raw: Option<f32>, expected: bool| -> MoistureSensorState {
            match raw {
-                None => MoistureSensorState::SensorError(MoistureSensorError::NoMessage),
+                None => {
+                    if expected {
+                        MoistureSensorState::SensorError(MoistureSensorError::MissingMessage)
+                    } else {
+                        MoistureSensorState::NoMessage
+                    }
+                }
                Some(raw) => {
-                    match map_range_moisture(
-                        raw,
-                        board.board_hal.get_config().plants[plant_id]
-                            .moisture_sensor_min_frequency
-                            .map(|a| a as f32),
-                        board.board_hal.get_config().plants[plant_id]
-                            .moisture_sensor_max_frequency
-                            .map(|b| b as f32),
-                    ) {
-                        Ok(moisture_percent) => MoistureSensorState::MoistureValue {
-                            raw_hz: raw,
-                            moisture_percent,
-                        },
-                        Err(err) => MoistureSensorState::SensorError(err),
+                    if expected {
+                        match map_range_moisture(raw, min.map(|a| a as f32), max.map(|b| b as f32))
+                        {
+                            Ok(moisture_percent) => MoistureSensorState::MoistureValue {
+                                hz: raw,
+                                moisture_percent,
+                            },
+                            Err(err) => MoistureSensorState::SensorError(err),
+                        }
+                    } else {
+                        MoistureSensorState::SensorError(MoistureSensorError::NotExpectedMessage {
+                            hz: raw,
+                        })
                    }
                }
            }
-        }; // else {
-           //    MoistureSensorState::Disabled
-           //};
+        };
+
+        let expected_a = board.board_hal.get_config().plants[plant_id].sensor_a;
+        let expected_b = board.board_hal.get_config().plants[plant_id].sensor_b;
+
+        let sensor_a = { raw_to_value(moistures.sensor_a_hz[plant_id], expected_a) };
+        let sensor_b = { raw_to_value(moistures.sensor_b_hz[plant_id], expected_b) };

        let previous_pump = board.board_hal.get_esp().last_pump_time(plant_id);
        let consecutive_pump_count = board.board_hal.get_esp().consecutive_pump_count(plant_id);
+        let last_fertilizer_timestamp = board.board_hal.get_esp().last_fertilizer_time(plant_id);
+        let (a_builds, b_builds) = board.board_hal.get_sensor_build_minutes();
+
+        let last_fertilizer_time = DateTime::from_timestamp_millis(last_fertilizer_timestamp);
+
+        // Create plant state first, then check for warnings
        let state = Self {
            sensor_a,
            sensor_b,
            pump: PumpState {
                consecutive_pump_count,
                previous_pump,
+                overcurrent_error: None,
            },
+            sensor_a_firmware_build_minutes: a_builds[plant_id],
+            sensor_b_firmware_build_minutes: b_builds[plant_id],
+            last_fertilizer_time,
        };
-        if state.is_err() {
+
+        // Check for sensor warning condition (expected 2 sensors, only 1 responding)
+        let has_a =
+            state.sensor_a.moisture_percent().is_some() && state.sensor_a.is_err().is_none();
+        let has_b =
+            state.sensor_b.moisture_percent().is_some() && state.sensor_b.is_err().is_none();
+
+        // Check if we expected two sensors but only got one
+        let has_sensor_warning =
+            expected_a && expected_b && ((has_a && !has_b) || (!has_a && has_b));
+
+        // Set fault LED for both errors AND sensor warnings
+        let has_issue = state.is_err() || has_sensor_warning;
+        if has_issue {
            let _ = board.board_hal.fault(plant_id, true).await;
        }
        state
@@ -203,26 +280,25 @@ impl PlantState {
        self.sensor_a.is_err().is_some() || self.sensor_b.is_err().is_some()
    }

-    pub fn plant_moisture(
-        &self,
-    ) -> (
-        Option<u8>,
-        (Option<&MoistureSensorError>, Option<&MoistureSensorError>),
-    ) {
+    /// Get combined moisture value with configurable combination mode and sensor warning.
+    ///
+    /// Returns:
+    /// - Combined moisture percentage (or None if no valid readings)
+    /// - Tuple of errors from sensor A and B
+    /// - Sensor warning indicating if warning LED should be lit (MissingSecondSensor)
+    pub fn plant_moisture_with_warning(&self, plant_conf: &PlantConfig) -> Option<f32> {
        match (
            self.sensor_a.moisture_percent(),
            self.sensor_b.moisture_percent(),
        ) {
-            (Some(moisture_a), Some(moisture_b)) => {
-                (Some(((moisture_a + moisture_b) / 2.) as u8), (None, None))
-            }
-            (Some(moisture_percent), _) => {
-                (Some(moisture_percent as u8), (None, self.sensor_b.is_err()))
-            }
-            (_, Some(moisture_percent)) => {
-                (Some(moisture_percent as u8), (self.sensor_a.is_err(), None))
-            }
-            _ => (None, (self.sensor_a.is_err(), self.sensor_b.is_err())),
+            (Some(moisture_a), Some(moisture_b)) => match plant_conf.sensor_combine_mode {
+                SensorCombineMode::Min => Some(moisture_a.min(moisture_b)),
+                SensorCombineMode::Max => Some(moisture_a.max(moisture_b)),
+                SensorCombineMode::Avg => Some((moisture_a + moisture_b) / 2.0),
+            },
+            (Some(moisture), _) => Some(moisture),
+            (_, Some(moisture)) => Some(moisture),
+            _ => None,
        }
    }

@@ -234,11 +310,11 @@ impl PlantState {
        match plant_conf.mode {
            PlantWateringMode::Off => false,
            PlantWateringMode::TargetMoisture => {
-                let (moisture_percent, _) = self.plant_moisture();
+                let moisture_percent = self.plant_moisture_with_warning(plant_conf);
                if let Some(moisture_percent) = moisture_percent {
                    if self.pump_in_timeout(plant_conf, current_time) {
                        false
-                    } else if moisture_percent < plant_conf.target_moisture {
+                    } else if moisture_percent < plant_conf.target_moisture.into() {
                        in_time_range(
                            current_time,
                            plant_conf.pump_hour_start,
@@ -260,23 +336,26 @@ impl PlantState {
        }
    }

-    pub fn to_mqtt_info(
-        &self,
-        plant_conf: &PlantConfig,
-        current_time: &DateTime<Tz>,
-    ) -> PlantInfo<'_> {
+    pub fn to_mqtt_info(&self, plant_conf: &PlantConfig, current_time: &DateTime<Tz>) -> PlantInfo {
+        let moisture_pct = self.plant_moisture_with_warning(plant_conf);
        PlantInfo {
-            sensor_a: &self.sensor_a,
-            sensor_b: &self.sensor_b,
+            moisture_pct,
+            sensor_a: Self::sensor_to_telemetry(&self.sensor_a),
+            sensor_b: Self::sensor_to_telemetry(&self.sensor_b),
            mode: plant_conf.mode,
+            target_pct: if plant_conf.mode == TargetMoisture {
+                Some(plant_conf.target_moisture as f32)
+            } else {
+                None
+            },
            do_water: self.needs_to_be_watered(plant_conf, current_time),
-            dry: if let Some(moisture_percent) = self.plant_moisture().0 {
-                moisture_percent < plant_conf.target_moisture
+            dry: if let Some(moisture_percent) = moisture_pct {
+                moisture_percent < plant_conf.target_moisture.into()
            } 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,
@@ -301,17 +380,67 @@ impl PlantState {
            } else {
                None
            },
+            last_fertilizer: self
+                .last_fertilizer_time
+                .map(|t| t.with_timezone(&current_time.timezone())),
+            next_fertilizer: if matches!(
+                plant_conf.mode,
+                PlantWateringMode::TimerOnly
+                    | PlantWateringMode::TargetMoisture
+                    | PlantWateringMode::MinMoisture
+            ) {
+                self.last_fertilizer_time.and_then(|last_fert| {
+                    // Convert to Tz for calculation, then back
+                    let tz_last_fert = last_fert.with_timezone(&current_time.timezone());
+                    tz_last_fert
+                        .checked_add_signed(TimeDelta::minutes(
+                            plant_conf.fertilizer_cooldown_min.into(),
+                        ))
+                        .map(|t| t.with_timezone(&current_time.timezone()))
+                })
+            } else {
+                None
+            },
+            sensor_a_firmware_build_minutes: self.sensor_a_firmware_build_minutes,
+            sensor_b_firmware_build_minutes: self.sensor_b_firmware_build_minutes,
+        }
+    }
+
+    fn sensor_to_telemetry(sensor: &MoistureSensorState) -> SensorTelemetry {
+        match sensor {
+            MoistureSensorState::NoMessage => SensorTelemetry {
+                moisture_pct: None,
+                raw_hz: None,
+                error: None,
+            },
+            MoistureSensorState::MoistureValue {
+                hz,
+                moisture_percent,
+            } => SensorTelemetry {
+                moisture_pct: Some(*moisture_percent),
+                raw_hz: Some(*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>,
+    /// moisture target, if in targetmode
+    target_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
@@ -329,4 +458,12 @@ pub struct PlantInfo<'a> {
    last_pump: Option<DateTime<Tz>>,
    /// next time when pump should activate
    next_pump: Option<DateTime<Tz>>,
+    /// last time when fertilizer was applied
+    last_fertilizer: Option<DateTime<Tz>>,
+    /// next time when fertilizer should be applied
+    next_fertilizer: Option<DateTime<Tz>>,
+    /// firmware build timestamp of sensor A (minutes since Unix epoch); None if unknown
+    sensor_a_firmware_build_minutes: Option<u32>,
+    /// firmware build timestamp of sensor B (minutes since Unix epoch); None if unknown
+    sensor_b_firmware_build_minutes: Option<u32>,
 }
--- a/Software/MainBoard/rust/src/tank.rs
+++ b/Software/MainBoard/rust/src/tank.rs
@@ -10,11 +10,12 @@ 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 {
@@ -25,7 +26,9 @@ 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);
@@ -141,15 +144,15 @@ 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,
        }
    }
 }
@@ -161,10 +164,13 @@ pub async fn determine_tank_state(
        match board
            .board_hal
            .get_tank_sensor()
-            .map(|f| f.tank_sensor_voltage())
+            .tank_sensor_voltage()
+            .await
        {
-            Ok(raw_sensor_value_mv) => TankState::Present(raw_sensor_value_mv.await.unwrap()),
-            Err(err) => TankState::Error(TankError::BoardError(err.to_string())),
+            Ok(raw_sensor_value_mv) => TankState::Present(raw_sensor_value_mv),
+            Err(err) => TankState::Error(TankError::BoardError {
+                message: err.to_string(),
+            }),
        }
    } else {
        TankState::Disabled
@@ -179,16 +185,16 @@ pub struct TankInfo {
    /// warning that water needs to be refilled soon
    pub(crate) warn_level: bool,
    /// estimation how many ml are still in the tank
-    pub(crate) left_ml: Option<f32>,
+    pub(crate) volume_ml: Option<f32>,
    /// if there is an issue with the water level sensor
    pub(crate) sensor_error: Option<TankError>,
    /// raw water sensor value
-    pub(crate) raw: Option<f32>,
+    pub(crate) fill_raw_v: Option<f32>,
    /// percent value
-    pub(crate) percent: Option<f32>,
+    pub(crate) fill_pct: Option<f32>,
    /// water in the tank might be frozen
    pub(crate) water_frozen: bool,
    /// water temperature
-    pub(crate) water_temp: Option<f32>,
+    pub(crate) water_temp_c: Option<f32>,
    pub(crate) temp_sensor_error: Option<String>,
 }
--- a/Software/MainBoard/rust/src/util.rs
+++ b/Software/MainBoard/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;
--- a/Software/MainBoard/rust/src/webserver/backup_manager.rs
+++ b/Software/MainBoard/rust/src/webserver/backup_manager.rs
@@ -1,8 +1,8 @@
 use crate::fat_error::{FatError, FatResult};
-use crate::hal::rtc::X25;
+use crate::hal::savegame_manager::SAVEGAME_SLOT_SIZE;
+use crate::webserver::read_up_to_bytes_from_request;
 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;
@@ -21,48 +21,9 @@ pub(crate) async fn get_backup_config<T, const N: usize>(
 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?;
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let backup = board.board_hal.read_backup().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 {expected_crc} got {actual_crc}")
-                            .as_str(),
-                    ),
-                    &[],
-                )
-                .await?;
-                return Ok(Some(409));
-            }
-            break;
-        }
-        chunk += 1;
-    }
    // Second pass: stream data
    conn.initiate_response(
        200,
@@ -75,35 +36,8 @@ where
    )
    .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;
+    conn.write_all(serde_json::to_string(&backup)?.as_bytes())
+        .await?;
    Ok(Some(200))
 }

@@ -113,49 +47,12 @@ pub(crate) async fn backup_config<T, const N: usize>(
 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 += 1;
-            board
-                .board_hal
-                .get_rtc_module()
-                .backup_config(offset, &buf[0..to_write])
-                .await?;
-            checksum.update(&buf[0..to_write]);
-        }
-        offset += to_write;
-    }
-
+    let input = read_up_to_bytes_from_request(conn, Some(SAVEGAME_SLOT_SIZE)).await?;
+    info!("Read input with length {}", input.len());
    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?;
+    let config_to_backup = serde_json::from_slice(&input)?;
+    info!("Parsed send config to object");
+    board.board_hal.backup_config(&config_to_backup).await?;
    Ok(Some("saved".to_owned()))
 }

@@ -166,10 +63,12 @@ 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 {
+    let info = board.board_hal.backup_info().await;
+
+    let json = match info {
        Ok(h) => {
-            let timestamp = DateTime::from_timestamp_millis(h.timestamp).unwrap();
+            info!("Got backup info: {:?}", h);
+            let timestamp = DateTime::from_timestamp_millis(h.timestamp).unwrap_or_default();
            let wbh = WebBackupHeader {
                timestamp: timestamp.to_rfc3339(),
                size: h.size,
@@ -177,6 +76,7 @@ where
            serde_json::to_string(&wbh)?
        }
        Err(err) => {
+            info!("Error getting backup info: {:?}", err);
            let wbh = WebBackupHeader {
                timestamp: err.to_string(),
                size: 0,
--- a/Software/MainBoard/rust/src/webserver/file_manager.rs
+++ b/Software/MainBoard/rust/src/webserver/file_manager.rs
@@ -1,160 +0,0 @@
-use crate::fat_error::{FatError, FatResult};
-use crate::webserver::read_up_to_bytes_from_request;
-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 {filename} with method {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 {filename} finished");
-                    break;
-                }
-                let data = &read_chunk.0[0..length];
-                conn.write_all(data).await?;
-                if length < read_chunk.0.len() {
-                    info!("file request for {filename} finished");
-                    break;
-                }
-                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 buf = read_up_to_bytes_from_request(conn, Some(4096)).await?;
-                if buf.is_empty() {
-                    info!("file request for {filename} finished");
-                    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)
-                        .await?;
-                }
-                offset += buf.len();
-                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,
-    })
-}
--- a/Software/MainBoard/rust/src/webserver/get_json.rs
+++ b/Software/MainBoard/rust/src/webserver/get_json.rs
@@ -1,11 +1,11 @@
 use crate::fat_error::{FatError, FatResult};
-use crate::hal::{esp_time, PLANT_COUNT};
+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;
+use alloc::string::{String, ToString};
 use alloc::vec::Vec;
 use chrono_tz::Tz;
 use core::str::FromStr;
@@ -23,6 +23,8 @@ struct LoadData<'a> {
 struct Moistures {
    moisture_a: Vec<String>,
    moisture_b: Vec<String>,
+    sensor_a_build_minutes: Vec<Option<u32>>,
+    sensor_b_build_minutes: Vec<Option<u32>>,
 }
 #[derive(Serialize, Debug)]
 struct SolarState {
@@ -40,30 +42,43 @@ where
    let moistures = board.board_hal.measure_moisture_hz().await?;
    let mut plant_state = Vec::new();
    for i in 0..PLANT_COUNT {
-        plant_state.push(PlantState::read_hardware_state(moistures, i, &mut board).await);
+        plant_state.push(PlantState::interpret_raw_values(moistures, i, &mut board).await);
    }
    let a = Vec::from_iter(plant_state.iter().map(|s| match &s.sensor_a {
        MoistureSensorState::MoistureValue {
-            raw_hz,
+            hz: raw_hz,
            moisture_percent,
        } => {
            format!("{moisture_percent:.2}% {raw_hz}hz",)
        }
        MoistureSensorState::SensorError(err) => format!("{err:?}"),
+        MoistureSensorState::NoMessage => "No Message".to_string(),
    }));
    let b = Vec::from_iter(plant_state.iter().map(|s| match &s.sensor_b {
        MoistureSensorState::MoistureValue {
-            raw_hz,
+            hz: raw_hz,
            moisture_percent,
        } => {
            format!("{moisture_percent:.2}% {raw_hz}hz",)
        }
        MoistureSensorState::SensorError(err) => format!("{err:?}"),
+        MoistureSensorState::NoMessage => "No Message".to_string(),
    }));

+    let sensor_a_build_minutes: Vec<Option<u32>> = plant_state
+        .iter()
+        .map(|s| s.sensor_a_firmware_build_minutes)
+        .collect();
+    let sensor_b_build_minutes: Vec<Option<u32>> = plant_state
+        .iter()
+        .map(|s| s.sensor_b_firmware_build_minutes)
+        .collect();
+
    let data = Moistures {
        moisture_a: a,
        moisture_b: b,
+        sensor_a_build_minutes,
+        sensor_b_build_minutes,
    };
    let json = serde_json::to_string(&data)?;

@@ -78,10 +93,11 @@ where
 {
    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;
+    let water_temp: FatResult<f32> = board
+        .board_hal
+        .get_tank_sensor()
+        .water_temperature_c()
+        .await;
    Ok(Some(serde_json::to_string(&tank_state.as_mqtt_info(
        &board.board_hal.get_config().tank,
        &water_temp,
@@ -107,19 +123,44 @@ pub(crate) async fn get_solar_state<T, const N: usize>(
    Ok(Some(serde_json::to_string(&state)?))
 }

-pub(crate) async fn get_version_web<T, const N: usize>(
+pub(crate) async fn get_firmware_info_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)?))
 }

+/// Return the current in-memory config, or — when `saveidx` is `Some(idx)` —
+/// the JSON stored in save slot `idx`.
 pub(crate) async fn get_config<T, const N: usize>(
    _request: &mut Connection<'_, T, N>,
+    saveidx: Option<usize>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let json = match saveidx {
+        None => serde_json::to_string(board.board_hal.get_config())?,
+        Some(idx) => board.board_hal.get_esp().load_config_slot(idx).await?,
+    };
+    Ok(Some(json))
+}
+
+/// Return a JSON array describing every valid save slot on flash.
+pub(crate) async fn list_saves<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))
+    let saves = board.board_hal.get_esp().list_saves().await?;
+    Ok(Some(serde_json::to_string(&saves)?))
+}
+
+/// Erase (delete) a single save slot by index.
+pub(crate) async fn delete_save<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+    idx: usize,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    board.board_hal.get_esp().delete_save_slot(idx).await?;
+    Ok(None)
 }

 pub(crate) async fn get_battery_state<T, const N: usize>(
@@ -147,7 +188,12 @@ pub(crate) async fn get_time<T, const N: usize>(
        },
    };

-    let native = esp_time().await.with_timezone(&tz).to_rfc3339();
+    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(),
@@ -172,3 +218,12 @@ pub(crate) async fn get_log_localization_config<T, const N: usize>(
        &LogMessage::log_localisation_config(),
    )?))
 }
+
+/// Return Wi-Fi scan details including signal strength (RSSI)
+pub(crate) async fn get_wifi_details<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let wifi_details = board.board_hal.get_esp().wifi_scan_details().await?;
+    Ok(Some(serde_json::to_string(&wifi_details)?))
+}
--- a/Software/MainBoard/rust/src/webserver/get_log.rs
+++ b/Software/MainBoard/rust/src/webserver/get_log.rs
@@ -1,7 +1,10 @@
 use crate::fat_error::FatResult;
 use crate::log::LOG_ACCESS;
+use alloc::string::String;
+use alloc::vec::Vec;
 use edge_http::io::server::Connection;
 use edge_nal::io::{Read, Write};
+use serde::Serialize;

 pub(crate) async fn get_log<T, const N: usize>(
    conn: &mut Connection<'_, T, N>,
@@ -34,3 +37,29 @@ where
    conn.write_all("]".as_bytes()).await?;
    Ok(Some(200))
 }
+
+#[derive(Serialize)]
+struct LiveLogEntry {
+    seq: u64,
+    text: String,
+}
+
+#[derive(Serialize)]
+struct LiveLogResponse {
+    entries: Vec<LiveLogEntry>,
+    dropped: bool,
+    next_seq: u64,
+}
+
+pub(crate) async fn get_live_log(after: Option<u64>) -> FatResult<Option<String>> {
+    let (raw_entries, dropped, next_seq) = crate::log::INTERCEPTOR.get_live_logs(after);
+    let response = LiveLogResponse {
+        entries: raw_entries
+            .into_iter()
+            .map(|(seq, text)| LiveLogEntry { seq, text })
+            .collect(),
+        dropped,
+        next_seq,
+    };
+    Ok(Some(serde_json::to_string(&response)?))
+}
--- a/Software/MainBoard/rust/src/webserver/mod.rs
+++ b/Software/MainBoard/rust/src/webserver/mod.rs
@@ -1,7 +1,6 @@
 //offer ota and config mode

 mod backup_manager;
-mod file_manager;
 mod get_json;
 mod get_log;
 mod get_static;
@@ -10,17 +9,17 @@ mod post_json;

 use crate::fat_error::{FatError, FatResult};
 use crate::webserver::backup_manager::{backup_config, backup_info, get_backup_config};
-use crate::webserver::file_manager::{file_operations, list_files};
 use crate::webserver::get_json::{
-    get_battery_state, get_config, get_live_moisture, get_log_localization_config, get_solar_state,
-    get_time, get_timezones, get_version_web, tank_info,
+    delete_save, get_battery_state, get_config, get_firmware_info_web, get_live_moisture,
+    get_log_localization_config, get_solar_state, get_time, get_timezones, get_wifi_details,
+    list_saves, tank_info,
 };
-use crate::webserver::get_log::get_log;
+use crate::webserver::get_log::{get_live_log, get_log};
 use crate::webserver::get_static::{serve_bundle, serve_favicon, serve_index};
 use crate::webserver::ota::ota_operations;
 use crate::webserver::post_json::{
-    board_test, can_power, detect_sensors, night_lamp_test, pump_test, set_config, wifi_scan,
-    write_time,
+    board_test, can_power, detect_sensors, fertilizer_pump_test, night_lamp_test, pump_test,
+    set_config, wifi_scan, write_time,
 };
 use crate::{bail, BOARD_ACCESS};
 use alloc::borrow::ToOwned;
@@ -60,10 +59,7 @@ impl Handler for HTTPRequestRouter {
        let method = headers.method;
        let path = headers.path;

-        let prefix = "/file?filename=";
-        let status = if path.starts_with(prefix) {
-            file_operations(conn, method, &path, &prefix).await?
-        } else if path == "/ota" {
+        let status = if path == "/ota" {
            ota_operations(conn, method).await.map_err(|e| {
                error!("Error handling ota: {e}");
                e
@@ -78,17 +74,33 @@ impl Handler for HTTPRequestRouter {
                    "/get_backup_config" => get_backup_config(conn).await?,
                    &_ => {
                        let json = match path {
-                            "/version" => Some(get_version_web(conn).await),
+                            "/firmware_info" => Some(get_firmware_info_web(conn).await),
                            "/time" => Some(get_time(conn).await),
                            "/battery" => Some(get_battery_state(conn).await),
                            "/solar" => Some(get_solar_state(conn).await),
-                            "/get_config" => Some(get_config(conn).await),
-                            "/files" => Some(list_files(conn).await),
                            "/log_localization" => Some(get_log_localization_config(conn).await),
                            "/tank" => Some(tank_info(conn).await),
                            "/backup_info" => Some(backup_info(conn).await),
                            "/timezones" => Some(get_timezones().await),
                            "/moisture" => Some(get_live_moisture(conn).await),
+                            "/list_saves" => Some(list_saves(conn).await),
+                            "/wifi_details" => Some(get_wifi_details(conn).await),
+                            // /live_log accepts an optional ?after=N query parameter
+                            p if p == "/live_log" || p.starts_with("/live_log?") => {
+                                let after: Option<u64> = p
+                                    .find("after=")
+                                    .and_then(|pos| p[pos + 6..].split('&').next())
+                                    .and_then(|s| s.parse().ok());
+                                Some(get_live_log(after).await)
+                            }
+                            // /get_config accepts an optional ?saveidx=N query parameter
+                            p if p == "/get_config" || p.starts_with("/get_config?") => {
+                                let saveidx: Option<usize> = p
+                                    .find("saveidx=")
+                                    .and_then(|pos| p[pos + 8..].split('&').next())
+                                    .and_then(|s| s.parse().ok());
+                                Some(get_config(conn, saveidx).await)
+                            }
                            _ => None,
                        };
                        match json {
@@ -106,6 +118,7 @@ impl Handler for HTTPRequestRouter {
                        "/pumptest" => Some(pump_test(conn).await),
                        "/can_power" => Some(can_power(conn).await),
                        "/lamptest" => Some(night_lamp_test(conn).await),
+                        "/fertilizerpumptest" => Some(fertilizer_pump_test(conn).await),
                        "/boardtest" => Some(board_test().await),
                        "/detect_sensors" => Some(detect_sensors(conn).await),
                        "/reboot" => {
@@ -127,7 +140,28 @@ impl Handler for HTTPRequestRouter {
                        Some(json) => Some(handle_json(conn, json).await?),
                    }
                }
-                Method::Options | Method::Delete | Method::Head | Method::Put => None,
+                Method::Delete => {
+                    // DELETE /delete_save?idx=N
+                    let json = if path == "/delete_save" || path.starts_with("/delete_save?") {
+                        let idx: Option<usize> = path
+                            .find("idx=")
+                            .and_then(|pos| path[pos + 4..].split('&').next())
+                            .and_then(|s| s.parse().ok());
+                        match idx {
+                            Some(idx) => Some(delete_save(conn, idx).await),
+                            None => Some(Err(FatError::String {
+                                error: "missing idx parameter".into(),
+                            })),
+                        }
+                    } else {
+                        None
+                    };
+                    match json {
+                        None => None,
+                        Some(json) => Some(handle_json(conn, json).await?),
+                    }
+                }
+                Method::Options | Method::Head | Method::Put => None,
                _ => None,
            }
        };
@@ -181,6 +215,7 @@ where
 }

 #[embassy_executor::task]
+#[allow(clippy::panic, clippy::unwrap_used, clippy::expect_used)]
 pub async fn http_server(reboot_now: Arc<AtomicBool>, stack: Stack<'static>) {
    let buffer: TcpBuffers<2, 1024, 1024> = TcpBuffers::new();
    let tcp = Tcp::new(stack, &buffer);
@@ -241,6 +276,7 @@ where
        Err(err) => {
            let error_text = err.to_string();
            info!("error handling process {error_text}");
+
            conn.initiate_response(
                500,
                Some("OK"),
--- a/Software/MainBoard/rust/src/webserver/post_json.rs
+++ b/Software/MainBoard/rust/src/webserver/post_json.rs
@@ -1,13 +1,16 @@
 use crate::config::PlantControllerConfig;
 use crate::fat_error::FatResult;
-use crate::hal::{esp_set_time, Detection};
+use crate::hal::savegame_manager::SAVEGAME_SLOT_SIZE;
+use crate::hal::DetectionRequest;
 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};

@@ -40,10 +43,10 @@ pub(crate) async fn wifi_scan<T, const N: usize>(
    let mut board = BOARD_ACCESS.get().await.lock().await;
    info!("start wifi scan");
    let mut ssids: Vec<String> = Vec::new();
-    let scan_result = board.board_hal.get_esp().wifi_scan().await?;
+    let scan_result: Vec<AccessPointInfo> = board.board_hal.get_esp().wifi_scan().await?;
    scan_result
        .iter()
-        .for_each(|s| ssids.push(s.ssid.to_string()));
+        .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))
@@ -62,7 +65,7 @@ where
    T: Read + Write,
 {
    let actual_data = read_up_to_bytes_from_request(request, None).await?;
-    let detect: Detection = serde_json::from_slice(&actual_data)?;
+    let detect: DetectionRequest = serde_json::from_slice(&actual_data)?;
    let mut board = BOARD_ACCESS.get().await.lock().await;
    let result = board.board_hal.detect_sensors(detect).await?;
    let json = serde_json::to_string(&result)?;
@@ -100,6 +103,19 @@ where
    Ok(None)
 }

+pub(crate) async fn fertilizer_pump_test<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;
+    board.board_hal.fertilizer_pump(true).await?;
+    embassy_time::Timer::after_millis(1000).await;
+    board.board_hal.fertilizer_pump(false).await?;
+    Ok(None)
+}
+
 pub(crate) async fn write_time<T, const N: usize>(
    request: &mut Connection<'_, T, N>,
 ) -> FatResult<Option<String>>
@@ -108,8 +124,9 @@ where
 {
    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).unwrap();
-    esp_set_time(parsed).await?;
+    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)
 }

@@ -119,7 +136,8 @@ pub(crate) async fn set_config<T, const N: usize>(
 where
    T: Read + Write,
 {
-    let all = read_up_to_bytes_from_request(request, Some(4096)).await?;
+    //accept nearly full slotsize leave some space for header
+    let all = read_up_to_bytes_from_request(request, Some(SAVEGAME_SLOT_SIZE - 512)).await?;
    let length = all.len();
    let config: PlantControllerConfig = serde_json::from_slice(&all)?;

--- a/Software/MainBoard/rust/src_webpack/src/api.ts
+++ b/Software/MainBoard/rust/src_webpack/src/api.ts
@@ -1,6 +1,17 @@
 export interface LogArray extends Array<LogEntry> {
 }

+export interface LiveLogEntry {
+    seq: number,
+    text: string,
+}
+
+export interface LiveLogResponse {
+    entries: LiveLogEntry[],
+    dropped: boolean,
+    next_seq: number,
+}
+
 export interface LogEntry {
    timestamp: string,
    message_id: number,
@@ -34,6 +45,12 @@ export interface NetworkConfig {
    max_wait: number
 }

+export interface SaveInfo {
+    idx: number,
+    len: number,
+    created_at: string | null,
+}
+
 export interface FileList {
    total: number,
    used: number,
@@ -92,6 +109,7 @@ export enum BoardVersion {
 export interface BoardHardware {
    board: BoardVersion,
    battery: BatteryBoardVersion,
+    pump_corrosion_protection: boolean,
 }

 export interface PlantControllerConfig {
@@ -110,6 +128,8 @@ export interface PlantConfig {
    min_moisture: number,
    pump_time_s: number,
    pump_cooldown_min: number,
+    fertilizer_s: number,
+    fertilizer_cooldown_min: number,
    pump_hour_start: number,
    pump_hour_end: number,
    pump_limit_ml: number,
@@ -121,6 +141,7 @@ export interface PlantConfig {
    min_pump_current_ma: number,
    max_pump_current_ma: number,
    ignore_current_error: boolean,
+    sensor_combine_mode: string,
 }

 export interface PumpTestResult {
@@ -157,6 +178,8 @@ export interface GetTime {
 export interface Moistures {
    moisture_a: [string],
    moisture_b: [string],
+    sensor_a_build_minutes: Array<number | null>,
+    sensor_b_build_minutes: Array<number | null>,
 }

 export interface VersionInfo {
@@ -165,6 +188,10 @@ export interface VersionInfo {
    current: string,
    slot0_state: string,
    slot1_state: string,
+    heap_total: number,
+    heap_used: number,
+    heap_free: number,
+    heap_max_used: number,
 }

 export interface BatteryState {
@@ -177,32 +204,54 @@ export interface BatteryState {
    state_of_health: string
 }

-export interface DetectionPlant {
+/// Request: which sensors to send IDENTIFY_CMD to.
+export interface SensorRequest {
    sensor_a: boolean,
-    sensor_b: boolean
+    sensor_b: boolean,
+}
+
+export interface DetectionRequest {
+    plant: SensorRequest[]
+}
+
+/// Response: detection result per plant.
+/// sensor_a / sensor_b: firmware build timestamp in minutes since Unix epoch,
+/// or null if the sensor did not respond.
+export interface DetectionPlant {
+    sensor_a: number | null,
+    sensor_b: number | null,
 }

 export interface Detection {
    plant: DetectionPlant[]
 }

+/// Wi-Fi scan result details for UI display
+export interface WifiScanResult {
+    ssid: string,
+    bssid: string,
+    rssi: number, // signal strength in dBm
+    channel: number,
+    auth_method: string
+}
+
 export interface TankInfo {
-    /// is there enough water in the tank
+    /// there is enough water in the tank
    enough_water: boolean,
    /// warning that water needs to be refilled soon
    warn_level: boolean,
-    /// estimation how many ml are still in tank
-    left_ml: number | null,
-    /// if there is was an issue with the water level sensor
+    /// estimation how many ml are still in the tank
+    volume_ml: number | null,
+    /// if there is an issue with the water level sensor
    sensor_error: string | null,
    /// raw water sensor value
-    raw: number | null,
+    fill_raw_v: number | null,
    /// percent value
-    percent: number | null,
-    /// water in tank might be frozen
+    fill_pct: number | null,
+    /// water in the tank might be frozen
    water_frozen: boolean,
    /// water temperature
-    water_temp: number | null,
+    water_temp_c: number | null,
    temp_sensor_error: string | null
 }

--- a/Software/MainBoard/rust/src_webpack/src/fileview.html
+++ b/Software/MainBoard/rust/src_webpack/src/fileview.html
@@ -29,44 +29,10 @@
  }
 </style>

-<div class="subtitle">Files:</div>
-<div class="flexcontainer">
-  <div class="filekey">Total Size</div>
-  <div id="filetotalsize" class="filevalue"></div>
-</div>
-<div class="flexcontainer">
-  <div class="filekey">Used Size</div>
-  <div id="fileusedsize" class="filevalue"></div>
-</div>
-<div class="flexcontainer">
-  <div class="filekey">Free Size</div>
-  <div id="filefreesize" class="filevalue"></div>
-</div>
-<br>
-
-<div class="flexcontainer"  style="border-left-style: double; border-right-style: double; border-top-style: double;">
-  <div class="subtitle" >Upload:</div>
-</div>
-<div class="flexcontainer" style="border-left-style: double; border-right-style: double;">
-  <div class="flexcontainer">
-    <div class="filekey">
-      File:
-    </div>
-    <input id="fileuploadfile" class="filevalue" type="file">
-  </div>
-  <div class="flexcontainer">
-    <div class="filekey">
-      Name:
-    </div>
-    <input id="fileuploadname" class="filevalue" type="text">
-  </div>
-</div>
-<div class="flexcontainer" style="border-left-style: double; border-right-style: double; border-bottom-style: double;">
-  <button id="fileuploadbtn" class="subtitle">Upload</button>
-</div>
+<div class="subtitle">Save Slots:</div>
 <br>
 <div class="flexcontainer" style="border-left-style: double; border-right-style: double; border-top-style: double;">
  <div class="subtitle">List:</div>
 </div>
 <div id="fileList" class="flexcontainer" style="border-left-style: double; border-right-style: double; border-bottom-style: double;">
-</div>
+</div>
--- a/Software/MainBoard/rust/src_webpack/src/fileview.ts
+++ b/Software/MainBoard/rust/src_webpack/src/fileview.ts
@@ -1,96 +1,62 @@
 import {Controller} from "./main";
-import {FileInfo, FileList} from "./api";
-const regex = /[^a-zA-Z0-9_.]/g;
-
-function sanitize(str:string){
-  return str.replaceAll(regex, '_')
-} 
+import {SaveInfo} from "./api";

 export class FileView {
  readonly fileListView: HTMLElement;
  readonly controller: Controller;
-  readonly filefreesize: HTMLElement;
-  readonly filetotalsize: HTMLElement;
-  readonly fileusedsize: HTMLElement;

  constructor(controller: Controller) {
    (document.getElementById("fileview") as HTMLElement).innerHTML = require('./fileview.html') as string;
-    this.fileListView = document.getElementById("fileList") as HTMLElement
-    this.filefreesize = document.getElementById("filefreesize") as HTMLElement
-    this.filetotalsize = document.getElementById("filetotalsize") as HTMLElement
-    this.fileusedsize = document.getElementById("fileusedsize") as HTMLElement
-
-    let fileuploadfile = document.getElementById("fileuploadfile") as HTMLInputElement
-    let fileuploadname = document.getElementById("fileuploadname") as HTMLInputElement
-    let fileuploadbtn = document.getElementById("fileuploadbtn") as HTMLInputElement
-    fileuploadfile.onchange = () => {
-      const selectedFile = fileuploadfile.files?.[0];
-      if (selectedFile == null) {
-        //TODO error dialog here
-        return
-      }
-      
-      fileuploadname.value = sanitize(selectedFile.name)
-    };
-
-    fileuploadname.onchange = () => {
-      let input = fileuploadname.value
-      let clean = sanitize(fileuploadname.value)
-      if (input != clean){
-        fileuploadname.value = clean
-      }
-    }
-
-    fileuploadbtn.onclick = () => {
-      const selectedFile = fileuploadfile.files?.[0];
-      if (selectedFile == null) {
-        //TODO error dialog here
-        return
-      }
-      controller.uploadFile(selectedFile, selectedFile.name)
-    }
-
-
-
+    this.fileListView = document.getElementById("fileList") as HTMLElement;
    this.controller = controller;
  }

-  setFileList(fileList: FileList, public_url: string) {
-    this.filetotalsize.innerText = Math.floor(fileList.total / 1024) + "kB"
-    this.fileusedsize.innerText = Math.ceil(fileList.used / 1024) + "kB"
-    this.filefreesize.innerText = Math.ceil((fileList.total - fileList.used) / 1024) + "kB"
+  setSaveList(saves: SaveInfo[], public_url: string) {
+    // Sort newest first (highest index = most recently written slot)
+    const sorted = saves.slice().sort((a, b) => b.idx - a.idx);

-    //fast clear
-    this.fileListView.textContent = ""
-    for (let i = 0; i < fileList.files.length; i++) {
-      let file = fileList.files[i]
-      new FileEntry(this.controller, i, file, this.fileListView, public_url);
+    this.fileListView.textContent = "";
+    for (let i = 0; i < sorted.length; i++) {
+      new SaveEntry(this.controller, i, sorted[i], this.fileListView, public_url);
    }
  }
 }

-class FileEntry {
+class SaveEntry {
  view: HTMLElement;
-  constructor(controller: Controller, fileid: number, fileinfo: FileInfo, parent: HTMLElement, public_url: string) {
-    this.view = document.createElement("div") as HTMLElement
-    parent.appendChild(this.view)
-    this.view.classList.add("fileentryouter")
+  constructor(controller: Controller, fileid: number, saveinfo: SaveInfo, parent: HTMLElement, public_url: string) {
+    this.view = document.createElement("div") as HTMLElement;
+    parent.appendChild(this.view);
+    this.view.classList.add("fileentryouter");

    const template = require('./fileviewentry.html') as string;
-    this.view.innerHTML = template.replaceAll("${fileid}", String(fileid))
+    this.view.innerHTML = template.replaceAll("${fileid}", String(fileid));

    let name = document.getElementById("file_" + fileid + "_name") as HTMLElement;
+    let created = document.getElementById("file_" + fileid + "_created") as HTMLElement;
    let size = document.getElementById("file_" + fileid + "_size") as HTMLElement;
    let deleteBtn = document.getElementById("file_" + fileid + "_delete") as HTMLButtonElement;
    deleteBtn.onclick = () => {
-      controller.deleteFile(fileinfo.filename);
-    }
+      controller.deleteSlot(saveinfo.idx);
+    };

    let downloadBtn = document.getElementById("file_" + fileid + "_download") as HTMLAnchorElement;
-    downloadBtn.href = public_url + "/file?filename=" + fileinfo.filename
-    downloadBtn.download = fileinfo.filename
+    downloadBtn.href = public_url + "/get_config?saveidx=" + saveinfo.idx;
+    downloadBtn.download = "config_slot_" + saveinfo.idx + ".json";

-    name.innerText = fileinfo.filename;
-    size.innerText = fileinfo.size.toString()
+    name.innerText = "Slot " + saveinfo.idx;
+    size.innerText = saveinfo.len + " bytes";
+
+    // Format timestamp in browser's local timezone
+    if (saveinfo.created_at) {
+      try {
+        const date = new Date(saveinfo.created_at);
+        created.innerText = date.toLocaleString();
+      } catch (e) {
+        created.innerText = "Invalid date";
+      }
+    } else {
+      created.innerText = "Unknown";
+    }
  }
-}
+}
--- a/Software/MainBoard/rust/src_webpack/src/fileviewentry.html
+++ b/Software/MainBoard/rust/src_webpack/src/fileviewentry.html
@@ -1,11 +1,17 @@
 <div class="flexcontainer">
-    <div id="file_${fileid}_name" class="filetitle">Name</div>
+    <div id="file_${fileid}_name" class="filetitle">Slot</div>
+</div>
+
+<div class="flexcontainer">
+    <div class="filekey">Created</div>
+    <div id="file_${fileid}_created" class="filevalue"></div>
 </div>

 <div class="flexcontainer">
    <div class="filekey">Size</div>
-    <div id = "file_${fileid}_size" class="filevalue"></div>
-    <a id = "file_${fileid}_download" class="filevalue" target="_blank">Download</a>
-    <button id = "file_${fileid}_delete" class="filevalue">Delete</button>
+    <div id="file_${fileid}_size" class="filevalue"></div>
+    <a id="file_${fileid}_download" class="filevalue" target="_blank">Download</a>
+    <button id="file_${fileid}_delete" class="filevalue">Delete</button>
 </div>

+
--- a/Software/MainBoard/rust/src_webpack/src/hardware.html
+++ b/Software/MainBoard/rust/src_webpack/src/hardware.html
@@ -18,3 +18,12 @@
    <select class="boardvalue" id="hardware_battery_value">
    </select>
 </div>
+<div class="flexcontainer">
+  <div class="boardkey">Pump corrosion protection (weekly)</div>
+  <input type="checkbox" id="hardware_pump_corrosion_protection">
+</div>
+
+<div class="subtitle">Fertilizer Pump:</div>
+<div class="flexcontainer">
+  <button class="subtitle" id="fertilizer_pump_test">Test Fertilizer Pump</button>
+</div>
--- a/Software/MainBoard/rust/src_webpack/src/hardware.ts
+++ b/Software/MainBoard/rust/src_webpack/src/hardware.ts
@@ -4,6 +4,8 @@ import {BatteryBoardVersion, BoardHardware, BoardVersion} from "./api";
 export class HardwareConfigView {
    private readonly hardware_board_value: HTMLSelectElement;
    private readonly hardware_battery_value: HTMLSelectElement;
+    private readonly hardware_pump_corrosion_protection: HTMLInputElement;
+    private readonly fertilizer_pump_test: HTMLButtonElement;
    constructor(controller:Controller){
      (document.getElementById("hardwareview") as HTMLElement).innerHTML = require('./hardware.html') as string;

@@ -29,17 +31,27 @@ export class HardwareConfigView {
        option.innerText = version.toString();
        this.hardware_battery_value.appendChild(option);
      })
+
+      this.hardware_pump_corrosion_protection = document.getElementById("hardware_pump_corrosion_protection") as HTMLInputElement;
+      this.hardware_pump_corrosion_protection.onchange = controller.configChanged
+
+      this.fertilizer_pump_test = document.getElementById("fertilizer_pump_test") as HTMLButtonElement;
+      this.fertilizer_pump_test.onclick = () => {
+        controller.testFertilizerPump();
+      }
    }
  
    setConfig(hardware: BoardHardware) {
      this.hardware_board_value.value = hardware.board.toString()
      this.hardware_battery_value.value = hardware.battery.toString()
+      this.hardware_pump_corrosion_protection.checked = hardware.pump_corrosion_protection
    }
  
    getConfig(): BoardHardware {
      return {
        board :  BoardVersion[this.hardware_board_value.value as keyof typeof BoardVersion],
        battery :  BatteryBoardVersion[this.hardware_battery_value.value as keyof typeof BatteryBoardVersion],
+        pump_corrosion_protection : this.hardware_pump_corrosion_protection.checked,
      }
    }
  }
--- a/Software/MainBoard/rust/src_webpack/src/log.html
+++ b/Software/MainBoard/rust/src_webpack/src/log.html
@@ -1,7 +1,48 @@
 <style>
+    #livelogpanel {
+        font-family: monospace;
+        font-size: 0.85em;
+        background: #1a1a1a;
+        color: #d4d4d4;
+        padding: 8px;
+        max-height: 300px;
+        overflow-y: auto;
+        border: 1px solid #444;
+        white-space: pre-wrap;
+        word-break: break-all;
+    }

+    .livelog-dropped {
+        color: #f0a500;
+        font-style: italic;
+    }
+
+    .log-accordion-header {
+        cursor: pointer;
+        user-select: none;
+        display: flex;
+        align-items: center;
+        gap: 6px;
+    }
+
+    .log-accordion-header::before {
+        content: "▶";
+        font-size: 0.75em;
+        transition: transform 0.15s;
+        display: inline-block;
+    }
+
+    .log-accordion-header.open::before {
+        transform: rotate(90deg);
+    }
+
+    #logpanel {
+
+    }
 </style>
-<button id="loadLog">Load Logs</button>
-<div id="logpanel">
-    
-</div>
+
+<h4 id="logAccordionHeader" class="log-accordion-header">Application Log</h4>
+<div id="logpanel"></div>
+
+<h4>Live Log</h4>
+<div id="livelogpanel"></div>
--- a/Software/MainBoard/rust/src_webpack/src/log.ts
+++ b/Software/MainBoard/rust/src_webpack/src/log.ts
@@ -1,19 +1,38 @@
 import { Controller } from "./main";
-import {LogArray, LogLocalisation} from "./api";
+import {LiveLogResponse, LogArray, LogLocalisation} from "./api";
+
+const LIVE_LOG_POLL_INTERVAL_MS = 2000;

 export class LogView {
  private readonly logpanel: HTMLElement;
-  private readonly loadLog: HTMLButtonElement;
+  private readonly livelogpanel: HTMLElement;
+  private readonly accordionHeader: HTMLElement;
  loglocale: LogLocalisation | undefined;

+  private liveLogNextSeq: number | undefined = undefined;
+  private liveLogTimer: ReturnType<typeof setTimeout> | undefined = undefined;
+  private structuredLogLoaded = false;
+
  constructor(controller: Controller) {
    (document.getElementById("logview") as HTMLElement).innerHTML = require('./log.html') as string;
-    this.logpanel = document.getElementById("logpanel") as HTMLElement
-    this.loadLog = document.getElementById("loadLog") as HTMLButtonElement
+    this.logpanel = document.getElementById("logpanel") as HTMLElement;
+    this.livelogpanel = document.getElementById("livelogpanel") as HTMLElement;
+    this.accordionHeader = document.getElementById("logAccordionHeader") as HTMLElement;

-    this.loadLog.onclick = () => {
-      controller.loadLog();
-    }
+    this.accordionHeader.onclick = () => {
+      const isOpen = this.logpanel.style.display !== "none";
+      if (isOpen) {
+        this.logpanel.style.display = "none";
+        this.accordionHeader.classList.remove("open");
+      } else {
+        this.logpanel.style.display = "";
+        this.accordionHeader.classList.add("open");
+        if (!this.structuredLogLoaded) {
+          this.structuredLogLoaded = true;
+          controller.loadLog();
+        }
+      }
+    };
  }

  setLogLocalisation(loglocale: LogLocalisation) {
@@ -21,10 +40,10 @@ export class LogView {
  }

  setLog(logs: LogArray) {
-    this.logpanel.textContent = ""
+    this.logpanel.textContent = "";
    logs.forEach(entry => {
      let message = this.loglocale!![entry.message_id];
-      let template = message.message
+      let template = message.message;
      template = template.replace("${number_a}", entry.a.toString());
      template = template.replace("${number_b}", entry.b.toString());
      template = template.replace("${txt_short}", entry.txt_short.toString());
@@ -32,15 +51,67 @@ export class LogView {

      let ts = new Date(entry.timestamp);

-      let div = document.createElement("div")
-      let timestampDiv = document.createElement("div")
-      let messageDiv = document.createElement("div")
+      let div = document.createElement("div");
+      let timestampDiv = document.createElement("div");
+      let messageDiv = document.createElement("div");
      timestampDiv.innerText = ts.toISOString();
      messageDiv.innerText = template;
-      div.appendChild(timestampDiv)
-      div.appendChild(messageDiv)
-      this.logpanel.appendChild(div)
-    }
-    )
+      div.appendChild(timestampDiv);
+      div.appendChild(messageDiv);
+      this.logpanel.appendChild(div);
+    });
  }
-}
+
+  startLivePoll(publicUrl: string) {
+    if (this.liveLogTimer !== undefined) {
+      return;
+    }
+    const poll = async () => {
+      try {
+        const url = this.liveLogNextSeq !== undefined
+          ? `${publicUrl}/live_log?after=${this.liveLogNextSeq}`
+          : `${publicUrl}/live_log`;
+        const response = await fetch(url);
+        const data = await response.json() as LiveLogResponse;
+        this.appendLiveLog(data);
+      } catch (_e) {
+        // network error — silently ignore, will retry next interval
+      }
+      this.liveLogTimer = setTimeout(poll, LIVE_LOG_POLL_INTERVAL_MS);
+    };
+    // Kick off immediately
+    this.liveLogTimer = setTimeout(poll, 0);
+  }
+
+  stopLivePoll() {
+    if (this.liveLogTimer !== undefined) {
+      clearTimeout(this.liveLogTimer);
+      this.liveLogTimer = undefined;
+    }
+  }
+
+  private appendLiveLog(data: LiveLogResponse) {
+    const panel = this.livelogpanel;
+    const wasAtBottom = panel.scrollHeight - panel.scrollTop <= panel.clientHeight + 4;
+
+    if (data.dropped) {
+      const marker = document.createElement("div");
+      marker.className = "livelog-dropped";
+      marker.textContent = "[..]";
+      panel.appendChild(marker);
+    }
+
+    for (const entry of data.entries) {
+      const line = document.createElement("div");
+      line.textContent = entry.text;
+      panel.appendChild(line);
+    }
+
+    this.liveLogNextSeq = data.next_seq;
+
+    // Auto-scroll to bottom only if user was already at the bottom
+    if (wasAtBottom) {
+      panel.scrollTop = panel.scrollHeight;
+    }
+  }
+}
--- a/Software/MainBoard/rust/src_webpack/src/main.html
+++ b/Software/MainBoard/rust/src_webpack/src/main.html
@@ -1,195 +1,202 @@
 <style>
-  .progressPane {
-    display: flex;
-    flex-direction: column;
-    position: fixed;
-    width: 100%;
-    height: 100%;
-    margin: 0;
-    padding: 0;
-    top: 0;
-    left: 0;
-    background-color: grey;
-    opacity: 0.8;
-  }
-
-  .progress {
-    height: 2.5em;
-    width: 100%;
-    background-color: #555;
-    position: relative;
-  }
-
-  .progressSpacer{
-    flex-grow: 1;
-  }
-
-  .progress:after {
-    content: attr(data-label);
-    font-size: 0.8em;
-    position: absolute;
-    text-align: center;
-    top: 10px;
-    left: 0;
-    right: 0;
-  }
-
-  .progress .value {
-    background-color: darkcyan;
-    display: inline-block;
-    height: 100%;
-  }
-
-  .progress .valueIndeterminate {
-    background-color: darkcyan;
-    display: inline-block;
-    height: 100%;
-    animation: indeterminateAnimation 1s infinite linear;
-    transform-origin: 0 50%;
-  }
-
-
-  @keyframes indeterminateAnimation {
-    0% {
-      transform: translateX(0%) scaleX(0.5);
+    .progressPane {
+        display: flex;
+        flex-direction: column;
+        position: fixed;
+        width: 100%;
+        height: 100%;
+        margin: 0;
+        padding: 0;
+        top: 0;
+        left: 0;
+        background-color: grey;
+        opacity: 0.8;
    }

-    50% {
-      transform: translateX(50%) scaleX(0.5);
+    .progress {
+        height: 2.5em;
+        width: 100%;
+        background-color: #555;
+        position: relative;
    }

-    100% {
-      transform: translateX(0%) scaleX(0.5);
+    .progressSpacer {
+        flex-grow: 1;
    }
-  }

-
-  .flexcontainer {
-    display: flex;
-    flex-wrap: wrap;
-  }
-  .flexcontainer-rev{
-    display: flex;
-    flex-wrap: wrap-reverse;
-  }
-  .subcontainer {
-    min-width: 300px;
-    max-width: 900px;
-    flex-grow: 1;
-    border-style: solid;
-    border-width: 1px;
-    padding: 8px;
-  }
-  .subcontainercontainer{
-    flex-grow: 1;
-  }
-
-  .plantcontainer {
-      flex-grow: 1;
-      min-width: 100%;
-      border-style: solid;
-      border-width: 1px;
-      padding: 8px;
+    .progress:after {
+        content: attr(data-label);
+        font-size: 0.8em;
+        position: absolute;
+        text-align: center;
+        top: 10px;
+        left: 0;
+        right: 0;
    }
-  @media (min-width: 350px) {
+
+    .progress .value {
+        background-color: darkcyan;
+        display: inline-block;
+        height: 100%;
+    }
+
+    .progress .valueIndeterminate {
+        background-color: darkcyan;
+        display: inline-block;
+        height: 100%;
+        animation: indeterminateAnimation 1s infinite linear;
+        transform-origin: 0 50%;
+    }
+
+
+    @keyframes indeterminateAnimation {
+        0% {
+            transform: translateX(0%) scaleX(0.5);
+        }
+
+        50% {
+            transform: translateX(50%) scaleX(0.5);
+        }
+
+        100% {
+            transform: translateX(0%) scaleX(0.5);
+        }
+    }
+
+
+    .flexcontainer {
+        display: flex;
+        flex-wrap: wrap;
+    }
+
+    .flexcontainer-rev {
+        display: flex;
+        flex-wrap: wrap-reverse;
+    }
+
+    .subcontainer {
+        min-width: 300px;
+        max-width: 900px;
+        flex-grow: 1;
+        border-style: solid;
+        border-width: 1px;
+        padding: 8px;
+    }
+
+    .subcontainercontainer {
+        flex-grow: 1;
+    }
+
    .plantcontainer {
-      flex-grow: 1;
-      min-width: 40%;
-      border-style: solid;
-      border-width: 1px;
-      padding: 8px;
+        flex-grow: 1;
+        min-width: 100%;
+        border-style: solid;
+        border-width: 1px;
+        padding: 8px;
    }
-  }
-  @media (min-width: 1100px) {
-    .plantcontainer {
-      flex-grow: 1;
-      min-width: 20%;
-      border-style: solid;
-      border-width: 1px;
-      padding: 8px;
+
+    @media (min-width: 350px) {
+        .plantcontainer {
+            flex-grow: 1;
+            min-width: 40%;
+            border-style: solid;
+            border-width: 1px;
+            padding: 8px;
+        }
    }
-  }
-  @media (min-width: 2150px) {
-    .plantcontainer {
-      flex-grow: 1;
-      min-width: 200px;
-      border-style: solid;
-      border-width: 1px;
-      padding: 8px;
+
+    @media (min-width: 1100px) {
+        .plantcontainer {
+            flex-grow: 1;
+            min-width: 20%;
+            border-style: solid;
+            border-width: 1px;
+            padding: 8px;
+        }
+    }
+
+    @media (min-width: 2150px) {
+        .plantcontainer {
+            flex-grow: 1;
+            min-width: 200px;
+            border-style: solid;
+            border-width: 1px;
+            padding: 8px;
+        }
    }
-  }


+    .plantlist {
+        display: flex;
+        flex-wrap: wrap;
+    }

-  .plantlist {
-    display: flex;
-    flex-wrap: wrap;
-  }
-
-  .subtitle {
-    flex-grow: 1;
-    text-align: center;
-    font-weight: bold;
-  }
-
+    .subtitle {
+        flex-grow: 1;
+        text-align: center;
+        font-weight: bold;
+    }


 </style>


 <div class="container-xl">
-  <div style="display:flex; flex-wrap: wrap;">
-    <div id="hardwareview" class="subcontainer"></div>
-  </div>
-
-  <div style="display:flex; flex-wrap: wrap;">
-    <div id="firmwareview" class="subcontainer">
+    <div style="display:flex; flex-wrap: wrap;">
+        <div id="hardwareview" class="subcontainer"></div>
    </div>
-    <div id="timeview" class="subcontainer">
+
+    <div style="display:flex; flex-wrap: wrap;">
+        <div id="firmwareview" class="subcontainer">
+        </div>
+        <div id="timeview" class="subcontainer">
+        </div>
+        <div id="batteryview" class="subcontainer">
+        </div>
+        <div id="solarview" class="subcontainer">
+        </div>
    </div>
-    <div id="batteryview" class="subcontainer">
+
+    <div class="flexcontainer">
+        <div id="network_view" class="subcontainercontainer"></div>
+        <div id="lightview" class="subcontainer">
+        </div>
+        <div id="tankview" class="subcontainer">
+        </div>
    </div>
-    <div id="solarview" class="subcontainer">
+
+    <h3>Plants:</h3>
+    <button id="measure_moisture">Measure Moisture</button>
+    <button id="detect_sensors" style="display:none">Detect/Test Sensors</button>
+    <input id="can_power" type="checkbox"><label for="can_power">Power CAN</label>
+    <input id="auto_refresh_moisture_sensors" type="checkbox"><label for="auto_refresh_moisture_sensors">Auto Refresh
+    Moisture/Sensors</label>
+    <div id="plants" class="plantlist"></div>
+
+    <div class="flexcontainer-rev">
+        <div id="submitview" class="subcontainer">
+        </div>
+        <div id="fileview" class="subcontainer">
+        </div>
    </div>
-  </div>

-  <div class="flexcontainer">
-    <div id="network_view" class="subcontainercontainer"></div>
-    <div id="lightview" class="subcontainer">
+
+    <button id="exit">Exit</button>
+    <button id="reboot">Reboot</button>
+
+    <div class="flexcontainer">
+        <div id="logview" class="subcontainercontainer"></div>
    </div>
-    <div id="tankview" class="subcontainer">
-    </div>
-  </div>

-  <h3>Plants:</h3>
-  <button id="measure_moisture">Measure Moisture</button>
-  <button id="detect_sensors" style="display:none">Detect/Test Sensors</button>
-  <input id="can_power" type="checkbox">Power CAN</input>
-  <div id="plants" class="plantlist"></div>
-
-  <div class="flexcontainer-rev">
-    <div id = "submitview" class="subcontainer">
-    </div>
-    <div id="fileview" class="subcontainer">
-    </div>
-  </div>
-
-
-
-  <button id="exit">Exit</button>
-  <button id="reboot">Reboot</button>
-
-  <div class="flexcontainer">
-    <div id="logview" class="subcontainercontainer"></div>
-  </div>
-
-  <script src="bundle.js"></script>
+    <script src="bundle.js"></script>
 </div>

 <div id="progressPane" class="progressPane">
-  <div class="progressSpacer"></div>>
-  <div id="progressPaneBar" class="progress" data-label="50% Complete">
-    <span id="progressPaneSpan" class="value" style="width:100%;"></span>
-  </div>
-  <div class="progressSpacer"></div>>
+    <div class="progressSpacer"></div>
+    >
+    <div id="progressPaneBar" class="progress" data-label="50% Complete">
+        <span id="progressPaneSpan" class="value" style="width:100%;"></span>
+    </div>
+    <div class="progressSpacer"></div>
+    >
 </div>
--- a/Software/MainBoard/rust/src_webpack/src/main.ts
+++ b/Software/MainBoard/rust/src_webpack/src/main.ts
@@ -26,10 +26,10 @@ import {
    Moistures,
    NightLampCommand,
    PlantControllerConfig,
-    SetTime, SSIDList, TankInfo,
+    SetTime, SSIDList, TankInfo, WifiScanResult,
    TestPump,
    VersionInfo,
-    FileList, SolarState, PumpTestResult, Detection, CanPower
+    SaveInfo, SolarState, PumpTestResult, Detection, DetectionRequest, CanPower
 } from "./api";
 import {SolarView} from "./solarview";
 import {toast} from "./toast";
@@ -43,32 +43,33 @@ export class Controller {
                controller.tankView.setTankInfo(tankinfo)
            })
            .catch(error => {
+                toast.error(`Failed to load tank info: ${error}`);
                console.log(error);
            });
    }

-    loadLogLocaleConfig() {
-        return fetch(PUBLIC_URL + "/log_localization")
-            .then(response => response.json())
-            .then(json => json as LogLocalisation)
-            .then(loglocale => {
-                controller.logView.setLogLocalisation(loglocale)
-            })
-            .catch(error => {
-                console.log(error);
-            });
+    async loadLogLocaleConfig() {
+        try {
+            const response = await fetch(PUBLIC_URL + "/log_localization");
+            const json = await response.json();
+            const loglocale = json as LogLocalisation;
+            controller.logView.setLogLocalisation(loglocale);
+        } catch (error) {
+            console.log(error);
+        }
    }

-    loadLog() {
-        return fetch(PUBLIC_URL + "/log")
-            .then(response => response.json())
-            .then(json => json as LogArray)
-            .then(logs => {
-                controller.logView.setLog(logs)
-            })
-            .catch(error => {
-                console.log(error);
-            });
+    async loadLog() {
+        try {
+            const response = await fetch(PUBLIC_URL + "/log");
+            const json = await response.json();
+            const logs = json as LogArray;
+            controller.logView.setLog(logs);
+            toast.info("Log loaded successfully");
+        } catch (error) {
+            toast.error(`Failed to load log: ${error}`);
+            console.log(error);
+        }
    }

    async getBackupInfo(): Promise<void> {
@@ -89,69 +90,47 @@ export class Controller {
            const timezones = json as string[];
            controller.timeView.timezones(timezones);
        } catch (error) {
+            toast.error(`Error fetching timezones: ${error}`);
            return console.error('Error fetching timezones:', error);
        }
    }

-    async updateFileList(): Promise<void> {
+    async updateSaveList(): Promise<void> {
        try {
-            const response = await fetch(PUBLIC_URL + "/files");
+            const response = await fetch(PUBLIC_URL + "/list_saves");
            const json = await response.json();
-            const filelist = json as FileList;
-            controller.fileview.setFileList(filelist, PUBLIC_URL);
+            const saves = json as SaveInfo[];
+            controller.fileview.setSaveList(saves, PUBLIC_URL);
        } catch (error) {
+            toast.error(`Failed to update save list: ${error}`);
            console.log(error);
        }
    }

-    uploadFile(file: File, name: string) {
-        let current = 0;
-        let max = 100;
-        controller.progressview.addProgress("file_upload", (current / max) * 100, "Uploading File " + name + "(" + current + "/" + max + ")")
+    deleteSlot(idx: number) {
+        controller.progressview.addIndeterminate("slot_delete", "Deleting slot " + idx);
        const ajax = new XMLHttpRequest();
-        ajax.upload.addEventListener("progress", event => {
-            current = event.loaded / 1000;
-            max = event.total / 1000;
-            controller.progressview.addProgress("file_upload", (current / max) * 100, "Uploading File " + name + "(" + current + "/" + max + ")")
-        }, false);
-        ajax.addEventListener("load", () => {
-            controller.progressview.removeProgress("file_upload")
-            controller.updateFileList()
-        }, false);
-        ajax.addEventListener("error", () => {
-            alert("Error upload")
-            controller.progressview.removeProgress("file_upload")
-            controller.updateFileList()
-        }, false);
-        ajax.addEventListener("abort", () => {
-            alert("abort upload")
-            controller.progressview.removeProgress("file_upload")
-            controller.updateFileList()
-        }, false);
-        ajax.open("POST", PUBLIC_URL + "/file?filename=" + name);
-        ajax.send(file);
-    }
-
-    deleteFile(name: string) {
-        controller.progressview.addIndeterminate("file_delete", "Deleting " + name);
-        const ajax = new XMLHttpRequest();
-        ajax.open("DELETE", PUBLIC_URL + "/file?filename=" + name);
+        ajax.open("DELETE", PUBLIC_URL + "/delete_save?idx=" + idx);
        ajax.send();
        ajax.addEventListener("error", () => {
-            controller.progressview.removeProgress("file_delete")
-            alert("Error delete")
-            controller.updateFileList()
+            controller.progressview.removeProgress("slot_delete");
+            toast.error(`Failed to delete slot ${idx}`);
+            controller.updateSaveList();
        }, false);
        ajax.addEventListener("abort", () => {
-            controller.progressview.removeProgress("file_delete")
-            alert("Error upload")
-            controller.updateFileList()
+            controller.progressview.removeProgress("slot_delete");
+            toast.warning(`Slot deletion aborted`);
+            controller.updateSaveList();
        }, false);
        ajax.addEventListener("load", () => {
-            controller.progressview.removeProgress("file_delete")
-            controller.updateFileList()
+            controller.progressview.removeProgress("slot_delete");
+            if (ajax.status >= 200 && ajax.status < 300) {
+                toast.success("Slot deleted successfully");
+            } else {
+                toast.error(`Failed to delete slot: ${ajax.status}`);
+            }
+            controller.updateSaveList();
        }, false);
-        controller.updateFileList()
    }

    async updateRTCData(): Promise<void> {
@@ -162,6 +141,7 @@ export class Controller {
            controller.timeView.update(time.native, time.rtc);
        } catch (error) {
            controller.timeView.update("n/a", "n/a");
+            toast.error(`Failed to update RTC data: ${error}`);
            console.log(error);
        }
    }
@@ -174,6 +154,7 @@ export class Controller {
            controller.batteryView.update(battery);
        } catch (error) {
            controller.batteryView.update(null);
+            toast.error(`Failed to update battery data: ${error}`);
            console.log(error);
        }
    }
@@ -186,6 +167,22 @@ export class Controller {
            controller.solarView.update(solar);
        } catch (error) {
            controller.solarView.update(null);
+            toast.error(`Failed to update solar data: ${error}`);
+            console.log(error);
+        }
+    }
+
+    async scanWifiDetails(): Promise<void> {
+        try {
+            const response = await fetch(PUBLIC_URL + "/wifi_details");
+            if (response.ok) {
+                const wifiDetails = await response.json();
+                controller.networkView.displayWifiResults(wifiDetails as WifiScanResult[]);
+            } else {
+                toast.error(`Failed to fetch Wi-Fi details: ${response.status}`);
+            }
+        } catch (error) {
+            toast.error(`Wi-Fi details error: ${error}`);
            console.log(error);
        }
    }
@@ -204,6 +201,7 @@ export class Controller {
            controller.progressview.removeProgress("ota_upload")
            const status = ajax.status;
            if (status >= 200 && status < 300) {
+                toast.success("OTA firmware upload successful");
                controller.reboot();
            } else {
                const statusText = ajax.statusText || "";
@@ -225,11 +223,12 @@ export class Controller {

    async version(): Promise<void> {
        controller.progressview.addIndeterminate("version", "Getting buildVersion")
-        const response = await fetch(PUBLIC_URL + "/version");
+        const response = await fetch(PUBLIC_URL + "/firmware_info");
        const json = await response.json();
        const versionInfo = json as VersionInfo;
        controller.progressview.removeProgress("version");
        controller.firmWareView.setVersion(versionInfo);
+        toast.info("Firmware version information updated");
    }

    getBackupConfig() {
@@ -264,13 +263,22 @@ export class Controller {
            method: "POST",
            body: json,
        })
-            .then(response => response.text())
-            .then(text => statusCallback(text))
-            .then(_ => {
+            .then(async response => {
+                let text = response.text();
+                statusCallback(await text)
+                return response.status
+            })
+            .then(status => {
                controller.progressview.removeProgress("set_config");
-                setTimeout(() => {
-                    controller.downloadConfig()
-                }, 250)
+                if (status == 200) {
+                    toast.success("Configuration saved successfully");
+                    setTimeout(() => {
+                        controller.downloadConfig().then(() => {
+                            controller.updateSaveList().then(() => {
+                            });
+                        });
+                    }, 250)
+                }
            })
    }

@@ -291,7 +299,14 @@ export class Controller {
        fetch(PUBLIC_URL + "/time", {
            method: "POST",
            body: pretty
-        }).then(
+        })
+        .then(response => {
+            if (!response.ok) {
+                toast.error(`Failed to sync RTC: ${response.status}`);
+            }
+            return response;
+        })
+        .then(
            _ => controller.progressview.removeProgress("write_rtc")
        )
    }
@@ -311,9 +326,23 @@ export class Controller {
    }

    selfTest() {
+        controller.progressview.addIndeterminate("self_test", "Running board test")
        fetch(PUBLIC_URL + "/boardtest", {
            method: "POST"
        })
+        .then(response => {
+            if (response.ok) {
+                toast.success("Board test completed");
+            } else {
+                toast.error(`Board test failed: ${response.status}`);
+            }
+        })
+        .catch(error => {
+            toast.error(`Board test error: ${error}`);
+        })
+        .finally(() => {
+            controller.progressview.removeProgress("self_test");
+        });
    }

    testNightLamp(active: boolean) {
@@ -321,15 +350,52 @@ export class Controller {
            active: active
        };
        var pretty = JSON.stringify(body, undefined, 1);
+        controller.progressview.addIndeterminate("night_lamp_test", "Testing night lamp")
        fetch(PUBLIC_URL + "/lamptest", {
            method: "POST",
            body: pretty
        })
+        .then(response => {
+            if (response.ok) {
+                toast.success(`Night lamp ${active ? "enabled" : "disabled"} successfully`);
+            } else {
+                toast.error(`Night lamp test failed: ${response.status}`);
+            }
+        })
+        .catch(error => {
+            toast.error(`Night lamp test error: ${error}`);
+        })
+        .finally(() => {
+            controller.progressview.removeProgress("night_lamp_test");
+        });
+    }
+
+    testFertilizerPump() {
+        controller.progressview.addIndeterminate("fert_test", "Testing fertilizer pump")
+        fetch(PUBLIC_URL + "/fertilizerpumptest", {
+            method: "POST"
+        })
+        .then(response => {
+            if (response.ok) {
+                toast.success("Fertilizer pump test completed");
+            } else {
+                toast.error(`Fertilizer pump test failed: ${response.status}`);
+            }
+        })
+        .catch(error => {
+            toast.error(`Fertilizer pump test error: ${error}`);
+        })
+        .finally(() => {
+            controller.progressview.removeProgress("fert_test");
+        });
    }

    testPlant(plantId: number) {
+        const plantConfig = controller.getConfig().plants[plantId];
+        const pumpTimeS = plantConfig.pump_time_s;
+        
        let counter = 0
-        let limit = 30
+        let limit = pumpTimeS > 0 ? Math.ceil(pumpTimeS) : 30
        controller.progressview.addProgress("test_pump", counter / limit * 100, "Testing pump " + (plantId + 1) + " for " + (limit - counter) + "s")

        let timerId: string | number | NodeJS.Timeout | undefined
@@ -358,20 +424,30 @@ export class Controller {
                    controller.plantViews.setPumpTestCurrent(plantId, response);
                    clearTimeout(timerId);
                    controller.progressview.removeProgress("test_pump");
+                    if (!response.error) {
+                        toast.success(`Pump ${plantId + 1} test completed successfully`);
+                    } else {
+                        toast.error(`Pump ${plantId + 1} test reported an error`);
+                    }
                }
            )
    }

-    async detectSensors(detection: Detection) {
+    async detectSensors(detection: DetectionRequest, silent: boolean = false) {
        let counter = 0
        let limit = 5
-        controller.progressview.addProgress("detect_sensors", counter / limit * 100, "Detecting sensors " + (limit - counter) + "s")
+        if (!silent) {
+            controller.progressview.addProgress("detect_sensors", counter / limit * 100, "Detecting sensors " + (limit - counter) + "s")
+        }
+

        let timerId: string | number | NodeJS.Timeout | undefined

        function updateProgress() {
            counter++;
-            controller.progressview.addProgress("detect_sensors", counter / limit * 100, "Detecting sensors " + (limit - counter) + "s")
+            if (!silent) {
+                controller.progressview.addProgress("detect_sensors", counter / limit * 100, "Detecting sensors " + (limit - counter) + "s")
+            }
            timerId = setTimeout(updateProgress, 1000);
        }

@@ -379,12 +455,15 @@ export class Controller {

        var pretty = JSON.stringify(detection, undefined, 1);

-        fetch(PUBLIC_URL + "/detect_sensors", {method: "POST", body: pretty})
+        return fetch(PUBLIC_URL + "/detect_sensors", {method: "POST", body: pretty})
            .then(response => response.json())
            .then(json => json as Detection)
            .then(json => {
                clearTimeout(timerId);
-                controller.progressview.removeProgress("detect_sensors");
+                if (!silent) {
+                    controller.progressview.removeProgress("detect_sensors");
+                }
+
                const pretty = JSON.stringify(json);
                toast.info("Detection result: " + pretty);
                console.log(pretty);
@@ -393,7 +472,9 @@ export class Controller {
            })
            .catch(error => {
                clearTimeout(timerId);
-                controller.progressview.removeProgress("detect_sensors");
+                if (!silent) {
+                    controller.progressview.removeProgress("detect_sensors");
+                }
                toast.error("Autodetect failed: " + error);
            });
    }
@@ -426,19 +507,26 @@ export class Controller {
        timerId = setTimeout(updateProgress, 1000);


-        var ajax = new XMLHttpRequest();
+        const ajax = new XMLHttpRequest();
        ajax.responseType = 'json';
        ajax.onreadystatechange = () => {
            if (ajax.readyState === 4) {
                clearTimeout(timerId);
                controller.progressview.removeProgress("scan_ssid");
-                this.networkView.setScanResult(ajax.response as SSIDList)
+                if (ajax.status >= 200 && ajax.status < 300) {
+                    this.networkView.setScanResult(ajax.response as SSIDList);
+                    toast.success("WiFi scan completed");
+                    // Also fetch detailed Wi-Fi information
+                    this.scanWifiDetails();
+                } else {
+                    toast.error(`WiFi scan failed: ${ajax.status}`);
+                }
            }
        };
-        ajax.onerror = (evt) => {
+        ajax.onerror = (_) => {
            clearTimeout(timerId);
            controller.progressview.removeProgress("scan_ssid");
-            alert("Failed to start see console")
+            toast.error("Failed to start WiFi scan");
        }
        ajax.open("POST", PUBLIC_URL + "/wifiscan");
        ajax.send();
@@ -459,16 +547,22 @@ export class Controller {
        this.hardwareView.setConfig(current.hardware);
    }

-    measure_moisture() {
+    measure_moisture(silent: boolean = false) {
        let counter = 0
        let limit = 2
-        controller.progressview.addProgress("measure_moisture", counter / limit * 100, "Measure Moisture " + (limit - counter) + "s")
+        if (!silent) {
+            controller.progressview.addProgress("measure_moisture", counter / limit * 100, "Measure Moisture " + (limit - counter) + "s")
+        }
+

        let timerId: string | number | NodeJS.Timeout | undefined

        function updateProgress() {
            counter++;
-            controller.progressview.addProgress("measure_moisture", counter / limit * 100, "Measure Moisture " + (limit - counter) + "s")
+            if (!silent) {
+                controller.progressview.addProgress("measure_moisture", counter / limit * 100, "Measure Moisture " + (limit - counter) + "s")
+            }
+
            timerId = setTimeout(updateProgress, 1000);

        }
@@ -476,17 +570,25 @@ export class Controller {
        timerId = setTimeout(updateProgress, 1000);


-        fetch(PUBLIC_URL + "/moisture")
+        return fetch(PUBLIC_URL + "/moisture")
            .then(response => response.json())
            .then(json => json as Moistures)
-            .then(time => {
-                controller.plantViews.update(time.moisture_a, time.moisture_b)
+            .then(data => {
+                controller.plantViews.update(data.moisture_a, data.moisture_b, data.sensor_a_build_minutes, data.sensor_b_build_minutes)
                clearTimeout(timerId);
-                controller.progressview.removeProgress("measure_moisture");
+                if (!silent) {
+                    controller.progressview.removeProgress("measure_moisture");
+                }
+                if (!silent) {
+                    toast.success("Moisture measurement completed");
+                }
+
            })
            .catch(error => {
                clearTimeout(timerId);
-                controller.progressview.removeProgress("measure_moisture");
+                if (!silent) {
+                    controller.progressview.removeProgress("measure_moisture");
+                }
                console.log(error);
            });
    }
@@ -501,7 +603,7 @@ export class Controller {

    waitForReboot() {
        console.log("Check if controller online again")
-        fetch(PUBLIC_URL + "/version", {
+        fetch(PUBLIC_URL + "/firmware_info", {
            method: "GET",
            signal: AbortSignal.timeout(5000)
        }).then(response => {
@@ -516,7 +618,7 @@ export class Controller {
                }, 2000);
            }
        })
-            .catch(err => {
+            .catch(_ => {
                console.log("Not reached yet, retrying")
                setTimeout(controller.waitForReboot, 1000)
            })
@@ -560,6 +662,8 @@ export class Controller {
    readonly logView: LogView
    readonly detectBtn: HTMLButtonElement
    readonly can_power: HTMLInputElement;
+    readonly auto_refresh_moisture_sensors: HTMLInputElement;
+    private auto_refresh_timer: NodeJS.Timeout | undefined;

    constructor() {
        this.timeView = new TimeView(this)
@@ -577,7 +681,7 @@ export class Controller {
        this.hardwareView = new HardwareConfigView(this)
        this.detectBtn = document.getElementById("detect_sensors") as HTMLButtonElement
        this.detectBtn.onclick = () => {
-            const detection: Detection = {
+            const detection: DetectionRequest = {
                plant: Array.from({length: PLANT_COUNT}, () => ({
                    sensor_a: true,
                    sensor_b: true,
@@ -597,6 +701,39 @@ export class Controller {
        this.can_power.onchange = () => {
            controller.setCanPower(this.can_power.checked);
        }
+        this.auto_refresh_moisture_sensors = document.getElementById("auto_refresh_moisture_sensors") as HTMLInputElement
+        this.auto_refresh_moisture_sensors.onchange = () => {
+            if (this.auto_refresh_timer) {
+                clearTimeout(this.auto_refresh_timer)
+            }
+            if (this.auto_refresh_moisture_sensors.checked) {
+                this.autoRefreshLoop()
+            }
+        }
+    }
+
+    private async autoRefreshLoop() {
+        if (!this.auto_refresh_moisture_sensors.checked) {
+            return;
+        }
+
+        try {
+            await this.measure_moisture(true);
+            const detection: DetectionRequest = {
+                plant: Array.from({length: PLANT_COUNT}, () => ({
+                    sensor_a: true,
+                    sensor_b: true,
+                })),
+            };
+            await this.detectSensors(detection, true);
+        } catch (e) {
+            toast.error(`Auto-refresh error: ${e}`);
+            console.error("Auto-refresh error", e);
+        }
+
+        if (this.auto_refresh_moisture_sensors.checked) {
+            this.auto_refresh_timer = setTimeout(() => this.autoRefreshLoop(), 1000);
+        }
    }


@@ -611,9 +748,10 @@ const tasks = [
    {task: controller.updateRTCData, displayString: "Updating RTC Data"},
    {task: controller.updateBatteryData, displayString: "Updating Battery Data"},
    {task: controller.updateSolarData, displayString: "Updating Solar Data"},
+    {task: () => controller.measure_moisture(true), displayString: "Measuring Moisture"},
    {task: controller.downloadConfig, displayString: "Downloading Configuration"},
    {task: controller.version, displayString: "Fetching Version Information"},
-    {task: controller.updateFileList, displayString: "Updating File List"},
+    {task: controller.updateSaveList, displayString: "Updating Save Slots"},
    {task: controller.getBackupInfo, displayString: "Fetching Backup Information"},
    {task: controller.loadLogLocaleConfig, displayString: "Loading Log Localization Config"},
    {task: controller.loadTankInfo, displayString: "Loading Tank Information"},
@@ -628,6 +766,7 @@ async function executeTasksSequentially() {
        try {
            await task();
        } catch (error) {
+            toast.error(`Error executing task '${displayString}': ${error}`);
            console.error(`Error executing task '${displayString}':`, error);
            // Optionally, you can decide whether to continue or break on errors
            break;
@@ -635,13 +774,19 @@ async function executeTasksSequentially() {
    }
 }

-executeTasksSequentially().then(r => {
-    controller.progressview.removeProgress("initial")
+executeTasksSequentially().then(() => {
+    controller.progressview.removeProgress("initial");
+    controller.logView.startLivePoll(PUBLIC_URL);
 });

 controller.progressview.removeProgress("rebooting");

 window.addEventListener("beforeunload", (event) => {
+    // Only check for unsaved changes if initialConfig has been loaded
+    if (controller.initialConfig === null) {
+        return;
+    }
+    
    const currentConfig = controller.getConfig();

    // Check if the current state differs from the initial configuration
--- a/Software/MainBoard/rust/src_webpack/src/network.html
+++ b/Software/MainBoard/rust/src_webpack/src/network.html
@@ -85,7 +85,15 @@
                <input class="mqttvalue" type="text" id="mqtt_password" placeholder="">
            </div>
        </div>
+        <div class="subcontainer">
+            <div class="flexcontainer">
+                <div class="subtitle">Wi-Fi Scan Results</div>
+            </div>
+            
+            <div id="wifi-results">
+                <p>Scan for available networks to see signal strength</p>
+            </div>
+        </div>
    </div>
-    

 </div>
--- a/Software/MainBoard/rust/src_webpack/src/network.ts
+++ b/Software/MainBoard/rust/src_webpack/src/network.ts
@@ -1,7 +1,9 @@
 import { Controller } from "./main";
-import {NetworkConfig, SSIDList} from "./api";
+import {NetworkConfig, SSIDList, WifiScanResult} from "./api";

 export class NetworkConfigView {
+    private wifiResults: HTMLElement;
+    
    setScanResult(ssidList: SSIDList) {
      this.ssidlist.innerHTML = ''
      for (const ssid of ssidList.ssids) {
@@ -10,6 +12,47 @@ export class NetworkConfigView {
        this.ssidlist.appendChild(wi);
      }
    }
+    
+    async scanAndDisplayWifiDetails() {
+        try {
+            const response = await fetch('/wifi_details');
+            if (response.ok) {
+                const data: WifiScanResult[] = await response.json();
+                this.displayWifiResults(data);
+            }
+        } catch (error) {
+            console.error('Error fetching Wi-Fi details:', error);
+            this.displayWifiResults([]);
+        }
+    }
+    
+    displayWifiResults(results: WifiScanResult[]) {
+        const wifiContainer = document.getElementById('wifi-results');
+        if (!wifiContainer) return;
+        
+        if (results.length === 0) {
+            wifiContainer.innerHTML = '<p>No Wi-Fi networks found</p>';
+            return;
+        }
+        
+        let html = '<table style="width:100%; border-collapse: collapse;">';
+        html += '<tr><th style="text-align:left; padding: 8px;">SSID</th>';
+        html += '<th style="text-align:left; padding: 8px;">Signal (RSSI)</th>';
+        html += '<th style="text-align:left; padding: 8px;">Channel</th>';
+        html += '<th style="text-align:left; padding: 8px;">Authentication</th></tr>';
+        
+        results.forEach(result => {
+            html += '<tr style="border-bottom: 1px solid #ddd;">';
+            html += `<td style="padding: 8px;">${result.ssid}</td>`;
+            html += `<td style="padding: 8px;">${result.rssi} dBm</td>`;
+            html += `<td style="padding: 8px;">${result.channel}</td>`;
+            html += `<td style="padding: 8px;">${result.auth_method}</td>`;
+            html += '</tr>';
+        });
+        
+        html += '</table>';
+        wifiContainer.innerHTML = html;
+    }
    private readonly ap_ssid: HTMLInputElement;
    private readonly ssid: HTMLInputElement;
    private readonly password: HTMLInputElement;
@@ -47,9 +90,14 @@ export class NetworkConfigView {
      this.ssidlist = document.getElementById("ssidlist") as HTMLElement

      let scanWifiBtn = document.getElementById("scan") as HTMLButtonElement;
-      scanWifiBtn.onclick = function (){
+      scanWifiBtn.onclick = async () => {
        controller.scanWifi();
-      }
+        // After Wi-Fi scan, fetch and display detailed results
+        await this.scanAndDisplayWifiDetails();
+      };
+      
+      // Store wifiResults reference for later use
+      this.wifiResults = document.getElementById('wifi-results') as HTMLElement;
    }

    setConfig(network: NetworkConfig) {
--- a/Software/MainBoard/rust/src_webpack/src/ota.html
+++ b/Software/MainBoard/rust/src_webpack/src/ota.html
@@ -21,6 +21,7 @@
    <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>
@@ -42,12 +43,35 @@
    <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>
--- a/Software/MainBoard/rust/src_webpack/src/ota.ts
+++ b/Software/MainBoard/rust/src_webpack/src/ota.ts
@@ -1,6 +1,10 @@
 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;
@@ -8,19 +12,26 @@ export class OTAView {
    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 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
@@ -36,6 +47,10 @@ export class OTAView {
        test.onclick = () => {
            controller.selfTest();
        }
+
+        refresh.onclick = () => {
+            controller.version();
+        }
    }

    setVersion(versionInfo: VersionInfo) {
@@ -44,5 +59,9 @@ export class OTAView {
        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);
    }
 }
--- a/Software/MainBoard/rust/src_webpack/src/plant.html
+++ b/Software/MainBoard/rust/src_webpack/src/plant.html
@@ -29,6 +29,9 @@
    .plantSensorEnabledOnly_ ${plantId} {
    }

+    .plantBothSensorsOnly_ ${plantId} {
+    }
+
    .plantHidden_ ${plantId} {
        display: none;
    }
@@ -48,6 +51,14 @@
        <div class="plantkey">Sensor B installed:</div>
        <input class="plantcheckbox" id="plant_${plantId}_sensor_b" type="checkbox">
    </div>
+    <div class="flexcontainer plantBothSensorsOnly_${plantId}">
+        <div class="plantkey">Sensor Combine Mode:</div>
+        <select class="plantvalue" id="plant_${plantId}_sensor_combine_mode">
+            <option value="Min">Min</option>
+            <option value="Max">Max</option>
+            <option value="Avg">Average</option>
+        </select>
+    </div>
    <div class="flexcontainer">
        <div class="plantkey">
            Mode:
@@ -78,6 +89,16 @@
        <input class="plantvalue" id="plant_${plantId}_pump_cooldown_min" type="number" min="0" max="600"
               placeholder="30">
    </div>
+    <div class="flexcontainer plantPumpEnabledOnly_${plantId}">
+        <div class="plantkey">Fertilizer (s):</div>
+        <input class="plantvalue" id="plant_${plantId}_fertilizer_s" type="number" min="0" max="60"
+               placeholder="0">
+    </div>
+    <div class="flexcontainer plantPumpEnabledOnly_${plantId}">
+        <div class="plantkey">Fertilizer Cooldown (m):</div>
+        <input class="plantvalue" id="plant_${plantId}_fertilizer_cooldown_min" type="number" min="0" max="20160"
+               placeholder="1440">
+    </div>
    <div class="flexcontainer plantPumpEnabledOnly_${plantId}">
        <div class="plantkey">"Pump Hour Start":</div>
        <select class="plantvalue" id="plant_${plantId}_pump_hour_start">10</select>
@@ -126,17 +147,25 @@
        <div class="subtitle">Live:</div>
    </div>
    <div class="flexcontainer plantSensorEnabledOnly_${plantId}">
-        <button class="subtitle" id="plant_${plantId}_test_sensor_a">Test Sensor A</button>
-        <button class="subtitle" id="plant_${plantId}_test_sensor_b">Test Sensor B</button>
+        <button class="subtitle" id="plant_${plantId}_test_sensor_a">Identify Sensor A</button>
+        <button class="subtitle" id="plant_${plantId}_test_sensor_b">Identify Sensor B</button>
    </div>
    <div class="flexcontainer plantSensorEnabledOnly_${plantId}">
        <span class="plantsensorkey">Sensor A:</span>
        <span class="plantsensorvalue" id="plant_${plantId}_moisture_a">not measured</span>
    </div>
+    <div class="flexcontainer plantSensorEnabledOnly_${plantId}">
+        <span class="plantsensorkey">Sensor A FW:</span>
+        <span class="plantsensorvalue" id="plant_${plantId}_sensor_a_fw_build">unknown</span>
+    </div>
    <div class="flexcontainer plantSensorEnabledOnly_${plantId}">
        <div class="plantsensorkey">Sensor B:</div>
        <span class="plantsensorvalue" id="plant_${plantId}_moisture_b">not measured</span>
    </div>
+    <div class="flexcontainer plantSensorEnabledOnly_${plantId}">
+        <span class="plantsensorkey">Sensor B FW:</span>
+        <span class="plantsensorvalue" id="plant_${plantId}_sensor_b_fw_build">unknown</span>
+    </div>
    <div class="flexcontainer plantPumpEnabledOnly_${plantId}">
        <div class="plantsensorkey">Max Current</div>
        <span class="plantsensorvalue" id="plant_${plantId}_pump_test_current_max">not_tested</span>
--- a/Software/MainBoard/rust/src_webpack/src/plant.ts
+++ b/Software/MainBoard/rust/src_webpack/src/plant.ts
@@ -1,7 +1,14 @@
-import {DetectionPlant, Detection, PlantConfig, PumpTestResult} from "./api";
+import {Detection, DetectionPlant, DetectionRequest, PlantConfig, PumpTestResult} from "./api";

 export const PLANT_COUNT = 8;

+/** Format a firmware build timestamp (minutes since Unix epoch) as a human-readable date/time. */
+function formatBuildMinutes(buildMinutes: number | null): string {
+    if (buildMinutes === null) return "not detected";
+    if (buildMinutes === 0) return "detected (no timestamp)";
+    const ms = buildMinutes * 60 * 1000;
+    return new Date(ms).toISOString().replace("T", " ").slice(0, 16) + " UTC";
+}

 import {Controller} from "./main";

@@ -12,7 +19,9 @@ export class PlantViews {

    constructor(syncConfig: Controller) {
        this.measure_moisture = document.getElementById("measure_moisture") as HTMLButtonElement
-        this.measure_moisture.onclick = syncConfig.measure_moisture
+        this.measure_moisture.onclick = async () => {
+            return syncConfig.measure_moisture(false)
+        }
        this.plantsDiv = document.getElementById("plants") as HTMLDivElement;
        for (let plantId = 0; plantId < PLANT_COUNT; plantId++) {
            this.plants[plantId] = new PlantView(plantId, this.plantsDiv, syncConfig);
@@ -27,11 +36,19 @@ export class PlantViews {
        return rv
    }

-    update(moisture_a: [string], moisture_b: [string]) {
+    update(moisture_a: [string], moisture_b: [string], sensor_a_build_minutes?: Array<number | null>, sensor_b_build_minutes?: Array<number | null>) {
        for (let plantId = 0; plantId < PLANT_COUNT; plantId++) {
            const a = moisture_a[plantId]
            const b = moisture_b[plantId]
            this.plants[plantId].setMeasurementResult(a, b)
+            
+            // Update firmware build timestamps if provided
+            if (sensor_a_build_minutes && sensor_a_build_minutes[plantId] !== undefined) {
+                this.plants[plantId].setFirmwareBuild("sensor_a", sensor_a_build_minutes[plantId])
+            }
+            if (sensor_b_build_minutes && sensor_b_build_minutes[plantId] !== undefined) {
+                this.plants[plantId].setFirmwareBuild("sensor_b", sensor_b_build_minutes[plantId])
+            }
        }
    }

@@ -48,16 +65,15 @@ export class PlantViews {
        plantView.setTestResult(response)
    }

-  applyDetectionResult(json: Detection) {
-      for (let i = 0; i < PLANT_COUNT; i++) {
-          var plantResult = json.plant[i];
-          this.plants[i].setDetectionResult(plantResult);
-      }
-  }
+    applyDetectionResult(json: Detection) {
+        for (let i = 0; i < PLANT_COUNT; i++) {
+            var plantResult = json.plant[i];
+            this.plants[i].setDetectionResult(plantResult);
+        }
+    }
 }


-
 export class PlantView {
    private readonly moistureSensorMinFrequency: HTMLInputElement;
    private readonly moistureSensorMaxFrequency: HTMLInputElement;
@@ -71,13 +87,18 @@ export class PlantView {
    private readonly minMoisture: HTMLInputElement;
    private readonly pumpTimeS: HTMLInputElement;
    private readonly pumpCooldown: HTMLInputElement;
+    private readonly fertilizerS: HTMLInputElement;
+    private readonly fertilizerCooldownMin: HTMLInputElement;
    private readonly pumpHourStart: HTMLSelectElement;
    private readonly pumpHourEnd: HTMLSelectElement;
    private readonly sensorAInstalled: HTMLInputElement;
    private readonly sensorBInstalled: HTMLInputElement;
+    private readonly sensorCombineMode: HTMLSelectElement;
    private readonly mode: HTMLSelectElement;
    private readonly moistureA: HTMLElement;
    private readonly moistureB: HTMLElement;
+    private readonly sensorAFwBuild: HTMLElement;
+    private readonly sensorBFwBuild: HTMLElement;
    private readonly maxConsecutivePumpCount: HTMLInputElement;
    private readonly minPumpCurrentMa: HTMLInputElement;
    private readonly maxPumpCurrentMa: HTMLInputElement;
@@ -108,6 +129,8 @@ export class PlantView {

        this.moistureA = document.getElementById("plant_" + plantId + "_moisture_a")! as HTMLElement;
        this.moistureB = document.getElementById("plant_" + plantId + "_moisture_b")! as HTMLElement;
+        this.sensorAFwBuild = document.getElementById("plant_" + plantId + "_sensor_a_fw_build")! as HTMLElement;
+        this.sensorBFwBuild = document.getElementById("plant_" + plantId + "_sensor_b_fw_build")! as HTMLElement;

        this.pump_test_current_max = document.getElementById("plant_" + plantId + "_pump_test_current_max")! as HTMLElement;
        this.pump_test_current_min = document.getElementById("plant_" + plantId + "_pump_test_current_min")! as HTMLElement;
@@ -123,7 +146,7 @@ export class PlantView {

        this.testSensorAButton = document.getElementById("plant_" + plantId + "_test_sensor_a")! as HTMLButtonElement;
        this.testSensorAButton.onclick = () => {
-            const detection: Detection = {
+            const detection: DetectionRequest = {
                plant: Array.from({length: PLANT_COUNT}, (_v, idx) => ({
                    sensor_a: idx === plantId,
                    sensor_b: false,
@@ -134,7 +157,7 @@ export class PlantView {

        this.testSensorBButton = document.getElementById("plant_" + plantId + "_test_sensor_b")! as HTMLButtonElement;
        this.testSensorBButton.onclick = () => {
-            const detection: Detection = {
+            const detection: DetectionRequest = {
                plant: Array.from({length: PLANT_COUNT}, (_v, idx) => ({
                    sensor_a: false,
                    sensor_b: idx === plantId,
@@ -168,6 +191,16 @@ export class PlantView {
            controller.configChanged()
        }

+        this.fertilizerS = document.getElementById("plant_" + plantId + "_fertilizer_s") as HTMLInputElement;
+        this.fertilizerS.onchange = function () {
+            controller.configChanged()
+        }
+
+        this.fertilizerCooldownMin = document.getElementById("plant_" + plantId + "_fertilizer_cooldown_min") as HTMLInputElement;
+        this.fertilizerCooldownMin.onchange = function () {
+            controller.configChanged()
+        }
+
        this.pumpHourStart = document.getElementById("plant_" + plantId + "_pump_hour_start") as HTMLSelectElement;
        this.pumpHourStart.onchange = function () {
            controller.configChanged()
@@ -204,6 +237,14 @@ export class PlantView {
            controller.configChanged()
        }

+        this.sensorCombineMode = document.getElementById("plant_" + plantId + "_sensor_combine_mode") as HTMLSelectElement;
+        this.sensorCombineMode.onchange = function () {
+            controller.configChanged()
+        }
+
+        // Initial visibility update for sensor combine mode
+        this.updateSensorCombineModeState();
+
        this.minPumpCurrentMa = document.getElementById("plant_" + plantId + "_min_pump_current_ma") as HTMLInputElement;
        this.minPumpCurrentMa.onchange = function () {
            controller.configChanged()
@@ -239,11 +280,24 @@ export class PlantView {
        };
    }

+    updateSensorCombineModeState() {
+        const bothActive = this.sensorAInstalled.checked && this.sensorBInstalled.checked;
+        const bothOnlyElements = document.getElementsByClassName("plantBothSensorsOnly_" + this.plantId);
+        for (const element of Array.from(bothOnlyElements)) {
+            if (bothActive) {
+                element.classList.remove("plantHidden_" + this.plantId);
+            } else {
+                element.classList.add("plantHidden_" + this.plantId);
+            }
+        }
+        this.sensorCombineMode.disabled = !bothActive;
+    }
+
    updateVisibility(plantConfig: PlantConfig) {
-        let sensorOnly = document.getElementsByClassName("plantSensorEnabledOnly_"+ this.plantId)
-        let pumpOnly = document.getElementsByClassName("plantPumpEnabledOnly_"+ this.plantId)
-        let targetOnly = document.getElementsByClassName("plantTargetEnabledOnly_"+ this.plantId)
-        let minOnly = document.getElementsByClassName("plantMinEnabledOnly_"+ this.plantId)
+        let sensorOnly = document.getElementsByClassName("plantSensorEnabledOnly_" + this.plantId)
+        let pumpOnly = document.getElementsByClassName("plantPumpEnabledOnly_" + this.plantId)
+        let targetOnly = document.getElementsByClassName("plantTargetEnabledOnly_" + this.plantId)
+        let minOnly = document.getElementsByClassName("plantMinEnabledOnly_" + this.plantId)

        console.log("updateVisibility plantConfig: " + plantConfig.mode)
        let showSensor = plantConfig.sensor_a || plantConfig.sensor_b
@@ -259,7 +313,7 @@ export class PlantView {
        //     this.plantDiv.style.display = "none";
        // }

-        console.log("updateVisibility showsensor: " + showSensor + " pump " + showPump + " target " +showTarget + " min " + showMin)
+        console.log("updateVisibility showsensor: " + showSensor + " pump " + showPump + " target " + showTarget + " min " + showMin)

        // for (const element of Array.from(sensorOnly)) {
        //     if (showSensor) {
@@ -292,6 +346,9 @@ export class PlantView {
        //         element.classList.add("plantHidden_" + this.plantId)
        //     }
        // }
+
+        // Update sensor combine mode visibility based on whether both sensors are active
+        this.updateSensorCombineModeState();
    }

    setTestResult(result: PumpTestResult) {
@@ -316,10 +373,13 @@ export class PlantView {
        this.minMoisture.value = plantConfig.min_moisture?.toString() || "";
        this.pumpTimeS.value = plantConfig.pump_time_s.toString();
        this.pumpCooldown.value = plantConfig.pump_cooldown_min.toString();
+        this.fertilizerS.value = plantConfig.fertilizer_s?.toString() || "0";
+        this.fertilizerCooldownMin.value = plantConfig.fertilizer_cooldown_min?.toString() || "1440";
        this.pumpHourStart.value = plantConfig.pump_hour_start.toString();
        this.pumpHourEnd.value = plantConfig.pump_hour_end.toString();
        this.sensorBInstalled.checked = plantConfig.sensor_b;
        this.sensorAInstalled.checked = plantConfig.sensor_a;
+        this.sensorCombineMode.value = plantConfig.sensor_combine_mode || "Min";
        this.maxConsecutivePumpCount.value = plantConfig.max_consecutive_pump_count.toString();
        this.minPumpCurrentMa.value = plantConfig.min_pump_current_ma.toString();
        this.maxPumpCurrentMa.value = plantConfig.max_pump_current_ma.toString();
@@ -336,17 +396,20 @@ export class PlantView {

    getConfig(): PlantConfig {

-        let conv: PlantConfig =  {
+        let conv: PlantConfig = {
            mode: this.mode.value,
            target_moisture: this.targetMoisture.valueAsNumber,
            min_moisture: this.minMoisture.valueAsNumber,
            pump_time_s: this.pumpTimeS.valueAsNumber,
            pump_limit_ml: 5000,
            pump_cooldown_min: this.pumpCooldown.valueAsNumber,
+            fertilizer_s: this.fertilizerS.valueAsNumber || 0,
+            fertilizer_cooldown_min: this.fertilizerCooldownMin.valueAsNumber || 1440,
            pump_hour_start: +this.pumpHourStart.value,
            pump_hour_end: +this.pumpHourEnd.value,
            sensor_b: this.sensorBInstalled.checked,
            sensor_a: this.sensorAInstalled.checked,
+            sensor_combine_mode: this.sensorCombineMode.value,
            max_consecutive_pump_count: this.maxConsecutivePumpCount.valueAsNumber,
            moisture_sensor_min_frequency: this.moistureSensorMinFrequency.valueAsNumber || null,
            moisture_sensor_max_frequency: this.moistureSensorMaxFrequency.valueAsNumber || null,
@@ -359,19 +422,31 @@ export class PlantView {
    }

    setDetectionResult(plantResult: DetectionPlant) {
-        console.log("setDetectionResult plantResult: " + plantResult.sensor_a + " " + plantResult.sensor_b)
+        const sensorADetected = plantResult.sensor_a !== null;
+        const sensorBDetected = plantResult.sensor_b !== null;
+        console.log("setDetectionResult plantResult: a=" + plantResult.sensor_a + " b=" + plantResult.sensor_b);
        var changed = false;
-        if (this.sensorAInstalled.checked != plantResult.sensor_a){
+        if (this.sensorAInstalled.checked != sensorADetected) {
            changed = true;
-            this.sensorAInstalled.checked = plantResult.sensor_a;
+            this.sensorAInstalled.checked = sensorADetected;
        }
-        if (this.sensorBInstalled.checked !=  plantResult.sensor_b){
+        if (this.sensorBInstalled.checked != sensorBDetected) {
            changed = true;
-            this.sensorBInstalled.checked = plantResult.sensor_b;
+            this.sensorBInstalled.checked = sensorBDetected;
        }
        if (changed) {
            this.controller.configChanged();
        }

+        this.sensorAFwBuild.innerText = formatBuildMinutes(plantResult.sensor_a);
+        this.sensorBFwBuild.innerText = formatBuildMinutes(plantResult.sensor_b);
+    }
+
+    setFirmwareBuild(sensor: "sensor_a" | "sensor_b", buildMinutes: number | null) {
+        if (sensor === "sensor_a") {
+            this.sensorAFwBuild.innerText = formatBuildMinutes(buildMinutes);
+        } else {
+            this.sensorBFwBuild.innerText = formatBuildMinutes(buildMinutes);
+        }
    }
 }
--- a/Software/MainBoard/rust/src_webpack/src/submitView.ts
+++ b/Software/MainBoard/rust/src_webpack/src/submitView.ts
@@ -1,5 +1,6 @@
 import {Controller} from "./main";
 import {BackupHeader} from "./api";
+import {toast} from "./toast";

 export class SubmitView {
    json: HTMLDivElement;
@@ -26,25 +27,28 @@ export class SubmitView {
        this.submit_status = document.getElementById("submit_status") as HTMLElement
        this.submitFormBtn.onclick = () => {
            controller.uploadConfig(this.json.textContent as string, (status: string) => {
-                if (status != "OK") {
-                    // Show error toast (click to dismiss only)
-                    const { toast } = require('./toast');
-                    toast.error(status);
-                } else {
-                    // Show info toast (auto hides after 5s, or click to dismiss sooner)
-                    const { toast } = require('./toast');
-                    toast.info('Config uploaded successfully');
-                }
+                toast.info(status);
                this.submit_status.innerHTML = status;
            });
        }
        this.backupBtn.onclick = () => {
            controller.progressview.addIndeterminate("backup", "Backup to EEPROM running")
            controller.backupConfig(this.json.textContent as string).then(saveStatus => {
+                if (saveStatus === "OK") {
+                    toast.success("Configuration backup successful");
+                } else {
+                    toast.error(`Backup failed: ${saveStatus}`);
+                }
                controller.getBackupInfo().then(r => {
                    controller.progressview.removeProgress("backup")
                    this.submit_status.innerHTML = saveStatus;
                });
+            }).catch(error => {
+                toast.error(`Backup error: ${error}`);
+                controller.getBackupInfo().then(r => {
+                    controller.progressview.removeProgress("backup")
+                    this.submit_status.innerHTML = "Error";
+                });
            });
        }
        this.restoreBackupBtn.onclick = () => {
--- a/Software/MainBoard/rust/src_webpack/src/tankview.ts
+++ b/Software/MainBoard/rust/src_webpack/src/tankview.ts
@@ -93,28 +93,28 @@ export class TankConfigView {
        this.tank_measure_error.innerText = JSON.stringify(tankinfo.sensor_error) ;
        this.tank_measure_error_container.classList.remove("hidden")
      }
-      if (tankinfo.left_ml == null){
+      if (tankinfo.volume_ml == null){
        this.tank_measure_ml_container.classList.add("hidden")
      } else {
-        this.tank_measure_ml.innerText = tankinfo.left_ml.toString();
+        this.tank_measure_ml.innerText = tankinfo.volume_ml.toString();
        this.tank_measure_ml_container.classList.remove("hidden")
      }
-      if (tankinfo.percent == null){
+      if (tankinfo.fill_pct == null){
        this.tank_measure_percent_container.classList.add("hidden")
      } else {
-        this.tank_measure_percent.innerText = tankinfo.percent.toString();
+        this.tank_measure_percent.innerText = tankinfo.fill_pct.toString();
        this.tank_measure_percent_container.classList.remove("hidden")
      }
-      if (tankinfo.water_temp == null){
+      if (tankinfo.water_temp_c == null){
        this.tank_measure_temperature_container.classList.add("hidden")
      } else {
-        this.tank_measure_temperature.innerText = tankinfo.water_temp.toString();
+        this.tank_measure_temperature.innerText = tankinfo.water_temp_c.toString();
        this.tank_measure_temperature_container.classList.remove("hidden")
      }
-      if (tankinfo.raw == null){
+      if (tankinfo.fill_raw_v == null){
        this.tank_measure_rawvolt_container.classList.add("hidden")
      } else {
-        this.tank_measure_rawvolt.innerText = tankinfo.raw.toString();
+        this.tank_measure_rawvolt.innerText = tankinfo.fill_raw_v.toString();
        this.tank_measure_rawvolt_container.classList.remove("hidden")
      }

--- a/Software/MainBoard/rust/src_webpack/src/toast.ts
+++ b/Software/MainBoard/rust/src_webpack/src/toast.ts
@@ -1,94 +1,432 @@
-class ToastService {
-  private container: HTMLElement;
-  private stylesInjected = false;
+/**
+ * Toast notification service for PlantCtrl embedded web interface
+ * Provides non-blocking notifications with auto-dismiss and click-to-close functionality
+ */

-  constructor() {
-    this.container = this.ensureContainer();
-    this.injectStyles();
-  }
+const TOAST_container_ID = 'toast-container';
+const TOAST_STYLES_KEY = 'toast-styles-injected';

-  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);
-    });
-  }
+interface ToastOptions {
+    duration?: number;
+    dismissible?: boolean;
+}

-  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));
-  }
+interface ToastData {
+    id: string;
+    type: 'info' | 'success' | 'warning' | 'error';
+    message: string;
+    createdAt: number;
+    element?: HTMLElement;
+}

-  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);
+/**
+ * Toast service for displaying notifications
+ */
+export class ToastService {
+    private container: HTMLElement | null = null;
+    private activeToasts: Map<string, ToastData> = new Map();
+    private maxToasts: number = 5;
+    
+    // Default configuration
+    private defaultDuration: number = 5000; // 5 seconds for info messages
+    private errorDuration: number = 10000; // 10 seconds for error messages
+    
+    constructor() {
+        this.init();
    }
-    return container;
-  }
-
-  private injectStyles() {
-    if (this.stylesInjected) return;
-    const style = document.createElement('style');
-    style.textContent = `
+    
+    /**
+     * Initialize the toast container and inject styles
+     */
+    private init(): void {
+        this.ensureContainer();
+        this.injectStyles();
+    }
+    
+    /**
+     * Get or create the toast container element
+     */
+    private ensureContainer(): HTMLElement {
+        if (this.container) return this.container;
+        
+        let container = document.getElementById(TOAST_container_ID);
+        if (!container) {
+            container = document.createElement('div');
+            container.id = TOAST_container_ID;
+            container.setAttribute('role', 'region');
+            container.setAttribute('aria-label', 'Notifications');
+            document.body.appendChild(container);
+        }
+        
+        this.container = container;
+        return container;
+    }
+    
+    /**
+     * Inject toast styles if not already injected
+     */
+    private injectStyles(): void {
+        if (document.querySelector(`style[data-id="${TOAST_STYLES_KEY}"]`)) {
+            return;
+        }
+        
+        const style = document.createElement('style');
+        style.setAttribute('data-id', TOAST_STYLES_KEY);
+        style.textContent = `
 #toast-container {
  position: fixed;
-  top: 12px;
-  right: 12px;
+  top: 16px;
+  right: 16px;
  display: flex;
  flex-direction: column;
-  gap: 8px;
+  gap: 10px;
  z-index: 9999;
+  max-width: 400px;
+  pointer-events: none;
 }
+
 .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;
+  background: #fff;
+  border-left: 4px solid transparent;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  border-radius: 8px;
+  padding: 12px 16px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
  font-size: 14px;
-  line-height: 1.3;
+  line-height: 1.4;
+  color: #333;
+  max-width: 100%;
+  pointer-events: auto;
+  animation: toast-slide-in 0.3s cubic-bezier(0.4, 0, 0.2, 1),
+             toast-fade-in 0.3s ease-out;
+  display: flex;
+  align-items: center;
+  gap: 12px;
 }
+
 .toast.info {
-  background-color: #d4edda; /* green-ish */
-  color: #155724;
-  border-left: 4px solid #28a745;
+  border-color: #3b82f6;
+  background: linear-gradient(135deg, #eff6ff 0%, #dbeafe 100%);
 }
+
+.toast.success {
+  border-color: #22c55e;
+  background: linear-gradient(135deg, #f0fdf4 0%, #dcfce7 100%);
+}
+
+.toast.warning {
+  border-color: #f59e0b;
+  background: linear-gradient(135deg, #fffbeb 0%, #fef3c7 100%);
+}
+
 .toast.error {
-  background-color: #f8d7da; /* red-ish */
-  color: #721c24;
-  border-left: 4px solid #dc3545;
+  border-color: #ef4444;
+  background: linear-gradient(135deg, #fef2f2 0%, #fee2e2 100%);
 }
-`;
-    document.head.appendChild(style);
-    this.stylesInjected = true;
+
+.toast:hover {
+  transform: translateX(-2px);
+  box-shadow: 0 6px 16px rgba(0, 0, 0, 0.2);
+}
+
+.toast-icon {
+  flex-shrink: 0;
+  font-size: 18px;
+}
+
+.toast-message {
+  flex-grow: 1;
+  word-wrap: break-word;
+  overflow-wrap: anywhere;
+}
+
+.toast-close-btn {
+  flex-shrink: 0;
+  background: none;
+  border: none;
+  cursor: pointer;
+  padding: 4px;
+  margin-left: -4px;
+  opacity: 0.6;
+  transition: opacity 0.2s;
+  color: inherit;
+}
+
+.toast-close-btn:hover {
+  opacity: 1;
+}
+
+@keyframes toast-slide-in {
+  from {
+    transform: translateX(100%);
+    opacity: 0;
+  }
+  to {
+    transform: translateX(0);
+    opacity: 1;
  }
 }

+@keyframes toast-fade-in {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}
+
+@keyframes toast-dismiss {
+  from {
+    transform: translateX(0);
+    opacity: 1;
+  }
+  to {
+    transform: translateX(100%);
+    opacity: 0;
+  }
+}
+`;
+        document.head.appendChild(style);
+    }
+    
+    /**
+     * Create a unique ID for toast messages
+     */
+    private generateId(): string {
+        return `toast-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    }
+    
+    /**
+     * Create a toast element
+     */
+    private createToast(type: 'info' | 'success' | 'warning' | 'error', message: string): HTMLElement {
+        const div = document.createElement('div');
+        div.className = 'toast';
+        div.classList.add(type);
+        
+        // Add icon based on type
+        const icon = this.getIconForType(type);
+        div.innerHTML = `
+            <span class="toast-icon">${icon}</span>
+            <span class="toast-message">${this.escapeHtml(message)}</span>
+            <button class="toast-close-btn" aria-label="Dismiss notification">
+                <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                    <line x1="18" y1="6" x2="6" y2="18"></line>
+                    <line x1="6" y1="6" x2="18" y2="18"></line>
+                </svg>
+            </button>
+        `;
+        
+        return div;
+    }
+    
+    /**
+     * Get icon based on toast type
+     */
+    private getIconForType(type: 'info' | 'success' | 'warning' | 'error'): string {
+        const icons: Record<string, string> = {
+            info: '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"></circle><line x1="12" y1="16" x2="12" y2="12"></line><line x1="12" y1="8" x2="12.01" y2="8"></line></svg>',
+            success: '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"></path><polyline points="22 4 12 14.01 9 11.01"></polyline></svg>',
+            warning: '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z"></path><line x1="12" y1="9" x2="12" y2="13"></line><line x1="12" y1="17" x2="12.01" y2="17"></line></svg>',
+            error: '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"></circle><line x1="15" y1="9" x2="9" y2="15"></line><line x1="9" y1="9" x2="15" y2="15"></line></svg>'
+        };
+        return icons[type] || icons.info;
+    }
+    
+    /**
+     * Escape HTML to prevent XSS
+     */
+    private escapeHtml(text: string): string {
+        const map: Record<string, string> = {
+            '&': '&amp;',
+            '<': '&lt;',
+            '>': '&gt;',
+            '"': '&quot;',
+            "'": '&#039;'
+        };
+        return text.replace(/[&<>"']/g, (char) => map[char] || char);
+    }
+    
+    /**
+     * Display an info toast notification
+     */
+    info(message: string, options?: ToastOptions): void {
+        const duration = options?.duration ?? this.defaultDuration;
+        this.showToast('info', message, duration);
+    }
+    
+    /**
+     * Display a success toast notification
+     */
+    success(message: string, options?: ToastOptions): void {
+        const duration = options?.duration ?? this.defaultDuration;
+        this.showToast('success', message, duration);
+    }
+    
+    /**
+     * Display a warning toast notification
+     */
+    warning(message: string, options?: ToastOptions): void {
+        const duration = options?.duration ?? this.defaultDuration;
+        this.showToast('warning', message, duration);
+    }
+    
+    /**
+     * Display an error toast notification
+     */
+    error(message: string, options?: ToastOptions): void {
+        console.error(`[Toast Error] ${message}`);
+        const duration = options?.duration ?? this.errorDuration;
+        this.showToast('error', message, duration);
+    }
+    
+    /**
+     * Show a toast notification with the given type
+     */
+    private showToast(type: 'info' | 'success' | 'warning' | 'error', message: string, duration: number): void {
+        // Limit the number of concurrent toasts
+        this.limitToasts();
+        
+        const id = this.generateId();
+        const element = this.createToast(type, message);
+        const container = this.ensureContainer();
+        
+        // Add to active toasts
+        this.activeToasts.set(id, { id, type, message, createdAt: Date.now() });
+        
+        // Append to container
+        container.appendChild(element);
+        
+        // Store reference
+        this.activeToasts.get(id)!.element = element;
+        
+        // Set up auto-dismiss timer
+        let dismissTimer: number | undefined;
+        
+        const scheduleDismiss = () => {
+            if (duration > 0) {
+                dismissTimer = window.setTimeout(() => this.dismiss(id), duration);
+            }
+        };
+        
+        // Setup click to dismiss
+        const handleClick = () => {
+            if (dismissTimer !== undefined) {
+                window.clearTimeout(dismissTimer);
+                dismissTimer = undefined;
+            }
+            this.dismiss(id);
+        };
+        
+        // Setup close button handler
+        const closeBtn = element.querySelector('.toast-close-btn');
+        if (closeBtn) {
+            closeBtn.addEventListener('click', (e) => {
+                e.stopPropagation();
+                handleClick();
+            });
+        }
+        
+        // Setup click on toast to dismiss
+        element.addEventListener('click', handleClick);
+        
+        // Start timer
+        scheduleDismiss();
+    }
+    
+    /**
+     * Dismiss a toast by ID
+     */
+    dismiss(id: string): void {
+        const toastData = this.activeToasts.get(id);
+        if (!toastData || !toastData.element) return;
+        
+        const element = toastData.element;
+        
+        // Add dismiss animation
+        element.style.animation = 'toast-dismiss 0.2s ease-in forwards';
+        
+        // Remove from DOM after animation
+        setTimeout(() => {
+            if (element.parentElement) {
+                element.parentElement.removeChild(element);
+            }
+            this.activeToasts.delete(id);
+            
+            // Ensure container exists before trying to append
+            if (this.container) {
+                this.moveToasts();
+            }
+        }, 200);
+    }
+    
+    /**
+     * Remove a toast by element reference
+     */
+    dismissElement(element: HTMLElement): void {
+        const entries = Array.from(this.activeToasts.entries());
+        for (const [id, data] of entries) {
+            if (data.element === element) {
+                this.dismiss(id);
+                break;
+            }
+        }
+    }
+    
+    /**
+     * Limit the number of concurrent toasts
+     */
+    private limitToasts(): void {
+        if (this.container && this.activeToasts.size >= this.maxToasts) {
+            // Dismiss the oldest toast
+            const oldestId = Array.from(this.activeToasts.keys())[0];
+            if (oldestId) {
+                this.dismiss(oldestId);
+            }
+        }
+    }
+    
+    /**
+     * Move toasts to ensure proper stacking
+     */
+    private moveToasts(): void {
+        if (!this.container) return;
+        
+        // Remove any empty container
+        if (this.activeToasts.size === 0) {
+            if (this.container.parentElement) {
+                this.container.parentElement.removeChild(this.container);
+            }
+            this.container = null;
+        }
+    }
+    
+    /**
+     * Clear all active toasts
+     */
+    clear(): void {
+        const ids = Array.from(this.activeToasts.keys());
+        for (const id of ids) {
+            this.dismiss(id);
+        }
+    }
+    
+    /**
+     * Get the number of active toasts
+     */
+    getActiveCount(): number {
+        return this.activeToasts.size;
+    }
+    
+    /**
+     * Set the maximum number of concurrent toasts
+     */
+    setMaxToasts(count: number): void {
+        this.maxToasts = count;
+        this.limitToasts();
+    }
+}
+
+// Export a singleton instance
 export const toast = new ToastService();
--- a/Software/Shared/canapi/src/lib.rs
+++ b/Software/Shared/canapi/src/lib.rs
@@ -43,6 +43,7 @@ pub mod id {
    // Message group base offsets relative to SENSOR_BASE_ADDRESS
    pub const MOISTURE_DATA_OFFSET: u16 = 0; // periodic data from sensor (sensor -> controller)
    pub const IDENTIFY_CMD_OFFSET: u16 = 32; // identify LED command (controller -> sensor)
+    pub const FIRMWARE_BUILD_OFFSET: u16 = 64; // firmware build timestamp (sensor -> controller, sent after identify)

    #[inline]
    pub const fn plant_id(message_type_offset: u16, sensor: SensorSlot, plant: u16) -> u16 {
@@ -55,8 +56,9 @@ pub mod id {
    /// Kinds of message spaces recognized by the addressing scheme.
    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
    pub enum MessageKind {
-        MoistureData, // sensor -> controller
-        IdentifyCmd,  // controller -> sensor
+        MoistureData,    // sensor -> controller
+        IdentifyCmd,     // controller -> sensor
+        FirmwareBuild,   // sensor -> controller, sent after receiving identify cmd
    }

    /// Try to classify a received 11-bit standard ID into a known message kind and extract plant and sensor slot.
@@ -93,6 +95,9 @@ pub mod id {
        if let Some((plant, slot)) = decode_in_group(rel, IDENTIFY_CMD_OFFSET) {
            return Some((MessageKind::IdentifyCmd, plant, slot));
        }
+        if let Some((plant, slot)) = decode_in_group(rel, FIRMWARE_BUILD_OFFSET) {
+            return Some((MessageKind::FirmwareBuild, plant, slot));
+        }
        None
    }

--- a/rust/website/content/Hardware/CAN-Bus-Protocol/1745239200000-CAN-Bus-Protocol/index.md
+++ b/rust/website/content/Hardware/CAN-Bus-Protocol/1745239200000-CAN-Bus-Protocol/index.md
@@ -0,0 +1,194 @@
+---
+title: "CAN Bus Protocol"
+date: 2026-05-21
+draft: false
+description: "Complete documentation of the CAN bus communication protocol between PlantCtrl sensor modules and main controller."
+tags: ["can", "protocol", "sensor"]
+---
+
+# CAN Bus Protocol
+
+The PlantCtrl system uses a custom **CAN bus-based communication protocol** to connect sensor modules (moisture sensors) with the MainBoard controller. This modular design allows for scalable, reliable digital communication even over long cable runs and in electrically noisy environments.
+
+## Overview
+
+- **Protocol**: Standard CAN 2.0A (11-bit identifier)
+- **Baud Rate**: 50 kbps
+- **Base Address**: `0x03E8` (decimal 1000)
+- **Maximum Plants**: 16 per sensor module
+- **Sensors per Plant**: 2 slots (A and B) for redundancy or larger planters
+
+## CAN Bus IDs
+
+All messages use the standard base address `0x03E8` with message-specific offsets. The ID structure is:
+
+```
+ID = 0x03E8 + Message_Offset + Plant_Index (+ Slot_Offset if B)
+```
+
+### Message Groups
+
+| Group | Offset (hex) | Direction | Description |
+|-------|--------------|-----------|-------------|
+| Moisture Data | `0x00` | Sensor → Controller | Periodic moisture readings |
+| Identify Command | `0x20` | Controller → Sensor | LED identification command |
+| Firmware Build | `0x40` | Sensor → Controller | Compile-time build timestamp |
+
+### Plant Addressing (Slots A & B)
+
+Each plant gets two sensor slots:
+- **Slot A**: Base offset + plant index (0–15)
+- **Slot B**: Base offset + 16 + plant index (0–15)
+
+#### Example ID Calculations
+
+| Message Type | Plant | Slot | CAN ID (hex) |
+|--------------|-------|------|-------------|
+| Moisture Data | 0 | A | `0x03E8` |
+| Moisture Data | 7 | A | `0x0415` |
+| Moisture Data | 15 | A | `0x042F` |
+| Identify Command | 0 | A | `0x0400` |
+| Firmware Build | 3 | B | `0x0467` |
+
+## Message Formats
+
+All messages are serialized using **bincode v2** (fixed-size integers, no varints). Each message fits within a single CAN frame.
+
+### Moisture Data (Sensor → Controller)
+
+Sent periodically by each sensor module. Contains:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `plant` | u8 | Plant index (0–15) |
+| `sensor` | SensorSlot | A or B slot |
+| `hz` | u16 | Measured frequency in Hz |
+
+**Total size**: 4 bytes (fits easily in CAN frame)
+
+### Identify Command (Controller → Sensor)
+
+Sent by the controller to trigger an LED identification sequence on the sensor module.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| *(empty)* | - | No payload data |
+
+**Purpose**: When received, the sensor blinks its status LED for a few seconds to confirm it's online and properly configured.
+
+### Firmware Build (Sensor → Controller)
+
+Sent immediately after receiving an Identify Command. Contains:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `build_minutes` | u32 | Compile-time timestamp in minutes since Unix epoch |
+
+**Purpose**: Allows the controller to track firmware versions and deployment history without requiring a separate request.
+
+## Sensor Configuration
+
+Each sensor module is configured via **hardware jumpers** on startup. The configuration is read by the CH32V203 MCU and determines:
+- Whether it's Slot A or B for a plant
+- The plant index (1–8)
+
+### Hardware Switches
+
+| Pin | Function |
+|-----|----------|
+| PA3 | **Slot selector**: Low = A, High = B |
+| PA4 | Address bit 1 (value: 1) |
+| PA5 | Address bit 2 (value: 2) |
+| PA6 | Address bit 3 (value: 4) |
+| PA7 | Address bit 4 (value: 8) |
+
+### Valid Addresses
+
+- **Allowed**: 1–8 (binary combinations of bits 1,2,4,8)
+- **Invalid**: 0 or >8 (will trigger error code)
+
+#### Example Configurations
+
+| Address | Binary | Jumpers |
+|---------|--------|----------|
+| 1 | `0001` | PA4 only |
+| 3 | `0011` | PA4 + PA5 |
+| 7 | `0111` | PA4 + PA5 + PA6 |
+| 8 | `1000` | PA7 only |
+
+## Error Detection & Blink Codes
+
+The sensor module performs **floating pin detection** at startup. If any configuration pin is left floating (not connected to VCC or GND), the system enters an error state and blinks a diagnostic code.
+
+### Error Code Table
+
+| Code | Cause | LED Pattern |
+|------|-------|-------------|
+| 1 | PB4 floating (bit 1) | 1 blink info, 2 blinks warning |
+| 2 | PB5 floating (bit 2) | 2 blinks info, 2 blinks warning |
+| 3 | PB6 floating (bit 3) | 3 blinks info, 2 blinks warning |
+| 4 | PB7 floating (bit 4) | 4 blinks info, 2 blinks warning |
+| 5 | PB3 floating (A/B selector) | 5 blinks info, 2 blinks warning |
+| 6 | Invalid address (0 or >8) | 6 blinks info, 2 blinks warning |
+
+### LED Indicators
+
+- **Info LED** (PA10): Green – indicates information state
+- **Warning LED** (PA9): Yellow/Orange – indicates error/warning state
+
+The blink pattern repeats 5 times, then the system resets automatically.
+
+## Address Collision Detection
+
+The protocol includes built-in collision detection. If a sensor receives a moisture data packet addressed to itself, it triggers an error sequence:
+- **Blink code**: 1 info blink, 2 warning blinks
+- **Log message**: "We should never receive moisture packets addressed to ourselves"
+
+This indicates another node is using the same jumper configuration.
+
+## CAN Bus Robustness Features
+
+The firmware implements several features for reliable operation:
+
+### Automatic Retransmission (NART)
+Enabled on the CH32V203 CAN controller to recover from transient errors without manual intervention.
+
+### Resync Jump Width (SJW = 4TQ)
+Increased from default (1TQ) to improve jitter tolerance over long cable runs. This allows the receiver to resynchronize with the bit stream even if timing drifts slightly.
+
+### Error Status Monitoring
+The controller monitors CAN error registers for:
+- Bus-off condition (`BOFF`)
+- Error warning flag (`EWGF`)
+- Error passive flag (`EPVF`)
+
+When errors are detected, warning LEDs blink and the system logs the status.
+
+## Troubleshooting
+
+### Sensor Not Detected
+1. Check all jumpers – ensure no floating pins
+2. Verify address is 1–8 (not 0 or >8)
+3. Confirm slot selector (A/B) matches expected configuration
+4. Listen for CAN traffic with a CAN analyzer
+5. Check error blink codes on the sensor module
+
+### Address Collision
+- Two sensors using identical jumper settings will cause collisions
+- Use the collision detection feature to identify duplicate addresses
+- Reconfigure one of the conflicting sensors to a different address
+
+### Communication Errors
+- **Bus-off**: Check CAN termination resistors (120Ω at each end)
+- **High error rate**: Verify cable quality and shielding
+- **Intermittent errors**: Check for electrical noise from pumps or motors
+
+## Future Extensions
+
+The protocol is designed to be extensible. New message types can be added by:
+1. Defining a new offset in `canapi/src/lib.rs`
+2. Implementing the corresponding message struct with bincode serialization
+3. Adding receive handlers on both sensor and controller sides
+4. Documenting the new ID range and format
+
+The current design supports up to 64 distinct message types (16 plants × 2 slots × 2 directions) while maintaining a clean, plant-indexed addressing scheme.
--- a/rust/website/content/Hardware/CAN-Bus-Protocol/1745239260000-CAN-Bus-IDs-and-Wire-Format/index.md
+++ b/rust/website/content/Hardware/CAN-Bus-Protocol/1745239260000-CAN-Bus-IDs-and-Wire-Format/index.md
@@ -0,0 +1,142 @@
+---
+title: "CAN Bus IDs and Wire Format"
+date: 2026-05-21
+draft: false
+description: "Quick reference for CAN bus identifiers, message formats, and on-the-wire data structures."
+tags: ["can", "protocol", "wire-format"]
+---
+
+# CAN Bus IDs and Wire Format
+
+A concise technical reference for the PlantCtrl CAN bus protocol.
+
+## Quick Reference Table
+
+| CAN ID (hex) | Message Type | Direction | Payload |
+|--------------|--------------|-----------|----------|
+| `0x03E8` | Moisture Data - Plant 0, Slot A | Sensor → Controller | u8 plant + u8 slot + u16 hz |
+| `0x0400` | Identify Command - Plant 0, Slot A | Controller → Sensor | *(empty)* |
+| `0x042F` | Moisture Data - Plant 15, Slot A | Sensor → Controller | u8 plant + u8 slot + u16 hz |
+| `0x0467` | Firmware Build - Plant 3, Slot B | Sensor → Controller | u32 build_minutes |
+
+## ID Calculation Formula
+
+```
+ID = 0x03E8 + Message_Offset + Plant_Index (+ Slot_Offset if B)
+```
+
+### Constants
+
+| Constant | Value (hex) | Description |
+|----------|-------------|-------------|
+| `SENSOR_BASE_ADDRESS` | `0x03E8` | Base address for all messages |
+| `MOISTURE_DATA_OFFSET` | `0x00` | Moisture data group |
+| `IDENTIFY_CMD_OFFSET` | `0x20` | Identify command group |
+| `FIRMWARE_BUILD_OFFSET` | `0x40` | Firmware build group |
+| `B_SLOT_OFFSET` | `0x10` | Offset for Slot B within a group |
+
+### Message Type Offsets
+
+```rust
+pub const MOISTURE_DATA_OFFSET: u16 = 0;      // sensor → controller
+pub const IDENTIFY_CMD_OFFSET: u16 = 32;      // controller → sensor
+pub const FIRMWARE_BUILD_OFFSET: u16 = 64;    // sensor → controller
+```
+
+## On-the-Wire Formats
+
+### Moisture Data Frame (Sensor → Controller)
+
+**CAN ID**: `0x03E8 + offset + plant_index` (or `+ 16 + plant_index` for Slot B)
+
+| Byte | Field | Type |
+|------|-------|------|
+| 0 | `plant` | u8 (0–15) |
+| 1 | `sensor` | SensorSlot (A=0, B=1) |
+| 2-3 | `hz` | u16 big-endian |
+
+**Example**: Plant 7, Slot A, frequency 45 Hz
+```
+CAN ID: 0x0415
+Payload: [07 00 00 2D]
+         plant=7, sensor=A, hz=45 (0x002D)
+```
+
+### Firmware Build Frame (Sensor → Controller)
+
+**CAN ID**: `0x03E8 + 64 + plant_index` (or `+ 80 + plant_index` for Slot B)
+
+| Byte | Field | Type |
+|------|-------|------|
+| 0-3 | `build_minutes` | u32 big-endian |
+
+**Example**: Build timestamp 1,745,239,200 minutes since epoch (May 2026)
+```
+CAN ID: 0x0440
+Payload: [00 00 6A F8]
+         build_minutes = 1,745,239,200
+```
+
+### Identify Command Frame (Controller → Sensor)
+
+**CAN ID**: `0x03E8 + 32 + plant_index` (or `+ 48 + plant_index` for Slot B)
+
+| Byte | Field | Type |
+|------|-------|------|
+| *(none)* | *(empty payload)* | - |
+
+**Example**: Identify Plant 5, Slot A
+```
+CAN ID: 0x0410
+Payload: (empty)
+```
+
+## Addressing Scheme Details
+
+### Plant Index Range
+- **Valid**: 0–15 (decimal) or 1–8 on hardware jumpers (mapped internally as 0–7)
+- **Slot A**: `plant_index` = jumper value - 1
+- **Slot B**: Same mapping, but ID offset differs by +16
+
+### Slot Selection
+| Hardware | Internal Value |
+|----------|---------------|
+| Jumper on PA3 (Low) | Slot A (0) |
+| Jumper on PA3 (High) | Slot B (1) |
+
+## Error Detection IDs
+
+The sensor module monitors for unexpected messages:
+
+- **Moisture Data collision**: If a sensor receives moisture data addressed to itself, it triggers error code 1 (1 info blink, 2 warning blinks)
+- **CAN errors**: Bus-off, EWGF, EPVF flags trigger warning LED blinking
+
+## Protocol Extensions
+
+To add new message types:
+
+1. Define offset in `canapi/src/lib.rs`:
+   ```rust
+   pub const NEW_MESSAGE_OFFSET: u16 = 96; // Next available slot
+   ```
+
+2. Implement message struct with bincode serialization
+3. Add receive handler on both sides
+4. Update documentation
+
+## Binary Protocol Reference
+
+### bincode v2 Serialization
+- **u8**: Single byte, no sign extension
+- **u16**: 2 bytes big-endian (network order)
+- **u32**: 4 bytes big-endian (network order)
+- No varints – fixed size for predictable CAN frame lengths
+
+### CAN Frame Structure
+```
+| Arbitration Field | Control Field | Data Field (8 bytes) |
+|-------------------|---------------|----------------------|
+| 11-bit ID         | RTR + IDE     | Payload (max 4-6 bytes)|
+```
+
+All PlantCtrl messages fit within the 8-byte data field with room for CAN overhead.
--- a/website/content/Hardware/1737993462790-BatteryManagement/index.md
+++ b/website/content/Hardware/1737993462790-BatteryManagement/index.md
@@ -3,39 +3,55 @@ title: "BatteryManagement"
 date: 2025-01-27
 draft: false
 description: "a description"
-tags: ["battery", "bq34z100"]
+tags: ["battery", "bms"]
 ---
 # Battery Management Module
-The project contains an additional companion board (Fuel Gauge), with a bq34z100 battery management IC. 

-It allows to track the health and charge for an external battery and is supposed to be soldered directly to the battery. 
-The MainBoard contains a connector for power, and additionally a two-pin I2C bus to communicate with the Battery Management module.
+The PlantCtrl system uses an external **Battery Management System (BMS)** board that connects to the MainBoard. This module monitors battery voltage, current, and health metrics and communicates with the ESP32-C6 via I2C.

-<!-- TODO: Add photo of the new modular Battery Management board -->
-
-# Setup
 {{< alert >}}
-A protected Battery is required. There is only a very simplistic output voltage adjustment for the MPPT system and no charge termination. It is expected that the battery itself protects against overcharging and deep discharges!
+The open-bms is a custom battery management board designed for this project. It uses a CH32V203 microcontroller to handle battery monitoring and protection. The older bq34z100-based battery management board is deprecated and located in the `__Legay_Unused` folder.
 {{< /alert >}}
-* BatteryManagement is purely optional, but recommended for solar power.
-* If available it will be used for an extended low power deep sleep in case of critical charge.
-* If available it will also be used, to reduce the nightlight, if the charge drops to a predefined level, so the nightlight cannot drain to much battery
-* If available, all relevant battery metrics will be published via mqtt

- Currently the setup requires a custom Ev2400 flasher and the properitary windows software from texas instruments.
- {{< alert >}}
- Before soldering to the battery
-{{< /alert >}}
-1. The voltage devider high side must be bridged, while being connected to the computer and being supplied with around 4.2 V from the battery solder leads.
-2. Then the data/register for low voltage flash write protection should be set to 0V, as else with the voltage divider and no further configuration, the IC will refuse all write requests.
-3. After this the supplied golden image can be used, it will setup the battery for 6Ah and a 4S lifepo. Different values can be adjusted after this to the users liking.
+## Hardware
+
+The Battery Management Board features:
+* CH32V203 RISC-V microcontroller for battery monitoring
+* I2C interface for communication with the MainBoard
+* Battery voltage and current sensing
+
 {{< alert >}}
-The main board, does not care or process any of the charge discharge limits that can be set. Ensure that the battery can supply enough current as well as accept a 2.4A charging current from the MPPT system.
+The open-bms board does not use the bq34z100 fuel gauge IC. That component was used in an older legacy design now located in the `__Legay_Unused` folder.
 {{< /alert >}}

-The golden image sets the statups led up, to be in blinky mode. one very long interval means, that the battery is pretty much full. A few very short flashes mean that the battery is nearly empty. No light means, that the battery is in discharge protection and shut down.
+## Integration with MainBoard

-If the red error led lights, something is wrong with the battery. This can be abnormal voltages or a very low health state.
+The battery management board:
+* Connects to the MainBoard via a two-pin I2C bus
+* Provides power connection to the battery
+* Reports battery metrics via MQTT (if configured)

-# Todo?
-If the battery reports that no discharging should occure, report this and then shutdown without using pumps
+## Usage
+
+* If available, the system will use battery metrics for deep sleep management when charge is critical
+* The nightlight can be automatically disabled if battery level drops below a predefined threshold
+* All battery metrics are published via MQTT when configured
+* The system includes safety mechanisms to prevent overcharging and deep discharges through the battery's built-in protection circuitry
+
+## Safety Notes
+
+{{< alert >}}
+The system requires a battery with built-in protection circuitry. The MPPT system does not include charge termination or overcharge protection - the battery itself must provide these safety features.
+{{< /alert >}}
+
+The CH32V203-based BMS monitors battery health and provides status information but does not control the charge/discharge limits. Ensure your battery can handle the maximum charging current from the MPPT system (up to 2.4A).
+
+## Setup
+
+1. **Connect Battery:** Connect your protected battery to the BMS board
+2. **_connect MainBoard:** Connect the Battery Management Board to the MainBoard via the I2C bus connector
+3. **Power On:** Power on the system and verify communication via MQTT
+
+## Status Indicators
+
+The BMS board includes status LEDs, they behave like every normal powerbank (1-5 lights, animted if charging)
--- a/website/content/Hardware/1737993490702-Sensors&Pumps/index.md
+++ b/website/content/Hardware/1737993490702-Sensors&Pumps/index.md
@@ -1,77 +0,0 @@
---
-title: "Sensors&Pumps"
-date: 2025-01-27
-draft: false
-description: "a description"
-tags: ["sensor"]
---
-# Sensors & Pumps Module
-
-This functionality is now provided by dedicated modules that can be connected to the MainBoard.
-
-# Sensors
-The moisture sensing functionality is handled by a dedicated **CAN bus-based Sensor Module**. This modular approach allows for better scalability and reduces electrical interference by moving the measurement logic closer to the sensors and using digital communication.
-
-## Sensor Module (CAN bus)
-The standard sensor module features its own **CH32V203 RISC-V microcontroller**, which handles the measurement of soil moisture and communicates the results back to the MainBoard via the CAN bus.
-
-* **Capacity:** Supports up to 16 sensors (typically 8 plants with an A and B sensor each).
-* **Reliability:** Digital communication via CAN bus ensures data integrity even over longer cable runs and in electrically noisy environments.
-* **Addressing:** The A sensor is always used; the B sensor is optional and suggested for larger planters to provide a better average of the soil moisture.
-
-## Sensor Hardware
-The sensors themselves remain simple and cost-effective:
-* **Design:** Two spikes with a defined distance.
-* **DIY Friendly:** Can be bought readymade or easily made with two long nails (galvanized or stainless steel suggested to prevent rusting).
-
-## Measurement Principle
-The new CAN-based sensor module uses a sophisticated measurement technique that replaces the outdated 555-oscillator and multiplexer design. By using a dedicated MCU for measurement:
-* **Minimized Corrosion:** The system changes polarity between measurements, minimizing corrosion due to organic battery effects (electrolysis) and preventing errors caused by building up a DC voltage in the soil.
-* **Interference Resistance:** The measurement is resistant to common failure signals, such as 50Hz hum from nearby power circuits.
-* **Digital Accuracy:** The local MCU processes the analog signals and sends precise digital values to the MainBoard.
-
-# Pumps
-The Pump module contains low side switched pump outputs. The pumps are running directly from the battery without further voltage conversion, so ensure that they can survive the full voltage range of the battery.
-Each output can supply up to 3A continously.
-The board will never switch more than one output concurrently, so there is no need to size the battery for higher maximum load.
-An additinal extra output exists, that is switched when any of the pump outputs is supposed to run.
-
-<!-- TODO: Add photo of the new modular Pump and Sensor boards -->
-
-This allows for multiple possible setups
-## Layout Central Pump
-One central pump is connected to the extra output, and multiple magnetic valves are used for the different plants
-## Multi Gravity Feed Valves
-Per plant a Valve that can close against pressure is used, no pump exists
-## Multi Pump Setup
-Multiple smaller cheaper pumps with no shared hoses, so that failures will only affect a single planter.
-
-In any case I suggest to use a Water Filter on the Intake, as else you will get severe algae problems.
-
-In my personal opinion small membrane pumps are a really good fit
-* can be housed outside the tank 
-* require less maintance/cleaning
-* are able to pump smaller impurities without issues. 
-* Can pull water 1-2meters
-* Have higher output pressure -> Will blow out blockages in hoses
-However
-* are louder
-* pump less volume per time and energy
-
-{{< alert >}}
-DO NOT DIRECTLY CONNECT TO WATER MAINS, YOU HAVE BEEN WARNED!
-
-Software and Hardware may fail: It is your responsibility to ensure that a stuck valve or short circuit mosfet will not cause flooding and property destruction, for example by limiting the water tank to size that can drain.
-{{< /alert >}}
-
-
-# Todo
-## Flow Sensor
-There is a input for a flow sensor, currently it is not used as the software is missing. 
-* Allow monitoring if pumps are actually moving water
-* Allow to set limits for how much ml are allowed additinally to the current time limit per watering run
-
-
-
-Currently it cannot be set how two sensor should be interpreted and they are only averaged. More complex functions would be nice here, eg. allowing a user settable interpolation (0.8*a+0.2*b)/2 and Min(a,b) as well as max(a,b) 
-
--- a/website/content/Hardware/_index.md
+++ b/website/content/Hardware/_index.md
@@ -11,8 +11,6 @@ tags: ["esp32", "hardware"]
  <img src="pcb_back.png" class="grid-w50" />
 {{< /gallery >}}

-<!-- TODO: Add new screenshots of the modular PCB setup -->
-
 {{< gitea server="https://git.mannheim.ccc.de/" repo="C3MA/PlantCtrl" >}}

 ## Modular Design
@@ -27,17 +25,25 @@ The system now consists of a **MainBoard** which acts as the controller and seve
 * **Fully Open Source:** Designed in KiCad

 ## Available Modules
-* **MPPT Charger:** Efficient solar charging for batteries.
-* **Pump Driver:** High-current outputs for pumps and valves.
-* **Sensor Interface:** Support for multiple moisture sensors.
-* **Light Controller:** For LED nightlights or growth lights.
+* **MPPT Charger:** Efficient solar charging for batteries using CN3795.
+* **Pump Driver:** High-current outputs (up to 3A) for pumps and valves.
+* **Sensor Module:** CAN bus-based moisture sensors using CH32V203 microcontroller.
+* **Battery Management:** External BMS board with CH32V203 for battery monitoring.
+* **Light Controller:** For LED nightlights or growth lights using AP63200.
+
+## Sensor Module (CAN bus)
+The standard sensor module features its own **CH32V203 RISC-V microcontroller**, which handles the measurement of soil moisture and communicates the results back to the MainBoard via the CAN bus.
+
+* **Capacity:** Supports up to 16 sensors (typically 8 plants with an A and B sensor each).
+* **Reliability:** Digital communication via CAN bus ensures data integrity even over longer cable runs and in electrically noisy environments.
+* **Addressing:** The A sensor is always used; the B sensor is optional and suggested for larger planters to provide a better average of the soil moisture.

 ## Capabilities
-* **Moisture Sensors:** Supports multiple capacitive or resistive sensors via expansion modules.
+* **Moisture Sensors:** Supports multiple capacitive or resistive sensors via CAN bus-based Sensor Modules.
 * **Pumps/Valves:** Support for multiple independent watering zones.
 * **Power:** 
    * Solar powered with MPPT
-    * Battery powered with optional Battery Management (Fuel Gauge)
+    * Battery powered with optional Battery Management System (BMS)
    * Can also be used with a standard power supply (7-24V)
 * **Efficient Power:** Use of high-efficiency DC-DC converters for 3.3V and peripherals.

--- a/website/content/Software/1737993506015-Firmware-Upload/index.md
+++ b/website/content/Software/1737993506015-Firmware-Upload/index.md
@@ -6,9 +6,12 @@ description: "a description"
 tags: ["firmeware", "upload"]
 ---
 # From Source
+
+The PlantCtrl firmware is written in Rust for the ESP32-C6 RISC-V microcontroller.
+
 ## Preconditions
 * **Rust:** Current version of `rustup`.
-* **ESP32 Toolchain:** `espup` installed and configured.
+* **ESP32 Toolchain:** `espup` installed and configured for ESP32-C6.
 * **espflash:** Installed via `cargo install espflash`.
 * **Node.js:** `npm` installed (for the web interface).

@@ -37,10 +40,8 @@ You can use the provided bash scripts to automate the build and flash process:
 You can also update the firmware wirelessly if the system is already running and connected to your network.

 1. Generate the OTA binary:
-   ```bash
-   cargo build --release
-   ```
-2. The binary will be at `target/riscv32imac-unknown-none-elf/release/plant-ctrl2`.
+   **`./image.sh`**
+2. The binary will be `image.bin`.
 3. Open the PlantCtrl web interface in your browser.
 4. Navigate to the **OTA** section.
 5. Upload the `plant-ctrl2` file.
--- a/website/content/Software/1737993539359-MQTT/index.md
+++ b/website/content/Software/1737993539359-MQTT/index.md
@@ -6,23 +6,26 @@ description: "a description"
 tags: ["mqtt", "esp"]
 ---
 # MQTT
-A configured MQTT server will receive statistical and status data from the controller.
+
+The PlantCtrl firmware publishes comprehensive status and telemetry data via MQTT when configured. The system uses the **mcutie** crate for Home Assistant integration and standard MQTT topics.

 ### Topics

 | Topic | Example | Description |
 |-------|---------|-------------|
 | `firmware/address` | `192.168.1.2` | IP address in station mode |
-| `firmware/state` | `VersionInfo { ... }` | Debug information about the current firmware and OTA slots |
+| `firmware/state` | `{...}` | Debug information about the current firmware and OTA slots |
 | `firmware/last_online` | `2025-01-22T08:56:46.664+01:00` | Last time the board was online |
 | `state` | `online` | Current state of the controller |
-| `mppt` | `{"current_ma":1200,"voltage_ma":18500}` | MPPT charging metrics |
-| `battery` | `{"Info":{"voltage_milli_volt":12860,"average_current_milli_ampere":-16,...}}` | Battery health and charge data |
-| `water` | `{"enough_water":true,"warn_level":false,"left_ml":1337,...}` | Water tank status |
-| `plant{1-8}` | `{"sensor_a":...,"sensor_b":...,"mode":"TargetMoisture",...}` | Detailed status for each plant slot |
-| `pump{1-8}` | `{"enabled":true,"pump_ineffective":false,...}` | Metrics for the last pump activity |
+| `mppt` | `{"current_ma":1200,"voltage_ma":18500}` | MPPT charging metrics (current and voltage from solar panel) |
+| `battery` | `{"Info":{"voltage_milli_volt":12860,"state_of_charge":95,...}}` | Battery health and charge data from the BMS |
+| `water` | `{"enough_water":true,"warn_level":false,"left_ml":1337,...}` | Water tank status (level, temperature, frozen detection) |
+| `plant{1-8}` | `{"sensor_a":...,"sensor_b":...,"mode":"TargetMoisture",...}` | Detailed status for each plant slot including moisture sensors |
+| `pump{1-8}` | `{"enabled":true,"median_current_ma":500,...}` | Metrics for each pump output |
 | `light` | `{"enabled":true,"active":true,...}` | Night light status |
-| `deepsleep` | `night 1h` | Why and how long the ESP will sleep |
+| `deepsleep` | `night 1h` | Reason and duration of deep sleep |
+
+Note: The batteries `average_current_milli_ampere` field uses a placeholder value (1337) and should be updated with actual current sensor readings when available.

 ### Data Structures

@@ -39,14 +42,15 @@ Contains a debug dump of the `VersionInfo` struct:
 - `voltage_ma`: Solar panel voltage in mV

 #### Battery (`battery`)
-Can be `"Unknown"` or an `Info` object:
- `voltage_milli_volt`: Battery voltage
- `average_current_milli_ampere`: Current draw/charge
- `design_milli_ampere_hour`: Battery capacity
- `remaining_milli_ampere_hour`: Remaining capacity
+Can be `"Unknown"` or an `Info` object. The battery data comes from a custom BMS (Battery Management System) board that uses the CH32V203 microcontroller with I2C communication.
+
+- `voltage_milli_volt`: Battery voltage in millivolts
+- `average_current_milli_ampere`: Current draw/charge in milliamperes (placeholder: 1337)
+- `design_milli_ampere_hour`: Battery design capacity in milliampere-hours
+- `remaining_milli_ampere_hour`: Remaining capacity in milliampere-hours
 - `state_of_charge`: Charge percentage (0-100)
- `state_of_health`: Health percentage (0-100)
- `temperature`: Temperature in degrees Celsius
+- `state_of_health`: Health percentage (0-100) based onLifetime capacity vs design capacity
+- `temperature`: Battery temperature in degrees Celsius

 #### Water (`water`)
 - `enough_water`: Boolean, true if level is above empty threshold
--- a/website/content/Software/1740079429350-compiling/index.md
+++ b/website/content/Software/1740079429350-compiling/index.md
@@ -6,9 +6,9 @@ description: "How to compile the project"
 tags: ["clone", "compile"]
 ---
 # Preconditions:
-* **Rust:** `rustup` installed.
-* **ESP32 Toolchain:** `espup` installed.
-* **Build Utilities:** `ldproxy` and `espflash` installed.
+* **Rust:** `rustup` installed with the Rust toolchain.
+* **ESP32 Toolchain:** `espup` installed for ESP32 support.
+* **Build Utilities:** `ldproxy` and `espflash` installed via cargo.
 * **Node.js:** `npm` installed (for the web interface).

 # Cloning the Repository
@@ -19,24 +19,16 @@ cd PlantCtrl/Software/MainBoard/rust
 ```

 # Toolchain Setup
-1. **Install Rust:** If not already done, visit [rustup.rs](https://rustup.rs/).
-2. **Install ldproxy:**
+
+The project uses Rust with ESP32-C6 support. The toolchain setup involves installing the necessary components:
+
+1. **Rust Toolchain:**
   ```bash
-   cargo install ldproxy
-   ```
-3. **Install espup:**
-   ```bash
-   cargo install espup
-   ```
-4. **Install ESP toolchain:**
-   ```bash
-   espup install
-   ```
-5. **Install espflash:**
-   ```bash
-   cargo install espflash
+   rustup toolchain install stable
+   rustup default stable
   ```

+
 # Building the Web Interface
 The configuration website is built using TypeScript and Webpack, then embedded into the Rust binary.
 ```bash
@@ -46,14 +38,7 @@ npx webpack
 cd ..
 ```

-# Compiling the Firmware
-Build the project using Cargo:
-```bash
-cargo build --release
-```
-The resulting binary will be located in `target/riscv32imac-unknown-none-elf/release/plant-ctrl2`.
-
-# Using Build Scripts
+# Compiling the Firmware using Build Scripts
 To simplify the process, several bash scripts are provided in the `Software/MainBoard/rust` directory:

 *   **`image_build.sh`**: Automatically builds the web interface, compiles the Rust firmware in release mode, and creates a flashable `image.bin`.
--- a/website/themes/blowfish
+++ b/website/themes/blowfish
Author	SHA1	Message	Date
Empire Phoenix	c112d133db	Add missing `Box` import in battery module	2026-05-30 21:01:29 +02:00
Empire Phoenix	95281d617f	clippy fixed	2026-05-30 20:59:58 +02:00
Empire Phoenix	a2abc99275	Refactor formatting and remove unused imports in mqtt and plant_state modules	2026-05-30 20:57:39 +02:00
Empire Phoenix	4b3c003996	Add `target_pct` field to `PlantInfo` for target moisture mode	2026-05-30 20:57:31 +02:00
Empire Phoenix	bba959f2a2	Update POST JSON size limit to use SAVEGAME_SLOT_SIZE minus header space	2026-05-30 20:55:51 +02:00
Empire	c9a96f37f0	feat: add sensor combine mode with Min, Max, and Avg options, update web UI and configuration for multi-sensor support	2026-05-29 11:22:12 +02:00
Empire	fbf97732a4	refactor: update KiCad 3D model paths and zone settings for compatibility with updated libraries	2026-05-28 20:14:51 +02:00
Empire Phoenix	6b419dba6c	Add Wi-Fi scan details display and MQTT publish - HTML: Add Wi-Fi scan results container to network.html - Rust: Implement `wifi_scan_details()` with RSSI, channel, auth method - API & UI: Fetch and display scan results in table format - MQTT: Publish top 10 networks sorted by RSSI to `/wifi_scan`	2026-05-28 00:46:14 +02:00
Empire Phoenix	3618b3329c	refactor tank info field names and improve null checks in UI	2026-05-27 15:18:46 +02:00
Empire Phoenix	f5f73723d1	retry wifi connection, show canbus FW version, adjust measurement formular	2026-05-27 03:36:39 +02:00
Empire Phoenix	be98380ba4	new toast impl, wip	2026-05-26 13:27:35 +02:00
Empire Phoenix	fe2d227c67	Fix fertilizer calculation and logging	2026-05-26 02:03:19 +02:00
Empire Phoenix	bd5b687430	fix pump test progress bar	2026-05-25 23:22:21 +02:00
Empire Phoenix	7679fa09dc	clippy: fix clippy warnings	2026-05-25 20:11:58 +02:00
EmpirePhoenix	7078af5713	Merge pull request 'refactor/mqtt-data-serialization' (#23 ) from refactor/mqtt-data-serialization into develop Reviewed-on: #23	2026-05-25 19:42:14 +02:00
ju6ge	32256d0c91	move all mqtt publishing functions to mqtt module	2026-05-24 18:32:10 +02:00
ju6ge	d4a4c1b573	refctor: TankInfo structure (consistent layout) - 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	2026-05-24 17:51:17 +02:00
ju6ge	6bf7a04024	refactor: PlantInfo structure (consistent layout) - fix: use tagged enum serialization for MoistureSensorError and PumpError - fix: flatten PlantInfo sensors to SensorTelemetry with top-level moisture_pct	2026-05-24 17:50:38 +02:00
ju6ge	df3159aa16	refactor: BatteryInfo structure (consistent layout) - use tagged enum serialization for BatteryError - flatten BatteryInfo telemetry with consistent field names and typed error	2026-05-24 14:49:35 +02:00
ju6ge	7866604a40	fix: serialize firmware/state as JSON instead of Debug format	2026-05-24 14:06:39 +02:00
Empire Phoenix	d989b41bdd	wip website docu	2026-05-21 07:16:39 +02:00
EmpirePhoenix	ac8305953a	Merge pull request 'refactor/mkstatic-util' (#22 ) from refactor/mkstatic-util into develop Reviewed-on: #22	2026-05-18 00:29:52 +02:00
EmpirePhoenix	d1076145c4	Merge branch 'develop' into refactor/mkstatic-util	2026-05-18 00:29:41 +02:00
EmpirePhoenix	cf32f7e05d	Merge pull request 'refactor/network-module' (#21 ) from refactor/network-module into develop Reviewed-on: #21	2026-05-18 00:29:14 +02:00
EmpirePhoenix	5e08820276	Merge pull request 'refactor/mqtt-module' (#20 ) from refactor/mqtt-module into develop Reviewed-on: #20	2026-05-18 00:28:12 +02:00
ju6ge	d2a659638d	refactor: create util module with shared mk_static - use crate::util::mk_static in network module - use crate::util::mk_static in mqtt module - use crate::util::mk_static in hal module - remove dead mk_static macro from esp module	2026-05-17 12:39:41 +02:00
ju6ge	40f99870cf	refactor: move try_connect_wifi_sntp_mqtt to network module	2026-05-17 12:30:43 +02:00
ju6ge	ac200af7a9	refactor: move wifi to network module	2026-05-17 12:29:57 +02:00
ju6ge	9d57805502	refactor: move wifi_ap to network module	2026-05-17 12:27:54 +02:00
ju6ge	bafc86681c	refactor: move sntp to network module	2026-05-17 12:24:39 +02:00
ju6ge	5f9db41d65	refactor: move run_dhcp to network module	2026-05-17 12:22:07 +02:00
ju6ge	ba654a904b	refactor: move net_task to network module	2026-05-17 12:21:32 +02:00
ju6ge	cd4d0cc683	refactor: create network module - move NetworkMode and SntpMode enums	2026-05-17 12:19:22 +02:00
ju6ge	2cfb2607a9	refactor: move Solar struct to mqtt module	2026-05-10 02:38:50 +02:00
ju6ge	271c1a1383	refactor: move PumpInfo struct to mqtt module	2026-05-10 02:38:43 +02:00
ju6ge	a02b84d732	refactor: create mqtt module with core MQTT statics and tasks	2026-05-10 02:34:16 +02:00
Empire Phoenix	b0f8bcc9da	Merge remote-tracking branch 'origin/develop' into develop # Conflicts: # Software/MainBoard/rust/src/hal/water.rs	2026-05-06 09:29:25 +02:00
Empire Phoenix	103859120c	Add initial TODO file with pending tasks for One Wire, Flow Sensor, and PlantProfiles implementation	2026-05-06 09:27:19 +02:00
Empire Phoenix	403517fdb4	Suppress EMI noise on water flow sensor by filtering short pulses	2026-05-06 09:26:14 +02:00
Empire	11eb8713bf	more startup debugging	2026-05-05 18:04:00 +02:00
Empire Phoenix	d903c2bf52	Refactor flow meter logic: replace global mutex with per-instance `flow_unit` and use `critical-section` for thread safety.	2026-05-05 16:27:21 +02:00
Empire Phoenix	f8f76674ce	Refactor flow meter handling: switch `get_flow_meter_value` to `get_full_flow_count`, update related structs and logic to use `u32` for flow values.	2026-05-05 01:14:54 +02:00
Empire Phoenix	3cc5a0d2bd	dependency lock upgrade	2026-05-05 00:50:18 +02:00
Empire Phoenix	3be585ecbf	Refactor flow meter handling with interrupt-based logic and global state - Added `flow_interrupt_handler` for efficient interrupt processing. - Replaced per-instance `flow_counter` with global atomic and mutex-based state (`FLOW_OVERFLOW_COUNTER`, `FLOW_UNIT`). - Updated flow meter functions to leverage the new architecture for better modularity and thread safety. - Switched debugging output from `println!` to `log` for improved logging consistency.	2026-05-05 00:50:18 +02:00
Empire Phoenix	5b1a945ac3	Replace blocking `http_server` call with async task using `spawner`	2026-05-05 00:50:18 +02:00
Empire Phoenix	f4e050d413	Add `ChecksumError` handling to `FatError` conversion	2026-05-05 00:50:18 +02:00
Empire Phoenix	776db785c4	Update hardware and firmware documentation for new modules and features - Removed outdated TODOs and legacy references in hardware documentation. - Added details on the new CH32V203-based Sensor Module for CAN bus soil moisture sensors. - Documented updates to the Battery Management System (CH32V203-based) replacing the older bq34z100 design. - Refined sensor, pump, and power module descriptions with updated specifications. - Expanded firmware documentation to include Rust-based ESP32-C6 platform details, new OTA procedure, and MQTT telemetry topics. - Simplified toolchain setup and compilation process with updated scripts and instructions.	2026-05-05 00:50:18 +02:00
Kai Börnert	ef0ec47d92	Improve CAN bus robustness: adjust NART, add transmission delays for error recovery.	2026-05-04 17:44:54 +02:00
Empire Phoenix	0ed9d6bb57	Adjust timeouts and constants for improved moisture sensor and backup management accuracy - Increased CAN measurement timeout to 5000ms for reliability. - Updated `SAVEGAME_SLOT_SIZE` usage in backup handling for consistency. - Refined moisture sensor frequency thresholds for better sensor calibration (400Hz-70kHz).	2026-05-03 21:03:13 +02:00
Empire Phoenix	4771a77686	Merge branch 'test_new_storage' into develop # Conflicts: # Software/MainBoard/rust/src/main.rs	2026-05-03 14:42:08 +02:00
Empire Phoenix	eef165b6de	Track overcurrent issues during pump operation - Added `overcurrent_ma` field to pump results for capturing overcurrent data. - Enhanced pumping logic to record and propagate overcurrent issues per plant. - Updated `PumpState` and `PlantState` to handle overcurrent errors.	2026-05-02 01:38:30 +02:00
Empire Phoenix	1ace878488	Refactor `extra1` to `fertilizer_pump` in HAL and main logic - Renamed `extra1` method and related calls to `fertilizer_pump` for clarity and better domain alignment. - Updated HAL implementation to control `extra2` GPIO for fertilizer pump operations. - Added build script trigger to refresh `VERGEN_BUILD_TIMESTAMP` on each build.	2026-05-01 13:11:47 +02:00
Empire Phoenix	a30d59605d	Improve CAN bus error handling and logging - Enhanced error detection with detailed status logging for bus-off, error warning, and passive errors. - Added line breaks to CAN and RX error logs for better readability. - Refined CAN transmission logic and error feedback, including buffer overflow handling. - Simplified firmware timestamp frame creation and ensured successful sending.	2026-05-01 13:11:37 +02:00
Empire Phoenix	2ee3615dcd	switch fertilizer to extra 1	2026-05-01 10:45:54 +02:00
Empire	db0f7daa4c	feat: add fertilizer cooldown functionality with web UI, HAL integration, and configuration support	2026-04-30 22:09:04 +02:00
Empire	6809a37d9d	feat: add fertilizer pump functionality with configuration, web UI, and HAL integration	2026-04-30 20:44:07 +02:00
Empire	0ca09ed498	feat: add fertilizer pump test functionality with web integration and HAL support	2026-04-30 20:37:07 +02:00
Empire	542ff578bc	feat: add bus-off error handling in CAN error status register with error blinking loop	2026-04-30 20:27:38 +02:00
Empire	2e16163b0e	feat: implement interleaved sensor measurement timing with slot-based coordination to prevent overlap	2026-04-30 20:19:13 +02:00
Empire	9280bbb244	refactor: rename `deep_sleep` to `deep_sleep_ms` for consistency across the codebase	2026-04-30 20:09:48 +02:00
Kai Börnert	e0b8acd55c	Add firmware build timestamp support for sensors; update detection workflows and UI accordingly.	2026-04-27 16:46:24 +02:00
Kai Börnert	c04109a76c	Rename `/version` endpoint to `/firmware_info`; add heap memory statistics to firmware data and UI.	2026-04-27 15:46:29 +02:00
Kai Börnert	f0c9ed4e7f	Add live log buffering support and endpoint; enhance log display functionality.	2026-04-27 15:04:05 +02:00
Kai Börnert	3fa8077b81	Update button labels to clarify sensor identification actions in plant.html	2026-04-27 13:56:32 +02:00
Kai Börnert	7f0714914f	Add averaging over multiple windows for frequency measurement; optimize task yielding for USB stability.	2026-04-27 13:42:30 +02:00
Empire Phoenix	61806a5fa2	Add `mcutie` MQTT client implementation and improve library structure - Integrated `mcutie` library as a core MQTT client for device communication. - Added support for Home Assistant entities (binary sensor, button) via MQTT. - Implemented buffer management, async operations, and packet encoding/decoding. - Introduced structured error handling and device registration features. - Updated `Cargo.toml` with new dependencies and enabled feature flags for `serde` and `log`. - Enhanced logging macros with configurable options (`defmt` or `log`). - Organized codebase into modules (buffer, components, IO, publish, etc.) for better maintainability.	2026-04-27 09:39:29 +02:00
Empire Phoenix	016047ab23	Update `Water` HAL: enhance GPIO config with drive mode and input settings - Added `DriveMode` configuration and input enablement for `one_wire_pin`. - Improved GPIO initialization with `InputConfig` and default pull settings.	2026-04-26 21:24:51 +02:00
Empire Phoenix	eb276cfa68	Refactor HAL modules: update async support in `Water` module and reorganize `detect_sensors` logic - Replaced `Blocking` with `Async` for ADC operations in `Water` module. - Improved `detect_sensors` implementation with better structure for sensor messages and autodetection. - Updated tank ADC sampling to yield between readings, improving efficiency.	2026-04-26 21:01:27 +02:00
Empire Phoenix	f1c85d1d74	Migrate serialization from Bincode to Postcard - Replaced Bincode with Postcard for serialization/deserialization across configs and save operations. - Simplified struct derives by removing `bincode`-specific traits. - Updated `Cargo.toml` and `Cargo.lock` to include `postcard` and dependencies. - Added padding stripping for deserialization and improved error handling. - Adjusted serialization logic in `savegame_manager.rs` and related modules.	2026-04-26 20:46:52 +02:00
Empire Phoenix	097aff5360	Switch savegame serialization format from Bincode to custom parsing - Replaced Bincode-based serialization/deserialization with a custom save format for better control. - Introduced save header with magic bytes, timestamp handling, and UTF-8 validation. - Enhanced error handling for save parsing and increased format flexibility. - Removed	2026-04-26 20:31:56 +02:00
Empire Phoenix	fc0e18da56	Integrate `mcutie` library for MQTT functionality - Added `mcutie` as a dependency in `Cargo.toml` and updated `Cargo.lock`. - Replaced commented-out MQTT logic with fully implemented functionality in `esp.rs`. - Enhanced MQTT publish and subscription handling with configurable topics and error handling. - Updated MQTT connection logic to improve reliability and logging.	2026-04-26 19:56:16 +02:00
Empire Phoenix	2e4eb283b5	Add `AGENTS.md` to document repository structure and development guidelines - Introduced `AGENTS.md` to provide an overview of the repository layout and working conventions. - Included guidance for firmware, hardware, and website contributions. - Added validation, file hygiene, and handoff expectations for consistent development practices.	2026-04-26 19:47:07 +02:00
Empire Phoenix	cc92c82ac9	Fix incorrect `spawn` function call and update dependencies - Corrected usage of `spawner.spawn` by fixing misplaced error propagation. - Updated `Cargo.lock` with new and upgraded dependencies, including `base64`, `darling`, and `smoltcp` upgrades.	2026-04-26 19:46:46 +02:00
Empire Phoenix	b8f01f0de9	Remove unused dependencies and imports, cleanup `Cargo.lock` - Removed `smoltcp`, `defmt`, and associated dependencies as they are no longer used. - Updated `Cargo.toml` to exclude unused features from `esp-radio`. - Cleaned up imports in `esp.rs` for better clarity and consistency.	2026-04-26 19:08:18 +02:00
Empire	79daecf97d	add lock for now, as otherwise it wont build	2026-04-26 16:06:13 +02:00
Empire Phoenix	6b4fd3f701	Add `DeepSleep` log message and improve formatting consistency - Introduced `DeepSleep` log message for tracking system sleep events. - Updated MQTT topic to use `/state` instead of `/firmware/state`. - Improved code formatting for enhanced readability and maintainability.	2026-04-17 00:31:21 +02:00
Empire Phoenix	3157ba7e76	Merge branch 'test_new_storage' of ssh://git.mannheim.ccc.de:1337/C3MA/PlantCtrl into test_new_storage	2026-04-16 23:58:38 +02:00
Empire Phoenix	2493507304	Refactor plant state handling and moisture interpretation - Replaced `read_hardware_state` with `interpret_raw_values` for better abstraction and clarity. - Enhanced error handling by introducing `NoMessage` and `NotExpectedMessage` states. - Updated moisture sensor logic to differentiate expected and unexpected messages. - Renamed and refactored enum fields for consistency (`raw_hz` to `hz`). - Minor imports and formatting optimizations.	2026-04-16 23:58:23 +02:00
Empire	0f6cb5243c	feat: add pump corrosion protection feature, extend error handling for pump operations, and enhance configuration options	2026-04-16 21:56:46 +02:00
Empire	b740574c68	refactor: add timezone support to `wait_infinity`, improve MQTT updates in config mode, and minor cleanup	2026-04-16 20:42:08 +02:00
Empire Phoenix	6a71ac4234	Improve flash operation logging and serialization padding - Added detailed logging for flash write and erase operations. - Ensured serialized save data is aligned to 4-byte boundaries.	2026-04-14 00:19:18 +02:00
Kai Börnert	8ce00c9d95	Refactor async logging to synchronous; improve error handling consistency across modules.	2026-04-13 17:03:47 +02:00
Empire	964bdb0454	fix: handle non-200 responses in config update, ensure progress removal runs only on success	2026-04-13 12:38:00 +02:00
Empire	12405d1bef	cleanup	2026-04-12 22:15:52 +02:00
Empire Phoenix	0e3786a588	Add `InterceptorLogger` for async log capturing and enhanced debugging - Implemented `InterceptorLogger` to enable async and sync log capture. - Integrated log interception for easier diagnostics and debugging. - Allowed log redirection to serial output via `esp_println`.	2026-04-12 20:45:36 +02:00
Empire Phoenix	b26206eb96	Introduce watchdog and serialization improvements - Added watchdog timer for improved system stability and responsiveness. - Switched save data serialization to Bincode for better efficiency. - Enhanced compatibility by supporting fallback to older JSON format. - Improved logging during flash operations for easier debugging. - Simplified SavegameManager by managing storage directly.	2026-04-12 20:38:52 +02:00
Empire Phoenix	95f7488fa3	Add save timestamp support and log interceptor for enhanced debugging - Introduced `created_at` metadata for saves, enabling timestamp tracking. - Added `InterceptorLogger` to capture logs, aiding in error diagnostics. - Updated web UI to display save creation timestamps. - Improved save/load functionality to maintain compatibility with older formats.	2026-04-11 22:40:25 +02:00
Empire	0d7074bd89	save tests	2026-04-11 21:34:48 +02:00
Empire	bc25fef5ec	refactor: consolidate logging and time handling, remove `TIME_ACCESS` and `LOG_ACCESS`	2026-04-10 18:53:30 +02:00
Empire	301298522b	remove: eliminate file management and LittleFS-based filesystem, implement savegame management for JSON config slots with wear-leveling	2026-04-08 22:12:55 +02:00
Empire Phoenix	1da6d54d7a	new backup adjustments	2026-04-06 19:51:46 +02:00
Empire Phoenix	0ad7a58219	Improve error handling, ensure robust defaults, and eliminate unsafe unwraps/expectations across modules.	2026-04-06 15:26:52 +02:00
Empire Phoenix	07aed02fe7	fix mqtt not starting webserver	2026-04-06 12:54:18 +02:00
Empire	aef0ffd5a1	add v1 revisio of bms	2026-04-06 12:40:52 +02:00
Empire	4d4fcbe33b	store backup now in binary, and let backend serialize/deserialize	2026-04-05 13:30:11 +02:00
Empire	1fa765a5d8	adjust can to hopefull work better	2026-04-01 21:43:16 +02:00
Empire Phoenix	eaa65637f1	Enhance error handling and robustness in TWAI-based sensor detection and moisture measurement.	2026-04-01 01:24:04 +02:00
Empire Phoenix	f1dadd7e6e	massivly reduce canbus speed	2026-03-31 18:24:23 +02:00
Empire Phoenix	7121dd0fae	Add silent mode for sensor detection and moisture measurement - Introduced the `silent` parameter to prevent UI progress updates during automatic operations. - Enhanced CAN robustness with improved bus-off management, retransmission settings, and jitter tolerance. - Added auto-refresh functionality for plant moisture and sensor detection with configurable enablement.	2026-03-29 14:21:12 +02:00
Empire	4cf5f6d151	fix: correctly retrieve and display IP address for both IPv4 and IPv6 configurations	2026-03-27 20:45:24 +01:00
Empire	9de5236e65	fix tank sensor	2026-03-27 10:45:33 +01:00
				`@@ -0,0 +1 @@`
				`{"ARCHIVE_NAME": "", "EXTRA_LAYERS": "", "ALL_ACTIVE_LAYERS": false, "EXTEND_EDGE_CUT": false, "ALTERNATIVE_EDGE_CUT": false, "AUTO TRANSLATE": true, "AUTO FILL": true, "EXCLUDE DNP": false, "OPEN BROWSER": true, "NO_BACKUP_OPT": false}`