Merge pull request #17 from Valar-Systems/feat/ota-manual-check

feat(ota): manual update check + robust release parse, friendlier status (1.0.7)

Author: daniel-frenkel

version/r1.1/firmware/platformio/esp32_firmware_platformio/platformio.ini

@@ -63,7 +63,7 @@ build_flags =
     -DARDUINO_USB_CDC_ON_BOOT=1
     ; ESP32 firmware version: reported in the heartbeat and used by the OTA
     ; flow to decide whether this board needs updating. Bump on every release.
-    '-DFW_VERSION="1.0.6"'
+    '-DFW_VERSION="1.0.7"'
     ; Bootstrap token for register_device/capture transport auth. Sourced from
     ; the environment so the secret is never committed: set MSC_BOOTSTRAP_TOKEN
     ; before building (PowerShell: $env:MSC_BOOTSTRAP_TOKEN="..."; bash:

version/r1.1/firmware/platformio/esp32_firmware_platformio/src/config_portal.h

@@ -129,6 +129,7 @@ button.warn{background:#3a2326;color:#f87171;border:1px solid #5b2a2e}
 <div class=row><span class=k>Boot count</span><span class=v id=bootCount>&mdash;</span></div>
 <div class=row><span class=k>Firmware</span><span class=v id=fwVersion>&mdash;</span></div>
 <div class=row><span class=k>Update status</span><span class=v id=otaStatus>&mdash;</span></div>
+<button onclick=checkUpdate()>Check for updates now</button>
 </div>
 
 <div class=toast id=toast></div>
@@ -186,6 +187,10 @@ async function clearWifi(){
   await post('/api/clear',{});
   document.body.innerHTML='<h1>Cleared. Rebooting&hellip;</h1><p class=sub>Join the MiniSpeedCam WiFi to reconfigure.</p>';
 }
+async function checkUpdate(){
+  await post('/api/ota/check',{});
+  toast('Checking GitHub for updates...');
+}
 function syncStream(on){
   if(on===streamShown)return;
   const img=$('streamImg');
@@ -401,6 +406,16 @@ static esp_err_t portalStreamPost(httpd_req_t* req) {
   return httpd_resp_sendstr(req, "{\"ok\":true}");
 }
 
+// POST /api/ota/check -> request an immediate GitHub update check. Only sets the
+// flag; taskCore0's otaAutoService() runs the check (and applies any newer image)
+// the next time it's idle, bypassing the periodic timer. The result appears in
+// the "Update status" line the page already polls.
+static esp_err_t portalOtaCheckPost(httpd_req_t* req) {
+  ota_check_now = true;
+  httpd_resp_set_type(req, "application/json");
+  return httpd_resp_sendstr(req, "{\"ok\":true}");
+}
+
 static httpd_handle_t config_httpd = NULL;
 
 /**
@@ -417,7 +432,7 @@ void load_config_portal(void) {
   // /api/state polls; the old separate :81 stream server is gone (its sockets
   // freed), so this single server can afford more open sockets.
   config.max_open_sockets = 7;
-  config.max_uri_handlers = 8;
+  config.max_uri_handlers = 10;
   config.lru_purge_enable = true;
   config.stack_size       = 8192;   // headroom for ArduinoJson + String building
 
@@ -432,12 +447,14 @@ void load_config_portal(void) {
   httpd_uri_t u_wifi   = { .uri = "/api/wifi",     .method = HTTP_POST, .handler = portalWifiPost,     .user_ctx = NULL };
   httpd_uri_t u_clear  = { .uri = "/api/clear",    .method = HTTP_POST, .handler = portalClearPost,    .user_ctx = NULL };
   httpd_uri_t u_stream = { .uri = "/api/stream",   .method = HTTP_POST, .handler = portalStreamPost,   .user_ctx = NULL };
+  httpd_uri_t u_otachk = { .uri = "/api/ota/check",.method = HTTP_POST, .handler = portalOtaCheckPost, .user_ctx = NULL };
   httpd_register_uri_handler(config_httpd, &u_root);
   httpd_register_uri_handler(config_httpd, &u_state);
   httpd_register_uri_handler(config_httpd, &u_set);
   httpd_register_uri_handler(config_httpd, &u_wifi);
   httpd_register_uri_handler(config_httpd, &u_clear);
   httpd_register_uri_handler(config_httpd, &u_stream);
+  httpd_register_uri_handler(config_httpd, &u_otachk);
 
   // The aiming MJPEG stream shares this same server (GET /stream), shown inline
   // in a small window on the config page. See camera_stream.cpp.

version/r1.1/firmware/platformio/esp32_firmware_platformio/src/ota.h

@@ -122,10 +122,21 @@ bool otaCheckGithub() {
     filter["tag_name"] = true;
     filter["assets"][0]["name"] = true;
     filter["assets"][0]["browser_download_url"] = true;
-    JsonDocument doc;
-    DeserializationError err = deserializeJson(doc, https.getStream(), DeserializationOption::Filter(filter));
+    // Buffer the body before parsing. Reading the (large) release JSON straight
+    // off the TLS stream is fragile -- a mid-transfer stall (seen on the check
+    // that runs right after an STM flash) surfaces as "bad API response"
+    // (IncompleteInput). getString() reads the whole body within the timeout so
+    // the parser sees it intact; the error detail makes any recurrence concrete
+    // (and is NOT an "up to date" signal).
+    String body = https.getString();
     https.end();
-    if (err) { otaSetStatus("check: bad API response"); return false; }
+    JsonDocument doc;
+    DeserializationError err = deserializeJson(doc, body, DeserializationOption::Filter(filter));
+    if (err) {
+      Serial.printf("[OTA] api parse failed: %s (body=%u B)\n", err.c_str(), (unsigned)body.length());
+      otaSetStatus("check: bad API response (%s)", err.c_str());
+      return false;
+    }
 
     tag = (const char*)(doc["tag_name"] | "");
     for (JsonObject a : doc["assets"].as<JsonArray>()) {
@@ -171,12 +182,18 @@ bool otaCheckGithub() {
   // a valid health signal for the post-update watchdog (otaHealthService()).
   g_cloud_ok = true;
 
-  char espinfo[44], stminfo[44];
-  if (ota_esp_available) snprintf(espinfo, sizeof espinfo, "%s->%s", FW_VERSION, ota_esp_version.c_str());
-  else                   snprintf(espinfo, sizeof espinfo, "%s ok", FW_VERSION);
-  if (ota_stm_available) snprintf(stminfo, sizeof stminfo, "%s->%s", stm_fw_version.c_str(), ota_stm_version.c_str());
-  else                   snprintf(stminfo, sizeof stminfo, "%s ok", stm_fw_version.c_str());
-  otaSetStatus("ESP %s | STM %s", espinfo, stminfo);
+  if (!ota_esp_available && !ota_stm_available) {
+    // Both current -- the common, friendly "nothing to do" result.
+    otaSetStatus("Up to date (ESP %s, STM %s)", FW_VERSION, stm_fw_version.c_str());
+  } else {
+    // Something newer is available (and about to be applied below) -- show what.
+    char espinfo[44], stminfo[44];
+    if (ota_esp_available) snprintf(espinfo, sizeof espinfo, "%s->%s", FW_VERSION, ota_esp_version.c_str());
+    else                   snprintf(espinfo, sizeof espinfo, "%s ok", FW_VERSION);
+    if (ota_stm_available) snprintf(stminfo, sizeof stminfo, "%s->%s", stm_fw_version.c_str(), ota_stm_version.c_str());
+    else                   snprintf(stminfo, sizeof stminfo, "%s ok", stm_fw_version.c_str());
+    otaSetStatus("Update available: ESP %s | STM %s", espinfo, stminfo);
+  }
   return true;
 }
 
@@ -398,15 +415,21 @@ void otaAutoService() {
 
   if (stm_flash_busy) return;
   if (WiFi.getMode() != WIFI_STA || WiFi.status() != WL_CONNECTED) return;
-  if ((long)(millis() - nextCheck) < 0) return;
 
-  // Only act when idle. Don't advance the timer if busy, so we retry promptly
-  // once the current pass/stream/upload finishes (passes last only seconds).
+  // A manual "check now" (config-page button) bypasses the interval timer; the
+  // periodic check otherwise waits for nextCheck to elapse.
+  bool manual = ota_check_now;
+  if (!manual && (long)(millis() - nextCheck) < 0) return;
+
+  // Only act when idle. Don't advance the timer or consume the manual request if
+  // busy, so it retries promptly once the current pass/stream/upload finishes
+  // (passes last only seconds).
   bool idle = !g_run_active && !stream_active &&
               (uploadQueue == nullptr || uxQueueMessagesWaiting(uploadQueue) == 0);
   if (!idle) return;
 
-  nextCheck = millis() + OTA_CHECK_INTERVAL_MS;  // schedule the next check regardless of outcome
+  ota_check_now = false;                          // consume the manual request (if any)
+  nextCheck = millis() + OTA_CHECK_INTERVAL_MS;   // schedule the next periodic check regardless of outcome
 
   if (!otaCheckGithub()) return;
 

version/r1.1/firmware/platformio/esp32_firmware_platformio/src/variables.h

@@ -189,6 +189,10 @@ const char* server_github_latest = "https://api.github.com/repos/" GITHUB_OWNER
 // URLs/MD5s and the *_available flags are touched only on Core 0, so they need
 // no guarding.
 char ota_status[96] = "idle";
+// Manual "check for updates now" request from the config-page button. Set by the
+// POST /api/ota/check handler (httpd task) and consumed by otaAutoService() on
+// Core 0, which then runs a check immediately instead of waiting for the timer.
+volatile bool ota_check_now = false;
 String ota_esp_version, ota_esp_url, ota_esp_md5;
 String ota_stm_version, ota_stm_url, ota_stm_md5;
 bool ota_esp_available = false;