sync(rx): rx-v2.8.6

Author: smartghar-sync[bot]

README.md

@@ -1,6 +1,5 @@
 # TankSync — reliable smart water monitoring
 
-[![Pre-order Developer Edition](https://img.shields.io/badge/Pre--order-Developer%20Edition-success.svg?style=flat)](https://shop.smartghar.org)
 [![Firmware: AGPL-3.0](https://img.shields.io/badge/Firmware-AGPL--3.0-blue.svg)](LICENSE)
 [![Hardware: CC BY-SA 4.0](https://img.shields.io/badge/Hardware-CC%20BY--SA%204.0-orange.svg)](hardware/LICENSE)
 [![ESP-IDF](https://img.shields.io/badge/ESP--IDF-v5.4-red.svg)](https://docs.espressif.com/projects/esp-idf/)
@@ -17,17 +16,6 @@
   <sub><em>The indoor hub (left), the solar tank sensor with non-contact ultrasonic measurement (centre), and the custom circular TX PCB (right) — current production hardware, REV 2.2 (May 2026), tested through Delhi summer at 45°C ambient.</em></sub>
 </p>
 
-## Watch the story — Episode 1
-
-<p align="center">
-  <a href="https://www.youtube.com/watch?v=ZZt6cZbWM0g">
-    <img src="https://img.youtube.com/vi/ZZt6cZbWM0g/maxresdefault.jpg" width="70%" alt="TankSync Episode 1 — Smart Home That Works Without Internet" />
-  </a>
-</p>
-<p align="center">
-  <sub><em>Why I built TankSync, the local-first philosophy, and how the rooftop sensor + indoor hub stay reliable when the internet doesn't. <a href="https://www.youtube.com/watch?v=ZZt6cZbWM0g">Watch on YouTube →</a></em></sub>
-</p>
-
 ## Try the in-browser flasher first
 
 👉 **[tanksync.smartghar.org/firmware/](https://tanksync.smartghar.org/firmware/)**
@@ -194,26 +182,6 @@ This is the open-source TankSync firmware + hardware mirror. The hosted cloud da
 
 The firmware works fully **without** the cloud — local web UI on the hub gives you tank levels, settings, OTA updates, Home Assistant integration. Cloud is opt-in convenience, never a dependency.
 
-## Developer Edition hardware
-
-If you'd rather skip sourcing parts, flashing firmware, printing enclosures, and assembling hardware yourself, prebuilt TankSync Developer Edition kits are available for preorder.
-
-Each kit includes:
-- assembled RX hub
-- assembled TX sensor node
-- flashed firmware
-- LoRa modules preconfigured
-- waterproof enclosure set
-- OLED display + local web UI
-- access to the hosted TankSync PWA experience
-
-The firmware and hardware files remain fully open for self-build deployments.
-
-Preorders:
-https://shop.smartghar.org
-
-First batch is currently planned for end of July / early August 2026.
-
 ## Licenses
 
 | Component | License | What this means |

firmware/Receiver-ESP32-DevKit/VERSION

@@ -1 +1 @@
-2.8.5
+2.8.6

firmware/Receiver-ESP32-DevKit/components/log_buffer/CMakeLists.txt

@@ -0,0 +1,7 @@
+idf_component_register(
+    SRCS "log_buffer.c"
+    INCLUDE_DIRS "include"
+    REQUIRES
+        log
+        freertos
+)

firmware/Receiver-ESP32-DevKit/components/log_buffer/include/log_buffer.h

@@ -0,0 +1,57 @@
+/**
+ * log_buffer — captures ESP_LOG output into an in-RAM ring buffer so the TX
+ * web UI can show live boot/runtime logs without a USB cable attached.
+ *
+ * Usage:
+ *   log_buffer_init();          // call once early in app_main
+ *   // ... all subsequent ESP_LOGI/W/E calls are also appended to the ring
+ *
+ *   size_t cursor = 0;
+ *   char out[2048];
+ *   size_t n = log_buffer_read(out, sizeof(out), &cursor);
+ *   // out contains up to n bytes of log text; cursor advances so the next
+ *   // call returns only newly-appended bytes.
+ *
+ * Thread-safety: vprintf callback + read both take a FreeRTOS mutex so the
+ * HTTP handler can safely read while the LoRa / sensor tasks are logging.
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+#include "esp_err.h"
+
+#ifndef LOG_BUFFER_BYTES
+#define LOG_BUFFER_BYTES   4096   // ~50 typical log lines
+#endif
+
+/**
+ * Install the vprintf hook so every ESP_LOG* call also lands in the ring
+ * buffer. The original vprintf (stdout via USB-Serial-JTAG / UART) keeps
+ * working — both paths receive the same bytes.
+ * Safe to call multiple times; subsequent calls are no-ops.
+ */
+esp_err_t log_buffer_init(void);
+
+/**
+ * Copy the bytes appended since *cursor into out_buf.
+ *
+ * @param out_buf   destination
+ * @param out_sz    max bytes to copy (capped at out_sz - 1; output is NUL-terminated)
+ * @param cursor    in: last-seen byte count; out: new byte count after this read
+ *                  pass *cursor=0 on first call to get everything currently buffered.
+ *                  If the reader fell behind (cursor < total - LOG_BUFFER_BYTES),
+ *                  cursor is silently advanced to the oldest available byte and a
+ *                  "<gap of N bytes>" marker is prepended to out_buf so the UI can
+ *                  show that some lines were dropped.
+ * @return          number of bytes written to out_buf (excluding the NUL).
+ */
+size_t log_buffer_read(char *out_buf, size_t out_sz, size_t *cursor);
+
+/**
+ * Drop everything currently in the ring. Useful if the UI has a "Clear" button.
+ * Cursor values held by clients become stale but they'll catch up on next read
+ * via the gap-marker path.
+ */
+void log_buffer_clear(void);

firmware/Receiver-ESP32-DevKit/components/log_buffer/log_buffer.c

@@ -0,0 +1,107 @@
+/**
+ * log_buffer — see log_buffer.h for design notes.
+ *
+ * Implementation: byte-based circular buffer protected by a FreeRTOS mutex.
+ * Each ESP_LOG call routes through esp_log_set_vprintf(), where we vsnprintf
+ * the formatted line into a small stack buffer, copy bytes into the ring,
+ * and forward the same bytes to the original vprintf so the USB-Serial-JTAG
+ * console still works.
+ */
+
+#include "log_buffer.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include "esp_log.h"
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+static char           s_ring[LOG_BUFFER_BYTES];
+static size_t         s_head     = 0;                  // next write index
+static size_t         s_total    = 0;                  // monotonic byte count
+static SemaphoreHandle_t s_mu    = NULL;
+static vprintf_like_t s_prev_vprintf = NULL;
+static bool           s_inited   = false;
+
+static int log_buffer_vprintf(const char *fmt, va_list args) {
+    // Format into a local stack buffer first so we hold the mutex for the
+    // minimum time. 256 chars handles every ESP_LOGI / LOGW / LOGE the
+    // codebase emits without truncation in practice.
+    char line[256];
+    va_list args_copy;
+    va_copy(args_copy, args);
+    int n = vsnprintf(line, sizeof(line), fmt, args_copy);
+    va_end(args_copy);
+    if (n < 0) n = 0;
+    if (n >= (int)sizeof(line)) n = sizeof(line) - 1;
+
+    if (s_mu && xSemaphoreTake(s_mu, pdMS_TO_TICKS(5)) == pdTRUE) {
+        for (int i = 0; i < n; i++) {
+            s_ring[s_head] = line[i];
+            s_head = (s_head + 1) % sizeof(s_ring);
+            s_total++;
+        }
+        xSemaphoreGive(s_mu);
+    }
+
+    // Forward to the original sink (USB-Serial-JTAG / UART console) so the
+    // serial monitor still works when a cable is attached.
+    if (s_prev_vprintf) return s_prev_vprintf(fmt, args);
+    return vprintf(fmt, args);
+}
+
+esp_err_t log_buffer_init(void) {
+    if (s_inited) return ESP_OK;
+    s_mu = xSemaphoreCreateMutex();
+    if (!s_mu) return ESP_ERR_NO_MEM;
+    s_prev_vprintf = esp_log_set_vprintf(log_buffer_vprintf);
+    s_inited = true;
+    return ESP_OK;
+}
+
+size_t log_buffer_read(char *out_buf, size_t out_sz, size_t *cursor) {
+    if (!out_buf || out_sz < 2 || !cursor) return 0;
+    if (!s_mu) { out_buf[0] = '\0'; return 0; }
+
+    size_t written = 0;
+    if (xSemaphoreTake(s_mu, pdMS_TO_TICKS(50)) != pdTRUE) {
+        out_buf[0] = '\0';
+        return 0;
+    }
+
+    size_t total  = s_total;
+    size_t oldest = (total > sizeof(s_ring)) ? (total - sizeof(s_ring)) : 0;
+
+    // Detect and report gap for clients that fell behind.
+    if (*cursor < oldest) {
+        size_t lost = oldest - *cursor;
+        int marker = snprintf(out_buf, out_sz, "<gap of %u bytes>\n",
+                              (unsigned)lost);
+        if (marker > 0) {
+            written = (size_t)marker;
+            if (written >= out_sz) written = out_sz - 1;
+        }
+        *cursor = oldest;
+    }
+
+    // Copy from cursor to total, respecting buffer wrap.
+    while (*cursor < total && written < out_sz - 1) {
+        size_t idx = *cursor % sizeof(s_ring);
+        out_buf[written++] = s_ring[idx];
+        (*cursor)++;
+    }
+    out_buf[written] = '\0';
+
+    xSemaphoreGive(s_mu);
+    return written;
+}
+
+void log_buffer_clear(void) {
+    if (!s_mu) return;
+    if (xSemaphoreTake(s_mu, pdMS_TO_TICKS(50)) == pdTRUE) {
+        s_head  = 0;
+        s_total = 0;
+        memset(s_ring, 0, sizeof(s_ring));
+        xSemaphoreGive(s_mu);
+    }
+}

firmware/Receiver-ESP32-DevKit/components/lora_rylr998/lora_rylr998.c

@@ -270,6 +270,7 @@ static bool parse_rcv(const char *line, lora_rx_packet_t *pkt) {
     pkt->power_mw      = 0;
     pkt->charging      = false;
     pkt->sensor_status = 'u';
+    pkt->sensor_kind[0] = '\0';
 
     char *mode_s = strtok_r(NULL, ":\r\n", &sp2);
     if (mode_s && mode_s[0] != '\0') {
@@ -295,6 +296,15 @@ static bool parse_rcv(const char *line, lora_rx_packet_t *pkt) {
         if (s == 'o' || s == 'e') pkt->sensor_status = s;
     }
 
+    // Optional 11th field: sensor_kind tag (since TX v2.0.15) — "sr04" |
+    // "ld2413" | "?" sentinel. Older TX firmware that omits this leaves the
+    // field empty so the dashboard knows "TX too old to report".
+    char *skind_s = strtok_r(NULL, ":\r\n", &sp2);
+    if (skind_s && skind_s[0] != '\0' && skind_s[0] != '?') {
+        strncpy(pkt->sensor_kind, skind_s, sizeof(pkt->sensor_kind) - 1);
+        pkt->sensor_kind[sizeof(pkt->sensor_kind) - 1] = '\0';
+    }
+
     pkt->charging = (pkt->power_mode == 'i' && pkt->current_ma < 0);
 
     return true;

firmware/Receiver-ESP32-DevKit/components/lora_rylr998/lora_rylr998.h

@@ -58,6 +58,11 @@ typedef struct {
     // but 'e' is an explicit failure signal (paint a sensor-error badge), while
     // 'u' just means "TX is too old to tell us either way."
     char     sensor_status;
+
+    // Sensor driver kind the TX is currently RUNNING (since TX firmware
+    // v2.0.15). Empty string if absent. Compared against the registry's
+    // queued sensor_kind so the dashboard can show Active vs Queued.
+    char     sensor_kind[12];
 } lora_rx_packet_t;
 
 // ── Hardware state ────────────────────────────────────────────────────────────

firmware/Receiver-ESP32-DevKit/components/mqtt_client/mqtt_manager.c

@@ -193,6 +193,11 @@ static void handle_cmd(const char *command, const char *payload) {
         cJSON *pwr_j = cJSON_GetObjectItem(j, "lora_pwr");
         uint8_t  pwr = pwr_j ? (uint8_t)cJSON_GetNumberValue(pwr_j) : 0;
         if (pwr > 22) pwr = 22;
+        // Optional sensor_kind ("sr04" | "ld2413"). Absent or empty = leave
+        // whatever the TX currently has. Validation is in registry_set_sensor_kind.
+        const char *sk_ptr = cJSON_GetStringValue(cJSON_GetObjectItem(j, "sensor_kind"));
+        char sk_buf[12] = {0};
+        if (sk_ptr) { strncpy(sk_buf, sk_ptr, sizeof(sk_buf) - 1); }
         cJSON_Delete(j);
 
         const char *name = name_ptr ? name_buf : NULL;
@@ -209,14 +214,21 @@ static void handle_cmd(const char *command, const char *payload) {
         if (sleep_s >= 60) {
             registry_set_remote_config(addr, sleep_s, samples > 0 ? samples : 5, pwr);
         }
+        if (sk_buf[0]) {
+            if (!registry_set_sensor_kind(addr, sk_buf)) {
+                pub(result_topic, "{\"ok\":false,\"err\":\"bad_sensor_kind\"}", 0);
+                return;
+            }
+        }
         // Republish config immediately so cloud sees the new state without waiting
         // for the next periodic publish cycle.
         int idx = registry_find(addr);
         if (idx >= 0) mqtt_publish_tank(idx);
 
         pub(result_topic, "{\"ok\":true}", 0);
-        ESP_LOGI(TAG, "CMD set_config: addr=%u sleep=%lu samples=%u pwr=%u",
-                 (unsigned)addr, (unsigned long)sleep_s, (unsigned)samples, (unsigned)pwr);
+        ESP_LOGI(TAG, "CMD set_config: addr=%u sleep=%lu samples=%u pwr=%u sensor=%s",
+                 (unsigned)addr, (unsigned long)sleep_s, (unsigned)samples, (unsigned)pwr,
+                 sk_buf[0] ? sk_buf : "(unchanged)");
 
     } else if (strcmp(command, "ota_check") == 0) {
         // PWA-triggered manifest check. Non-blocking — actual fetch runs in
@@ -800,6 +812,16 @@ void mqtt_publish_tank(int idx) {
     make_topic(topic, sizeof(topic), slug, "lora_pwr");
     pub(topic, val, 1);
 
+    // sensor_kind — what RX has QUEUED for this TX (the user's choice, what
+    // gets pushed in the next SET frame). Empty = no preference recorded.
+    make_topic(topic, sizeof(topic), slug, "sensor_kind");
+    pub(topic, info.sensor_kind, 1);
+
+    // active_sensor — what the TX is ACTUALLY running, reported in TANK
+    // packets (since TX v2.0.15). Empty if TX firmware doesn't declare it.
+    make_topic(topic, sizeof(topic), slug, "active_sensor");
+    pub(topic, data.active_sensor, 1);
+
     // TX firmware version — published only when TX has actually reported one.
     // Empty/zero means pre-power-telemetry TX or never received the version
     // packet yet; suppress to avoid clobbering a previously-known value.
@@ -821,7 +843,7 @@ void mqtt_unpublish_tank(uint16_t addr) {
         "sensor_error",
         "power_mode", "current_ma", "power_mw", "charging",
         "name", "min_dist", "max_dist", "capacity", "sleep_s", "samples",
-        "lora_pwr", "fw",
+        "lora_pwr", "sensor_kind", "active_sensor", "fw",
     };
     char topic[MAX_TOPIC_LEN];
     for (size_t i = 0; i < sizeof(retained_fields) / sizeof(retained_fields[0]); i++) {