Merge pull request #2739 from proddy/dev

update tests

.github/ISSUE_TEMPLATE/bug_report.md

@@ -21,7 +21,7 @@ _Make sure your have performed every step and checked the applicable boxes befor
 
 - [ ] Searched the issue in [issues](https://github.com/emsesp/EMS-ESP32/issues)
 - [ ] Searched the issue in [discussions](https://github.com/emsesp/EMS-ESP32/discussions)
-- [ ] Searched the issue in the [docs](https://emsesp.org/Troubleshooting/)
+- [ ] Searched the issue in the [docs](https://docs.emsesp.org/Troubleshooting/)
 - [ ] Searched the issue in the [chat](https://discord.gg/3J3GgnzpyT)
 - [ ] Provide the System information in the area below, taken from `http://<IP>/api/system`
 

.github/ISSUE_TEMPLATE/config.yml

@@ -1,7 +1,7 @@
 blank_issues_enabled: false
 contact_links:
   - name: EMS-ESP Docs
-    url: https://emsesp.org
+    url: https://docs.emsesp.org
     about: All the information related to EMS-ESP.
   - name: EMS-ESP Discussions and Support
     url: https://github.com/emsesp/EMS-ESP32/discussions

.github/workflows/dev_release.yml

@@ -64,7 +64,29 @@ jobs:
       - name: Commit the generated files
         uses: stefanzweifel/git-auto-commit-action@v5
         with:
-          commit_message: "chore: update generated files for v${{steps.build_info.outputs.VERSION}}"
+          commit_message: "chore: update generated files"
+
+      - name: Configure Git
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+
+      - name: Check for changes and commit
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "Changes detected, committing..."
+            git add .
+            git commit -m "Auto-commit build artifacts and configuration updates
+
+            - Updated build configurations
+            - Generated build artifacts
+            - Version: ${{steps.build_info.outputs.VERSION}}"
+            
+            echo "Pushing changes to repository..."
+            git push origin dev
+          else
+            echo "No changes to commit"
+          fi
 
       - name: Create GitHub Release
         id: 'automatic_releases'

.gitignore

@@ -2,6 +2,7 @@
 .vscode/c_cpp_properties.json
 .vscode/extensions.json
 .vscode/launch.json
+.vscode/settings.json
 
 # c++ compiling
 .clang_complete
@@ -72,6 +73,4 @@ logs/*
 sdkconfig.*
 sdkconfig_tasmota_esp32
 pnpm-lock.yaml
-.cache/
-interface/.tsbuildinfo
-test/test_api/package-lock.json
+package.json

CHANGELOG.md

@@ -5,92 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [3.8.0]
-
-## Added
-
-- analogsensor types: NTC and RGB-Led
-- Flag for HMC310 [#2465](https://github.com/emsesp/EMS-ESP32/issues/2465)
-- boiler auxheatersource [#2489](https://github.com/emsesp/EMS-ESP32/discussions/2489)
-- thermostat last error for RC100/300 [#2501](https://github.com/emsesp/EMS-ESP32/issues/2501)
-- boiler 0xC6 telegram [#1963](https://github.com/emsesp/EMS-ESP32/issues/1963)
-- CS6800i changes [#2448](https://github.com/emsesp/EMS-ESP32/issues/2448), [#2449](https://github.com/emsesp/EMS-ESP32/issues/2449)
-- charging pump [#2544](https://github.com/emsesp/EMS-ESP32/issues/2544)
-- hybrid CSH5800iG [#2569](https://github.com/emsesp/EMS-ESP32/issues/2569)
-- added EMS Device details to Home Assistant MQTT Discovery
-- disinfection command [#2601](https://github.com/emsesp/EMS-ESP32/issues/2601)
-- added new board profile for upcoming BBQKees E32V2.2
-- set differential pressure entity in Mixer device
-- set set climate action cooling/heating in HA [#2583](https://github.com/emsesp/EMS-ESP32/issues/2583)
-- Internal sensors of E32V2_2
-- FW200 display options [#2610](https://github.com/emsesp/EMS-ESP32/discussions/2610)
-- CR11 mode settings OFF/MANUAL depends on selTemp [#2437](https://github.com/emsesp/EMS-ESP32/issues/2437)
-- implemented eFuse settings for BBQKees boards to store model type and ESP chipset
-- Analogsensors for pulse output [#2624](https://github.com/emsesp/EMS-ESP32/discussions/2624)
-- Analogsensors frequency input [#2631](https://github.com/emsesp/EMS-ESP32/discussions/2631)
-- SRC plus thermostats [#2636](https://github.com/emsesp/EMS-ESP32/issues/2636)
-- Greenstar 2000 [#2645](https://github.com/emsesp/EMS-ESP32/issues/2645)
-- RC3xx `dhw modetype` [#2659](https://github.com/emsesp/EMS-ESP32/discussions/2659)
-- new boiler entities VR0,VR1, compressor speed [#2669](https://github.com/emsesp/EMS-ESP32/issues/2669)
-- solar temperature TS16 [#2690](https://github.com/emsesp/EMS-ESP32/issues/2690)
-- pumpmode enum for HT3 boilers, add commands for manual defrost, chimneysweeper [#2727](https://github.com/emsesp/EMS-ESP32/issues/2727)
-- pid settings [#2735](https://github.com/emsesp/EMS-ESP32/issues/2735)
-- refresh MQTT button added to MQTT Settings page
-- heating assistance, rounding custum settings [#2763](https://github.com/emsesp/EMS-ESP32/discussions/2763)
-- added counter 0..2 for short pulses, high frequency [#2758](https://github.com/emsesp/EMS-ESP32/issues/2758)
-- added LWT (Last Will and Testament) to MQTT entities in Home Assistant
-- added api/metrics endpoint for prometheus integration by @gr3enk [#2774](https://github.com/emsesp/EMS-ESP32/pull/2774)
-- added RTL8201 to eth phy list [#2800](https://github.com/emsesp/EMS-ESP32/issues/2800)
-- added partitions to Web UI Version page, so previous firmware versions can be installed [#2837](https://github.com/emsesp/EMS-ESP32/issues/2837)
-- button pressures show LED. On a long press (10 seconds) the LED flashes for 5 seconds to indicate a factory reset is about to happen. [#2848](https://github.com/emsesp/EMS-ESP32/issues/2848)
-- added `txpause` command to pause the TX, by setting Txmode to 0 (disabled) [#2850](https://github.com/emsesp/EMS-ESP32/issues/2850)
-
-## Fixed
-
-- dhw/switchtime [#2490](https://github.com/emsesp/EMS-ESP32/issues/2490)
-- switch to secure mqtt [#2492](https://github.com/emsesp/EMS-ESP32/issues/2492)
-- update link buttons [#2497](https://github.com/emsesp/EMS-ESP32/issues/2497)
-- refresh scheduler states [#2502](https://github.com/emsesp/EMS-ESP32/discussions/2502)
-- also rebuild HA config on mqtt connect for scheduler, custom and shower
-- FB100 controls the hc, not the master [#2510](https://github.com/emsesp/EMS-ESP32/issues/2510)
-- IPM DHW module, [#2524](https://github.com/emsesp/EMS-ESP32/issues/2524)
-- charge optimization [#2543](https://github.com/emsesp/EMS-ESP32/issues/2543)
-- shower active state retained, shows correctly in HA
-- MQTT Command Topic with slashes [#2571](https://github.com/emsesp/EMS-ESP32/issues/2571)
-- Add pulsed water meter input to V1.3 gateway with Lilygo S3 [#2550](https://github.com/emsesp/EMS-ESP32/issues/2550)
-- fix missing long 10-second press of Button to perform a factory reset
-- fix wwMaxPower on Junkers ZBS14 [#2609](https://github.com/emsesp/EMS-ESP32/issues/2609)
-- ventilation bypass state from telegram 0x55C [#1197](https://github.com/emsesp/EMS-ESP32/issues/1197)
-- set selflowtemp for ems+ boilers [#2641](https://github.com/emsesp/EMS-ESP32/discussions/2641)
-- syslog timestamp [#2704](https://github.com/emsesp/EMS-ESP32/issues/2704)
-- fixed FS format command [#2720](https://github.com/emsesp/EMS-ESP32/discussions/2720)
-- dhw priority setting to boiler and mixer, telegrams 0x2CC, 0x2CD, etc.
-- check for valid GPIOs when board profile is changed [#2841](https://github.com/emsesp/EMS-ESP32/issues/2841)
-
-## Changed
-
-- show console log with ISO date/time [#2533](https://github.com/emsesp/EMS-ESP32/discussions/2533)
-- removed ESP32 CPU temperature
-- updated core libraries like AsyncTCP, AsyncWebServer and Modbus
-- remove command `scan deep`
-- ignore repeated `forceheatingoff` commands [#2641](https://github.com/emsesp/EMS-ESP32/discussions/2641)
-- optimized web for better performance by adding lazy loading and caching
-- internal system analog sensors (core_voltage, supply_voltage and gateway_temperature) cannot be accidentally removed
-- double click button reconnects EMS-ESP to AP
-- place system message command in side scheduler loop to reduce stack memory usage by 2KB
-- syslog mark interval set to 1 hour
-- handle process_telegram in oneloop
-- improved GPIO validation for Analog Sensors and System GPIOs
-- entities with no values are greyed out in the Web UI in the Customization page
-- added System Status to Web Status page
-- show number on entities and supported languages in log on boot
-- on tx read fail delay the 3rd. retry 2 sec
-- move vectors and lists to PSRAM
-- removed unused last topic/payload echo-check
-- added Home Assistant device details to MQTT Discovery for all devices
-- device_class and state_class changes for HA MQTT Discovery [#2825](https://github.com/emsesp/EMS-ESP32/issues/2825)
-
-
 ## [3.7.2] 22 March 2025
 
 ## Added
@@ -171,7 +85,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - The automatically generated temperature sensor ID has replaced dashes (`-`) with underscores (`_`) to be compatible with Home Assistant.
 - `api/system/info` has it's JSON key names changed to camelCase syntax.
 
-For more details go to [emsesp.org](https://emsesp.org/).
+For more details go to [docs.emsesp.org](https://docs.emsesp.org/).
 
 ## Added
 

CHANGELOG_LATEST.md

@@ -1,3 +1,68 @@
 # Changelog
 
-For more details go to [emsesp.org](https://emsesp.org/).
+For more details go to [docs.emsesp.org](https://docs.emsesp.org/).
+
+## [3.7.3]
+
+## Added
+
+- analogsensor types: NTC and RGB-Led
+- Flag for HMC310 [#2465](https://github.com/emsesp/EMS-ESP32/issues/2465)
+- boiler auxheatersource [#2489](https://github.com/emsesp/EMS-ESP32/discussions/2489)
+- thermostat last error for RC100/300 [#2501](https://github.com/emsesp/EMS-ESP32/issues/2501)
+- boiler 0xC6 telegram [#1963](https://github.com/emsesp/EMS-ESP32/issues/1963)
+- CS6800i changes [#2448](https://github.com/emsesp/EMS-ESP32/issues/2448), [#2449](https://github.com/emsesp/EMS-ESP32/issues/2449)
+- charging pump [#2544](https://github.com/emsesp/EMS-ESP32/issues/2544)
+- hybrid CSH5800iG [#2569](https://github.com/emsesp/EMS-ESP32/issues/2569)
+- add EMS Device details to Home Assistant MQTT Discovery
+- disinfection command [#2601](https://github.com/emsesp/EMS-ESP32/issues/2601)
+- added new board profile for upcoming BBQKees E32V2.2
+- set differential pressure entity in Mixer device
+- set set climate action cooling/heating in HA [#2583](https://github.com/emsesp/EMS-ESP32/issues/2583)
+- Internal sensors of E32V2_2
+- FW200 display options [#2610](https://github.com/emsesp/EMS-ESP32/discussions/2610)
+- CR11 mode settings OFF/MANUAL depends on selTemp [#2437](https://github.com/emsesp/EMS-ESP32/issues/2437)
+- implemented eFuse settings for BBQKees boards to store model type and ESP chipset
+- Analogsensors for pulse output [#2624](https://github.com/emsesp/EMS-ESP32/discussions/2624)
+- Analogsensors frequency input [#2631](https://github.com/emsesp/EMS-ESP32/discussions/2631)
+- SRC plus thermostats [#2636](https://github.com/emsesp/EMS-ESP32/issues/2636)
+- Greenstar 2000 [#2645](https://github.com/emsesp/EMS-ESP32/issues/2645)
+- RC3xx `dhw modetype` [#2659](https://github.com/emsesp/EMS-ESP32/discussions/2659)
+- new boiler entities VR0,VR1, compressor speed [#2669](https://github.com/emsesp/EMS-ESP32/issues/2669)
+- solar temperature TS16 [#2690](https://github.com/emsesp/EMS-ESP32/issues/2690)
+- pumpmode enum for HT3 boilers, add commands for manual defrost, chimneysweeper [#2727](https://github.com/emsesp/EMS-ESP32/issues/2727)
+- pid settings [#2735](https://github.com/emsesp/EMS-ESP32/issues/2735)
+
+## Fixed
+
+- dhw/switchtime [#2490](https://github.com/emsesp/EMS-ESP32/issues/2490)
+- switch to secure mqtt [#2492](https://github.com/emsesp/EMS-ESP32/issues/2492)
+- update link buttons [#2497](https://github.com/emsesp/EMS-ESP32/issues/2497)
+- refresh scheduler states [#2502](https://github.com/emsesp/EMS-ESP32/discussions/2502)
+- also rebuild HA config on mqtt connect for scheduler, custom and shower
+- FB100 controls the hc, not the master [#2510](https://github.com/emsesp/EMS-ESP32/issues/2510)
+- IPM DHW module, [#2524](https://github.com/emsesp/EMS-ESP32/issues/2524)
+- charge optimization [#2543](https://github.com/emsesp/EMS-ESP32/issues/2543)
+- shower active state retained, shows correctly in HA
+- MQTT Command Topic with slashes [#2571](https://github.com/emsesp/EMS-ESP32/issues/2571)
+- Add pulsed water meter input to V1.3 gateway with Lilygo S3 [#2550](https://github.com/emsesp/EMS-ESP32/issues/2550)
+- fix missing long 10-second press of Button to perform a factory reset
+- fix wwMaxPower on Junkers ZBS14 [#2609](https://github.com/emsesp/EMS-ESP32/issues/2609)
+- ventilation bypass state from telegram 0x55C [#1197](https://github.com/emsesp/EMS-ESP32/issues/1197)
+- set selflowtemp for ems+ boilers [#2641](https://github.com/emsesp/EMS-ESP32/discussions/2641)
+- syslog timestamp [#2704](https://github.com/emsesp/EMS-ESP32/issues/2704)
+- fixed FS format command [#2720](https://github.com/emsesp/EMS-ESP32/discussions/2720)
+- dhw priority setting to boiler and mixer, telegrams 0x2CC, 0x2CD, etc.
+
+## Changed
+
+- show console log with ISO date/time [#2533](https://github.com/emsesp/EMS-ESP32/discussions/2533)
+- remove ESP32 CPU temperature
+- updated core libraries like AsyncTCP, AsyncWebServer and Modbus
+- remove command `scan deep`
+- ignore repeated `forceheatingoff` commands [#2641](https://github.com/emsesp/EMS-ESP32/discussions/2641)
+- optimized web for better performance by adding lazy loading and caching
+- internal system analog sensors (core_voltage, supply_voltage and gateway_temperature) cannot be accidentally removed
+- double click button reconnects EMS-ESP to AP
+- place system message command in side scheduler loop to reduce stack memory usage by 2KB
+- syslog mark interval set to 1 hour

CONTRIBUTING.md

@@ -6,7 +6,7 @@ Everybody is welcome and invited to contribute to the EMS-ESP Project by:
 
 - providing Pull Requests (Features, Fixes, suggestions)
 - testing new released features and report issues on your EMS equipment
-- contributing to missing [documentation](https://emsesp.org)
+- contributing to missing [documentation](https://docs.emsesp.org)
 
 This document describes rules that are in effect for this repository, meant for handling issues by contributors in the issue tracker and PRs.
 

Makefile

@@ -21,14 +21,13 @@ endif
 
 # Optimize parallel build configuration
 UNAME_S := $(shell uname -s)
-JOBS ?= 1
 ifeq ($(UNAME_S),Linux)
     EXTRA_CPPFLAGS = -D LINUX
-	JOBS := $(shell nproc)
+	JOBS ?= $(shell nproc)
 endif
 ifeq ($(UNAME_S),Darwin)
     EXTRA_CPPFLAGS = -D OSX -Wno-tautological-constant-out-of-range-compare
-	JOBS := $(shell sysctl -n hw.ncpu)
+	JOBS ?= $(shell sysctl -n hw.ncpu)
 endif
 
 # Set optimal parallel build settings
@@ -47,8 +46,8 @@ MAKEFLAGS += -j$(JOBS) -l$(shell echo $$(($(JOBS) * 2)))
 #----------------------------------------------------------------------
 TARGET    := emsesp
 BUILD     := build
-SOURCES   := src/core src/devices src/web src/test lib_standalone lib/semver lib/espMqttClient/src lib/espMqttClient/src/*         lib/ArduinoJson/src lib/uuid-common/src lib/uuid-console/src lib/uuid-log/src   lib/PButton 
-INCLUDES  := src/core src/devices src/web src/test lib_standalone lib/* lib/semver lib/espMqttClient/src lib/espMqttClient/src/Transport lib/ArduinoJson/src lib/uuid-common/src lib/uuid-console/src lib/uuid-log/src   lib/uuid-telnet/src lib/uuid-syslog/src
+SOURCES   := src/core src/devices src/web src/test       lib_standalone lib/semver lib/espMqttClient/src lib/espMqttClient/src/*         lib/ArduinoJson/src lib/uuid-common/src lib/uuid-console/src lib/uuid-log/src   lib/PButton 
+INCLUDES  := src/core src/devices src/web src/test lib/* lib_standalone lib/semver lib/espMqttClient/src lib/espMqttClient/src/Transport lib/ArduinoJson/src lib/uuid-common/src lib/uuid-console/src lib/uuid-log/src   lib/uuid-telnet/src lib/uuid-syslog/src
 LIBRARIES :=
 
 CPPCHECK = cppcheck
@@ -67,7 +66,7 @@ DEFINES += -DARDUINOJSON_ENABLE -DARDUINOJSON_ENABLE_ARDUINO_STRING -DARDUINOJSO
 DEFINES += -DEMSESP_STANDALONE -DEMSESP_TEST -DEMSESP_DEBUG -DEMC_RX_BUFFER_SIZE=1500
 DEFINES += $(ARGS)
 
-DEFAULTS = -DEMSESP_DEFAULT_LOCALE=\"en\" -DEMSESP_DEFAULT_TX_MODE=8 -DEMSESP_DEFAULT_VERSION=\"3.8.0-dev.0\" -DEMSESP_DEFAULT_BOARD_PROFILE=\"S32S3\"
+DEFAULTS = -DEMSESP_DEFAULT_LOCALE=\"en\" -DEMSESP_DEFAULT_TX_MODE=8 -DEMSESP_DEFAULT_VERSION=\"3.7.3-dev\" -DEMSESP_DEFAULT_BOARD_PROFILE=\"S32S3\"
 
 #----------------------------------------------------------------------
 # Sources & Files
@@ -138,7 +137,6 @@ DEPFLAGS   += -MF $(BUILD)/$*.d -MT $@
 LINK.o      = $(LD) $(LDFLAGS) $(LDLIBS) $^ -o $@
 COMPILE.c   = $(CC) $(C_STANDARD) $(CFLAGS) $(DEPFLAGS) -c $< -o $@
 COMPILE.cpp = $(CXX) $(CXX_STANDARD) $(CXXFLAGS) $(DEPFLAGS) -c $< -o $@
-COMPILE.s   = $(CC) $(CFLAGS) $(DEPFLAGS) -c $< -o $@
 
 #----------------------------------------------------------------------
 # Special Built-in Target
@@ -182,7 +180,6 @@ $(BUILD)/%.o: %.cpp
 
 $(BUILD)/%.o: %.s
 	@mkdir -p $(@D)
-	@$(ECHO) Compiling $@
 	@$(COMPILE.s)
 
 cppcheck: $(SOURCES)

README.md

@@ -15,7 +15,7 @@
   <a href="https://github.com/emsesp/EMS-ESP32/blob/dev/CONTRIBUTING.md">
     <img src="https://img.shields.io/badge/Contribute-ff4785?style=for-the-badge&logo=git&logoColor=white" alt="Contribute" />
   </a>
-  <a href="https://emsesp.org">
+  <a href="https://docs.emsesp.org">
     <img src="https://img.shields.io/badge/Documentation-0077b5?style=for-the-badge&logo=googledocs&logoColor=white" alt="Guides" />
   </a>
   <a href="https://discord.gg/3J3GgnzpyT">
@@ -60,17 +60,17 @@ It requires a small circuit to interface with the EMS bus which can be purchased
 
 ## 🚀&nbsp; **Installing**
 
-Head over to the [Installation Guide](https://emsesp.org/Installing) section of the documentation for instructions on how to install EMS-ESP.
+Head over to [download.emsesp.org](https://download.emsesp.org) for instructions on how to install EMS-ESP. There is also further details on which boards are supported in [this section](https://docs.emsesp.org/Installing/) of the documentation.
 
 ## 📋&nbsp; **Documentation**
 
-Visit [emsesp.org](https://emsesp.org) for more details on how to install and configure EMS-ESP. There is also a collection of Frequently Asked Questions and Troubleshooting tips with example customizations from the community.
+Visit [emsesp.org](https://docs.emsesp.org) for more details on how to install and configure EMS-ESP. There is also a collection of Frequently Asked Questions and Troubleshooting tips with example customizations from the community.
 
 ## 💬&nbsp; **Getting Support**
 
 To chat with the community reach out on our [Discord Server](https://discord.gg/3J3GgnzpyT).
 
-If you find an issue or have a request, see [how to request support](https://emsesp.org/Support/) on how to submit a bug report or feature request.
+If you find an issue or have a request, see [how to request support](https://docs.emsesp.org/Support/) on how to submit a bug report or feature request.
 
 ## 🎥&nbsp; **Live Demo**
 

boards/s3_32M_P.json

@@ -25,7 +25,7 @@
     "upload": {
       "flash_size": "32MB",
       "maximum_ram_size": 327680,
-      "maximum_size": 33554432,
+      "maximum_size": 16777216,
       "require_upload_port": true,
       "speed": 460800
     },

cspell.json

@@ -34,7 +34,6 @@
     "sdkconfig.*",
     "managed_components/**",
     "pnpm-*.yaml",
-    "vite.config.ts",
-    "lib/esp32-psram/**"
+    "vite.config.ts"
   ]
   }

interface/package.json

@@ -1,6 +1,6 @@
 {
   "name": "EMS-ESP",
-  "version": "3.8.0",
+  "version": "3.7.3",
   "description": "EMS-ESP WebUI",
   "homepage": "https://emsesp.org",
   "author": "proddy, emsesp.org",
@@ -17,55 +17,55 @@
     "preview-standalone": "typesafe-i18n --no-watch && vite build && concurrently -c \"auto\" \"pnpm:mock-rest\" \"vite preview\"",
     "standalone": "concurrently -c \"auto\" \"typesafe-i18n\" \"pnpm:mock-rest\" \"vite dev\"",
     "typesafe-i18n": "typesafe-i18n --no-watch",
-    "build_webUI": "typesafe-i18n --no-watch && vite build && node progmem-generator.js",
+    "webUI": "vite build && node progmem-generator.js",
     "format": "prettier -l -w '**/*.{ts,tsx,js,css,json,md}'",
     "lint": "eslint . --fix",
     "standalone-devcontainer": "concurrently -c \"auto\" \"typesafe-i18n\" \"pnpm:mock-rest\" \"vite --host\""
   },
   "dependencies": {
-    "@alova/adapter-xhr": "2.3.1",
+    "@alova/adapter-xhr": "2.2.1",
     "@emotion/react": "^11.14.0",
     "@emotion/styled": "^11.14.1",
-    "@mui/icons-material": "^7.3.6",
-    "@mui/material": "^7.3.6",
+    "@mui/icons-material": "^7.3.5",
+    "@mui/material": "^7.3.5",
     "@preact/compat": "^18.3.1",
     "@table-library/react-table-library": "4.1.15",
-    "alova": "3.4.1",
+    "alova": "3.3.4",
     "async-validator": "^4.2.5",
     "etag": "^1.8.1",
     "formidable": "^3.5.4",
     "jwt-decode": "^4.0.0",
     "magic-string": "^0.30.21",
-    "mime-types": "^3.0.2",
-    "preact": "^10.28.1",
-    "react": "^19.2.3",
-    "react-dom": "^19.2.3",
+    "mime-types": "^3.0.1",
+    "preact": "^10.27.2",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
     "react-icons": "^5.5.0",
-    "react-router": "^7.11.0",
+    "react-router": "^7.9.5",
     "react-toastify": "^11.0.5",
     "typesafe-i18n": "^5.26.2",
     "typescript": "^5.9.3"
   },
   "devDependencies": {
     "@babel/core": "^7.28.5",
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^9.39.1",
     "@preact/compat": "^18.3.1",
     "@preact/preset-vite": "^2.10.2",
     "@trivago/prettier-plugin-sort-imports": "^6.0.0",
-    "@types/node": "^25.0.3",
-    "@types/react": "^19.2.7",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.4",
     "@types/react-dom": "^19.2.3",
     "axe-core": "^4.11.0",
     "concurrently": "^9.2.1",
-    "eslint": "^9.39.2",
+    "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
-    "prettier": "^3.7.4",
+    "prettier": "^3.6.2",
     "rollup-plugin-visualizer": "^6.0.5",
     "terser": "^5.44.1",
-    "typescript-eslint": "^8.51.0",
-    "vite": "^7.3.0",
+    "typescript-eslint": "^8.46.4",
+    "vite": "^7.2.2",
     "vite-plugin-imagemin": "^0.6.1",
-    "vite-tsconfig-paths": "^6.0.3"
+    "vite-tsconfig-paths": "^5.1.4"
   },
-  "packageManager": "pnpm@10.27.0+sha512.72d699da16b1179c14ba9e64dc71c9a40988cbdc65c264cb0e489db7de917f20dcf4d64d8723625f2969ba52d4b7e2a1170682d9ac2a5dcaeaab732b7e16f04a"
+  "packageManager": "pnpm@10.22.0+sha512.bf049efe995b28f527fd2b41ae0474ce29186f7edcb3bf545087bd61fbbebb2bf75362d1307fda09c2d288e1e499787ac12d4fcb617a974718a6051f2eee741c"
 }

interface/src/App.tsx

@@ -8,6 +8,7 @@ import type { Locales } from 'i18n/i18n-types';
 import { loadLocaleAsync } from 'i18n/i18n-util.async';
 import { detectLocale, navigatorDetector } from 'typesafe-i18n/detectors';
 
+// Memoize available locales to prevent recreation on every render
 const AVAILABLE_LOCALES = [
   'de',
   'en',

interface/src/CustomTheme.tsx

@@ -11,15 +11,17 @@ import { createTheme } from '@mui/material/styles';
 
 import type { RequiredChildrenProps } from 'utils';
 
+// Memoize dialog style to prevent recreation
 export const dialogStyle = {
   '& .MuiDialog-paper': {
     borderRadius: '8px',
     borderColor: '#565656',
     borderStyle: 'solid',
-    borderWidth: '2px'
+    borderWidth: '1px'
   }
 } as const;
 
+// Memoize theme creation to prevent recreation
 const theme = responsiveFontSizes(
   createTheme({
     typography: {

interface/src/SignIn.tsx

@@ -1,4 +1,4 @@
-import { memo, useCallback, useContext, useEffect, useMemo, useState } from 'react';
+import { memo, useCallback, useContext, useMemo, useState } from 'react';
 import { toast } from 'react-toastify';
 
 import ForwardIcon from '@mui/icons-material/Forward';
@@ -81,15 +81,6 @@ const SignIn = memo(() => {
   // Memoize callback to prevent recreation on every render
   const submitOnEnter = useMemo(() => onEnterCallback(signIn), [signIn]);
 
-  // get rid of scrollbar
-  useEffect(() => {
-    const originalOverflow = document.body.style.overflow;
-    document.body.style.overflow = 'hidden';
-    return () => {
-      document.body.style.overflow = originalOverflow;
-    };
-  }, []);
-
   return (
     <Box
       display="flex"
@@ -111,27 +102,23 @@ const SignIn = memo(() => {
           width: '100%'
         })}
       >
-        <Typography mb={1} variant="h4">
-          {PROJECT_NAME}
-        </Typography>
+        <Typography variant="h4">{PROJECT_NAME}</Typography>
+
         <LanguageSelector />
-        <Box
-          mt={1}
-          display="flex"
-          flexDirection="column"
-          gap={1}
-          alignItems="center"
-        >
+
+        <Box display="flex" flexDirection="column" alignItems="center">
           <ValidatedTextField
             fieldErrors={fieldErrors || {}}
             disabled={processing}
             sx={{
-              width: '32ch'
+              width: 240
             }}
             name="username"
             label={LL.USERNAME(0)}
             value={signInRequest.username}
             onChange={updateLoginRequestValue}
+            margin="normal"
+            variant="outlined"
             slotProps={{
               input: {
                 autoCapitalize: 'none',
@@ -143,13 +130,14 @@ const SignIn = memo(() => {
             fieldErrors={fieldErrors || {}}
             disabled={processing}
             sx={{
-              width: '32ch'
+              width: 240
             }}
             name="password"
             label={LL.PASSWORD()}
             value={signInRequest.password}
             onChange={updateLoginRequestValue}
             onKeyDown={submitOnEnter}
+            variant="outlined"
           />
         </Box>
 

interface/src/app/main/Customizations.tsx

@@ -285,17 +285,13 @@ const Customizations = () => {
     return value as string;
   }
 
-  const isCommand = useCallback((de: DeviceEntity) => {
-    return de.n && de.n[0] === '!';
-  }, []);
-
   const formatName = useCallback(
     (de: DeviceEntity, withShortname: boolean) => {
       let name: string;
-      if (isCommand(de)) {
+      if (de.n && de.n[0] === '!') {
         name = de.t
-          ? `${LL.COMMAND(1)}: ${de.t} ${de.n?.slice(1)}`
-          : `${LL.COMMAND(1)}: ${de.n?.slice(1)}`;
+          ? `${LL.COMMAND(1)}: ${de.t} ${de.n.slice(1)}`
+          : `${LL.COMMAND(1)}: ${de.n.slice(1)}`;
       } else if (de.cn && de.cn !== '') {
         name = de.t ? `${de.t} ${de.cn}` : de.cn;
       } else {
@@ -547,7 +543,7 @@ const Customizations = () => {
     return (
       <>
         <Box color="warning.main">
-          <Typography variant="body2" mt={1} mb={1}>
+          <Typography variant="body2" mt={1}>
             <OptionIcon type="favorite" isSet={true} />={LL.CUSTOMIZATIONS_HELP_2()}
             &nbsp;&nbsp;
             <OptionIcon type="readonly" isSet={true} />={LL.CUSTOMIZATIONS_HELP_3()}
@@ -670,27 +666,14 @@ const Customizations = () => {
                       <EntityMaskToggle onUpdate={updateDeviceEntity} de={de} />
                     </Cell>
                     <Cell>
-                      <span
-                        style={{
-                          color:
-                            de.v === undefined && !isCommand(de) ? 'grey' : 'inherit'
-                        }}
+                      {formatName(de, false)}&nbsp;(
+                      <Link
+                        target="_blank"
+                        href={APIURL + selectedDeviceTypeNameURL + '/' + de.id}
                       >
-                        {formatName(de, false)}&nbsp;(
-                        <Link
-                          style={{
-                            color:
-                              de.v === undefined && !isCommand(de)
-                                ? 'grey'
-                                : 'primary'
-                          }}
-                          target="_blank"
-                          href={APIURL + selectedDeviceTypeNameURL + '/' + de.id}
-                        >
-                          {de.id}
-                        </Link>
-                        )
-                      </span>
+                        {de.id}
+                      </Link>
+                      )
                     </Cell>
                     <Cell>
                       {!(de.m & DeviceEntityMask.DV_READONLY) && formatValue(de.mi)}
@@ -743,9 +726,8 @@ const Customizations = () => {
       {devices && renderDeviceList()}
       {selectedDevice !== -1 && !rename && renderDeviceData()}
       {restartNeeded ? (
-        <MessageBox level="warning" message={LL.RESTART_TEXT(0)}>
+        <MessageBox my={2} level="warning" message={LL.RESTART_TEXT(0)}>
           <Button
-            sx={{ ml: 2 }}
             startIcon={<PowerSettingsNewIcon />}
             variant="contained"
             color="error"

interface/src/app/main/Dashboard.tsx

@@ -263,7 +263,7 @@ const Dashboard = memo(() => {
     return (
       <>
         {!data.connected && (
-          <MessageBox level="error" message={LL.EMS_BUS_WARNING()} />
+          <MessageBox mb={2} level="error" message={LL.EMS_BUS_WARNING()} />
         )}
 
         {data.connected && data.nodes.length > 0 && !hasFavEntities && (

interface/src/app/main/Devices.tsx

@@ -533,17 +533,19 @@ const Devices = memo(() => {
 
   const renderCoreData = () => (
     <>
-      {!coreData.connected ? (
-        <MessageBox level="error" message={LL.EMS_BUS_WARNING()} />
-      ) : (
-        <Box justifyContent="center" flexDirection="column">
-          <IconContext.Provider
-            value={{
-              color: 'lightblue',
-              size: '18',
-              style: { verticalAlign: 'middle' }
-            }}
-          >
+      <Box justifyContent="center" flexDirection="column">
+        <IconContext.Provider
+          value={{
+            color: 'lightblue',
+            size: '18',
+            style: { verticalAlign: 'middle' }
+          }}
+        >
+          {!coreData.connected && (
+            <MessageBox my={2} level="error" message={LL.EMS_BUS_WARNING()} />
+          )}
+
+          {coreData.connected && (
             <Table
               data={{ nodes: [...coreData.devices] }}
               select={device_select}
@@ -579,9 +581,9 @@ const Devices = memo(() => {
                 </>
               )}
             </Table>
-          </IconContext.Provider>
-        </Box>
-      )}
+          )}
+        </IconContext.Provider>
+      </Box>
     </>
   );
 

interface/src/app/main/Help.tsx

@@ -42,7 +42,8 @@ interface CustomSupport {
   html: string | null;
 }
 
-const DEFAULT_IMAGE_URL = 'https://emsesp.org/_media/images/installer.jpeg';
+// Constants moved outside component to prevent recreation
+const DEFAULT_IMAGE_URL = 'https://docs.emsesp.org/_media/images/installer.jpeg';
 
 const SUPPORT_BOX_STYLES: SxProps<Theme> = {
   borderRadius: 3,
@@ -115,7 +116,7 @@ const HelpComponent = () => {
   const helpLinks: HelpLink[] = useMemo(
     () => [
       {
-        href: 'https://emsesp.org',
+        href: 'https://docs.emsesp.org',
         icon: <MenuBookIcon />,
         label: () => LL.HELP_INFORMATION_1()
       },

interface/src/app/main/Sensors.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useContext, useMemo, useRef, useState } from 'react';
+import { useCallback, useContext, useMemo, useState } from 'react';
 import { toast } from 'react-toastify';
 
 import AddCircleOutlineOutlinedIcon from '@mui/icons-material/AddCircleOutlineOutlined';
@@ -54,6 +54,7 @@ const MS_PER_SECOND = 1000;
 const MS_PER_MINUTE = 60 * MS_PER_SECOND;
 const MS_PER_HOUR = 60 * MS_PER_MINUTE;
 const MS_PER_DAY = 24 * MS_PER_HOUR;
+const DEFAULT_GPIO = 21; // Safe GPIO for all platforms
 const MIN_TEMP_ID = -100;
 const MAX_TEMP_ID = 100;
 const GPIO_25 = 25;
@@ -127,21 +128,14 @@ const Sensors = () => {
   const [temperatureDialogOpen, setTemperatureDialogOpen] = useState<boolean>(false);
   const [analogDialogOpen, setAnalogDialogOpen] = useState<boolean>(false);
   const [creating, setCreating] = useState<boolean>(false);
-  const firstAvailableGPIO = useRef<number>(undefined);
 
   const { data: sensorData, send: fetchSensorData } = useRequest(readSensorData, {
     initialData: {
       ts: [],
       as: [],
       analog_enabled: false,
-      available_gpios: [] as number[],
       platform: 'ESP32'
     }
-  }).onSuccess((event) => {
-    // store the first available GPIO in a ref
-    if (event.data.available_gpios.length > 0) {
-      firstAvailableGPIO.current = event.data.available_gpios[0];
-    }
   });
 
   const { send: sendTemperatureSensor } = useRequest(
@@ -191,14 +185,10 @@ const Sensors = () => {
       sortToggleType: SortToggleType.AlternateWithReset,
       sortFns: {
         GPIO: (array) =>
-          [...array].sort(
-            (a, b) => ((a as AnalogSensor)?.g ?? 0) - ((b as AnalogSensor)?.g ?? 0)
-          ),
+          [...array].sort((a, b) => (a as AnalogSensor).g - (b as AnalogSensor).g),
         NAME: (array) =>
           [...array].sort((a, b) =>
-            ((a as AnalogSensor)?.n ?? '').localeCompare(
-              (b as AnalogSensor)?.n ?? ''
-            )
+            (a as AnalogSensor).n.localeCompare((b as AnalogSensor).n)
           ),
         TYPE: (array) =>
           [...array].sort((a, b) => (a as AnalogSensor).t - (b as AnalogSensor).t),
@@ -347,23 +337,19 @@ const Sensors = () => {
   }, [fetchSensorData]);
 
   const addAnalogSensor = useCallback(() => {
-    if (firstAvailableGPIO.current === undefined) {
-      toast.error('No available GPIO found');
-      return;
-    }
     setCreating(true);
     setSelectedAnalogSensor({
       id: Math.floor(Math.random() * (MAX_TEMP_ID - MIN_TEMP_ID) + MIN_TEMP_ID),
       n: '',
-      g: firstAvailableGPIO.current,
-      u: DeviceValueUOM.NONE,
+      g: DEFAULT_GPIO,
+      u: 0,
       v: 0,
       o: 0,
+      t: 0,
       f: 1,
-      t: AnalogType.DIGITAL_IN, // default to digital in 1
       d: false,
-      s: false,
-      o_n: ''
+      o_n: '',
+      s: false
     });
     setAnalogDialogOpen(true);
   }, []);
@@ -462,7 +448,7 @@ const Sensors = () => {
                 >
                   <Cell stiff>{as.g}</Cell>
                   <Cell>{as.n}</Cell>
-                  <Cell stiff>{AnalogTypeNames[as.t - 1]} </Cell>
+                  <Cell stiff>{AnalogTypeNames[as.t]} </Cell>
                   {(as.t === AnalogType.DIGITAL_OUT &&
                     as.g !== GPIO_25 &&
                     as.g !== GPIO_26) ||
@@ -470,7 +456,9 @@ const Sensors = () => {
                   as.t === AnalogType.PULSE ? (
                     <Cell stiff>{as.v ? LL.ON() : LL.OFF()}</Cell>
                   ) : (
-                    <Cell stiff>{formatValue(as.v, as.u)}</Cell>
+                    <Cell stiff>
+                      {as.t !== AnalogType.NOTUSED ? formatValue(as.v, as.u) : ''}
+                    </Cell>
                   )}
                 </Row>
               ))}
@@ -585,9 +573,12 @@ const Sensors = () => {
           onSave={onAnalogDialogSave}
           creating={creating}
           selectedItem={selectedAnalogSensor}
-          analogGPIOList={sensorData.available_gpios}
-          disabledTypeList={sensorData.exclude_types}
-          validator={analogSensorItemValidation(sensorData.as, selectedAnalogSensor)}
+          validator={analogSensorItemValidation(
+            sensorData.as,
+            selectedAnalogSensor,
+            creating,
+            sensorData.platform
+          )}
         />
       )}
       {sensorData?.analog_enabled === true && me.admin && (

interface/src/app/main/SensorsAnalogDialog.tsx

@@ -14,6 +14,7 @@ import {
   Grid,
   InputAdornment,
   MenuItem,
+  TextField,
   Typography
 } from '@mui/material';
 
@@ -34,8 +35,6 @@ interface DashboardSensorsAnalogDialogProps {
   onSave: (as: AnalogSensor) => void;
   creating: boolean;
   selectedItem: AnalogSensor;
-  analogGPIOList: number[];
-  disabledTypeList: number[];
   validator: Schema;
 }
 
@@ -45,8 +44,6 @@ const SensorsAnalogDialog = ({
   onSave,
   creating,
   selectedItem,
-  analogGPIOList,
-  disabledTypeList,
   validator
 }: DashboardSensorsAnalogDialogProps) => {
   const { LL } = useI18nContext();
@@ -68,16 +65,7 @@ const SensorsAnalogDialog = ({
 
   // Memoize helper functions to check sensor type conditions
   const isCounterOrRate = useMemo(
-    () =>
-      editItem.t === AnalogType.COUNTER ||
-      editItem.t === AnalogType.RATE ||
-      (editItem.t >= AnalogType.CNT_0 && editItem.t <= AnalogType.CNT_2),
-    [editItem.t]
-  );
-  const isCounter = useMemo(
-    () =>
-      editItem.t === AnalogType.COUNTER ||
-      (editItem.t >= AnalogType.CNT_0 && editItem.t <= AnalogType.CNT_2),
+    () => editItem.t >= AnalogType.COUNTER && editItem.t <= AnalogType.RATE,
     [editItem.t]
   );
   const isFreqType = useMemo(
@@ -91,13 +79,13 @@ const SensorsAnalogDialog = ({
       editItem.t === AnalogType.PWM_2,
     [editItem.t]
   );
-  const isDACOutGPIO = useMemo(
+  const isDigitalOutGPIO = useMemo(
     () =>
       editItem.t === AnalogType.DIGITAL_OUT &&
       (editItem.g === 25 || editItem.g === 26),
     [editItem.t, editItem.g]
   );
-  const isDigitalOutGPIO = useMemo(
+  const isDigitalOutNonGPIO = useMemo(
     () =>
       editItem.t === AnalogType.DIGITAL_OUT &&
       editItem.g !== 25 &&
@@ -108,18 +96,12 @@ const SensorsAnalogDialog = ({
   // Memoize menu items to avoid recreation on each render
   const analogTypeMenuItems = useMemo(
     () =>
-      AnalogTypeNames.map((val, i) => ({ name: val, value: i + 1 }))
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .map(({ name, value }) => (
-          <MenuItem
-            key={name}
-            value={value}
-            disabled={disabledTypeList?.includes(value)}
-          >
-            {name}
-          </MenuItem>
-        )),
-    [disabledTypeList]
+      AnalogTypeNames.map((val, i) => (
+        <MenuItem key={val} value={i}>
+          {val}
+        </MenuItem>
+      )),
+    []
   );
 
   const uomMenuItems = useMemo(
@@ -132,23 +114,6 @@ const SensorsAnalogDialog = ({
     []
   );
 
-  const analogGPIOMenuItems = () =>
-    // add selectedItem.g to the list
-    [
-      ...(analogGPIOList?.includes(selectedItem.g) || selectedItem.g === undefined
-        ? analogGPIOList
-        : [selectedItem.g, ...analogGPIOList])
-    ]
-      .filter((gpio, idx, arr) => arr.indexOf(gpio) === idx)
-      .sort((a, b) => a - b)
-      .map((gpio: number) => {
-        return (
-          <MenuItem key={gpio} value={gpio}>
-            {gpio}
-          </MenuItem>
-        );
-      });
-
   // Reset form when dialog opens or selectedItem changes
   useEffect(() => {
     if (open) {
@@ -191,67 +156,72 @@ const SensorsAnalogDialog = ({
       <DialogTitle>{dialogTitle}</DialogTitle>
       <DialogContent dividers>
         <Grid container spacing={2}>
-          <ValidatedTextField
-            name="g"
-            label="GPIO"
-            value={editItem.g}
-            sx={{ width: '9ch' }}
-            disabled={editItem.s || !creating}
-            select
-            onChange={updateFormValue}
-          >
-            {analogGPIOMenuItems()}
-          </ValidatedTextField>
           <Grid>
             <ValidatedTextField
+              fieldErrors={fieldErrors || {}}
+              name="g"
+              label="GPIO"
+              sx={{ width: '11ch' }}
+              value={numberValue(editItem.g)}
+              type="number"
+              variant="outlined"
+              onChange={updateFormValue}
+            />
+          </Grid>
+          {creating && (
+            <Grid>
+              <Box color="warning.main" mt={2}>
+                <Typography variant="body2">{LL.WARN_GPIO()}</Typography>
+              </Box>
+            </Grid>
+          )}
+          <Grid>
+            <ValidatedTextField
+              fieldErrors={fieldErrors || {}}
               name="n"
               label={LL.NAME(0)}
               value={editItem.n}
               fullWidth
+              variant="outlined"
               onChange={updateFormValue}
             />
           </Grid>
           <Grid>
-            <ValidatedTextField
+            <TextField
               name="t"
               label={LL.TYPE(0)}
               value={editItem.t}
               fullWidth
               select
               onChange={updateFormValue}
-              disabled={editItem.s}
             >
               {analogTypeMenuItems}
-            </ValidatedTextField>
+            </TextField>
           </Grid>
-          {(isCounterOrRate ||
-            isFreqType ||
-            editItem.t === AnalogType.ADC ||
-            editItem.t === AnalogType.TIMER) && (
+          {(isCounterOrRate || isFreqType) && (
             <Grid>
-              <ValidatedTextField
+              <TextField
                 name="u"
                 label={LL.UNIT()}
                 value={editItem.u}
                 sx={{ width: '15ch' }}
                 select
                 onChange={updateFormValue}
-                disabled={editItem.s}
               >
                 {uomMenuItems}
-              </ValidatedTextField>
+              </TextField>
             </Grid>
           )}
           {editItem.t === AnalogType.ADC && (
             <Grid>
-              <ValidatedTextField
+              <TextField
                 name="o"
                 label={LL.OFFSET()}
                 value={numberValue(editItem.o)}
                 type="number"
                 sx={{ width: '11ch' }}
+                variant="outlined"
                 onChange={updateFormValue}
-                disabled={editItem.s}
                 slotProps={{
                   input: {
                     startAdornment: (
@@ -265,14 +235,14 @@ const SensorsAnalogDialog = ({
           )}
           {editItem.t === AnalogType.NTC && (
             <Grid>
-              <ValidatedTextField
+              <TextField
                 name="o"
                 label={LL.OFFSET()}
                 value={numberValue(editItem.o)}
                 sx={{ width: '11ch' }}
                 type="number"
+                variant="outlined"
                 onChange={updateFormValue}
-                disabled={editItem.s}
                 slotProps={{
                   input: {
                     startAdornment: (
@@ -284,16 +254,16 @@ const SensorsAnalogDialog = ({
               />
             </Grid>
           )}
-          {isCounter && (
+          {editItem.t === AnalogType.COUNTER && (
             <Grid>
-              <ValidatedTextField
+              <TextField
                 name="o"
                 label={LL.STARTVALUE()}
                 value={numberValue(editItem.o)}
                 type="number"
                 sx={{ width: '11ch' }}
+                variant="outlined"
                 onChange={updateFormValue}
-                disabled={editItem.s}
                 slotProps={{
                   htmlInput: { step: '0.001' }
                 }}
@@ -302,90 +272,85 @@ const SensorsAnalogDialog = ({
           )}
           {editItem.t === AnalogType.RGB && (
             <Grid>
-              <ValidatedTextField
+              <TextField
                 name="o"
                 label={'RGB ' + LL.VALUE(0)}
                 value={numberValue(editItem.o)}
                 type="number"
                 sx={{ width: '11ch' }}
+                variant="outlined"
                 onChange={updateFormValue}
-                disabled={editItem.s}
               />
             </Grid>
           )}
-          {(isCounterOrRate ||
-            isFreqType ||
-            editItem.t === AnalogType.ADC ||
-            editItem.t === AnalogType.TIMER) && (
+          {isCounterOrRate && (
             <Grid>
-              <ValidatedTextField
+              <TextField
                 name="f"
                 label={LL.FACTOR()}
                 value={numberValue(editItem.f)}
                 sx={{ width: '14ch' }}
                 type="number"
+                variant="outlined"
                 onChange={updateFormValue}
-                disabled={editItem.s}
                 slotProps={{
                   htmlInput: { step: '0.001' }
                 }}
               />
             </Grid>
           )}
-          {isDACOutGPIO && (
+          {isDigitalOutGPIO && (
             <Grid>
-              <ValidatedTextField
+              <TextField
                 name="o"
                 label={LL.VALUE(0)}
                 value={numberValue(editItem.o)}
                 sx={{ width: '11ch' }}
                 type="number"
+                variant="outlined"
                 onChange={updateFormValue}
-                disabled={editItem.s}
                 slotProps={{
                   htmlInput: { min: '0', max: '255', step: '1' }
                 }}
               />
             </Grid>
           )}
-          {isDigitalOutGPIO && (
+          {isDigitalOutNonGPIO && (
             <>
               <Grid>
-                <ValidatedTextField
+                <TextField
                   name="o"
                   label={LL.VALUE(0)}
                   value={numberValue(editItem.o)}
                   select
+                  variant="outlined"
                   onChange={updateFormValue}
-                  disabled={editItem.s}
                 >
                   <MenuItem value={0}>{LL.OFF()}</MenuItem>
                   <MenuItem value={1}>{LL.ON()}</MenuItem>
-                </ValidatedTextField>
+                </TextField>
               </Grid>
               <Grid>
-                <ValidatedTextField
+                <TextField
                   name="f"
                   label={LL.POLARITY()}
                   value={editItem.f}
                   sx={{ width: '15ch' }}
                   select
                   onChange={updateFormValue}
-                  disabled={editItem.s}
                 >
                   <MenuItem value={1}>{LL.ACTIVEHIGH()}</MenuItem>
                   <MenuItem value={-1}>{LL.ACTIVELOW()}</MenuItem>
-                </ValidatedTextField>
+                </TextField>
               </Grid>
               <Grid>
-                <ValidatedTextField
+                <TextField
                   name="u"
                   label={LL.STARTVALUE()}
                   sx={{ width: '15ch' }}
                   value={editItem.u}
                   select
                   onChange={updateFormValue}
-                  disabled={editItem.s}
                 >
                   <MenuItem value={0}>{LL.UNCHANGED()}</MenuItem>
                   <MenuItem value={1}>
@@ -394,21 +359,21 @@ const SensorsAnalogDialog = ({
                   <MenuItem value={2}>
                     {LL.ALWAYS()}&nbsp;{LL.ON()}
                   </MenuItem>
-                </ValidatedTextField>
+                </TextField>
               </Grid>
             </>
           )}
           {isPWM && (
             <>
               <Grid>
-                <ValidatedTextField
+                <TextField
                   name="f"
                   label={LL.FREQ()}
                   value={numberValue(editItem.f)}
                   type="number"
+                  variant="outlined"
                   sx={{ width: '11ch' }}
                   onChange={updateFormValue}
-                  disabled={editItem.s}
                   slotProps={{
                     input: {
                       startAdornment: (
@@ -420,14 +385,14 @@ const SensorsAnalogDialog = ({
                 />
               </Grid>
               <Grid>
-                <ValidatedTextField
+                <TextField
                   name="o"
                   label={LL.DUTY_CYCLE()}
                   value={numberValue(editItem.o)}
                   type="number"
                   sx={{ width: '11ch' }}
+                  variant="outlined"
                   onChange={updateFormValue}
-                  disabled={editItem.s}
                   slotProps={{
                     input: {
                       startAdornment: (
@@ -443,28 +408,27 @@ const SensorsAnalogDialog = ({
           {editItem.t === AnalogType.PULSE && (
             <>
               <Grid>
-                <ValidatedTextField
+                <TextField
                   name="o"
                   label={LL.POLARITY()}
                   value={editItem.o}
                   sx={{ width: '11ch' }}
                   select
                   onChange={updateFormValue}
-                  disabled={editItem.s}
                 >
                   <MenuItem value={0}>{LL.ACTIVEHIGH()}</MenuItem>
                   <MenuItem value={1}>{LL.ACTIVELOW()}</MenuItem>
-                </ValidatedTextField>
+                </TextField>
               </Grid>
               <Grid>
-                <ValidatedTextField
+                <TextField
                   name="f"
                   label="Pulse"
                   value={numberValue(editItem.f)}
                   type="number"
                   sx={{ width: '15ch' }}
+                  variant="outlined"
                   onChange={updateFormValue}
-                  disabled={editItem.s}
                   slotProps={{
                     input: {
                       startAdornment: (
@@ -478,24 +442,6 @@ const SensorsAnalogDialog = ({
             </>
           )}
         </Grid>
-        {fieldErrors && Object.keys(fieldErrors).length > 0 && (
-          <Box mt={1}>
-            {Object.values(fieldErrors).map((errArr, idx) =>
-              Array.isArray(errArr)
-                ? errArr.map((err, j) => (
-                    <Typography
-                      key={`${idx}-${j}`}
-                      color="error"
-                      variant="caption"
-                      display="block"
-                    >
-                      {err.message}
-                    </Typography>
-                  ))
-                : null
-            )}
-          </Box>
-        )}
         {editItem.s && (
           <Grid>
             <Typography mt={1} color="warning.main" variant="body2">

interface/src/app/main/types.ts

@@ -89,15 +89,15 @@ export interface TemperatureSensor {
 export interface AnalogSensor {
   id: number;
   g: number; // GPIO
-  n: string; // name
-  v: number; // value
-  u: number; // uom
-  o: number; // offset
-  f: number; // factor
-  t: number; // type
+  n: string;
+  v: number;
+  u: number;
+  o: number;
+  f: number;
+  t: number;
   d: boolean; // deleted flag
   s: boolean; // system sensor flag
-  o_n?: string; // original name
+  o_n?: string;
 }
 
 export interface WriteTemperatureSensor {
@@ -111,8 +111,6 @@ export interface SensorData {
   ts: TemperatureSensor[];
   as: AnalogSensor[];
   analog_enabled: boolean;
-  available_gpios: number[];
-  exclude_types: number[];
   platform: string;
 }
 
@@ -202,7 +200,7 @@ export enum DeviceValueUOM {
 export const DeviceValueUOM_s = [
   '',
   '°C',
-  '°C Rel',
+  '°C',
   '%',
   'l/min',
   'kWh',
@@ -232,6 +230,7 @@ export const DeviceValueUOM_s = [
 
 export enum AnalogType {
   REMOVED = -1,
+  NOTUSED = 0,
   DIGITAL_IN = 1,
   COUNTER = 2,
   ADC = 3,
@@ -246,31 +245,26 @@ export enum AnalogType {
   PULSE = 12,
   FREQ_0 = 13,
   FREQ_1 = 14,
-  FREQ_2 = 15,
-  CNT_0 = 16,
-  CNT_1 = 17,
-  CNT_2 = 18
+  FREQ_2 = 15
 }
 
 export const AnalogTypeNames = [
-  'Digital In', // 1
-  'Counter', // 2
-  'ADC In', // 3
-  'Timer', // 4
-  'Rate', // 5
-  'Digital Out', // 6
-  'PWM 0', // 7
-  'PWM 1', // 8
-  'PWM 2', // 9
-  'NTC Temp', // 10
-  'RGB Led', // 11
-  'Pulse', // 12
-  'Freq 0', // 13
-  'Freq 1', // 14
-  'Freq 2', // 15
-  'Counter 0', // 16
-  'Counter 1', // 17
-  'Counter 2' // 18
+  '(disabled)',
+  'Digital In',
+  'Counter',
+  'ADC In',
+  'Timer',
+  'Rate',
+  'Digital Out',
+  'PWM 0',
+  'PWM 1',
+  'PWM 2',
+  'NTC Temp.',
+  'RGB Led',
+  'Pulse',
+  'Freq 0',
+  'Freq 1',
+  'Freq 2'
 ] as const;
 
 export const BOARD_PROFILES = {

interface/src/app/main/validators.ts

@@ -45,15 +45,121 @@ const VALIDATION_LIMITS = {
   HEX_BASE: 16
 } as const;
 
+// Helper to create GPIO validator from invalid ranges
+const createGPIOValidator = (
+  invalidRanges: Array<number | [number, number]>,
+  maxValue: number
+) => ({
+  validator(
+    _rule: InternalRuleItem,
+    value: number,
+    callback: (error?: string) => void
+  ) {
+    if (!value) {
+      callback();
+      return;
+    }
+
+    if (value < 0 || value > maxValue) {
+      callback(ERROR_MESSAGES.GPIO_INVALID);
+      return;
+    }
+
+    for (const range of invalidRanges) {
+      if (typeof range === 'number') {
+        if (value === range) {
+          callback(ERROR_MESSAGES.GPIO_INVALID);
+          return;
+        }
+      } else {
+        const [start, end] = range;
+        if (value >= start && value <= end) {
+          callback(ERROR_MESSAGES.GPIO_INVALID);
+          return;
+        }
+      }
+    }
+
+    callback();
+  }
+});
+
+export const GPIO_VALIDATOR = createGPIOValidator(
+  [[6, 11], 1, 20, 24, [28, 31]],
+  40
+);
+
+export const GPIO_VALIDATORC3 = createGPIOValidator([[11, 19]], 21);
+
+export const GPIO_VALIDATORS2 = createGPIOValidator(
+  [
+    [19, 20],
+    [22, 32]
+  ],
+  40
+);
+
+export const GPIO_VALIDATORS3 = createGPIOValidator(
+  [
+    [19, 20],
+    [22, 37],
+    [39, 42]
+  ],
+  48
+);
+
+const GPIO_FIELD_NAMES = [
+  'led_gpio',
+  'dallas_gpio',
+  'pbutton_gpio',
+  'tx_gpio',
+  'rx_gpio'
+] as const;
+
 type ValidationRules = Array<{
   required?: boolean;
   message?: string;
   [key: string]: unknown;
 }>;
 
+const createGPIOValidations = (
+  validator: typeof GPIO_VALIDATOR
+): Record<string, ValidationRules> =>
+  GPIO_FIELD_NAMES.reduce(
+    (acc, field) => {
+      const fieldName = field.replace('_gpio', '').toUpperCase();
+      acc[field] = [
+        { required: true, message: `${fieldName} GPIO is required` },
+        validator
+      ];
+      return acc;
+    },
+    {} as Record<string, ValidationRules>
+  );
+
+const PLATFORM_VALIDATORS = {
+  ESP32: GPIO_VALIDATOR,
+  ESP32C3: GPIO_VALIDATORC3,
+  ESP32S2: GPIO_VALIDATORS2,
+  ESP32S3: GPIO_VALIDATORS3
+} as const;
+
 export const createSettingsValidator = (settings: Settings) => {
   const schema: Record<string, ValidationRules> = {};
 
+  // Add GPIO validations for CUSTOM board profiles
+  if (
+    settings.board_profile === 'CUSTOM' &&
+    settings.platform in PLATFORM_VALIDATORS
+  ) {
+    Object.assign(
+      schema,
+      createGPIOValidations(
+        PLATFORM_VALIDATORS[settings.platform as keyof typeof PLATFORM_VALIDATORS]
+      )
+    );
+  }
+
   // Syslog validations
   if (settings.syslog_enabled) {
     schema.syslog_host = [
@@ -295,21 +401,52 @@ export const temperatureSensorItemValidation = (
     n: [NAME_PATTERN, uniqueTemperatureNameValidator(sensors, sensor.o_n)]
   });
 
+export const isGPIOUniqueValidator = (sensors: AnalogSensor[]) => ({
+  validator(
+    _rule: InternalRuleItem,
+    gpio: number,
+    callback: (error?: string) => void
+  ) {
+    if (sensors.some((as) => as.g === gpio)) {
+      callback(ERROR_MESSAGES.GPIO_DUPLICATE);
+      return;
+    }
+    callback();
+  }
+});
+
 export const uniqueAnalogNameValidator = (
   sensors: AnalogSensor[],
   o_name?: string
 ) => createUniqueFieldNameValidator(sensors, (s) => s.n, o_name);
 
+const getPlatformGPIOValidator = (platform: string) => {
+  switch (platform) {
+    case 'ESP32S3':
+      return GPIO_VALIDATORS3;
+    case 'ESP32S2':
+      return GPIO_VALIDATORS2;
+    case 'ESP32C3':
+      return GPIO_VALIDATORC3;
+    default:
+      return GPIO_VALIDATOR;
+  }
+};
+
 export const analogSensorItemValidation = (
   sensors: AnalogSensor[],
-  sensor: AnalogSensor
+  sensor: AnalogSensor,
+  creating: boolean,
+  platform: string
 ) => {
+  const gpioValidator = getPlatformGPIOValidator(platform);
+
   return new Schema({
-    // name is required and must be unique
-    n: [
-      { required: true, message: 'Name is required' },
-      NAME_PATTERN,
-      uniqueAnalogNameValidator(sensors, sensor.o_n)
+    n: [NAME_PATTERN, uniqueAnalogNameValidator(sensors, sensor.o_n)],
+    g: [
+      { required: true, message: 'GPIO is required' },
+      gpioValidator,
+      ...(creating ? [isGPIOUniqueValidator(sensors)] : [])
     ]
   });
 };

interface/src/app/settings/ApplicationSettings.tsx

@@ -328,9 +328,9 @@ const ApplicationSettings = () => {
               >
                 <MenuItem value={-1}>OFF</MenuItem>
                 <MenuItem value={3}>ERR</MenuItem>
-                <MenuItem value={4}>WARN</MenuItem>
                 <MenuItem value={5}>NOTICE</MenuItem>
                 <MenuItem value={6}>INFO</MenuItem>
+                <MenuItem value={7}>DEBUG</MenuItem>
                 <MenuItem value={9}>ALL</MenuItem>
               </TextField>
             </Grid>
@@ -602,7 +602,6 @@ const ApplicationSettings = () => {
                   <MenuItem value={0}>{LL.DISABLED(1)}</MenuItem>
                   <MenuItem value={1}>LAN8720</MenuItem>
                   <MenuItem value={2}>TLK110</MenuItem>
-                  <MenuItem value={3}>RTL8201</MenuItem>
                 </TextField>
               </Grid>
             </Grid>
@@ -858,9 +857,8 @@ const ApplicationSettings = () => {
         </Grid>
 
         {restartNeeded && (
-          <MessageBox level="warning" message={LL.RESTART_TEXT(0)}>
+          <MessageBox my={2} level="warning" message={LL.RESTART_TEXT(0)}>
             <Button
-              sx={{ ml: 2 }}
               startIcon={<PowerSettingsNewIcon />}
               variant="contained"
               color="error"

interface/src/app/settings/MqttSettings.tsx

@@ -1,11 +1,8 @@
 import { useCallback, useMemo, useState } from 'react';
-import { toast } from 'react-toastify';
 
 import CancelIcon from '@mui/icons-material/Cancel';
-import SettingsBackupRestoreIcon from '@mui/icons-material/SettingsBackupRestore';
 import WarningIcon from '@mui/icons-material/Warning';
 import {
-  Box,
   Button,
   Checkbox,
   Grid,
@@ -33,8 +30,6 @@ import type { MqttSettingsType } from 'types';
 import { numberValue, updateValueDirty, useRest } from 'utils';
 import { createMqttSettingsValidator, validate } from 'validators';
 
-import { callAction } from '../../api/app';
-
 const MqttSettings = () => {
   const {
     loadData,
@@ -57,16 +52,6 @@ const MqttSettings = () => {
 
   const [fieldErrors, setFieldErrors] = useState<ValidateFieldsError>();
 
-  const sendResetMQTT = useCallback(() => {
-    void callAction({ action: 'resetMQTT' })
-      .then(() => {
-        toast.success('MQTT ' + LL.REFRESH() + ' successful');
-      })
-      .catch((error) => {
-        toast.error(String(error.error?.message || 'An error occurred'));
-      });
-  }, []);
-
   const updateFormValue = useMemo(
     () =>
       updateValueDirty(
@@ -129,28 +114,16 @@ const MqttSettings = () => {
     <SectionContent>
       {blocker ? <BlockNavigation blocker={blocker} /> : null}
       <>
-        <Box display="flex" gap={2} mb={1}>
-          <BlockFormControlLabel
-            control={
-              <Checkbox
-                name="enabled"
-                checked={data.enabled}
-                onChange={updateFormValue}
-              />
-            }
-            label={LL.ENABLE_MQTT()}
-          />
-          {data.enabled && (
-            <Button
-              startIcon={<SettingsBackupRestoreIcon />}
-              color="secondary"
-              variant="outlined"
-              onClick={sendResetMQTT}
-            >
-              {LL.REFRESH() + ' MQTT'}
-            </Button>
-          )}
-        </Box>
+        <BlockFormControlLabel
+          control={
+            <Checkbox
+              name="enabled"
+              checked={data.enabled}
+              onChange={updateFormValue}
+            />
+          }
+          label={LL.ENABLE_MQTT()}
+        />
         <Grid container spacing={2} rowSpacing={0}>
           <Grid>
             <ValidatedTextField
@@ -266,7 +239,6 @@ const MqttSettings = () => {
             label={LL.CERT()}
             variant="outlined"
             value={data.rootCA}
-            sx={{ width: '50ch' }}
             onChange={updateFormValue}
             margin="normal"
           />

interface/src/app/settings/TZ.tsx

@@ -2,7 +2,9 @@ import { useMemo } from 'react';
 
 import { MenuItem } from '@mui/material';
 
-export const TIME_ZONES: Record<string, string> = {
+type TimeZones = Record<string, string>;
+
+export const TIME_ZONES: Readonly<TimeZones> = {
   'Africa/Abidjan': 'GMT0',
   'Africa/Accra': 'GMT0',
   'Africa/Addis_Ababa': 'EAT-3',

interface/src/app/settings/network/NetworkSettings.tsx

@@ -355,9 +355,8 @@ const NetworkSettings = () => {
           </>
         )}
         {restartNeeded && (
-          <MessageBox level="warning" message={LL.RESTART_TEXT(0)}>
+          <MessageBox my={2} level="warning" message={LL.RESTART_TEXT(0)}>
             <Button
-              sx={{ ml: 2 }}
               startIcon={<PowerSettingsNewIcon />}
               variant="contained"
               color="error"

interface/src/app/settings/network/WiFiNetworkSelector.tsx

@@ -94,7 +94,7 @@ const WiFiNetworkSelector = ({ networkList }: { networkList: WiFiNetworkList })
   );
 
   if (networkList.networks.length === 0) {
-    return <MessageBox message={LL.NETWORK_NO_WIFI()} level="info" />;
+    return <MessageBox mt={2} mb={1} message={LL.NETWORK_NO_WIFI()} level="info" />;
   }
 
   return <List>{networkList.networks.map(renderNetwork)}</List>;

interface/src/app/status/Status.tsx

@@ -8,10 +8,10 @@ import DeviceHubIcon from '@mui/icons-material/DeviceHub';
 import DirectionsBusIcon from '@mui/icons-material/DirectionsBus';
 import LogoDevIcon from '@mui/icons-material/LogoDev';
 import MemoryIcon from '@mui/icons-material/Memory';
-import MonitorHeartIcon from '@mui/icons-material/MonitorHeart';
 import PowerSettingsNewIcon from '@mui/icons-material/PowerSettingsNew';
 import RouterIcon from '@mui/icons-material/Router';
 import SettingsInputAntennaIcon from '@mui/icons-material/SettingsInputAntenna';
+import TimerIcon from '@mui/icons-material/Timer';
 import WifiIcon from '@mui/icons-material/Wifi';
 import {
   Avatar,
@@ -37,7 +37,7 @@ import { FormLoader, SectionContent, useLayoutTitle } from 'components';
 import ListMenuItem from 'components/layout/ListMenuItem';
 import { AuthenticatedContext } from 'contexts/authentication';
 import { useI18nContext } from 'i18n/i18n-react';
-import { NTPSyncStatus, NetworkConnectionStatus, SystemStatusCodes } from 'types';
+import { NTPSyncStatus, NetworkConnectionStatus } from 'types';
 import { useInterval } from 'utils';
 import { formatDateTime } from 'utils/time';
 
@@ -113,27 +113,6 @@ const SystemStatus = () => {
     }
   }, [data?.bus_status, data?.bus_uptime, LL]);
 
-  // Memoize derived status values to avoid recalculation on every render
-  const systemStatus = useMemo(() => {
-    if (!data) return '??';
-
-    switch (data.status) {
-      case SystemStatusCodes.SYSTEM_STATUS_PENDING_UPLOAD:
-      case SystemStatusCodes.SYSTEM_STATUS_UPLOADING:
-        return LL.WAIT_FIRMWARE();
-      case SystemStatusCodes.SYSTEM_STATUS_ERROR_UPLOAD:
-        return LL.ERROR();
-      case SystemStatusCodes.SYSTEM_STATUS_PENDING_RESTART:
-      case SystemStatusCodes.SYSTEM_STATUS_RESTART_REQUESTED:
-        return LL.RESTARTING_PRE();
-      case SystemStatusCodes.SYSTEM_STATUS_INVALID_GPIO:
-        return LL.GPIO_OF(LL.FAILED(0));
-      default:
-        // SystemStatusCodes.SYSTEM_STATUS_NORMAL
-        return 'OK';
-    }
-  }, [data?.status, LL]);
-
   const busStatusHighlight = useMemo(() => {
     if (!data) return theme.palette.warning.main;
 
@@ -334,13 +313,10 @@ const SystemStatus = () => {
           <ListItem>
             <ListItemAvatar>
               <Avatar sx={{ bgcolor: '#c5572c', color: 'white' }}>
-                <MonitorHeartIcon />
+                <TimerIcon />
               </Avatar>
             </ListItemAvatar>
-            <ListItemText
-              primary={LL.STATUS_OF(LL.SYSTEM(0))}
-              secondary={`${systemStatus} (${LL.UPTIME()}: ${uptimeText})`}
-            />
+            <ListItemText primary={LL.UPTIME()} secondary={uptimeText} />
             {me.admin && (
               <Button
                 startIcon={<PowerSettingsNewIcon />}

interface/src/app/status/SystemMonitor.tsx

@@ -113,7 +113,7 @@ const SystemMonitor = () => {
           minWidth: '300px',
           maxWidth: '500px',
           backgroundColor: '#393939',
-          border: 2,
+          border: 3,
           borderColor: '#565656',
           borderRadius: '8px',
           boxShadow: '0 8px 32px rgba(0, 0, 0, 0.3)',
@@ -136,10 +136,10 @@ const SystemMonitor = () => {
           </Typography>
 
           {errorMessage ? (
-            <MessageBox level="error" message={errorMessage}>
+            <MessageBox my={2} level="error" message={errorMessage}>
               <Button
-                sx={{ ml: 2 }}
                 size="small"
+                sx={{ ml: 2 }}
                 startIcon={<CancelIcon />}
                 variant="contained"
                 color="error"

interface/src/app/status/Version.tsx

@@ -1,12 +1,4 @@
-import {
-  memo,
-  useCallback,
-  useContext,
-  useEffect,
-  useMemo,
-  useRef,
-  useState
-} from 'react';
+import { memo, useCallback, useContext, useEffect, useMemo, useState } from 'react';
 import { toast } from 'react-toastify';
 
 import CancelIcon from '@mui/icons-material/Cancel';
@@ -18,10 +10,12 @@ import WarningIcon from '@mui/icons-material/Warning';
 import {
   Box,
   Button,
+  Checkbox,
   Dialog,
   DialogActions,
   DialogContent,
   DialogTitle,
+  FormControlLabel,
   Grid,
   IconButton,
   Link,
@@ -60,13 +54,6 @@ const DEV_RELNOTES_URL =
   'https://github.com/emsesp/EMS-ESP32/blob/dev/CHANGELOG_LATEST.md';
 
 // Types for better type safety
-interface PartitionData {
-  partition: string;
-  version: string;
-  install_date?: string;
-  size: number;
-}
-
 interface VersionData {
   emsesp_version: string;
   arduino_version: string;
@@ -74,9 +61,6 @@ interface VersionData {
   flash_chip_size: number;
   psram: boolean;
   build_flags?: string;
-  partition: string;
-  partitions: PartitionData[];
-  developer_mode: boolean;
 }
 
 interface UpgradeCheckData {
@@ -96,10 +80,6 @@ const VersionInfoDialog = memo(
     showVersionInfo,
     latestVersion,
     latestDevVersion,
-    partitionVersion,
-    partition,
-    currentPartition,
-    size,
     locale,
     LL,
     onClose
@@ -107,10 +87,6 @@ const VersionInfoDialog = memo(
     showVersionInfo: number;
     latestVersion?: VersionInfo;
     latestDevVersion?: VersionInfo;
-    partitionVersion?: VersionInfo | undefined;
-    partition: string;
-    currentPartition: string;
-    size: number;
     locale: string;
     LL: TranslationFunctions;
     onClose: () => void;
@@ -118,19 +94,8 @@ const VersionInfoDialog = memo(
     if (showVersionInfo === 0) return null;
 
     const isStable = showVersionInfo === 1;
-    const isDev = showVersionInfo === 2;
-    const isPartition = showVersionInfo === 3;
-
-    const version = isStable
-      ? latestVersion
-      : isDev
-        ? latestDevVersion
-        : partitionVersion;
-    const relNotesUrl = isStable
-      ? STABLE_RELNOTES_URL
-      : isDev
-        ? DEV_RELNOTES_URL
-        : '';
+    const version = isStable ? latestVersion : latestDevVersion;
+    const relNotesUrl = isStable ? STABLE_RELNOTES_URL : DEV_RELNOTES_URL;
 
     return (
       <Dialog sx={dialogStyle} open={showVersionInfo !== 0} onClose={onClose}>
@@ -147,17 +112,14 @@ const VersionInfoDialog = memo(
                     borderBottom: 'none',
                     pr: 1,
                     py: 0.5,
-                    fontSize: 13
+                    fontSize: 13,
+                    width: 90
                   }}
                 >
-                  {LL.VERSION()}
+                  {LL.TYPE(0)}
                 </TableCell>
                 <TableCell sx={{ borderBottom: 'none', py: 0.5, fontSize: 13 }}>
-                  {isPartition
-                    ? typeof version === 'string'
-                      ? version
-                      : version?.name
-                    : version?.name}
+                  {isStable ? LL.STABLE() : LL.DEVELOPMENT()}
                 </TableCell>
               </TableRow>
               <TableRow sx={{ height: 24, borderBottom: 'none' }}>
@@ -169,61 +131,15 @@ const VersionInfoDialog = memo(
                     borderBottom: 'none',
                     pr: 1,
                     py: 0.5,
-                    fontSize: 13,
-                    width: 140
+                    fontSize: 13
                   }}
                 >
-                  {isPartition ? LL.TYPE(0) : LL.RELEASE_TYPE()}
+                  {LL.VERSION()}
                 </TableCell>
                 <TableCell sx={{ borderBottom: 'none', py: 0.5, fontSize: 13 }}>
-                  {partition === currentPartition && LL.ACTIVE() + ' '}
-                  {isStable
-                    ? LL.STABLE()
-                    : isDev
-                      ? LL.DEVELOPMENT()
-                      : 'Partition ' + LL.VERSION()}
+                  {version?.name}
                 </TableCell>
               </TableRow>
-              {isPartition && (
-                <TableRow sx={{ height: 24, borderBottom: 'none' }}>
-                  <TableCell
-                    component="th"
-                    scope="row"
-                    sx={{
-                      color: 'lightblue',
-                      borderBottom: 'none',
-                      pr: 1,
-                      py: 0.5,
-                      fontSize: 13
-                    }}
-                  >
-                    Partition
-                  </TableCell>
-                  <TableCell sx={{ borderBottom: 'none', py: 0.5, fontSize: 13 }}>
-                    {partition}
-                  </TableCell>
-                </TableRow>
-              )}
-              {isPartition && (
-                <TableRow sx={{ height: 24, borderBottom: 'none' }}>
-                  <TableCell
-                    component="th"
-                    scope="row"
-                    sx={{
-                      color: 'lightblue',
-                      borderBottom: 'none',
-                      pr: 1,
-                      py: 0.5,
-                      fontSize: 13
-                    }}
-                  >
-                    Size
-                  </TableCell>
-                  <TableCell sx={{ borderBottom: 'none', py: 0.5, fontSize: 13 }}>
-                    {size} KB
-                  </TableCell>
-                </TableRow>
-              )}
               {version?.published_at && (
                 <TableRow sx={{ height: 24, borderBottom: 'none' }}>
                   <TableCell
@@ -237,7 +153,7 @@ const VersionInfoDialog = memo(
                       fontSize: 13
                     }}
                   >
-                    {isPartition ? 'Install Date' : 'Build Date'}
+                    Build Date
                   </TableCell>
                   <TableCell sx={{ borderBottom: 'none', py: 0.5, fontSize: 13 }}>
                     {prettyDateTime(locale, new Date(version.published_at))}
@@ -248,17 +164,15 @@ const VersionInfoDialog = memo(
           </Table>
         </DialogContent>
         <DialogActions>
-          {!isPartition && (
-            <Button
-              variant="outlined"
-              component="a"
-              href={relNotesUrl}
-              target="_blank"
-              color="primary"
-            >
-              Changelog
-            </Button>
-          )}
+          <Button
+            variant="outlined"
+            component="a"
+            href={relNotesUrl}
+            target="_blank"
+            color="primary"
+          >
+            Changelog
+          </Button>
           <Button variant="outlined" onClick={onClose} color="secondary">
             {LL.CLOSE()}
           </Button>
@@ -304,7 +218,7 @@ const InstallDialog = memo(
     return (
       <Dialog sx={dialogStyle} open={openInstallDialog} onClose={onClose}>
         <DialogTitle>
-          {`${LL.INSTALL()} ${fetchDevVersion ? LL.DEVELOPMENT() : LL.STABLE()} Firmware`}
+          {`${LL.UPDATE()} ${fetchDevVersion ? LL.DEVELOPMENT() : LL.STABLE()} Firmware`}
         </DialogTitle>
         <DialogContent dividers>
           <Typography mb={2}>
@@ -349,54 +263,6 @@ const InstallDialog = memo(
   }
 );
 
-const InstallPartitionDialog = memo(
-  ({
-    openInstallPartitionDialog,
-    version,
-    partition,
-    LL,
-    onClose,
-    onInstall
-  }: {
-    openInstallPartitionDialog: boolean;
-    version: string;
-    partition: string;
-    LL: TranslationFunctions;
-    onClose: () => void;
-    onInstall: (partition: string) => void;
-  }) => {
-    return (
-      <Dialog sx={dialogStyle} open={openInstallPartitionDialog} onClose={onClose}>
-        <DialogTitle>
-          {LL.INSTALL()} {LL.STORED_VERSIONS()}
-        </DialogTitle>
-        <DialogContent dividers>
-          <Typography mb={2}>{LL.INSTALL_VERSION(LL.INSTALL(), version)}</Typography>
-        </DialogContent>
-        <DialogActions>
-          <Button
-            startIcon={<CancelIcon />}
-            variant="outlined"
-            onClick={onClose}
-            color="secondary"
-          >
-            {LL.CANCEL()}
-          </Button>
-
-          <Button
-            startIcon={<WarningIcon color="warning" />}
-            variant="outlined"
-            onClick={() => onInstall(partition)}
-            color="primary"
-          >
-            {LL.INSTALL()}
-          </Button>
-        </DialogActions>
-      </Dialog>
-    );
-  }
-);
-
 // Helper function moved outside component
 const getPlatform = (data: VersionData): string => {
   return `${data.esp_platform}-${data.flash_chip_size >= 16384 ? '16MB' : '4MB'}${data.psram ? '+' : ''}`;
@@ -409,14 +275,6 @@ const Version = () => {
   // State management
   const [restarting, setRestarting] = useState<boolean>(false);
   const [openInstallDialog, setOpenInstallDialog] = useState<boolean>(false);
-
-  const [partitionVersion, setPartitionVersion] = useState<VersionInfo | undefined>(
-    undefined
-  );
-  const [partition, setPartition] = useState<string>('');
-  const [openInstallPartitionDialog, setOpenInstallPartitionDialog] =
-    useState<boolean>(false);
-
   const [usingDevVersion, setUsingDevVersion] = useState<boolean>(false);
   const [fetchDevVersion, setFetchDevVersion] = useState<boolean>(false);
   const [devUpgradeAvailable, setDevUpgradeAvailable] = useState<boolean>(false);
@@ -424,8 +282,7 @@ const Version = () => {
     useState<boolean>(false);
   const [internetLive, setInternetLive] = useState<boolean>(false);
   const [downloadOnly, setDownloadOnly] = useState<boolean>(false);
-  const [showVersionInfo, setShowVersionInfo] = useState<number>(0); // 1 = stable, 2 = dev, 3 = partition
-  const [firmwareSize, setFirmwareSize] = useState<number>(0);
+  const [showVersionInfo, setShowVersionInfo] = useState<number>(0);
 
   const { send: sendCheckUpgrade } = useRequest(
     (versions: string) => callAction({ action: 'checkUpgrade', param: versions }),
@@ -436,13 +293,6 @@ const Version = () => {
     setStableUpgradeAvailable(data.stable_upgradeable);
   });
 
-  const { send: sendSetPartition } = useRequest(
-    (partition: string) => callAction({ action: 'setPartition', param: partition }),
-    { immediate: false }
-  ).onError((error) => {
-    toast.error(String(error.error?.message || 'An error occurred'));
-  });
-
   const {
     data,
     send: loadData,
@@ -469,38 +319,18 @@ const Version = () => {
 
   // Memoized values
   const platform = useMemo(() => (data ? getPlatform(data) : ''), [data]);
-
-  // Memoize filtered partitions to avoid recomputing on every render
-  const otherPartitions = useMemo(
-    () => data?.partitions.filter((p) => p.partition !== data.partition) ?? [],
-    [data]
-  );
-
-  const setPartitionVersionInfo = useCallback(
-    (partition: string) => {
-      setShowVersionInfo(3);
-
-      // search for the partition in the data.partitions array
-      const partitionData = data?.partitions.find((p) => p.partition === partition);
-      if (partitionData) {
-        setPartitionVersion({
-          name: partitionData.version,
-          published_at: partitionData.install_date ?? ''
-        });
-        setPartition(partitionData.partition);
-        setFirmwareSize(partitionData.size);
-      }
-    },
-    [data]
+  const isDev = useMemo(
+    () => data?.emsesp_version.includes('dev') ?? false,
+    [data?.emsesp_version]
   );
 
   const doRestart = useCallback(async () => {
+    setRestarting(true);
     await sendAPI({ device: 'system', cmd: 'restart', id: 0 }).catch(
       (error: Error) => {
         toast.error(error.message);
       }
     );
-    setRestarting(true);
   }, [sendAPI]);
 
   const installFirmwareURL = useCallback(
@@ -508,28 +338,9 @@ const Version = () => {
       await sendUploadURL(url).catch((error: Error) => {
         toast.error(error.message);
       });
-      await doRestart();
-    },
-    [sendUploadURL, doRestart]
-  );
-
-  const installPartitionFirmware = useCallback(
-    async (partition: string) => {
-      await sendSetPartition(partition).catch((error: Error) => {
-        toast.error(error.message);
-      });
       setRestarting(true);
     },
-    [sendSetPartition]
-  );
-
-  const showPartitionDialog = useCallback(
-    (version: string, partition: string, install_date: string) => {
-      setOpenInstallPartitionDialog(true);
-      setPartitionVersion({ name: version, published_at: install_date });
-      setPartition(partition);
-    },
-    []
+    [sendUploadURL]
   );
 
   const showFirmwareDialog = useCallback((useDevVersion: boolean) => {
@@ -541,21 +352,13 @@ const Version = () => {
     setOpenInstallDialog(false);
   }, []);
 
-  const closeInstallPartitionDialog = useCallback(() => {
-    setOpenInstallPartitionDialog(false);
-  }, []);
-
   const handleVersionInfoClose = useCallback(() => {
     setShowVersionInfo(0);
-    setPartitionVersion(undefined);
-    setPartition('');
   }, []);
 
-  // check upgrades - only once when both versions are available
-  const upgradeCheckedRef = useRef(false);
+  // Effect for checking upgrades
   useEffect(() => {
-    if (latestVersion && latestDevVersion && !upgradeCheckedRef.current) {
-      upgradeCheckedRef.current = true;
+    if (latestVersion && latestDevVersion) {
       const versions = `${latestDevVersion.name},${latestVersion.name}`;
       sendCheckUpgrade(versions)
         .catch((error: Error) => {
@@ -595,7 +398,7 @@ const Version = () => {
               {LL.LATEST_VERSION(usingDevVersion ? LL.DEVELOPMENT() : LL.STABLE())}
             </span>
             <Button
-              sx={{ ml: 1 }}
+              sx={{ ml: 2 }}
               variant="outlined"
               size="small"
               onClick={() => showFirmwareDialog(showingDev)}
@@ -610,7 +413,7 @@ const Version = () => {
 
       return (
         <Button
-          sx={{ ml: 1 }}
+          sx={{ ml: 2 }}
           variant="outlined"
           color={choice === LL.UPDATE_AVAILABLE() ? 'success' : 'warning'}
           size="small"
@@ -638,13 +441,14 @@ const Version = () => {
     return (
       <>
         <Box p={2} border="1px solid grey" borderRadius={2}>
-          <Typography mb={1} variant="h6" color="primary">
+          <Typography mb={2} variant="h6" color="primary">
             {LL.THIS_VERSION()}
           </Typography>
 
           <Grid
             container
             direction="row"
+            rowSpacing={1}
             sx={{
               justifyContent: 'flex-start',
               alignItems: 'baseline'
@@ -661,12 +465,6 @@ const Version = () => {
                     &nbsp; &#40;{data.build_flags}&#41;
                   </Typography>
                 )}
-                <IconButton
-                  onClick={() => setPartitionVersionInfo(data.partition)}
-                  aria-label={LL.FIRMWARE_VERSION_INFO()}
-                >
-                  <InfoOutlinedIcon color="primary" sx={{ fontSize: 18 }} />
-                </IconButton>
               </Typography>
             </Grid>
 
@@ -699,11 +497,57 @@ const Version = () => {
                 </Typography>
               </Typography>
             </Grid>
+
+            <Grid size={{ xs: 4, md: 2 }}>
+              <Typography color="secondary">{LL.RELEASE_TYPE()}</Typography>
+            </Grid>
+            <Grid size={{ xs: 8, md: 10 }}>
+              <FormControlLabel
+                disabled={!isDev}
+                control={
+                  <Checkbox
+                    sx={{
+                      '&.Mui-checked': {
+                        color: 'lightblue'
+                      }
+                    }}
+                  />
+                }
+                slotProps={{
+                  typography: {
+                    color: 'grey'
+                  }
+                }}
+                checked={!isDev}
+                label={LL.STABLE()}
+                sx={{ '& .MuiSvgIcon-root': { fontSize: 16 } }}
+              />
+              <FormControlLabel
+                disabled={isDev}
+                control={
+                  <Checkbox
+                    sx={{
+                      '&.Mui-checked': {
+                        color: 'lightblue'
+                      }
+                    }}
+                  />
+                }
+                slotProps={{
+                  typography: {
+                    color: 'grey'
+                  }
+                }}
+                checked={isDev}
+                label={LL.DEVELOPMENT()}
+                sx={{ '& .MuiSvgIcon-root': { fontSize: 16 } }}
+              />
+            </Grid>
           </Grid>
 
           {internetLive ? (
             <>
-              <Typography mt={4} mb={1} variant="h6" color="primary">
+              <Typography mt={2} mb={2} variant="h6" color="primary">
                 {LL.AVAILABLE_VERSION()}
               </Typography>
 
@@ -716,47 +560,6 @@ const Version = () => {
                   alignItems: 'baseline'
                 }}
               >
-                {otherPartitions.length > 0 && data.developer_mode && (
-                  <>
-                    <Grid size={{ xs: 4, md: 2 }}>
-                      <Typography color="secondary">
-                        {LL.STORED_VERSIONS()}
-                      </Typography>
-                    </Grid>
-                    <Grid size={{ xs: 8, md: 10 }}>
-                      {otherPartitions.map((partition) => (
-                        <Typography key={partition.partition} mb={1}>
-                          {partition.version}
-                          <IconButton
-                            onClick={() =>
-                              setPartitionVersionInfo(partition.partition)
-                            }
-                            aria-label={LL.FIRMWARE_VERSION_INFO()}
-                          >
-                            <InfoOutlinedIcon
-                              color="primary"
-                              sx={{ fontSize: 18 }}
-                            />
-                          </IconButton>
-                          <Button
-                            sx={{ ml: 0 }}
-                            variant="outlined"
-                            size="small"
-                            onClick={() =>
-                              showPartitionDialog(
-                                partition.version,
-                                partition.partition,
-                                partition.install_date ?? ''
-                              )
-                            }
-                          >
-                            {LL.INSTALL()}
-                          </Button>
-                        </Typography>
-                      ))}
-                    </Grid>
-                  </>
-                )}
                 <Grid size={{ xs: 4, md: 2 }}>
                   <Typography color="secondary">{LL.STABLE()}</Typography>
                 </Grid>
@@ -802,11 +605,7 @@ const Version = () => {
                 showVersionInfo={showVersionInfo}
                 latestVersion={latestVersion}
                 latestDevVersion={latestDevVersion}
-                partitionVersion={partitionVersion}
                 locale={locale}
-                partition={partition}
-                currentPartition={data?.partition ?? ''}
-                size={firmwareSize}
                 LL={LL}
                 onClose={handleVersionInfoClose}
               />
@@ -821,14 +620,6 @@ const Version = () => {
                 onClose={closeInstallDialog}
                 onInstall={installFirmwareURL}
               />
-              <InstallPartitionDialog
-                openInstallPartitionDialog={openInstallPartitionDialog}
-                version={partitionVersion?.name || ''}
-                partition={partition}
-                LL={LL}
-                onClose={closeInstallPartitionDialog}
-                onInstall={installPartitionFirmware}
-              />
               <Typography sx={{ pt: 2, pb: 2 }} variant="h6" color="primary">
                 {LL.UPLOAD()}
               </Typography>
@@ -844,6 +635,7 @@ const Version = () => {
     loadData,
     LL,
     platform,
+    isDev,
     internetLive,
     latestVersion,
     latestDevVersion,
@@ -857,15 +649,7 @@ const Version = () => {
     handleVersionInfoClose,
     closeInstallDialog,
     installFirmwareURL,
-    doRestart,
-    otherPartitions,
-    setPartitionVersionInfo,
-    showPartitionDialog,
-    partitionVersion,
-    partition,
-    firmwareSize,
-    closeInstallPartitionDialog,
-    installPartitionFirmware
+    doRestart
   ]);
 
   return <SectionContent>{restarting ? <SystemMonitor /> : content}</SectionContent>;

interface/src/components/inputs/LanguageSelector.tsx

@@ -19,8 +19,10 @@ import { I18nContext } from 'i18n/i18n-react';
 import type { Locales } from 'i18n/i18n-types';
 import { loadLocaleAsync } from 'i18n/i18n-util.async';
 
+// Extract style to constant to prevent recreation
 const flagStyle: CSSProperties = { width: 16, verticalAlign: 'middle' };
 
+// Define language options outside component to prevent recreation
 interface LanguageOption {
   key: Locales;
   flag: string;

interface/src/components/inputs/ValidatedTextField.tsx

@@ -15,35 +15,13 @@ export type ValidatedTextFieldProps = ValidatedFieldProps & TextFieldProps;
 
 const ValidatedTextField: FC<ValidatedTextFieldProps> = ({
   fieldErrors,
-  sx,
   ...rest
 }) => {
   const errors = fieldErrors?.[rest.name];
 
   return (
     <>
-      <TextField
-        error={!!errors}
-        {...rest}
-        aria-label="Error"
-        sx={{
-          '& .MuiInputBase-input.Mui-disabled': {
-            WebkitTextFillColor: 'grey'
-          },
-          ...(sx || {})
-        }}
-        {...(rest.disabled && {
-          slotProps: {
-            select: {
-              IconComponent: () => null
-            },
-            inputLabel: {
-              style: { color: 'grey' }
-            }
-          }
-        })}
-        color={rest.disabled ? 'secondary' : 'primary'}
-      />
+      <TextField error={!!errors} {...rest} aria-label="Error" />
       {errors?.map((e) => (
         <FormHelperText key={e.message} sx={{ color: 'rgb(250, 95, 84)' }}>
           {e.message}

interface/src/components/layout/ListMenuItem.tsx

@@ -22,6 +22,7 @@ interface ListMenuItemProps {
   disabled?: boolean;
 }
 
+// Extract styles to prevent recreation
 const iconStyles: CSSProperties = {
   justifyContent: 'right',
   color: 'lightblue',

interface/src/components/loading/FormLoader.tsx

@@ -16,7 +16,7 @@ const FormLoaderComponent = ({ errorMessage, onRetry }: FormLoaderProps) => {
 
   if (errorMessage) {
     return (
-      <MessageBox level="error" message={errorMessage}>
+      <MessageBox my={2} level="error" message={errorMessage}>
         {onRetry && (
           <Button
             sx={{ ml: 2 }}

interface/src/components/loading/LazyLoader.tsx

@@ -3,6 +3,7 @@ import { memo } from 'react';
 import { Box, CircularProgress } from '@mui/material';
 import type { SxProps, Theme } from '@mui/material';
 
+// Extract styles to prevent recreation on every render
 const containerStyles: SxProps<Theme> = {
   display: 'flex',
   justifyContent: 'center',

interface/src/components/loading/LoadingSpinner.tsx

@@ -7,6 +7,7 @@ interface LoadingSpinnerProps {
   height?: number | string;
 }
 
+// Extract styles to prevent recreation on every render
 const circularProgressStyles: SxProps<Theme> = (theme: Theme) => ({
   margin: theme.spacing(4),
   color: theme.palette.text.secondary

interface/src/i18n/cz/index.ts

@@ -60,6 +60,7 @@ const cz: Translation = {
   DUTY_CYCLE: 'Pracovní cyklus',
   UNIT: 'Jednotka',
   STARTVALUE: 'Počáteční hodnota',
+  WARN_GPIO: 'Upozornění: buďte opatrní při přiřazování GPIO!',
   EDIT: 'Upravit',
   SENSOR: 'Senzor',
   TEMP_SENSOR: 'Teplotní senzor',
@@ -355,8 +356,7 @@ const cz: Translation = {
   SWITCH_RELEASE_TYPE: 'Přepnout na {0} verzi',
   FIRMWARE_VERSION_INFO: 'Informace o verzi firmwaru',
   NO_DATA: 'Žádná data',
-  USER_PROFILE: 'Uživatelský profil',
-  STORED_VERSIONS: 'Uložené verze'
+  USER_PROFILE: 'Uživatelský profil'
 };
 
 export default cz;

interface/src/i18n/de/index.ts

@@ -60,6 +60,7 @@ const de: Translation = {
   DUTY_CYCLE: 'Arbeitszyklus',
   UNIT: 'Maßeinheit',
   STARTVALUE: 'Startwert',
+  WARN_GPIO: 'Warnung: Vorsicht bei der korrekten Wahl des GPIO!',
   EDIT: 'Editiere',
   SENSOR: 'Sensor',
   TEMP_SENSOR: 'Temperatursensor',
@@ -355,8 +356,7 @@ const de: Translation = {
   SWITCH_RELEASE_TYPE: 'Zum {0}-Release wechseln',
   FIRMWARE_VERSION_INFO: 'Firmware-Versionsinformation',
   NO_DATA: 'Keine Daten',
-  USER_PROFILE: 'Benutzerprofil',
-  STORED_VERSIONS: 'Gespeicherte Versionen'
+  USER_PROFILE: 'Benutzerprofil'
 };
 
 export default de;

interface/src/i18n/en/index.ts

@@ -60,6 +60,7 @@ const en: Translation = {
   DUTY_CYCLE: 'Duty Cycle',
   UNIT: 'UoM',
   STARTVALUE: 'Start Value',
+  WARN_GPIO: 'Warning: be careful when assigning a GPIO!',
   EDIT: 'Edit',
   SENSOR: 'Sensor',
   TEMP_SENSOR: 'Temperature Sensor',
@@ -355,8 +356,7 @@ const en: Translation = {
   SWITCH_RELEASE_TYPE: 'Switch to {0} release',
   FIRMWARE_VERSION_INFO: 'Firmware Version Information',
   NO_DATA: 'No data',
-  USER_PROFILE: 'User Profile',
-  STORED_VERSIONS: 'Stored Versions'
+  USER_PROFILE: 'User Profile'
 };
 
 export default en;

interface/src/i18n/fr/index.ts

@@ -60,6 +60,7 @@ const fr: Translation = {
   DUTY_CYCLE: 'Cycle de fonctionnement',
   UNIT: 'Unité',
   STARTVALUE: 'Valeur de départ',
+  WARN_GPIO: 'Attention: soyez vigilant en choisissant un GPIO!',
   EDIT: 'Éditer',
   SENSOR: 'Capteur',
   TEMP_SENSOR: 'Capteur de température',
@@ -355,8 +356,7 @@ const fr: Translation = {
   SWITCH_RELEASE_TYPE: 'Passer à la version {0}',
   FIRMWARE_VERSION_INFO: 'Informations sur la version du firmware',
   NO_DATA: 'Aucune donnée',
-  USER_PROFILE: 'Profil utilisateur',
-  STORED_VERSIONS: 'Versions stockées'
+  USER_PROFILE: 'Profil utilisateur'
 };
 
 export default fr;

interface/src/i18n/it/index.ts

@@ -60,6 +60,7 @@ const it: Translation = {
   DUTY_CYCLE: 'Ciclo di lavoro',
   UNIT: 'UoM',
   STARTVALUE: 'Valore di partenza',
+  WARN_GPIO: 'Avvertimento: prestare attenzione quando si assegna un GPIO!',
   EDIT: 'Modifica',
   SENSOR: 'Sensore',
   TEMP_SENSOR: 'Sensore Temperatura',
@@ -355,8 +356,7 @@ const it: Translation = {
   SWITCH_RELEASE_TYPE: 'Cambia in {0} rilascio',
   FIRMWARE_VERSION_INFO: 'Informazioni sulla versione del firmware',
   NO_DATA: 'Nessun dato',
-  USER_PROFILE: 'Profilo utente',
-  STORED_VERSIONS: 'Versioni memorizzate'
+  USER_PROFILE: 'Profilo utente'
 };
 
 export default it;

interface/src/i18n/nl/index.ts

@@ -60,6 +60,7 @@ const nl: Translation = {
   DUTY_CYCLE: 'Duty Cycle',
   UNIT: 'UoM',
   STARTVALUE: 'Startwaarde',
+  WARN_GPIO: 'Waarschuwing: let op met het koppelen van de juiste GPIO pin!',
   EDIT: 'Wijzigen',
   SENSOR: 'Sensor',
   TEMP_SENSOR: 'Temperatuur sensor',
@@ -355,8 +356,7 @@ const nl: Translation = {
   SWITCH_RELEASE_TYPE: 'Switch naar {0} release',
   FIRMWARE_VERSION_INFO: 'Informatie over firmwareversie',
   NO_DATA: 'Geen data',
-  USER_PROFILE: 'Gebruikersprofiel',
-  STORED_VERSIONS: 'Opgeslagen versies'
+  USER_PROFILE: 'Gebruikersprofiel'
 };
 
 export default nl;

interface/src/i18n/no/index.ts

@@ -60,6 +60,7 @@ const no: Translation = {
   DUTY_CYCLE: 'Duty Cycle',
   UNIT: 'UoM',
   STARTVALUE: 'Startverdi',
+  WARN_GPIO: 'Advarsel: vær forsiktig ved aktivering av GPIO!',
   EDIT: 'Endre',
   SENSOR: 'Sensor',
   TEMP_SENSOR: 'Temperatursensor',
@@ -355,8 +356,7 @@ const no: Translation = {
   SWITCH_RELEASE_TYPE: 'Bytt til {0} utgivelse',
   FIRMWARE_VERSION_INFO: 'Informasjon om firmwareversjon',
   NO_DATA: 'Ingen data',
-  USER_PROFILE: 'Brukerprofil',
-  STORED_VERSIONS: 'Lagret versjoner'
+  USER_PROFILE: 'Brukerprofil'
 };
 
 export default no;

interface/src/i18n/pl/index.ts

@@ -60,6 +60,7 @@ const pl: BaseTranslation = {
   DUTY_CYCLE: 'Wypełnienie',
   UNIT: 'J.m.',
   STARTVALUE: 'Wartość początkowa',
+  WARN_GPIO: 'Uwaga! Zachowaj ostrożność przypisując GPIO do urządzenia!',
   EDIT: 'Edycja',
   SENSOR: '{{c|ustawienia c||ustawień c|}}zujnika',
   TEMP_SENSOR: 'czujnika temperatury',
@@ -331,7 +332,7 @@ const pl: BaseTranslation = {
   SERVICES: 'Usługi',
   ALLVALUES: 'Wszystkie wartości',
   SPECIAL_FUNCTIONS: 'Specjalne funkcje',
-  WAIT_FIRMWARE: 'Firmware ściąga się i instaluje',
+  WAIT_FIRMWARE: 'Firma jest wysyłana i instaluje się',
   INSTALL_VERSION: 'To zainstaluje wersję {1} {0}. Jesteś pewny?',
   UPDATE_AVAILABLE: 'aktualizacja dostępna',
   LATEST_VERSION: 'Jesteś używając najnowszej wersji firmware {0}',
@@ -355,8 +356,7 @@ const pl: BaseTranslation = {
   SWITCH_RELEASE_TYPE: 'Zmień na {0} wydanie',
   FIRMWARE_VERSION_INFO: 'Informacje o wersji firmware',
   NO_DATA: 'Brak danych',
-  USER_PROFILE: 'Profil użytkownika',
-  STORED_VERSIONS: 'Zapisane wersje'
+  USER_PROFILE: 'Profil użytkownika'
 };
 
 export default pl;

interface/src/i18n/sk/index.ts

@@ -60,6 +60,7 @@ const sk: Translation = {
   DUTY_CYCLE: 'Pracovný cyklus',
   UNIT: 'UoM',
   STARTVALUE: 'Počiatočná hodnota',
+  WARN_GPIO: 'Upozornenie: Buďte opatrní pri priraďovaní GPIO!',
   EDIT: 'Editovať',
   SENSOR: 'Snímač',
   TEMP_SENSOR: 'Snímač teploty',
@@ -355,8 +356,7 @@ const sk: Translation = {
   SWITCH_RELEASE_TYPE: 'Prepnúť na {0} verziu',
   FIRMWARE_VERSION_INFO: 'Informácie o verzii firmware',
   NO_DATA: 'Žiadne dáta',
-  USER_PROFILE: 'Profil používateľa',
-  STORED_VERSIONS: 'Uložené verzie'
+  USER_PROFILE: 'Profil používateľa'
 };
 
 export default sk;

interface/src/i18n/sv/index.ts

@@ -60,6 +60,7 @@ const sv: Translation = {
   DUTY_CYCLE: 'Pulskvot',
   UNIT: 'Måttenhet',
   STARTVALUE: 'Startvärde',
+  WARN_GPIO: 'Varning: Var försiktig vid aktivering av GPIO!',
   EDIT: 'Ändra',
   SENSOR: 'Sensor',
   TEMP_SENSOR: 'Temperatursensor',
@@ -355,8 +356,7 @@ const sv: Translation = {
   SWITCH_RELEASE_TYPE: 'Byt till {0} utgåva',
   FIRMWARE_VERSION_INFO: 'Information om firmwareversion',
   NO_DATA: 'Ingen data',
-  USER_PROFILE: 'Användarprofil',
-  STORED_VERSIONS: 'Lagrad versioner'
+  USER_PROFILE: 'Användarprofil'
 };
 
 export default sv;

interface/src/i18n/tr/index.ts

@@ -60,6 +60,7 @@ const tr: Translation = {
   DUTY_CYCLE: 'Görev Çevrimi',
   UNIT: 'ÖB',
   STARTVALUE: 'Başlangıç değeri',
+  WARN_GPIO: 'Uyarı: bir GPIO atarken dikkatli olun!',
   EDIT: 'Değiştir',
   SENSOR: 'Sensör',
   TEMP_SENSOR: 'Sıcaklık Sensörü',
@@ -355,8 +356,7 @@ const tr: Translation = {
   SWITCH_RELEASE_TYPE: '{0} sürümüne geç',
   FIRMWARE_VERSION_INFO: 'Firmware Sürüm Bilgisi',
   NO_DATA: 'Hiçbir veri yok',
-  USER_PROFILE: 'Kullanıcı Profili',
-  STORED_VERSIONS: 'Kaydedilmiş Sürümler'
+  USER_PROFILE: 'Kullanıcı Profili'
 };
 
 export default tr;

interface/src/index.tsx

@@ -91,12 +91,12 @@ function ErrorPage() {
       <p style={errorPageStyles.message2}>
         Please report on{' '}
         <a
-          href="https://emsesp.org/Support"
+          href="https://docs.emsesp.org/Support"
           target="_blank"
           rel="noreferrer"
           style={{ color: 'inherit', textDecoration: 'underline' }}
         >
-          https://emsesp.org/Support
+          https://docs.emsesp.org/Support
         </a>
       </p>
     </div>

interface/src/types/system.ts

@@ -2,15 +2,13 @@ import type { busConnectionStatus } from 'app/main/types';
 
 import type { NetworkConnectionStatus } from './network';
 
-// match SYSTEM_STATUS in System.h
 export enum SystemStatusCodes {
   SYSTEM_STATUS_NORMAL = 0,
   SYSTEM_STATUS_PENDING_UPLOAD = 1,
   SYSTEM_STATUS_UPLOADING = 100,
   SYSTEM_STATUS_ERROR_UPLOAD = 3,
   SYSTEM_STATUS_PENDING_RESTART = 4,
-  SYSTEM_STATUS_RESTART_REQUESTED = 5,
-  SYSTEM_STATUS_INVALID_GPIO = 6
+  SYSTEM_STATUS_RESTART_REQUESTED = 5
 }
 
 export interface SystemStatus {
@@ -52,14 +50,7 @@ export interface SystemStatus {
   model: string;
   has_loader: boolean;
   has_partition: boolean;
-  partitions: {
-    partition: string;
-    version: string;
-    size: number;
-    install_date?: string;
-  }[];
-  status: number; // System Status Codes which matches SYSTEM_STATUS in System.h
-  developer_mode: boolean;
+  status: number; // SystemStatusCodes which matches SYSTEM_STATUS in System.h
   temperature?: number;
 }
 

interface/src/utils/binding.ts

@@ -25,7 +25,6 @@ export const extractEventValue = (
       normalizedValue.endsWith('.') ||
       normalizedValue === '-' ||
       normalizedValue === '-.' ||
-      normalizedValue === '-0' ||
       endsWithDecimalAndZeros;
 
     if (isIncomplete) {

interface/src/utils/useRest.ts

@@ -60,28 +60,21 @@ export const useRest = <D>({ read, update }: RestRequestOptions<D>) => {
     // Reset states before saving
     setRestartNeeded(false);
     setErrorMessage(undefined);
+    setDirtyFlags([]);
+    setOrigData(data as D);
 
     try {
       await writeData(data as D);
-      // Only update origData on successful save (dirtyFlags cleared by onSuccess handler)
-      setOrigData(data as D);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-
       if (message === REBOOT_ERROR_MESSAGE) {
         setRestartNeeded(true);
-        return; // Early return - save succeeded but needs reboot
+      } else {
+        toast.error(message);
+        setErrorMessage(message);
       }
-
-      // Restore original data on validation error
-      if (origData) {
-        updateData({ data: origData });
-      }
-      toast.error(message);
-      setErrorMessage(message);
-      setDirtyFlags([]); // Clear flags so user can retry
     }
-  }, [data, writeData, origData, updateData]);
+  }, [data, writeData]);
 
   return useMemo(
     () => ({

interface/vite.config.ts

@@ -26,9 +26,6 @@ const RESOLVE_ALIASES = {
   'react/jsx-runtime': 'preact/jsx-runtime'
 };
 
-// Common resolve extensions - prioritize TypeScript/React files for Windows compatibility
-const RESOLVE_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.json'];
-
 // Bundle file interface
 interface BundleFile {
   name: string;
@@ -104,12 +101,7 @@ const createBasePlugins = (
   devToolsEnabled: boolean,
   includeBundleReporter = true
 ) => {
-  const plugins = [
-    createPreactPlugin(devToolsEnabled),
-    viteTsconfigPaths({
-      projects: ['./tsconfig.json']
-    })
-  ];
+  const plugins = [createPreactPlugin(devToolsEnabled), viteTsconfigPaths()];
   if (includeBundleReporter) {
     plugins.push(bundleSizeReporter());
   }
@@ -226,8 +218,7 @@ export default defineConfig(
       return {
         plugins: [...createBasePlugins(true, true), mockServer()],
         resolve: {
-          alias: RESOLVE_ALIASES,
-          extensions: RESOLVE_EXTENSIONS
+          alias: RESOLVE_ALIASES
         },
         server: {
           open: true,
@@ -255,8 +246,7 @@ export default defineConfig(
       return {
         plugins: createBasePlugins(false, true),
         resolve: {
-          alias: RESOLVE_ALIASES,
-          extensions: RESOLVE_EXTENSIONS
+          alias: RESOLVE_ALIASES
         },
         build: {
           ...createBaseBuildConfig(),
@@ -289,8 +279,7 @@ export default defineConfig(
         })
       ],
       resolve: {
-        alias: RESOLVE_ALIASES,
-        extensions: RESOLVE_EXTENSIONS
+        alias: RESOLVE_ALIASES
       },
       build: {
         ...createBaseBuildConfig(),

lib/PButton/PButton.h

@@ -36,9 +36,6 @@ class PButton {
     void onVLongPress(uint16_t, buttonEventHandler handler);
     bool init(uint8_t pin, bool pullMode);
     bool check(void);
-    bool button_busy() {
-        return buttonBusy_;
-    }
 
   private:
     uint16_t Debounce_;        // Debounce period to prevent flickering when pressing or releasing the button (in ms)
@@ -50,21 +47,21 @@ class PButton {
     bool    pullMode_;
     bool    enabled_;
 
-    bool state_;            // Value read from button
-    bool lastState_;        // Last value of button state
-    bool dblClickWaiting_;  // whether we're waiting for a double click (down)
-    bool dblClickOnNextUp_; // whether to register a double click on next release, or whether to wait and click
-    bool singleClickOK_;    // whether it's OK to do a single click
+    bool state_;              // Value read from button
+    bool lastState_;          // Last value of button state
+    bool dblClickWaiting_;    // whether we're waiting for a double click (down)
+    bool dblClickOnNextUp_;   // whether to register a double click on next release, or whether to wait and click
+    bool singleClickOK_;      // whether it's OK to do a single click
 
-    uint32_t downTime_; // time the button was pressed down
-    uint32_t upTime_;   // time the button was released
+    uint32_t downTime_;       // time the button was pressed down
+    uint32_t upTime_;         // time the button was released
 
     bool ignoreUP_;           // whether to ignore the button release because the click+hold was triggered
     bool waitForUP_;          // when held, whether to wait for the up event
     bool longPressHappened_;  // whether or not the hold event happened already
     bool vLongPressHappened_; // whether or not the long hold event happened already
 
-    bool buttonBusy_; // false if idle
+    bool buttonBusy_;         // false if idle
 
     buttonEventHandler cb_onClick, cb_onDblClick, cb_onLongPress, cb_onVLongPress;
 };

lib/esp32-psram/README.md

@@ -1,91 +0,0 @@
-# ESP32-PSRAM Library
-
-[![Arduino Library](https://img.shields.io/badge/Arduino-Library-blue.svg)](https://www.arduino.cc/reference/en/libraries/)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-A comprehensive memory management library for ESP32 microcontrollers, providing efficient data structures that leverage __PSRAM__ and __HIMEM__ for expanded storage capabilities.
-
-
-## Overview
-
-The ESP32 can only address 4MB of PSRAM directly, so the remaining 4MB (HIMEM) are usually unsued!
-
-__esp32-psram__ is a C++ library that helps you manage large amounts of data on ESP32 devices by utilizing the full external PSRAM (SPI RAM) supporting the high memory (HIMEM) regions. This allows your applications to work with much larger datasets than would be possible using just internal RAM. 
-
-- **Use any STL Class in PSRAM**:
-  - Adapt any [STL class](https://en.wikipedia.org/wiki/Standard_Template_Library) that accepts with an Allocator by using the [AllocatorPSRAM](https://pschatzmann.github.io/esp32-psram/html/classesp32__psram_1_1_p_s_r_a_m_allocator.html)
-
-- **Memory-Efficient Data Structures**:
-  - `VectorPSRAM`: Vector implementation that automatically stores data in PSRAM
-  - `VectorHIMEM`: Vector implementation for extremely large datasets using ESP32's high memory region
-  
-- **File System Abstractions**:
-  - `FilePSRAM`: File-like interface backed by PSRAM
-  - `FileHIMEM`: File-like interface backed by high memory
-  - SD card-like API using familiar file operations to write to PSRAM or HIMEM.
-  
-- **Streaming Data Handling**:
-  - `RingBufferStreamRAM`: Circular buffer implementation in RAM (Stream-based)
-  - `RingBufferStreamPSRAM`: Circular buffer implementation in PSRAM (Stream-based)
-  - `RingBufferStreamHIMEM`: Circular buffer implementation in high memory (Stream-based)
-  - Fully compatible with Arduino's Stream class
-  
-- **Typed Ring Buffers**:
-  - `TypedRingBufferRAM<T>`: Type-safe circular buffer for any data type using RAM
-  - `TypedRingBufferPSRAM<T>`: PSRAM version for storing complex data structures
-  - `TypedRingBufferHIMEM<T>`: High memory version for storing complex data structures
-  - Optimized for struct/class storage with proper memory management
-
-
-## Installation
-
-1. Download the latest release from GitHub
-2. Extract the ZIP file
-3. Move the folder to your Arduino libraries directory (typically `~/Arduino/libraries/` on Linux/macOS or `Documents\Arduino\libraries\` on Windows)
-4. Restart Arduino IDE
-
-
-## API Reference
-
-- [Class Reference](https://pschatzmann.github.io/esp32-psram/html/namespaceesp32__psram.html)
-- [Further Information](https://github.com/pschatzmann/esp32-psram/wiki)
-
-## Memory Performance Comparison
-
-| Memory Type | Access Speed | Capacity | Use Case |
-|-------------|--------------|----------|----------|
-| RAM (DRAM)  | Very Fast    | ~200-300KB | Small, performance-critical data |
-| PSRAM       | Fast         | Up to 4MB  | Medium-sized datasets, frequent access |
-| HIMEM       | Medium       | Up to 8MB  | Large datasets, less frequent access |
-
-## Hardware Compatibility
-
-| ESP32 Board | PSRAM Size | HIMEM Support | Notes |
-|-------------|------------|--------------|-------|
-| ESP32       | Up to 4MB  | Yes          | Most common ESP32 modules |
-| ESP32-S2    | Up to 2MB  | Limited      | Check board specifications |
-| ESP32-S3    | Up to 8MB  | Yes          | Best memory capabilities |
-| ESP32-C3    | None       | No           | Not compatible with this library |
-
-## Design Philosophy
-
-The ESP32-PSRAM library is designed with these principles in mind:
-
-1. **Familiar interfaces**: API design mimics standard C++ containers and Arduino libraries
-2. **Memory efficiency**: Automatic use of appropriate memory regions
-3. **Type safety**: Template-based to work with any data type
-4. **Flexibility**: Configurable for different memory types and use cases
-5. **Zero overhead**: Direct memory access with minimal abstraction layers
-
-
-## License
-
-MIT License
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## Acknowledgements
-
-This library was inspired by the need for better memory management solutions on ESP32, especially for audio, image processing, and data logging applications.

lib/esp32-psram/library.properties

@@ -1,10 +0,0 @@
-name=ESP32-PSRAM
-version=0.1.3
-author=Phil Schatzmann
-maintainer=https://github.com/pschatzmann
-sentence=Memory management library for ESP32 using PSRAM and HIMEM
-paragraph=A comprehensive memory management library that provides vector, file, and ring buffer implementations using ESP32's PSRAM and HIMEM. Allows applications to work with large datasets beyond internal memory limitations.
-category=Data Storage
-url=https://github.com/pschatzmann/esp32-psram
-architectures=esp32
-depends=

lib/esp32-psram/license.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Phil Schatzmann
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

lib/esp32-psram/src/esp32-psram.h

@@ -1,31 +0,0 @@
-#pragma once
-
-#ifdef ESP32
-/**
- * @file ESP32-PSRAM.h
- * @brief Main include file for the ESP32-PSRAM library
- * 
- * This header includes all components of the ESP32-PSRAM library and
- * provides a using namespace directive for easier access to library features.
- */
-
-// Include all library components
-#include "esp32-psram/AllocatorPSRAM.h"   // PSRAM-backed vector
-#include "esp32-psram/VectorPSRAM.h"   // PSRAM-backed vector
-#include "esp32-psram/VectorHIMEM.h"   // HIMEM-backed vector
-// #include "esp32-psram/InMemoryFile.h"    // File interface using vectors
-// #include "esp32-psram/PSRAM.h"         // PSRAM file system
-// #include "esp32-psram/HIMEM.h"         // HIMEM file system
-#include "esp32-psram/RingBufferStream.h" // Stream-based ring buffer
-#include "esp32-psram/TypedRingBuffer.h" // Typed ring buffer for structured data
-
-#define stringPSRAM std::basic_string<char, std::char_traits<char>, AllocatorPSRAM<char>>
-
-#ifndef ESP32_PSRAM_NO_NAMESPACE
-using namespace esp32_psram;
-#endif
-
-#else
-#error "This library is only compatible with ESP32 platforms."
-#endif  // ESP32
-

lib/esp32-psram/src/esp32-psram/AllocatorPSRAM.h

@@ -1,159 +0,0 @@
-#pragma once
-
-#include <esp_heap_caps.h>
-
-/**
- * @namespace esp32_psram
- * @brief Namespace containing ESP32 PSRAM-specific implementations
- */
-namespace esp32_psram {
-
-/**
- * @class AllocatorPSRAM
- * @brief Custom allocator that uses ESP32's PSRAM for memory allocation
- * @tparam T Type of elements to allocate
- *
- * This allocator uses ESP32's heap_caps_malloc with MALLOC_CAP_SPIRAM flag
- * to ensure all memory is allocated in PSRAM instead of regular RAM. If PSRAM
- * allocation fails, it falls back to regular RAM.
- */
-template <typename T>
-class AllocatorPSRAM {
- public:
-  using value_type = T;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-
-  /**
-   * @brief Default constructor
-   */
-  AllocatorPSRAM() noexcept {}
-
-  /**
-   * @brief Copy constructor from another allocator type
-   * @tparam U Type of the other allocator
-   * @param other The other allocator
-   */
-  template <typename U>
-  AllocatorPSRAM(const AllocatorPSRAM<U>&) noexcept {}
-
-  /**
-   * @brief Allocate memory from PSRAM
-   * @param n Number of elements to allocate
-   * @return Pointer to allocated memory
-   * @throws std::bad_alloc If allocation fails or size is too large
-   */
-  pointer allocate(size_type n) {
-    // if (n > std::numeric_limits<size_type>::max() / sizeof(T))
-    //     throw std::bad_alloc();
-    // in Arduino excepitons are disabled!
-    assert(n <= std::numeric_limits<size_type>::max() / sizeof(T));
-
-    pointer p = static_cast<pointer>(
-        heap_caps_malloc(n * sizeof(T), MALLOC_CAP_SPIRAM));
-    if (p == nullptr) {
-      p = static_cast<pointer>(malloc(n * sizeof(T)));
-    }
-
-    // if (!p) throw std::bad_alloc();
-
-    // in Arduino excepitons are disabled!
-    assert(p);
-
-    return p;
-  }
-
-  /**
-   * @brief Deallocate memory
-   * @param p Pointer to memory to deallocate
-   * @param size Size of allocation (unused)
-   */
-  void deallocate(pointer p, size_type) noexcept { heap_caps_free(p); }
-
-  /**
-   * @brief Rebind allocator to another type
-   * @tparam U Type to rebind the allocator to
-   */
-  template <typename U>
-  struct rebind {
-    using other = AllocatorPSRAM<U>;
-  };
-};
-
-/**
- * @class AllocatorOnlyPSRAM
- * @brief Custom allocator that uses ESP32's PSRAM for memory allocation
- * @tparam T Type of elements to allocate
- *
- * This allocator uses ESP32's heap_caps_malloc with MALLOC_CAP_SPIRAM flag
- * to ensure all memory is allocated in PSRAM instead of regular RAM.
- * If PSRAM allocation fails, it does not fall back to regular RAM.
- */
-template <typename T>
-class AllocatorOnlyPSRAM {
- public:
-  using value_type = T;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using reference = T&;
-  using const_reference = const T&;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-
-  /**
-   * @brief Default constructor
-   */
-  AllocatorOnlyPSRAM() noexcept {}
-
-  /**
-   * @brief Copy constructor from another allocator type
-   * @tparam U Type of the other allocator
-   * @param other The other allocator
-   */
-  template <typename U>
-  AllocatorOnlyPSRAM(const AllocatorOnlyPSRAM<U>&) noexcept {}
-
-  /**
-   * @brief Allocate memory from PSRAM
-   * @param n Number of elements to allocate
-   * @return Pointer to allocated memory
-   * @throws std::bad_alloc If allocation fails or size is too large
-   */
-  pointer allocate(size_type n) {
-    // if (n > std::numeric_limits<size_type>::max() / sizeof(T))
-    //     throw std::bad_alloc();
-    // in Arduino excepitons are disabled!
-    assert(n <= std::numeric_limits<size_type>::max() / sizeof(T));
-
-    pointer p = static_cast<pointer>(
-        heap_caps_malloc(n * sizeof(T), MALLOC_CAP_SPIRAM));
-    // if (!p) throw std::bad_alloc();
-
-    // in Arduino excepitons are disabled!
-    assert(p);
-
-    return p;
-  }
-
-  /**
-   * @brief Deallocate memory
-   * @param p Pointer to memory to deallocate
-   * @param size Size of allocation (unused)
-   */
-  void deallocate(pointer p, size_type) noexcept { heap_caps_free(p); }
-
-  /**
-   * @brief Rebind allocator to another type
-   * @tparam U Type to rebind the allocator to
-   */
-  template <typename U>
-  struct rebind {
-    using other = AllocatorOnlyPSRAM<U>;
-  };
-};
-
-}  // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/HIMEM.h

@@ -1,54 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-#include "InMemoryFS.h"
-#include "VectorHIMEM.h"
-
-namespace esp32_psram {
-
-/**
- * @class HIMEMClass
- * @brief Class for managing files stored in ESP32's High Memory (HIMEM)
- * 
- * This class provides an interface similar to SD.h for managing files
- * that are stored in HIMEM memory (beyond the 4MB boundary) rather than on an SD card.
- * HIMEM offers larger storage capacity but slightly slower access than regular PSRAM.
- */
-class HIMEMClass : public InMemoryFS<VectorHIMEM<uint8_t>, FileHIMEM> {
-public:
-    /**
-     * @brief Initialize the HIMEM filesystem
-     * @return true if initialization was successful, false otherwise
-     */
-    bool begin() override {
-        if (esp_himem_get_free_size() > 0) {
-            initialized = true;
-            return true;
-        }
-        initialized = false;
-        return false;
-    }
-
-    /**
-     * @brief Get total space (returns available HIMEM)
-     * @return Total HIMEM size in bytes
-     */
-    uint64_t totalBytes() override {
-        return esp_himem_get_phys_size();
-    }
-
-    /**
-     * @brief Get free space (returns free HIMEM)
-     * @return Free HIMEM size in bytes
-     */
-    uint64_t freeBytes() override {
-        return esp_himem_get_free_size();
-    }
-};
-
-/**
- * @brief Global instance of HIMEMClass for easy access
- */
-static HIMEMClass HIMEM;
-
-} // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/HimemBlock.h

@@ -1,362 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <limits>
-#include <memory>
-#include <vector>
-// ESP32 HIMEM headers - using conditional inclusion for compatibility
-#if __has_include("esp32/himem.h")
-#include "esp32/himem.h"
-#elif __has_include("esp_himem.h")
-#include "esp_himem.h"
-#else
-// Fall back to Arduino ESP32 core path
-extern "C" {
-#include "esp32/himem.h"
-}
-
-// Define missing constants if needed
-#ifndef ESP_HIMEM_BLKSZ
-#define ESP_HIMEM_BLKSZ (32 * 1024)
-#endif
-#endif
-
-// Make sure ESP_HIMEM_PROT_RW is defined
-#ifndef ESP_HIMEM_PROT_RW
-#define ESP_HIMEM_PROT_RW 0
-#endif
-
-namespace esp32_psram {
-
-static constexpr const char* TAG = "HIMEM";  // Tag for ESP logging
-
-/**
- * @class HimemBlock
- * @brief Manages a block of himem memory with mapping functionality
- */
-class HimemBlock {
- public:
-  /**
-   * @brief Default constructor
-   */
-  HimemBlock() { ESP_LOGD(TAG, "HimemBlock constructor called"); }
-
-  /**
-   * @brief Allocate a block of himem
-   * @param block_size Size of memory to allocate in bytes
-   * @return the allocated (block) size in bytes, 0 otherwise
-   */
-  size_t allocate(size_t block_size) {
-    ESP_LOGI(TAG, "HimemBlock::allocate(%u bytes) - Current handle: %p",
-             block_size, handle);
-
-    if (handle != 0) {
-      ESP_LOGW(TAG, "Cannot allocate: Block already allocated");
-      return false;  // Already allocated
-    }
-
-    // Round up to the nearest multiple of ESP_HIMEM_BLKSZ (32K)
-    block_size = ((block_size + ESP_HIMEM_BLKSZ - 1) / ESP_HIMEM_BLKSZ) *
-                 ESP_HIMEM_BLKSZ;
-
-    size = block_size;
-    esp_err_t err = esp_himem_alloc(block_size, &handle);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "HIMEM allocation failed - error: %d, size: %d", err,
-               block_size);
-      return 0;
-    }
-
-    ESP_LOGD(TAG, "- Successfully allocated %u bytes, handle: %p", block_size,
-             handle);
-    return block_size;
-  }
-
-  /**
-   * @brief Read data from HIMEM at specified offset
-   * @param dest Destination buffer
-   * @param offset Offset in HIMEM to read from
-   * @param length Number of bytes to read
-   * @return Number of bytes actually read
-   */
-  size_t read(void* dest, size_t offset, size_t length) {
-    ESP_LOGD(TAG, "HimemBlock::read(dst=%p, offset=%u, length=%u)", dest,
-             offset, length);
-
-    if (!handle || offset >= size) {
-      ESP_LOGW(TAG, "Read failed: %s",
-               !handle ? "Invalid handle" : "Offset beyond size");
-      return 0;
-    }
-
-    // Ensure we don't read past the end
-    length = std::min(length, size - offset);
-    if (length == 0) {
-      ESP_LOGW(TAG, "Read failed: Zero length after bounds check");
-      return 0;
-    }
-
-    // Calculate which block this belongs to
-    size_t block_index = offset / ESP_HIMEM_BLKSZ;
-    size_t block_offset = offset % ESP_HIMEM_BLKSZ;
-    size_t bytes_read = 0;
-
-    ESP_LOGD(TAG, "- Reading from block %u, offset %u", block_index,
-             block_offset);
-    uint8_t* dest_ptr = static_cast<uint8_t*>(dest);
-
-    while (bytes_read < length) {
-      // Ensure the correct block is mapped
-      if (!ensure_block_mapped(block_index)) {
-        return bytes_read;
-      }
-
-      // Calculate how much to read from this block
-      size_t block_remain = ESP_HIMEM_BLKSZ - block_offset;
-      size_t to_read = std::min(block_remain, length - bytes_read);
-      ESP_LOGD(TAG, "- Reading %u bytes from window at offset %u", to_read,
-               block_offset);
-
-      // Copy the data
-      memcpy(dest_ptr + bytes_read,
-             static_cast<uint8_t*>(mapped_ptr) + block_offset, to_read);
-
-      bytes_read += to_read;
-      block_index++;
-      block_offset = 0;  // Reset offset for next blocks
-    }
-
-    ESP_LOGD(TAG, "- Successfully read %u bytes", bytes_read);
-    return bytes_read;
-  }
-
-  /**
-   * @brief Write data to HIMEM at specified offset
-   * @param src Source buffer
-   * @param offset Offset in HIMEM to write to
-   * @param length Number of bytes to write
-   * @return Number of bytes actually written
-   */
-  size_t write(const void* src, size_t offset, size_t length) {
-    ESP_LOGD(TAG, "HimemBlock::write(src=%p, offset=%u, length=%u)", src,
-             offset, length);
-
-    if (!handle || offset >= size) {
-      ESP_LOGW(TAG, "Write failed: %s",
-               !handle ? "Invalid handle" : "Offset beyond size");
-      return 0;
-    }
-
-    // Ensure we don't write past the end
-    length = std::min(length, size - offset);
-    if (length == 0) {
-      ESP_LOGW(TAG, "Write failed: Zero length after bounds check");
-      return 0;
-    }
-
-    // Calculate which block this belongs to
-    size_t block_index = offset / ESP_HIMEM_BLKSZ;
-    size_t block_offset = offset % ESP_HIMEM_BLKSZ;
-    size_t bytes_written = 0;
-
-    ESP_LOGD(TAG, "- Writing to block %u, offset %u", block_index,
-             block_offset);
-    const uint8_t* src_ptr = static_cast<const uint8_t*>(src);
-
-    while (bytes_written < length) {
-      // Ensure the correct block is mapped
-      if (!ensure_block_mapped(block_index)) {
-        return bytes_written;
-      }
-
-      // Calculate how much to write to this block
-      size_t block_remain = ESP_HIMEM_BLKSZ - block_offset;
-      size_t to_write = std::min(block_remain, length - bytes_written);
-      ESP_LOGD(TAG, "- Writing %u bytes to window at offset %u", to_write,
-               block_offset);
-
-      // Copy the data
-      memcpy(static_cast<uint8_t*>(mapped_ptr) + block_offset,
-             src_ptr + bytes_written, to_write);
-
-      bytes_written += to_write;
-      block_index++;
-      block_offset = 0;  // Reset offset for next blocks
-    }
-
-    ESP_LOGD(TAG, "- Successfully wrote %u bytes", bytes_written);
-    return bytes_written;
-  }
-
-  bool getAddress(size_t offset, void* &result, size_t &available) {
-    size_t block_index = offset / ESP_HIMEM_BLKSZ;
-    size_t block_offset = offset % ESP_HIMEM_BLKSZ;
-    if (!ensure_block_mapped(block_index)) return false;
-    available = ESP_HIMEM_BLKSZ - block_offset;
-    result = static_cast<uint8_t*>(mapped_ptr)+block_offset;
-    return true;
-  }
-
-  /**
-   * @brief Unmap the himem block
-   */
-  void unmap() {
-    ESP_LOGD(TAG, "HimemBlock::unmap() - mapped_ptr=%p, range=%p", mapped_ptr,
-             range);
-
-    if (mapped_ptr && range) {
-      ESP_LOGD(TAG, "- Unmapping memory and freeing range");
-      esp_himem_unmap(range, mapped_ptr, ESP_HIMEM_BLKSZ);
-      esp_himem_free_map_range(range);
-      mapped_ptr = nullptr;
-      range = 0;
-      current_mapped_block = SIZE_MAX;  // Reset currently mapped block
-      ESP_LOGD(TAG, "- Unmapped successfully");
-    } else {
-      ESP_LOGD(TAG, "- Nothing to unmap");
-    }
-  }
-
-  /**
-   * @brief Free the himem block
-   */
-  void free() {
-    ESP_LOGD(TAG, "HimemBlock::free() - handle=%p", handle);
-
-    if (handle) {
-      ESP_LOGD(TAG, "- Unmapping before freeing");
-      unmap();
-      ESP_LOGD(TAG, "- Freeing HIMEM handle %p", handle);
-      esp_himem_free(handle);
-      handle = 0;
-      size = 0;
-      ESP_LOGD(TAG, " - Successfully freed HIMEM block");
-    } else {
-      ESP_LOGD(TAG, "- Nothing to free");
-    }
-  }
-
-  /**
-   * @brief Get the size of the allocated block
-   * @return Size of the allocated block in bytes
-   */
-  size_t get_size() const {
-    ESP_LOGD(TAG, "HimemBlock::get_size() = %u", size);
-    return size;
-  }
-
-  /**
-   * @brief Destructor - ensures memory is properly freed
-   */
-  ~HimemBlock() {
-    ESP_LOGD(TAG, "HimemBlock destructor called");
-    free();
-  }
-
-  /**
-   * @brief Copy constructor (deleted)
-   */
-  HimemBlock(const HimemBlock&) = delete;
-
-  /**
-   * @brief Move constructor
-   */
-  HimemBlock(HimemBlock&& other) noexcept
-      : handle(other.handle),
-        range(other.range),
-        mapped_ptr(other.mapped_ptr),
-        size(other.size),
-        current_mapped_block(other.current_mapped_block) {
-    ESP_LOGD(TAG, "HimemBlock move constructor - moving handle=%p, size=%u",
-             other.handle, other.size);
-    other.handle = 0;
-    other.range = 0;
-    other.mapped_ptr = nullptr;
-    other.size = 0;
-    other.current_mapped_block = SIZE_MAX;
-  }
-
-  /**
-   * @brief Copy assignment operator (deleted)
-   */
-  HimemBlock& operator=(const HimemBlock&) = delete;
-
-  /**
-   * @brief Move assignment operator
-   */
-  HimemBlock& operator=(HimemBlock&& other) noexcept {
-    ESP_LOGD(TAG, "HimemBlock move assignment - from handle=%p to handle=%p",
-             other.handle, handle);
-
-    if (this != &other) {
-      ESP_LOGD(TAG, "Freeing current resources before move assignment");
-      free();
-      handle = other.handle;
-      range = other.range;
-      mapped_ptr = other.mapped_ptr;
-      size = other.size;
-      current_mapped_block = other.current_mapped_block;
-      ESP_LOGD(TAG, "Moved resources, new size=%u", size);
-      other.handle = 0;
-      other.range = 0;
-      other.mapped_ptr = nullptr;
-      other.size = 0;
-      other.current_mapped_block = SIZE_MAX;
-    } else {
-      ESP_LOGD(TAG, "Self-assignment detected, no action taken");
-    }
-    return *this;
-  }
-
- protected:
-  esp_himem_handle_t handle = 0;
-  esp_himem_rangehandle_t range = 0;
-  void* mapped_ptr = nullptr;
-  size_t size = 0;
-  size_t current_mapped_block =
-      SIZE_MAX;  // Track which block is currently mapped
-
-  /**
-   * @brief Ensure a specific block is mapped into memory
-   * @param block_index The index of the block to map
-   * @return true if mapping successful, false otherwise
-   */
-  bool ensure_block_mapped(size_t block_index) {
-    // If the requested block is already mapped, we're done
-    if (block_index == current_mapped_block) {
-      return true;
-    }
-
-    // Unmap previous block if any
-    if (mapped_ptr) {
-      ESP_LOGD(TAG, "- Unmapping block %u before mapping new block %u",
-               current_mapped_block, block_index);
-      unmap();  // Unmap previous block
-    }
-
-    // Allocate map range
-    ESP_LOGD(TAG, "- Allocating map range for block %u", block_index);
-    esp_err_t err = esp_himem_alloc_map_range(ESP_HIMEM_BLKSZ, &range);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to allocate map range: %d", err);
-      return false;
-    }
-
-    // Map the current block
-    ESP_LOGD(TAG, "- Mapping block %u (offset %u)", block_index,
-             block_index * ESP_HIMEM_BLKSZ);
-    err = esp_himem_map(handle, range, block_index * ESP_HIMEM_BLKSZ, 0,
-                        ESP_HIMEM_BLKSZ, ESP_HIMEM_PROT_RW, &mapped_ptr);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "Failed to map memory: %d", err);
-      esp_himem_free_map_range(range);
-      range = 0;
-      return false;
-    }
-
-    current_mapped_block = block_index;
-    return true;
-  }
-};
-
-}  // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/InMemoryFS.h_

@@ -1,251 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-
-#include <map>
-
-#include "InMemoryFile.h"
-
-// Define Arduino file mode constants if not already defined
-#ifndef FILE_READ
-#define FILE_READ 0
-#endif
-#ifndef FILE_WRITE
-#define FILE_WRITE 1
-#endif
-#ifndef FILE_APPEND
-#define FILE_APPEND 2
-#endif
-
-namespace esp32_psram {
-
-/**
- * @class InMemoryFS
- * @brief Base class for memory-based file systems like PSRAM and HIMEM
- *
- * This class provides a common interface for in-memory file systems,
- * with methods for file management and traversal.
- *
- * @tparam VectorType The vector implementation to use (VectorPSRAM or
- * VectorHIMEM)
- * @tparam FileType The file implementation to return (FilePSRAM or FileHIMEM)
- */
-template <typename VectorType, typename FileType>
-class InMemoryFS {
- public:
-  /**
-   * @brief Initialize the file system
-   * @return true if initialization was successful, false otherwise
-   */
-  virtual bool begin() = 0;
-
-  /**
-   * @brief Check if a file exists
-   * @param filename Name of the file to check
-   * @return true if the file exists, false otherwise
-   */
-  bool exists(const char* filename) {
-    if (!initialized) return false;
-    return fileData.find(std::string(filename)) != fileData.end();
-  }
-
-  /**
-   * @brief Open a file
-   * @param filename Name of the file to open
-   * @param mode Mode to open the file in (FILE_READ, FILE_WRITE, etc.)
-   * @return A file object for the opened file
-   */
-  FileType open(const char* filename, uint8_t mode) {
-    ESP_LOGD("InMemoryFS", "Opening file %s with mode %d", filename, mode);
-
-    if (!initialized) {
-      ESP_LOGW("InMemoryFS", "Filesystem not initialized");
-      FileType emptyFile;
-      return emptyFile;
-    }
-
-    // Convert Arduino file modes to our enum
-    FileMode fileMode;
-    if (mode == FILE_READ) {
-      fileMode = FileMode::READ;
-    } else if (mode == FILE_WRITE) {
-      fileMode = FileMode::WRITE;
-    } else if (mode == FILE_APPEND) {
-      fileMode = FileMode::APPEND;
-    } else {
-      fileMode = FileMode::READ_WRITE;
-    }
-
-    std::string filenameStr(filename);
-    auto it = fileData.find(filenameStr);
-    FileType file;
-
-    if (it != fileData.end()) {
-      // File exists, create a new file pointing to existing data
-      ESP_LOGD("InMemoryFS", "File exists, connecting to existing data");
-      file.setVector(&(it->second));
-    } else if (mode != FILE_READ) {
-      // File doesn't exist, create it for writing or appending
-      ESP_LOGD("InMemoryFS", "Creating new file for writing");
-      fileData[filenameStr] = VectorType();  // Create empty vector in the map
-      file.setVector(&(fileData[filenameStr]));
-    } else {
-      // File doesn't exist and mode is READ
-      ESP_LOGW("InMemoryFS", "File doesn't exist and mode is READ");
-      return file;  // Return empty file
-    }
-
-    // Configure the file
-    file.setName(filename);
-    file.open(fileMode);
-
-    // Set up the next file callback
-    file.setNextFileCallback(
-        [this](const char* currentFileName, FileMode currentMode) -> FileType {
-          ESP_LOGD("InMemoryFS", "NextFile callback called for %s",
-                   currentFileName);
-
-          // Get the next filename
-          String nextName = this->getNextFileName(currentFileName);
-          if (nextName.isEmpty()) {
-            ESP_LOGD("InMemoryFS", "No next file found");
-            return FileType();  // Return empty file if no next file
-          }
-
-          // Convert FileMode to Arduino mode
-          uint8_t arduinoMode;
-          if (currentMode == FileMode::READ)
-            arduinoMode = FILE_READ;
-          else if (currentMode == FileMode::WRITE)
-            arduinoMode = FILE_WRITE;
-          else if (currentMode == FileMode::APPEND)
-            arduinoMode = FILE_APPEND;
-          else
-            arduinoMode = FILE_READ | FILE_WRITE;
-
-          // Open and return the next file
-          ESP_LOGD("InMemoryFS", "Returning next file: %s", nextName.c_str());
-          return this->open(nextName.c_str(), arduinoMode);
-        });
-
-    ESP_LOGD("InMemoryFS", "File opened successfully");
-    return file;
-  }
-
-  /**
-   * @brief Remove a file
-   * @param filename Name of the file to remove
-   * @return true if the file was removed, false otherwise
-   */
-  bool remove(const char* filename) {
-    if (!initialized) return false;
-
-    std::string filenameStr(filename);
-    auto it = fileData.find(filenameStr);
-
-    if (it != fileData.end()) {
-      fileData.erase(it);
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * @brief Create a directory (no-op for compatibility)
-   * @param dirname Name of the directory
-   * @return Always returns true for compatibility
-   */
-  bool mkdir(const char* dirname) {
-    // No directories in this implementation, just for compatibility
-    return true;
-  }
-
-  /**
-   * @brief Remove a directory (no-op for compatibility)
-   * @param dirname Name of the directory
-   * @return Always returns true for compatibility
-   */
-  bool rmdir(const char* dirname) {
-    // No directories in this implementation, just for compatibility
-    return true;
-  }
-
-  /**
-   * @brief Get the name of the next file after the specified file
-   * @param currentFileName Name of the current file
-   * @return Name of the next file, or empty string if there are no more files
-   */
-  String getNextFileName(const char* currentFileName) {
-    if (!initialized || fileData.empty()) {
-      return String();
-    }
-
-    if (currentFileName == nullptr || strlen(currentFileName) == 0 ||
-        strcmp(currentFileName, "/") == 0) {
-      // Return the first file if current is empty or is root directory
-      return String(fileData.begin()->first.c_str());
-    }
-
-    std::string current(currentFileName);
-    auto it = fileData.find(current);
-
-    if (it == fileData.end()) {
-      // Current file not found, find the next one alphabetically
-      for (auto& entry : fileData) {
-        if (entry.first > current) {
-          return String(entry.first.c_str());
-        }
-      }
-      // No file after the specified name
-      return String();
-    } else {
-      // Found the current file, get the next one
-      ++it;
-      if (it != fileData.end()) {
-        return String(it->first.c_str());
-      } else {
-        // Was the last file
-        return String();
-      }
-    }
-  }
-
-  /**
-   * @brief Get the first file in the filesystem
-   * @return Name of the first file, or empty string if there are no files
-   */
-  String getFirstFileName() {
-    if (!initialized || fileData.empty()) {
-      return String();
-    }
-    return String(fileData.begin()->first.c_str());
-  }
-
-  /**
-   * @brief Get the total number of files
-   * @return Number of files in the filesystem
-   */
-  size_t fileCount() const {
-    if (!initialized) return 0;
-    return fileData.size();
-  }
-
-  /**
-   * @brief Get total space
-   * @return Total memory size in bytes
-   */
-  virtual uint64_t totalBytes() = 0;
-
-  /**
-   * @brief Get free space
-   * @return Free memory size in bytes
-   */
-  virtual uint64_t freeBytes() = 0;
-
- protected:
-  bool initialized = false;
-  std::map<std::string, VectorType> fileData;
-};
-
-}  // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/InMemoryFile.h_

@@ -1,421 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-
-#include "VectorHIMEM.h"
-#include "VectorPSRAM.h"
-
-namespace esp32_psram {
-
-// Define file modes
-enum class FileMode { READ, WRITE, APPEND, READ_WRITE };
-
-/**
- * @class InMemoryFile
- * @brief A file-like interface for vector-backed storage in memory
- *
- * This class provides a file-like interface (compatible with Arduino's Stream)
- * for reading and writing data to vector-backed storage. It can use either
- * standard PSRAM or ESP32's HIMEM (high memory beyond the 4MB boundary)
- * as its underlying storage mechanism through the VectorPSRAM and VectorHIMEM
- * implementations.
- *
- * InMemoryFile offers familiar file operations like open, close, read, write,
- * seek, and truncate while managing the data in memory rather than on disk.
- * This makes it useful for temporary storage, data processing, or situations
- * where file operations are needed but filesystem access is not available
- * or desirable.
- *
- * The class can either manage its own internal vector or reference an external
- * vector supplied by another component (like PSRAMClass or HIMEMClass).
- *
- * @tparam VectorType The vector implementation to use for storage (typically
- *                   VectorPSRAM<uint8_t> or VectorHIMEM<uint8_t>)
- *
- * @note The performance characteristics will depend on the underlying vector
- *       implementation. HIMEM operations are generally slower than regular
- *       PSRAM operations but allow for larger storage capacity.
- */
-template <typename VectorType>
-class InMemoryFile : public Stream {
- public:
-  // Define a single callback type that returns the next file directly
-  using NextFileCallback =
-      std::function<InMemoryFile<VectorType>(const char*, FileMode)>;
-  /**
-   * @brief Default constructor - initializes with internal vector
-   */
-  InMemoryFile() : data_ptr(&internal_data) {
-    ESP_LOGD(TAG, "InMemoryFile constructor called");
-  }
-
-  /**
-   * @brief Constructor with filename and mode
-   * @param filename Name of the file
-   * @param mode Mode to open the file in
-   */
-  InMemoryFile(const char* filename, FileMode mode)
-      : data_ptr(&internal_data), name_(filename) {
-    ESP_LOGD(TAG, "InMemoryFile constructor with name and mode called");
-    open(mode);
-  }
-
-  /**
-   * @brief Destructor - ensures proper cleanup
-   */
-  virtual ~InMemoryFile() {
-    ESP_LOGD(TAG, "InMemoryFile destructor called");
-    close();
-    if (!using_external_vector) {
-      data_ptr = nullptr;
-    }
-  }
-
-  /**
-   * @brief Set the vector to use for this file
-   * @param vec Pointer to the vector to use
-   */
-  void setVector(VectorType* vec) {
-    ESP_LOGD(TAG, "Setting external vector pointer: %p", vec);
-    if (vec) {
-      data_ptr = vec;
-      using_external_vector = true;
-    } else {
-      data_ptr = &internal_data;
-      using_external_vector = false;
-    }
-  }
-
-  /**
-   * @brief Set the name of this file
-   * @param name The name to set
-   */
-  void setName(const char* name) {
-    ESP_LOGD(TAG, "Setting file name: %s", name);
-    name_ = name;
-  }
-
-  /**
-   * @brief Open the file with the specified mode
-   * @param mode Mode to open the file in
-   * @return true if opened successfully, false otherwise
-   */
-  bool open(FileMode mode) {
-    ESP_LOGD(TAG, "Opening file '%s' with mode %d", name_.c_str(),
-             static_cast<int>(mode));
-    this->mode = mode;
-
-    if (mode == FileMode::WRITE) {
-      // Clear the vector for writing
-      data_ptr->clear();
-      position_ = 0;
-    } else if (mode == FileMode::APPEND) {
-      // Position at end for appending
-      position_ = data_ptr->size();
-    } else {
-      // READ or READ_WRITE - position at beginning
-      position_ = 0;
-    }
-
-    open_ = true;
-    return true;
-  }
-
-  /**
-   * @brief Close the file
-   */
-  void close() {
-    ESP_LOGD(TAG, "Closing file '%s'", name_.c_str());
-    open_ = false;
-  }
-
-  /**
-   * @brief Check if file is open
-   * @return true if open, false otherwise
-   */
-  bool isOpen() const { return open_; }
-
-  /**
-   * @brief Get the name of the file
-   * @return File name
-   */
-  String name() const { return name_; }
-
-  /**
-   * @brief Get the size of the file
-   * @return File size in bytes
-   */
-  size_t size() const { return data_ptr->size(); }
-
-  // Stream interface implementation
-
-  /**
-   * @brief Read a single byte from the file
-   * @return The next byte, or -1 if no data is available
-   */
-  int read() override {
-    ESP_LOGD(TAG, "InMemoryFile::read() - position %u", (unsigned)position_);
-    if (!open_ || (mode != FileMode::READ && mode != FileMode::READ_WRITE)) {
-      ESP_LOGE(TAG, "read failed: file not open for reading");
-      return -1;
-    }
-
-    if (position_ >= data_ptr->size()) {
-      ESP_LOGD(TAG, "read at EOF: pos=%u, size=%u", (unsigned)position_,
-               (unsigned)data_ptr->size());
-      return -1;  // EOF
-    }
-
-    uint8_t byte = (*data_ptr)[position_++];
-    return byte;
-  }
-
-  /**
-   * @brief Read multiple bytes from the file
-   * @param buffer Buffer to store the read data
-   * @param size Maximum number of bytes to read
-   * @return Number of bytes actually read
-   */
-  size_t readBytes(char* buffer, size_t size) override {
-    ESP_LOGD(TAG, "InMemoryFile::readBytes: %u", (unsigned)size);
-    if (!open_ || (mode != FileMode::READ && mode != FileMode::READ_WRITE)) {
-      ESP_LOGE(TAG, "read failed: file not open for reading");
-      return 0;
-    }
-
-    // Calculate how many bytes we can actually read
-    size_t available_bytes = data_ptr->size() - position_;
-    size_t bytes_to_read = min(size, available_bytes);
-
-    // Read the bytes
-    for (size_t i = 0; i < bytes_to_read; i++) {
-      buffer[i] = (*data_ptr)[position_ + i];
-    }
-
-    position_ += bytes_to_read;
-    return bytes_to_read;
-  }
-
-  /**
-   * @brief Get the number of bytes available to read
-   * @return Number of bytes available
-   */
-  int available() override {
-    if (!open_) return 0;
-    return data_ptr->size() - position_;
-  }
-
-  /**
-   * @brief Peek at the next byte without advancing the position
-   * @return The next byte, or -1 if no data is available
-   */
-  int peek() override {
-    if (!open_ || (mode != FileMode::READ && mode != FileMode::READ_WRITE)) {
-      return -1;
-    }
-
-    if (position_ >= data_ptr->size()) {
-      return -1;  // EOF
-    }
-
-    return (*data_ptr)[position_];
-  }
-
-  /**
-   * @brief Ensure all data is committed to the storage
-   * No-op for this implementation since data is in memory
-   */
-  void flush() override {
-    // No-op for in-memory implementation
-  }
-
-  /**
-   * @brief Write a single byte to the file
-   * @param b The byte to write
-   * @return 1 if the byte was written, 0 otherwise
-   */
-  size_t write(uint8_t b) override {
-    ESP_LOGD(TAG, "InMemoryFile::write: 1 byte");
-    if (!open_ || (mode != FileMode::WRITE && mode != FileMode::APPEND &&
-                   mode != FileMode::READ_WRITE)) {
-      ESP_LOGE(TAG, "write failed: file not open for writing");
-      return 0;
-    }
-
-    if (position_ >= data_ptr->size()) {
-      // Append to the end
-      data_ptr->push_back(b);
-    } else {
-      // Replace existing byte
-      (*data_ptr)[position_] = b;
-    }
-
-    position_++;
-    return 1;
-  }
-
-  /**
-   * @brief Write multiple bytes to the file
-   * @param buffer Buffer containing the data to write
-   * @param size Number of bytes to write
-   * @return Number of bytes actually written
-   */
-  size_t write(const uint8_t* buffer, size_t size) override {
-    ESP_LOGD(TAG, "InMemoryFile::write: %u", (unsigned)size);
-    if (!open_ || (mode != FileMode::WRITE && mode != FileMode::APPEND &&
-                   mode != FileMode::READ_WRITE)) {
-      ESP_LOGE(TAG, "write failed: file not open for writing");
-      return 0;
-    }
-
-    if (position_ >= data_ptr->size()) {
-      // Append to the end
-      data_ptr->reserve(data_ptr->size() + size);  // Optimize capacity
-      for (size_t i = 0; i < size; i++) {
-        data_ptr->push_back(buffer[i]);
-      }
-    } else {
-      // Replace/insert bytes
-      size_t space_available = data_ptr->size() - position_;
-      size_t bytes_to_replace = min(size, space_available);
-      size_t bytes_to_append = size - bytes_to_replace;
-
-      // Replace existing bytes
-      for (size_t i = 0; i < bytes_to_replace; i++) {
-        (*data_ptr)[position_ + i] = buffer[i];
-      }
-
-      // Append remaining bytes
-      for (size_t i = 0; i < bytes_to_append; i++) {
-        data_ptr->push_back(buffer[bytes_to_replace + i]);
-      }
-    }
-
-    position_ += size;
-    return size;
-  }
-
-  // File-specific methods
-
-  /**
-   * @brief Set the current position in the file
-   * @param pos The position to seek to
-   * @return true if successful, false otherwise
-   */
-  bool seek(size_t pos) {
-    ESP_LOGD(TAG, "InMemoryFile::seek: %u", (unsigned)pos);
-    if (!open_ || pos > data_ptr->size()) {
-      ESP_LOGE(TAG, "seek failed: file not open or position beyond size");
-      return false;
-    }
-
-    position_ = pos;
-    return true;
-  }
-
-  /**
-   * @brief Get the current position in the file
-   * @return Current position
-   */
-  size_t position() const { return position_; }
-
-  /**
-   * @brief Truncate the file to the current position
-   */
-  void truncate() {
-    ESP_LOGD(TAG, "InMemoryFile::truncate at position %u", (unsigned)position_);
-    if (!open_ || (mode != FileMode::WRITE && mode != FileMode::READ_WRITE)) {
-      ESP_LOGE(TAG, "truncate failed: file not open for writing");
-      return;
-    }
-
-    if (position_ < data_ptr->size()) {
-      // Create a new vector with just the data up to position_
-      VectorType new_data;
-      new_data.reserve(position_);
-      for (size_t i = 0; i < position_; i++) {
-        new_data.push_back((*data_ptr)[i]);
-      }
-
-      // Replace the old data
-      *data_ptr = std::move(new_data);
-    }
-  }
-
-  operator bool() const { return open_; }
-  /**
-   * @brief Set callback for navigating to the next file
-   *
-   * This function sets a callback that will be used to retrieve the next
-   * file when getNextFile() is called. The callback takes the current file name
-   * and mode, and returns the next file object directly.
-   *
-   * @param callback Function that returns the next file
-   */
-  void setNextFileCallback(NextFileCallback callback) {
-    ESP_LOGD(TAG, "Setting next file callback");
-    nextFileCallback = callback;
-  }
-
-  /**
-   * @brief Get the next file in the filesystem
-   *
-   * This method uses the registered callback to get the next file
-   * after this one in the filesystem.
-   *
-   * @return The next file, or an empty file if there is no next file or
-   * callback isn't set
-   */
-  InMemoryFile<VectorType> getNextFile() {
-    if (!nextFileCallback || name_.isEmpty()) {
-      // Return empty file if callback isn't set or no name
-      InMemoryFile<VectorType> emptyFile;
-      return emptyFile;
-    }
-
-    // Get the next file directly using the callback
-    return nextFileCallback(name_.c_str(), mode);
-  }
-
-  /**
-   * @brief Reserve storage
-   * @param new_cap The new capacity of the file
-   */
-  bool reserve(size_t new_cap) {
-    if (data_ptr == nullptr) return false;
-    data_ptr->reserve(new_cap);
-    return true;
-  }
-
-  /**
-   * @brief Get the number of bytes that can be held in current storage.
-   * Please note that this might dynamically grow!
-   * @return The capacity of the file
-   */
-  size_t capacity() const {
-    if (data_ptr == nullptr) return 0;
-    return data_ptr->capacity();
-  }
-
- private:
-  VectorType* data_ptr =
-      nullptr;               // Pointer to vector data (internal or external)
-  VectorType internal_data;  // Internal vector for standalone use
-  bool using_external_vector = false;
-  size_t position_ = 0;
-  bool open_ = false;
-  FileMode mode = FileMode::READ;
-  String name_;
-
-  // Single callback for getting the next file
-  NextFileCallback nextFileCallback = nullptr;
-
-  // Tags for debug logging
-  static constexpr const char* TAG = "InMemoryFile";
-};
-
-// Type aliases for convenience
-using FilePSRAM = InMemoryFile<VectorPSRAM<uint8_t>>;
-using FileHIMEM = InMemoryFile<VectorHIMEM<uint8_t>>;
-
-}  // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/PSRAM.h_

@@ -1,54 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-#include "InMemoryFS.h"
-#include "VectorPSRAM.h"
-
-
-namespace esp32_psram {
-
-/**
- * @class PSRAMClass
- * @brief Class for managing files stored in ESP32's PSRAM
- * 
- * This class provides an interface similar to SD.h for managing files
- * that are stored in PSRAM memory rather than on an SD card.
- */
-class PSRAMClass : public InMemoryFS<VectorPSRAM<uint8_t>, FilePSRAM> {
-public:
-    /**
-     * @brief Initialize the PSRAM filesystem
-     * @return true if initialization was successful, false otherwise
-     */
-    bool begin() override {
-        if (ESP.getFreePsram() > 0) {
-            initialized = true;
-            return true;
-        }
-        initialized = false;
-        return false;
-    }
-
-    /**
-     * @brief Get total space (returns available PSRAM)
-     * @return Total PSRAM size in bytes
-     */
-    uint64_t totalBytes() override {
-        return ESP.getPsramSize();
-    }
-
-    /**
-     * @brief Get free space (returns free PSRAM)
-     * @return Free PSRAM size in bytes
-     */
-    uint64_t freeBytes() override {
-        return ESP.getFreePsram();
-    }
-};
-
-/**
- * @brief Global instance of PSRAMClass for easy access
- */
-static PSRAMClass PSRAM;
-
-} // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/RingBufferStream.h

@@ -1,250 +0,0 @@
-#pragma once
-
-#include <Arduino.h>
-#include <Stream.h>
-#include "VectorPSRAM.h"
-#include "VectorHIMEM.h"
-
-namespace esp32_psram {
-
-/**
- * @class RingBufferStream
- * @brief A circular buffer implementation that extends Arduino's Stream
- * @tparam VectorType The vector type to use as underlying storage
- * 
- * This class implements a ring buffer (circular buffer) that uses a vector container
- * for storage. It extends Arduino's Stream class to provide standard stream functionality.
- * The buffer can be used with any vector type, including VectorPSRAM and VectorHIMEM.
- */
-template <typename VectorType>
-class RingBufferStream : public Stream {
-private:
-    VectorType buffer;
-    size_t readIndex = 0;
-    size_t writeIndex = 0;
-    bool full = false;
-    size_t maxSize;
-
-public:
-    /**
-     * @brief Constructor with specified buffer size
-     * @param size The size of the buffer in bytes
-     */
-    RingBufferStream(size_t size) : maxSize(size) {
-        buffer.resize(size);
-    }
-
-    /**
-     * @brief Get the number of bytes available for reading
-     * @return Number of bytes available
-     */
-    int available() override {
-        if (full) {
-            return maxSize;
-        }
-        if (writeIndex >= readIndex) {
-            return writeIndex - readIndex;
-        } else {
-            return maxSize - (readIndex - writeIndex);
-        }
-    }
-
-    /**
-     * @brief Read a byte from the buffer
-     * @return The byte read, or -1 if the buffer is empty
-     */
-    int read() override {
-        if (isEmpty()) {
-            return -1;
-        }
-
-        uint8_t value = buffer[readIndex];
-        readIndex = (readIndex + 1) % maxSize;
-        full = false;
-        return value;
-    }
-
-    /**
-     * @brief Look at the next byte in the buffer without removing it
-     * @return The next byte to be read, or -1 if the buffer is empty
-     */
-    int peek() override {
-        if (isEmpty()) {
-            return -1;
-        }
-
-        return buffer[readIndex];
-    }
-
-    /**
-     * @brief Write a byte to the buffer
-     * @param value The byte to write
-     * @return 1 if the byte was written, 0 if the buffer is full
-     */
-    size_t write(uint8_t value) override {
-        if (full) {
-            return 0;
-        }
-
-        buffer[writeIndex] = value;
-        writeIndex = (writeIndex + 1) % maxSize;
-        
-        // Check if buffer is now full
-        if (writeIndex == readIndex) {
-            full = true;
-        }
-        
-        return 1;
-    }
-
-    /**
-     * @brief Write multiple bytes to the buffer
-     * @param data Pointer to the data to write
-     * @param size Number of bytes to write
-     * @return Number of bytes written
-     */
-    size_t write(const uint8_t *data, size_t size) {
-        size_t bytesWritten = 0;
-        
-        for (size_t i = 0; i < size; i++) {
-            if (write(data[i])) {
-                bytesWritten++;
-            } else {
-                break;
-            }
-        }
-        
-        return bytesWritten;
-    }
-
-    /**
-     * @brief Clear the buffer, removing all content
-     */
-    void flush() override {
-        readIndex = 0;
-        writeIndex = 0;
-        full = false;
-    }
-
-    /**
-     * @brief Check if the buffer is empty
-     * @return true if the buffer is empty, false otherwise
-     */
-    bool isEmpty() const {
-        return !full && (readIndex == writeIndex);
-    }
-
-    /**
-     * @brief Check if the buffer is full
-     * @return true if the buffer is full, false otherwise
-     */
-    bool isFull() const {
-        return full;
-    }
-
-    /**
-     * @brief Get the number of bytes that can be written without blocking
-     * @return Number of bytes available for writing
-     */
-    int availableForWrite() override {
-        if (full) {
-            return 0;
-        }
-        if (readIndex > writeIndex) {
-            return readIndex - writeIndex;
-        } else {
-            return maxSize - (writeIndex - readIndex);
-        }
-    }
-
-    /**
-     * @brief Get the total capacity of the buffer
-     * @return Total buffer capacity in bytes
-     */
-    size_t size() const {
-        return maxSize;
-    }
-
-    /**
-     * @brief Get the number of bytes currently in the buffer
-     * @return Number of bytes in the buffer
-     */
-    size_t used() const {
-        return available();
-    }
-
-    /**
-     * @brief Get the number of bytes still available in the buffer
-     * @return Number of free bytes in the buffer
-     */
-    size_t free() const {
-        return maxSize - available();
-    }
-
-    /**
-     * @brief Read multiple bytes from the buffer
-     * @param buffer Buffer to store the read data
-     * @param size Maximum number of bytes to read
-     * @return Number of bytes actually read
-     */
-    size_t readBytes(char* buffer, size_t size) override {
-        size_t bytesRead = 0;
-        
-        for (size_t i = 0; i < size; i++) {
-            int value = read();
-            if (value >= 0) {
-                buffer[i] = (char)value;
-                bytesRead++;
-            } else {
-                break;
-            }
-        }
-        
-        return bytesRead;
-    }
-
-    /**
-     * @brief Read multiple bytes from the buffer
-     * @param buffer Buffer to store the read data
-     * @param size Maximum number of bytes to read
-     * @return Number of bytes actually read
-     */
-    size_t readBytes(uint8_t* buffer, size_t size) {
-        return readBytes(reinterpret_cast<char*>(buffer), size);
-    }
-
-    /**
-     * @brief Get direct access to the underlying vector
-     * @return Reference to the underlying vector
-     */
-    VectorType& getVector() {
-        return buffer;
-    }
-
-    /**
-     * @brief Get const access to the underlying vector
-     * @return Const reference to the underlying vector
-     */
-    const VectorType& getVector() const {
-        return buffer;
-    }
-};
-
-/**
- * @brief Type alias for a RingBufferStream that uses PSRAM-backed vector storage
- */
-using RingBufferStreamPSRAM = RingBufferStream<VectorPSRAM<uint8_t>>;
-
-/**
- * @brief Type alias for a RingBufferStream that uses HIMEM-backed vector storage
- */
-using RingBufferStreamHIMEM = RingBufferStream<VectorHIMEM<uint8_t>>;
-
-/**
- * @brief Type alias for a RingBufferStream that uses std::vector storage
- */
-
-using RingBufferStreamRAM = RingBufferStream<std::vector<uint8_t>>;
-
-
-} // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/TypedRingBuffer.h

@@ -1,227 +0,0 @@
-
-#pragma once
-
-#include <Arduino.h>
-#include <vector>
-#include "VectorPSRAM.h"
-#include "VectorHIMEM.h"
-
-namespace esp32_psram {
-
-/**
- * @class TypedRingBuffer
- * @brief A generic ring buffer implementation for any data type
- * @tparam T The data type to store in the buffer
- * @tparam VectorType The vector type to use as underlying storage
- * 
- * This class implements a ring buffer (circular buffer) that uses a vector container
- * for storage. Unlike the Stream-based RingBuffer, this can store any data type.
- */
-template <typename T, typename VectorType>
-class TypedRingBuffer {
-private:
-    VectorType buffer;
-    size_t readIndex = 0;
-    size_t writeIndex = 0;
-    bool full = false;
-    size_t maxSize;
-
-public:
-    /**
-     * @brief Constructor with specified buffer capacity
-     * @param capacity The maximum number of elements the buffer can hold
-     */
-    TypedRingBuffer(size_t capacity) : maxSize(capacity) {
-        buffer.resize(capacity);
-    }
-
-    /**
-     * @brief Push an element to the buffer
-     * @param value The value to add
-     * @return true if the element was added, false if the buffer is full
-     */
-    bool push(const T& value) {
-        if (full) {
-            return false;
-        }
-
-        buffer[writeIndex] = value;
-        advanceWriteIndex();
-        return true;
-    }
-
-    /**
-     * @brief Push an element to the buffer, overwriting oldest data if full
-     * @param value The value to add
-     * @return true if an old element was overwritten, false otherwise
-     */
-    bool pushOverwrite(const T& value) {
-        bool overwritten = full;
-        
-        buffer[writeIndex] = value;
-        advanceWriteIndex();
-        
-        return overwritten;
-    }
-
-    /**
-     * @brief Pop an element from the buffer
-     * @param value Reference to store the popped value
-     * @return true if an element was popped, false if the buffer is empty
-     */
-    bool pop(T& value) {
-        if (isEmpty()) {
-            return false;
-        }
-
-        value = buffer[readIndex];
-        advanceReadIndex();
-        return true;
-    }
-
-    /**
-     * @brief Peek at the next element without removing it
-     * @param value Reference to store the peeked value
-     * @return true if an element was peeked, false if the buffer is empty
-     */
-    bool peek(T& value) const {
-        if (isEmpty()) {
-            return false;
-        }
-
-        value = buffer[readIndex];
-        return true;
-    }
-
-    /**
-     * @brief Get the element at a specific index relative to the read position
-     * @param index The relative index from current read position
-     * @param value Reference to store the value
-     * @return true if the element exists, false otherwise
-     */
-    bool peekAt(size_t index, T& value) const {
-        if (isEmpty() || index >= available()) {
-            return false;
-        }
-
-        size_t actualIndex = (readIndex + index) % maxSize;
-        value = buffer[actualIndex];
-        return true;
-    }
-
-    /**
-     * @brief Clear the buffer, removing all content
-     */
-    void clear() {
-        readIndex = 0;
-        writeIndex = 0;
-        full = false;
-    }
-
-    /**
-     * @brief Check if the buffer is empty
-     * @return true if the buffer is empty, false otherwise
-     */
-    bool isEmpty() const {
-        return !full && (readIndex == writeIndex);
-    }
-
-    /**
-     * @brief Check if the buffer is full
-     * @return true if the buffer is full, false otherwise
-     */
-    bool isFull() const {
-        return full;
-    }
-
-    /**
-     * @brief Get the number of elements in the buffer
-     * @return Number of elements in the buffer
-     */
-    size_t available() const {
-        if (full) {
-            return maxSize;
-        }
-        if (writeIndex >= readIndex) {
-            return writeIndex - readIndex;
-        } else {
-            return maxSize - (readIndex - writeIndex);
-        }
-    }
-
-    /**
-     * @brief Get the number of empty slots in the buffer
-     * @return Number of empty slots
-     */
-    size_t availableForWrite() const {
-        return maxSize - available();
-    }
-
-    /**
-     * @brief Get the total capacity of the buffer
-     * @return Total buffer capacity
-     */
-    size_t capacity() const {
-        return maxSize;
-    }
-
-    /**
-     * @brief Get direct access to the underlying vector
-     * @return Reference to the underlying vector
-     */
-    VectorType& getVector() {
-        return buffer;
-    }
-
-    /**
-     * @brief Get const access to the underlying vector
-     * @return Const reference to the underlying vector
-     */
-    const VectorType& getVector() const {
-        return buffer;
-    }
-
-private:
-    /**
-     * @brief Advance the write index
-     */
-    void advanceWriteIndex() {
-        writeIndex = (writeIndex + 1) % maxSize;
-        if (writeIndex == readIndex) {
-            full = true;
-        }
-    }
-
-    /**
-     * @brief Advance the read index
-     */
-    void advanceReadIndex() {
-        readIndex = (readIndex + 1) % maxSize;
-        full = false;
-    }
-};
-
-/**
- * @brief Type alias for a typed ring buffer that uses std::vector (in RAM)
- */
-template<typename T>
-using TypedRingBufferRAM = TypedRingBuffer<T, std::vector<T>>;
-/**
- * @brief Type alias for a typed ring buffer that uses HIMEM-backed vector storage
- */
-template<typename T>
-using TypedRingBufferHIMEM = TypedRingBuffer<T, VectorHIMEM<T>>;
-
-/**
- * @brief Type alias for a typed ring buffer that uses PSRAM-backed vector storage
- */
-template<typename T>
-using TypedRingBufferPSRAM = TypedRingBuffer<T, VectorPSRAM<T>>;
-
-/**
- * @brief Type alias for a typed ring buffer that uses HIMEM-backed vector storage
- */
-// template<typename T>
-// using TypedRingBufferHIMEM = TypedRingBuffer<T, VectorHIMEM<T>>;
-
-} // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/VectorHIMEM.h

@@ -1,529 +0,0 @@
-#pragma once
-
-#include "HimemBlock.h"
-
-namespace esp32_psram {
-
-
-/**
- * @class VectorHIMEM
- * @brief Vector implementation that uses ESP32's high memory (himem) for
- * storage
- * @tparam T Type of elements stored in the vector
- */
-template <typename T>
-class VectorHIMEM {
- public:
-  // Type definitions
-  using value_type = T;
-  using reference = T&;
-  using const_reference = const T&;
-  using pointer = T*;
-  using const_pointer = const T*;
-  using size_type = size_t;
-  using difference_type = std::ptrdiff_t;
-
-  /**
-   * @brief Default constructor - creates an empty vector
-   */
-  VectorHIMEM() = default;
-
-  /**
-   * @brief Constructs a vector with the given number of default-initialized
-   * elements
-   * @param count The size of the vector
-   */
-  explicit VectorHIMEM(size_type count) { resize(count); }
-
-  /**
-   * @brief Constructs a vector with the given number of copies of a value
-   * @param count The size of the vector
-   * @param value The value to initialize elements with
-   */
-  VectorHIMEM(size_type count, const T& value) { resize(count, value); }
-
-  /**
-   * @brief Copy constructor
-   * @param other The vector to copy from
-   */
-  VectorHIMEM(const VectorHIMEM& other) {
-    if (other.element_count > 0) {
-      if (reallocate(other.element_count)) {
-        T temp;
-        VectorHIMEM& other_ = const_cast<VectorHIMEM&>(other);
-        for (size_t i = 0; i < other.element_count; ++i) {
-          other_.memory.read((void*)&temp, i * sizeof(T), sizeof(T));
-          memory.write((void*)&temp, i * sizeof(T), sizeof(T));
-        }
-        element_count = other.element_count;
-      }
-    }
-  }
-
-  /**
-   * @brief Move constructor
-   * @param other The vector to move from
-   */
-  VectorHIMEM(VectorHIMEM&& other) noexcept
-      : memory(std::move(other.memory)),
-        element_count(other.element_count),
-        element_capacity(other.element_capacity) {
-    other.element_count = 0;
-    other.element_capacity = 0;
-  }
-
-  /**
-   * @brief Initializer list constructor
-   * @param init The initializer list to copy from
-   */
-  VectorHIMEM(std::initializer_list<T> init) {
-    if (init.size() > 0) {
-      if (reallocate(init.size())) {
-        size_t i = 0;
-        for (const auto& item : init) {
-          memory.write(&item, i * sizeof(T), sizeof(T));
-          ++i;
-        }
-        element_count = init.size();
-      }
-    }
-  }
-
-  /**
-   * @brief Destructor - ensures all elements are properly destroyed
-   */
-  ~VectorHIMEM() { clear(); }
-
-  /**
-   * @brief Copy assignment operator
-   * @param other The vector to copy from
-   * @return Reference to this vector
-   */
-  VectorHIMEM& operator=(const VectorHIMEM& other) {
-    if (this != &other) {
-      clear();
-      if (other.element_count > 0) {
-        if (reallocate(other.element_count)) {
-          T temp;
-          for (size_t i = 0; i < other.element_count; ++i) {
-            const_cast<esp32_psram::HimemBlock*>(&other.memory)->read(&temp, i * sizeof(T), sizeof(T));
-            memory.write(&temp, i * sizeof(T), sizeof(T));
-          }
-          element_count = other.element_count;
-        }
-      }
-    }
-    return *this;
-  }
-
-  /**
-   * @brief Move assignment operator
-   * @param other The vector to move from
-   * @return Reference to this vector
-   */
-  VectorHIMEM& operator=(VectorHIMEM&& other) noexcept {
-    if (this != &other) {
-      clear();
-      memory = std::move(other.memory);
-      element_count = other.element_count;
-      element_capacity = other.element_capacity;
-      other.element_count = 0;
-      other.element_capacity = 0;
-    }
-    return *this;
-  }
-
-  /**
-   * @brief Initializer list assignment operator
-   * @param ilist The initializer list to copy from
-   * @return Reference to this vector
-   */
-  VectorHIMEM& operator=(std::initializer_list<T> ilist) {
-    clear();
-    if (ilist.size() > 0) {
-      if (reallocate(ilist.size())) {
-        size_t i = 0;
-        for (const auto& item : ilist) {
-          memory.write(&item, i * sizeof(T), sizeof(T));
-          ++i;
-        }
-        element_count = ilist.size();
-      }
-    }
-    return *this;
-  }
-
-  /**
-   * @brief Access element with bounds checking
-   * @param pos The position of the element
-   * @return Reference to the element at position pos
-   * @throws std::out_of_range if pos is not within the range of the vector
-   */
-  reference at(size_type pos) {
-    if (pos >= element_count) {
-      throw std::out_of_range("VectorHIMEM: index out of range");
-    }
-    static T temp;
-    memory.read(&temp, pos * sizeof(T), sizeof(T));
-    return temp;
-  }
-
-  /**
-   * @brief Access element with bounds checking (const version)
-   * @param pos The position of the element
-   * @return Const reference to the element at position pos
-   * @throws std::out_of_range if pos is not within the range of the vector
-   */
-  const_reference at(size_type pos) const {
-    if (pos >= element_count) {
-      throw std::out_of_range("VectorHIMEM: index out of range");
-    }
-    static T temp;
-    memory.read(&temp, pos * sizeof(T), sizeof(T));
-    return temp;
-  }
-
-  /**
-   * @brief Access element without bounds checking
-   * @param pos The position of the element
-   * @return Reference to the element at position pos
-   */
-  reference operator[](size_type pos) {
-    static T temp;
-    memory.read(&temp, pos * sizeof(T), sizeof(T));
-    return temp;
-  }
-
-  // Add const version of operator[]
-  const_reference operator[](size_type pos) const {
-     static T result;
-    // Need to cast away const for the read operation since it doesn't modify content
-    HimemBlock& non_const_memory = const_cast<HimemBlock&>(memory);
-    non_const_memory.read(&result, pos * sizeof(T), sizeof(T));
-    return result;
-  }
-
-
-  /**
-   * @brief Access the first element
-   * @return Reference to the first element
-   */
-  reference front() {
-    static T temp;
-    memory.read(&temp, 0, sizeof(T));
-    return temp;
-  }
-
-  /**
-   * @brief Access the first element (const version)
-   * @return Const reference to the first element
-   */
-  const_reference front() const {
-    static T temp;
-    memory.read(&temp, 0, sizeof(T));
-    return temp;
-  }
-
-  /**
-   * @brief Access the last element
-   * @return Reference to the last element
-   */
-  reference back() {
-    static T temp;
-    memory.read(&temp, (element_count - 1) * sizeof(T), sizeof(T));
-    return temp;
-  }
-
-  /**
-   * @brief Access the last element (const version)
-   * @return Const reference to the last element
-   */
-  const_reference back() const {
-    static T temp;
-    memory.read(&temp, (element_count - 1) * sizeof(T), sizeof(T));
-    return temp;
-  }
-
-  /**
-   * @brief Check if the vector is empty
-   * @return true if the vector is empty, false otherwise
-   */
-  bool empty() const { return element_count == 0; }
-
-  /**
-   * @brief Get the number of elements
-   * @return The number of elements in the vector
-   */
-  size_type size() const { return element_count; }
-
-  /**
-   * @brief Get the maximum possible number of elements
-   * @return The maximum possible number of elements the vector can hold
-   */
-  size_type max_size() const {
-    return std::numeric_limits<size_type>::max() / sizeof(T);
-  }
-
-  /**
-   * @brief Reserve storage
-   * @param new_cap The new capacity of the vector
-   */
-  void reserve(size_type new_cap) {
-    if (new_cap > element_capacity) {
-      reallocate(new_cap);
-    }
-  }
-
-  /**
-   * @brief Get the number of elements that can be held in current storage
-   * @return The capacity of the vector
-   */
-  size_type capacity() const { return element_capacity; }
-
-  /**
-   * @brief Clear the contents
-   */
-  void clear() {
-    // We're using plain memory so no destructors to call
-    element_count = 0;
-  }
-
-  /**
-   * @brief Add an element to the end
-   * @param value The value to append
-   */
-  void push_back(const T& value) {
-    if (element_count >= element_capacity) {
-      size_t new_capacity =
-          element_capacity == 0 ? min_elements : element_capacity * 2;
-      if (!reallocate(new_capacity)) {
-        ESP_LOGE(TAG, "Failed to reallocate for push_back");
-        return;
-      }
-    }
-
-    // Write the new element at the end
-    memory.write(&value, element_count * sizeof(T), sizeof(T));
-    ++element_count;
-  }
-
-  /**
-   * @brief Add an element to the end by moving it
-   * @param value The value to append
-   */
-  void push_back(T&& value) {
-    // For POD types, this is the same as the const& version
-    push_back(static_cast<const T&>(value));
-  }
-
-  /**
-   * @brief Remove the last element
-   */
-  void pop_back() {
-    if (element_count > 0) {
-      --element_count;
-    }
-  }
-
-  /**
-   * @brief Change the number of elements stored
-   * @param count The new size of the vector
-   */
-  void resize(size_type count) {
-    if (count > element_capacity) {
-      if (!reallocate(count)) {
-        return;
-      }
-    }
-    element_count = count;
-  }
-
-  /**
-   * @brief Change the number of elements stored
-   * @param count The new size of the vector
-   * @param value The value to initialize new elements with
-   */
-  void resize(size_type count, const value_type& value) {
-    size_t old_size = element_count;
-
-    if (count > element_count) {
-      // Need to add elements
-      if (count > element_capacity) {
-        if (!reallocate(count)) {
-          return;
-        }
-      }
-
-      // Initialize new elements with value
-      for (size_t i = old_size; i < count; ++i) {
-        memory.write(&value, i * sizeof(T), sizeof(T));
-      }
-    }
-
-    element_count = count;
-  }
-
-  /**
-   * @brief Erase an element
-   * @param pos Index of the element to erase
-   */
-  void erase(size_type pos) {
-    if (pos >= element_count) {
-      return;
-    }
-
-    // Move each element down by one, overwriting the erased element
-    T temp;
-    for (size_t i = pos + 1; i < element_count; ++i) {
-      memory.read(&temp, i * sizeof(T), sizeof(T));
-      memory.write(&temp, (i - 1) * sizeof(T), sizeof(T));
-    }
-
-    --element_count;
-  }
-
-  /**
-   * @brief Insert an element at a specific position
-   * @param pos Position where the element should be inserted
-   * @param value The value to insert
-   */
-  void insert(size_type pos, const T& value) {
-    if (pos > element_count) {
-      return;
-    }
-
-    if (element_count >= element_capacity) {
-      size_t new_capacity =
-          element_capacity == 0 ? min_elements : element_capacity * 2;
-      if (!reallocate(new_capacity)) {
-        return;
-      }
-    }
-
-    // Move elements up to make space
-    T temp;
-    for (size_t i = element_count; i > pos; --i) {
-      memory.read(&temp, (i - 1) * sizeof(T), sizeof(T));
-      memory.write(&temp, i * sizeof(T), sizeof(T));
-    }
-
-    // Insert new element
-    memory.write(&value, pos * sizeof(T), sizeof(T));
-    ++element_count;
-  }
-
-  /**
-   * @brief Swap the contents of this vector with another
-   * @param other Vector to swap with
-   */
-  void swap(VectorHIMEM& other) noexcept {
-    std::swap(memory, other.memory);
-    std::swap(element_count, other.element_count);
-    std::swap(element_capacity, other.element_capacity);
-  }
-
- protected:
-  HimemBlock memory;
-  size_t element_count = 0;
-  size_t element_capacity = 0;
-  static constexpr size_t min_elements = 16;  // Minimum allocation size
-
-  /**
-   * @brief Calculate required memory size in bytes for a given number of
-   * elements
-   * @param count Number of elements
-   * @return Size in bytes
-   */
-  static size_t calculate_size_bytes(size_t count) { return count * sizeof(T); }
-
-  /**
-   * @brief Reallocate memory with a new capacity
-   * @param new_capacity The new capacity to allocate
-   * @return true if reallocation was successful, false otherwise
-   */
-  bool reallocate(size_t new_capacity) {
-    if (new_capacity <= element_capacity) {
-      return true;  // No need to reallocate
-    }
-
-    // Calculate new size (at least min_elements)
-    new_capacity = std::max(new_capacity, min_elements);
-
-    // Create a new memory block
-    HimemBlock new_memory;
-    element_capacity = new_memory.allocate(calculate_size_bytes(new_capacity)) / sizeof(T);
-    if (element_capacity == 0) {
-      ESP_LOGE(TAG, "Failed to allocate new memory block");
-      return false;
-    }
-
-    // Copy existing elements if any
-    if (element_count > 0) {
-      T temp;
-      for (size_t i = 0; i < element_count; ++i) {
-        // Read from old memory
-        memory.read(&temp, i * sizeof(T), sizeof(T));
-
-        // Write to new memory
-        new_memory.write(&temp, i * sizeof(T), sizeof(T));
-      }
-    }
-
-    // Swap the memory blocks
-    memory = std::move(new_memory);
-
-    return true;
-  }
-
-
-};
-
-/**
- * @brief Equality comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if the vectors are equal, false otherwise
- */
-template <typename T>
-bool operator==(const VectorHIMEM<T>& lhs, const VectorHIMEM<T>& rhs) {
-  if (lhs.size() != rhs.size()) {
-    return false;
-  }
-
-  T lhs_val, rhs_val;
-  for (size_t i = 0; i < lhs.size(); ++i) {
-    lhs_val = lhs[i];  // Uses operator[] which calls read()
-    rhs_val = rhs[i];
-    if (!(lhs_val == rhs_val)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * @brief Inequality comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if the vectors are not equal, false otherwise
- */
-template <typename T>
-bool operator!=(const VectorHIMEM<T>& lhs, const VectorHIMEM<T>& rhs) {
-  return !(lhs == rhs);
-}
-
-/**
- * @brief Swap the contents of two vectors
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- */
-template <typename T>
-void swap(VectorHIMEM<T>& lhs, VectorHIMEM<T>& rhs) noexcept {
-  lhs.swap(rhs);
-}
-
-}  // namespace esp32_psram

lib/esp32-psram/src/esp32-psram/VectorPSRAM.h

@@ -1,521 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <memory>
-#include <limits>
-#include <algorithm>
-#include "AllocatorPSRAM.h"
-
-/**
- * @namespace esp32_psram
- * @brief Namespace containing ESP32 PSRAM-specific implementations
- */
-namespace esp32_psram {
-    
-
-/**
- * @brief Equality comparison operator for allocators
- * @tparam T Type of first allocator
- * @tparam U Type of second allocator
- * @return Always true since all instances are equivalent
- */
-template <typename T, typename U>
-bool operator==(const AllocatorPSRAM<T>&, const AllocatorPSRAM<U>&) noexcept {
-    return true;
-}
-
-/**
- * @brief Inequality comparison operator for allocators
- * @tparam T Type of first allocator
- * @tparam U Type of second allocator
- * @return Always false since all instances are equivalent
- */
-template <typename T, typename U>
-bool operator!=(const AllocatorPSRAM<T>&, const AllocatorPSRAM<U>&) noexcept {
-    return false;
-}
-
-/**
- * @class VectorPSRAM
- * @brief Vector implementation that uses ESP32's PSRAM for storage
- * @tparam T Type of elements stored in the vector
- * 
- * This class provides an interface identical to std::vector but allocates
- * all memory in ESP32's PSRAM, which helps preserve the limited internal RAM.
- * It wraps std::vector with a custom allocator that uses PSRAM.
- */
-template <typename T>
-class VectorPSRAM {
-private:
-    using vector_type = std::vector<T, AllocatorPSRAM<T>>;
-    vector_type vec;
-
-public:
-    // Type definitions
-    using value_type = typename vector_type::value_type;
-    using allocator_type = typename vector_type::allocator_type;
-    using size_type = typename vector_type::size_type;
-    using difference_type = typename vector_type::difference_type;
-    using reference = typename vector_type::reference;
-    using const_reference = typename vector_type::const_reference;
-    using pointer = typename vector_type::pointer;
-    using const_pointer = typename vector_type::const_pointer;
-    using iterator = typename vector_type::iterator;
-    using const_iterator = typename vector_type::const_iterator;
-    using reverse_iterator = typename vector_type::reverse_iterator;
-    using const_reverse_iterator = typename vector_type::const_reverse_iterator;
-    
-    /**
-     * @brief Default constructor - creates an empty vector
-     */
-    VectorPSRAM() : vec(AllocatorPSRAM<T>()) {}
-    
-    /**
-     * @brief Constructs a vector with the given number of default-initialized elements
-     * @param count The size of the vector
-     */
-    explicit VectorPSRAM(size_type count) : vec(count, AllocatorPSRAM<T>()) {}
-    
-    /**
-     * @brief Constructs a vector with the given number of copies of a value
-     * @param count The size of the vector
-     * @param value The value to initialize elements with
-     */
-    VectorPSRAM(size_type count, const T& value) : vec(count, value, AllocatorPSRAM<T>()) {}
-    
-    /**
-     * @brief Constructs a vector with the contents of the range [first, last)
-     * @tparam InputIt Input iterator type
-     * @param first Iterator to the first element in the range
-     * @param last Iterator to one past the last element in the range
-     */
-    template <typename InputIt>
-    VectorPSRAM(InputIt first, InputIt last) : vec(first, last, AllocatorPSRAM<T>()) {}
-    
-    /**
-     * @brief Copy constructor
-     * @param other The vector to copy from
-     */
-    VectorPSRAM(const VectorPSRAM& other) : vec(other.vec) {}
-    
-    /**
-     * @brief Move constructor
-     * @param other The vector to move from
-     */
-    VectorPSRAM(VectorPSRAM&& other) noexcept : vec(std::move(other.vec)) {}
-    
-    /**
-     * @brief Initializer list constructor
-     * @param init The initializer list to copy from
-     */
-    VectorPSRAM(std::initializer_list<T> init) : vec(init, AllocatorPSRAM<T>()) {}
-    
-    /**
-     * @brief Copy assignment operator
-     * @param other The vector to copy from
-     * @return Reference to this vector
-     */
-    VectorPSRAM& operator=(const VectorPSRAM& other) {
-        vec = other.vec;
-        return *this;
-    }
-    
-    /**
-     * @brief Move assignment operator
-     * @param other The vector to move from
-     * @return Reference to this vector
-     */
-    VectorPSRAM& operator=(VectorPSRAM&& other) noexcept {
-        vec = std::move(other.vec);
-        return *this;
-    }
-    
-    /**
-     * @brief Initializer list assignment operator
-     * @param ilist The initializer list to copy from
-     * @return Reference to this vector
-     */
-    VectorPSRAM& operator=(std::initializer_list<T> ilist) {
-        vec = ilist;
-        return *this;
-    }
-    
-    /**
-     * @brief Access element with bounds checking
-     * @param pos The position of the element
-     * @return Reference to the element at position pos
-     * @throws std::out_of_range if pos is not within the range of the vector
-     */
-    reference at(size_type pos) { return vec.at(pos); }
-    
-    /**
-     * @brief Access element with bounds checking (const version)
-     * @param pos The position of the element
-     * @return Const reference to the element at position pos
-     * @throws std::out_of_range if pos is not within the range of the vector
-     */
-    const_reference at(size_type pos) const { return vec.at(pos); }
-    
-    /**
-     * @brief Access element without bounds checking
-     * @param pos The position of the element
-     * @return Reference to the element at position pos
-     */
-    reference operator[](size_type pos) { return vec[pos]; }
-    
-    /**
-     * @brief Access element without bounds checking (const version)
-     * @param pos The position of the element
-     * @return Const reference to the element at position pos
-     */
-    const_reference operator[](size_type pos) const { return vec[pos]; }
-    
-    /**
-     * @brief Access the first element
-     * @return Reference to the first element
-     */
-    reference front() { return vec.front(); }
-    
-    /**
-     * @brief Access the first element (const version)
-     * @return Const reference to the first element
-     */
-    const_reference front() const { return vec.front(); }
-    
-    /**
-     * @brief Access the last element
-     * @return Reference to the last element
-     */
-    reference back() { return vec.back(); }
-    
-    /**
-     * @brief Access the last element (const version)
-     * @return Const reference to the last element
-     */
-    const_reference back() const { return vec.back(); }
-    
-    /**
-     * @brief Get pointer to the underlying array
-     * @return Pointer to the underlying array
-     */
-    T* data() noexcept { return vec.data(); }
-    
-    /**
-     * @brief Get pointer to the underlying array (const version)
-     * @return Const pointer to the underlying array
-     */
-    const T* data() const noexcept { return vec.data(); }
-    
-    /**
-     * @brief Get iterator to the beginning
-     * @return Iterator to the first element
-     */
-    iterator begin() noexcept { return vec.begin(); }
-    
-    /**
-     * @brief Get const iterator to the beginning
-     * @return Const iterator to the first element
-     */
-    const_iterator begin() const noexcept { return vec.begin(); }
-    
-    /**
-     * @brief Get const iterator to the beginning
-     * @return Const iterator to the first element
-     */
-    const_iterator cbegin() const noexcept { return vec.cbegin(); }
-    
-    /**
-     * @brief Get iterator to the end
-     * @return Iterator to one past the last element
-     */
-    iterator end() noexcept { return vec.end(); }
-    
-    /**
-     * @brief Get const iterator to the end
-     * @return Const iterator to one past the last element
-     */
-    const_iterator end() const noexcept { return vec.end(); }
-    
-    /**
-     * @brief Get const iterator to the end
-     * @return Const iterator to one past the last element
-     */
-    const_iterator cend() const noexcept { return vec.cend(); }
-    
-    /**
-     * @brief Get reverse iterator to the beginning
-     * @return Reverse iterator to the first element
-     */
-    reverse_iterator rbegin() noexcept { return vec.rbegin(); }
-    
-    /**
-     * @brief Get const reverse iterator to the beginning
-     * @return Const reverse iterator to the first element
-     */
-    const_reverse_iterator rbegin() const noexcept { return vec.rbegin(); }
-    
-    /**
-     * @brief Get const reverse iterator to the beginning
-     * @return Const reverse iterator to the first element
-     */
-    const_reverse_iterator crbegin() const noexcept { return vec.crbegin(); }
-    
-    /**
-     * @brief Get reverse iterator to the end
-     * @return Reverse iterator to one past the last element
-     */
-    reverse_iterator rend() noexcept { return vec.rend(); }
-    
-    /**
-     * @brief Get const reverse iterator to the end
-     * @return Const reverse iterator to one past the last element
-     */
-    const_reverse_iterator rend() const noexcept { return vec.rend(); }
-    
-    /**
-     * @brief Get const reverse iterator to the end
-     * @return Const reverse iterator to one past the last element
-     */
-    const_reverse_iterator crend() const noexcept { return vec.crend(); }
-    
-    /**
-     * @brief Check if the vector is empty
-     * @return true if the vector is empty, false otherwise
-     */
-    bool empty() const noexcept { return vec.empty(); }
-    
-    /**
-     * @brief Get the number of elements
-     * @return The number of elements in the vector
-     */
-    size_type size() const noexcept { return vec.size(); }
-    
-    /**
-     * @brief Get the maximum possible number of elements
-     * @return The maximum possible number of elements the vector can hold
-     */
-    size_type max_size() const noexcept { return vec.max_size(); }
-    
-    /**
-     * @brief Reserve storage
-     * @param new_cap The new capacity of the vector
-     * @throws std::length_error if new_cap > max_size()
-     */
-    void reserve(size_type new_cap) { vec.reserve(new_cap); }
-    
-    /**
-     * @brief Get the number of elements that can be held in current storage
-     * @return The capacity of the vector
-     */
-    size_type capacity() const noexcept { return vec.capacity(); }
-    
-    /**
-     * @brief Reduce memory usage by freeing unused memory
-     */
-    void shrink_to_fit() { vec.shrink_to_fit(); }
-    
-    /**
-     * @brief Clear the contents
-     */
-    void clear() noexcept { vec.clear(); }
-    
-    /**
-     * @brief Insert an element
-     * @param pos Iterator to the position before which the element will be inserted
-     * @param value The value to insert
-     * @return Iterator to the inserted element
-     */
-    iterator insert(const_iterator pos, const T& value) { return vec.insert(pos, value); }
-    
-    /**
-     * @brief Insert an element by moving it
-     * @param pos Iterator to the position before which the element will be inserted
-     * @param value The value to insert
-     * @return Iterator to the inserted element
-     */
-    iterator insert(const_iterator pos, T&& value) { return vec.insert(pos, std::move(value)); }
-    
-    /**
-     * @brief Insert multiple copies of an element
-     * @param pos Iterator to the position before which the elements will be inserted
-     * @param count Number of copies to insert
-     * @param value The value to insert
-     * @return Iterator to the first inserted element
-     */
-    iterator insert(const_iterator pos, size_type count, const T& value) { return vec.insert(pos, count, value); }
-    
-    /**
-     * @brief Insert elements from a range
-     * @tparam InputIt Input iterator type
-     * @param pos Iterator to the position before which the elements will be inserted
-     * @param first Iterator to the first element in the range
-     * @param last Iterator to one past the last element in the range
-     * @return Iterator to the first inserted element
-     */
-    template <typename InputIt>
-    iterator insert(const_iterator pos, InputIt first, InputIt last) { return vec.insert(pos, first, last); }
-    
-    /**
-     * @brief Insert elements from an initializer list
-     * @param pos Iterator to the position before which the elements will be inserted
-     * @param ilist The initializer list to insert from
-     * @return Iterator to the first inserted element
-     */
-    iterator insert(const_iterator pos, std::initializer_list<T> ilist) { return vec.insert(pos, ilist); }
-    
-    /**
-     * @brief Construct an element in-place
-     * @tparam Args Types of arguments to forward to the constructor
-     * @param pos Iterator to the position before which the element will be constructed
-     * @param args Arguments to forward to the constructor
-     * @return Iterator to the inserted element
-     */
-    template <typename... Args>
-    iterator emplace(const_iterator pos, Args&&... args) { return vec.emplace(pos, std::forward<Args>(args)...); }
-    
-    /**
-     * @brief Erase an element
-     * @param pos Iterator to the element to erase
-     * @return Iterator to the element after the erased element
-     */
-    iterator erase(const_iterator pos) { return vec.erase(pos); }
-    
-    /**
-     * @brief Erase a range of elements
-     * @param first Iterator to the first element to erase
-     * @param last Iterator to one past the last element to erase
-     * @return Iterator to the element after the erased range
-     */
-    iterator erase(const_iterator first, const_iterator last) { return vec.erase(first, last); }
-    
-    /**
-     * @brief Add an element to the end
-     * @param value The value to append
-     */
-    void push_back(const T& value) { vec.push_back(value); }
-    
-    /**
-     * @brief Add an element to the end by moving it
-     * @param value The value to append
-     */
-    void push_back(T&& value) { vec.push_back(std::move(value)); }
-    
-    /**
-     * @brief Construct an element in-place at the end
-     * @tparam Args Types of arguments to forward to the constructor
-     * @param args Arguments to forward to the constructor
-     * @return Reference to the inserted element
-     */
-    template <typename... Args>
-    reference emplace_back(Args&&... args) { return vec.emplace_back(std::forward<Args>(args)...); }
-    
-    /**
-     * @brief Remove the last element
-     */
-    void pop_back() { vec.pop_back(); }
-    
-    /**
-     * @brief Change the number of elements stored
-     * @param count The new size of the vector
-     */
-    void resize(size_type count) { vec.resize(count); }
-    
-    /**
-     * @brief Change the number of elements stored
-     * @param count The new size of the vector
-     * @param value The value to initialize new elements with
-     */
-    void resize(size_type count, const value_type& value) { vec.resize(count, value); }
-    
-    /**
-     * @brief Swap the contents
-     * @param other Vector to swap with
-     */
-    void swap(VectorPSRAM& other) noexcept { vec.swap(other.vec); }
-};
-
-/**
- * @brief Equality comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if the vectors are equal, false otherwise
- */
-template <typename T>
-bool operator==(const VectorPSRAM<T>& lhs, const VectorPSRAM<T>& rhs) {
-    return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
-}
-
-/**
- * @brief Inequality comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if the vectors are not equal, false otherwise
- */
-template <typename T>
-bool operator!=(const VectorPSRAM<T>& lhs, const VectorPSRAM<T>& rhs) {
-    return !(lhs == rhs);
-}
-
-/**
- * @brief Less than comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if lhs is lexicographically less than rhs, false otherwise
- */
-template <typename T>
-bool operator<(const VectorPSRAM<T>& lhs, const VectorPSRAM<T>& rhs) {
-    return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
-}
-
-/**
- * @brief Less than or equal comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if lhs is lexicographically less than or equal to rhs, false otherwise
- */
-template <typename T>
-bool operator<=(const VectorPSRAM<T>& lhs, const VectorPSRAM<T>& rhs) {
-    return !(rhs < lhs);
-}
-
-/**
- * @brief Greater than comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if lhs is lexicographically greater than rhs, false otherwise
- */
-template <typename T>
-bool operator>(const VectorPSRAM<T>& lhs, const VectorPSRAM<T>& rhs) {
-    return rhs < lhs;
-}
-
-/**
- * @brief Greater than or equal comparison operator
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- * @return true if lhs is lexicographically greater than or equal to rhs, false otherwise
- */
-template <typename T>
-bool operator>=(const VectorPSRAM<T>& lhs, const VectorPSRAM<T>& rhs) {
-    return !(lhs < rhs);
-}
-
-/**
- * @brief Swap the contents of two vectors
- * @tparam T Type of elements in the vectors
- * @param lhs First vector
- * @param rhs Second vector
- */
-template <typename T>
-void swap(VectorPSRAM<T>& lhs, VectorPSRAM<T>& rhs) noexcept {
-    lhs.swap(rhs);
-}
-
-} // namespace esp32_psram
-

lib/semver/Semver200_parser.cpp

@@ -50,7 +50,7 @@ inline Transition mkx(const char c, Parser_state p, State_transition_hook pth) {
 }
 
 inline void Parse_error(const std::string & s) {
-    // EMSESP::logger().err("parse error: %s", s.c_str());
+    // emsesp::EMSESP::logger().err("parse error: %s", s.c_str());
 }
 
 /// Advance parser state machine by a single step.

lib/uuid-syslog/src/syslog.cpp

@@ -346,6 +346,7 @@ void SyslogService::loop() {
 }
 
 bool SyslogService::can_transmit() {
+    // TODO this should be checked also for Eth
     if (!host_.empty() && (uint32_t)ip_ == 0) {
         WiFi.hostByName(host_.c_str(), ip_);
     }

lib_standalone/Arduino.h

@@ -59,8 +59,6 @@ typedef double double_t;
 
 #define snprintf snprintf_P // to keep backwards compatibility
 
-#define IRAM_ATTR
-
 void     pinMode(uint8_t pin, uint8_t mode);
 void     digitalWrite(uint8_t pin, uint8_t value);
 int      digitalRead(uint8_t pin);

lib_standalone/ESP32React.h

@@ -26,7 +26,7 @@ class DummySettings {
   public:
     // SYSTEM
     bool bandwidth20 = false;
-    bool nosleep     = true;
+    bool nosleep     = false;
 
     // MQTT
     uint16_t publish_time       = 10;

lib_standalone/ModuleLibrary.cpp

@@ -1,6 +1,6 @@
 /*
  * EMS-ESP - https://github.com/emsesp/EMS-ESP
- * Copyright 2020-2025  emsesp.org - proddy, MichaelDvP
+ * Copyright 2020-2024  emsesp.org - proddy, MichaelDvP
  * 
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

lib_standalone/ModuleLibrary.h

@@ -1,6 +1,6 @@
 /*
  * EMS-ESP - https://github.com/emsesp/EMS-ESP
- * Copyright 2020-2025  emsesp.org - proddy, MichaelDvP
+ * Copyright 2020-2024  emsesp.org - proddy, MichaelDvP
  * 
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

lib_standalone/Preferences.h

@@ -12,8 +12,8 @@ class Preferences {
     bool     _readOnly;
 
   public:
-    Preferences() {};
-    ~Preferences() {};
+    Preferences(){};
+    ~Preferences(){};
 
     bool begin(const char * name, bool readOnly = false, const char * partition_label = NULL) {
         return true;
@@ -26,49 +26,44 @@ class Preferences {
         return true;
     }
 
-    int getChar(const char * key, uint8_t defaultValue = 0) {
-        return 0;
-    }
     size_t putChar(const char * key, int8_t value) {
         return 0;
     }
-
-    uint8_t getUChar(const char * key, uint8_t defaultValue = 0) {
-        return 0;
-    }
     size_t putUChar(const char * key, uint8_t value) {
         return 0;
     }
 
-    double getDouble(const char * key, double defaultValue = NAN) {
-        return 0;
-    }
     size_t putDouble(const char * key, double value) {
         return 0;
     }
 
-    bool getBool(const char * key, bool defaultValue = false) {
-        return true;
-    }
-    size_t putBool(const char * key, bool value) {
+    uint8_t getUChar(const char * key, uint8_t defaultValue = 0) {
         return 0;
     }
 
-    String getString(const char * key, String defaultValue = String()) {
-        return "";
+    int getChar(const char * key, uint8_t defaultValue = 0) {
+        return 0;
     }
+
+    double getDouble(const char * key, double defaultValue = NAN) {
+        return 0;
+    }
+
     size_t putString(const char * key, const char * value) {
         return 0;
     }
-
-    size_t getString(const char * key, char * value, size_t maxLen) {
-        return 0;
-    }
     size_t putString(const char * key, String value) {
         return 0;
     }
 
-    // unused....
+    size_t getString(const char * key, char * value, size_t maxLen) {
+        return 0;
+    }
+    String getString(const char * key, String defaultValue = String()) {
+        return "";
+    }
+
+    // unused
 
     // void           end();
     // bool           clear();

lib_standalone/emsuart_standalone.cpp

@@ -1,6 +1,6 @@
 /*
  * EMS-ESP - https://github.com/emsesp/EMS-ESP
- * Copyright 2020-2025  emsesp.org - proddy, MichaelDvP
+ * Copyright 2020-2024  emsesp.org - proddy, MichaelDvP
  * 
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by

lib_standalone/emsuart_standalone.h

@@ -1,6 +1,6 @@
 /*
  * EMS-ESP - https://github.com/emsesp/EMS-ESP
- * Copyright 2020-2025  emsesp.org - proddy, MichaelDvP
+ * Copyright 2020-2024  emsesp.org - proddy, MichaelDvP
  * 
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,12 +21,6 @@
 
 #include "Arduino.h"
 
-#define EMS_TXMODE_OFF 0
-#define EMS_TXMODE_DEFAULT 1
-#define EMS_TXMODE_EMSPLUS 2
-#define EMS_TXMODE_HT3 3
-#define EMS_TXMODE_HW 4
-
 namespace emsesp {
 
 #define EMS_TX_STATUS_ERR 0

lib_standalone/esp32-psram.h

@@ -1,4 +0,0 @@
-#pragma once
-
-#define stringPSRAM std::string
-#define AllocatorPSRAM std::allocator