added lighting fading in and out, when connection is lost/reestablished

analog_system_monitor_arduino/Config.h

@@ -0,0 +1,105 @@
+#pragma once
+#include <Arduino.h>
+
+// -------------------------------
+// Firmware version
+// -------------------------------
+static const char* FIRMWARE_VERSION = "V2.4_UDP_LEDC_WM_SLEW";
+
+// -------------------------------
+// UDP
+// -------------------------------
+static const int listenPort = 12345;          // default / legacy constant
+static const unsigned long watchdogTimeout = 5000;  // 5 seconds
+
+// -------------------------------
+// PWM setup (LEDC, ESP32 Core 3.x)
+// -------------------------------
+static const uint8_t NUM_CHANNELS = 8;
+
+static const uint8_t pwmPins[NUM_CHANNELS] = {
+    26, // D0
+    22, // D1
+    21, // D2
+    17, // D3
+    16, // D4
+    5,  // D5
+    18, // D6
+    19  // D7
+};
+
+static const uint32_t pwmFrequency = 25000; // 25 kHz
+static const uint8_t pwmResolution = 10;    // 10-bit resolution (0–1023)
+
+// -------------------------------
+// Channel labels for debugging
+// -------------------------------
+static const char* const channelLabels[NUM_CHANNELS] = {
+  "CPU Load",
+  "CPU Temp",
+  "RAM Usage",
+  "GPU Load",
+  "GPU Temp",
+  "VRAM Usage",
+  "Reserved 6",
+  "Reserved 7"
+};
+
+static const char* const channelUnits[NUM_CHANNELS] = {
+  "%",     // CPU Load
+  "°C",    // CPU Temp
+  "%",     // RAM Usage
+  "%",     // GPU Load
+  "°C",    // GPU Temp
+  "%",     // VRAM Usage
+  "",      // Reserved
+  ""       // Reserved
+};
+
+// -------------------------------
+// Channel labels ESPUI
+// -------------------------------
+static const char* const channelDropdownLabels[NUM_CHANNELS] = {
+    "CH0 (CPU Load)",
+    "CH1 (CPU Temp)",
+    "CH2 (RAM Usage)",
+    "CH3 (GPU Load)",
+    "CH4 (GPU Temp)",
+    "CH5 (VRAM Usage)",
+    "CH6 (Reserved 6)",
+    "CH7 (Reserved 7)"
+};
+
+// -------------------------------
+// Calibration logical points
+// -------------------------------
+static const unsigned long slewDuration = 1000; // 1 second smooth transition
+
+// -------------------------------
+// Animation tuning
+// -------------------------------
+static const float FADE_IN_FACTOR  = 0.998f;   // boot-up 0 → 100%
+static const float FADE_OUT_FACTOR = 0.999f;   // watchdog 100% → 0
+static const unsigned long FADE_INTERVAL = 1;  // ms between fade steps
+// Lighting fade durations (milliseconds)
+#define LIGHTING_FADE_IN_DURATION   1250
+#define LIGHTING_FADE_OUT_DURATION  4250
+// Clamping brightness at the low end
+const uint8_t BRIGHTNESS_MIN_VISIBLE = 33;
+
+
+// -------------------------------
+// Lighting (FastLED)
+// -------------------------------
+#define LED_PIN 23
+#define NUM_LEDS 20
+
+// -------------------------------
+// Connection state machine
+// -------------------------------
+enum ConnectionState {
+    STATE_DISCONNECTED,          // fade to zero
+    STATE_CONNECTING,            // fade in 0 → 100%
+    STATE_WAIT_FOR_FIRST_PACKET, // hold at 100%, wait for first UDP
+    STATE_CONNECTED              // normal UDP-driven slew
+};

analog_system_monitor_arduino/Core.cpp

@@ -0,0 +1,438 @@
+#include <Arduino.h>
+#include "Core.h"
+#include <FastLED.h>
+
+WiFiUDP udp;
+Preferences prefs;
+int udpPort = listenPort;
+
+float currentDuty[NUM_CHANNELS] = {0.0f};
+float targetDuty[NUM_CHANNELS]  = {0.0f};
+float slewStartDuty[NUM_CHANNELS] = {0.0f};
+
+unsigned long slewStartTime = 0;
+unsigned long lastPacketTime = 0;
+unsigned long lastFadeTime = 0;
+
+float logicalPoints[5] = {0, 25, 50, 75, 100};
+
+float calibratedPoints[NUM_CHANNELS][5] = {
+  {0.0f, 25.0f, 50.0f, 75.0f, 99.0f},
+  {0.0f, 24.0f, 49.0f, 74.0f, 98.0f},
+  {0.0f, 26.0f, 51.0f, 76.0f, 99.0f},
+  {0.0f, 25.0f, 50.0f, 75.0f, 97.0f},
+  {0.0f, 25.0f, 50.0f, 75.0f, 99.0f},
+  {0.0f, 24.0f, 50.0f, 74.0f, 98.0f},
+  {0.0f, 25.0f, 49.0f, 75.0f, 97.0f},
+  {0.0f, 26.0f, 50.0f, 76.0f, 99.0f}
+};
+
+CRGB leds[NUM_LEDS];
+
+uint8_t lightingHue = 0;
+uint8_t lightingSaturation = 255;
+uint8_t lightingBrightness = 255;
+uint8_t lightingBrightnessSaved = 255;
+
+// Lighting fade state
+bool lightingFading = false;
+uint8_t lightingFadeStart = 0;
+uint8_t lightingFadeEnd = 0;
+unsigned long lightingFadeStartTime = 0;
+unsigned long lightingFadeDuration = 0;
+
+bool overrideActive[NUM_CHANNELS] = {false};
+
+ConnectionState connectionState = STATE_DISCONNECTED;
+
+// UI IDs (defined here, used also by UI.cpp)
+uint16_t connectionStatusLabel;
+uint16_t calChannelDropdown;
+uint16_t calInputs[5];
+uint16_t calTestValueInput;
+uint16_t calSaveButton;
+uint16_t calOverrideSwitch;
+uint8_t selectedCalChannel = 0;
+
+// -------------------------------
+// Calibration interpolation
+// -------------------------------
+float applyCalibration(uint8_t ch, float logicalDuty) {
+  if (logicalDuty <= 0.0f) return calibratedPoints[ch][0];
+  if (logicalDuty >= 100.0f) return calibratedPoints[ch][4];
+
+  for (int i = 0; i < 4; i++) {
+    if (logicalDuty >= logicalPoints[i] && logicalDuty <= logicalPoints[i+1]) {
+      float x0 = logicalPoints[i];
+      float x1 = logicalPoints[i+1];
+      float y0 = calibratedPoints[ch][i];
+      float y1 = calibratedPoints[ch][i+1];
+      float t = (logicalDuty - x0) / (x1 - x0);
+      return y0 + t * (y1 - y0);
+    }
+  }
+  return calibratedPoints[ch][4];
+}
+
+void applyLighting() {
+    // Convert HSV (0–255 each) to RGB
+    CHSV hsv(lightingHue, lightingSaturation, lightingBrightness);
+
+    for (int i = 0; i < NUM_LEDS; i++) {
+        leds[i] = hsv;
+    }
+
+    FastLED.show();
+}
+
+void startLightingFade(uint8_t from, uint8_t to, unsigned long duration) {
+    lightingFadeStart = from;
+    lightingFadeEnd = to;
+    lightingFadeDuration = duration;
+    lightingFadeStartTime = millis();
+    lightingFading = true;
+}
+
+void updateConnectionStatusUI(ConnectionState state) {
+    const char* text = "Unknown";
+
+    switch (state) {
+        case STATE_DISCONNECTED:
+            text = "Disconnected";
+            break;
+        case STATE_CONNECTING:
+            text = "Connecting...";
+            break;
+        case STATE_WAIT_FOR_FIRST_PACKET:
+            text = "Waiting for first UDP packet";
+            break;
+        case STATE_CONNECTED:
+            text = "Connected";
+            break;
+    }
+
+    ESPUI.updateControlValue(connectionStatusLabel, text);
+}
+
+// -------------------------------
+// Core init (called from setup)
+// -------------------------------
+void coreInit() {
+  // LEDC PWM init
+  for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+    bool ok = ledcAttach(pwmPins[ch], pwmFrequency, pwmResolution);
+    if (!ok) {
+      Serial.print("LEDC attach failed on pin ");
+      Serial.println(pwmPins[ch]);
+    }
+    ledcWrite(pwmPins[ch], 0);
+  }
+
+  // Preferences: load UDP port (default = listenPort)
+  prefs.begin("analogmon", false);
+  udpPort = prefs.getInt("udpPort", listenPort);
+
+  // Load calibration from flash (if present)
+  for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+    for (int i = 0; i < 5; i++) {
+      String key = "cal_" + String(ch) + "_" + String(i);
+      float val = prefs.getFloat(key.c_str(), calibratedPoints[ch][i]);
+      calibratedPoints[ch][i] = val;
+    }
+  }
+
+  lightingHue        = prefs.getUChar("light_hue",    0);
+  lightingSaturation = prefs.getUChar("light_sat",  255);
+  lightingBrightnessSaved = prefs.getUChar("light_bright",255);
+  lightingBrightness = lightingBrightnessSaved;
+
+
+  Serial.printf("Lighting loaded (0–255): H=%d S=%d B=%d\n",
+                lightingHue, lightingSaturation, lightingBrightness);
+
+  // FastLED init
+  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
+  FastLED.setBrightness(255);  // full brightness; HSV V controls actual output
+
+  // Apply lighting immediately at boot
+  applyLighting();
+
+  // Start UDP with runtime port
+  udp.begin(udpPort);
+  Serial.print("Listening on UDP port ");
+  Serial.println(udpPort);
+
+  lastPacketTime = millis();
+  connectionState = STATE_DISCONNECTED;
+  updateConnectionStatusUI(connectionState);
+}
+
+// -------------------------------
+// UDP parsing
+// -------------------------------
+void coreHandleUDP() {
+  int packetSize = udp.parsePacket();
+  if (packetSize <= 0) return;
+
+  char buf[256];
+  int len = udp.read(buf, sizeof(buf) - 1);
+  buf[len] = '\0';
+
+  float values[NUM_CHANNELS] = {0};
+  int idx = 0;
+
+  char* token = strtok(buf, ",");
+  while (token != nullptr && idx < NUM_CHANNELS) {
+    values[idx] = atof(token);
+    idx++;
+    token = strtok(nullptr, ",");
+  }
+
+  if (idx != NUM_CHANNELS) return;
+
+  if (connectionState == STATE_DISCONNECTED) {
+      // First valid packet after being disconnected → start CONNECTING
+      Serial.println("STATE CHANGE: DISCONNECTED → CONNECTING (UDP connection established)");
+      connectionState = STATE_CONNECTING;
+      updateConnectionStatusUI(connectionState);
+      startLightingFade(0, lightingBrightnessSaved, LIGHTING_FADE_IN_DURATION);
+
+      // Initialize fade-in: start from 0 on all non-override channels
+      for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+          if (!overrideActive[ch]) {
+              currentDuty[ch] = 0.0f;
+          }
+      }
+
+      lastPacketTime = millis();  // prevent watchdog during fade-in
+  }
+  else if (connectionState == STATE_CONNECTING) {
+      // Ignore UDP values during fade-in, just keep watchdog alive
+      lastPacketTime = millis();
+  }
+  else if (connectionState == STATE_WAIT_FOR_FIRST_PACKET) {
+      // First real packet after fade-in completes
+      Serial.println("STATE CHANGE: WAIT_FOR_FIRST_PACKET → CONNECTED (first UDP packet received)");
+
+      for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+          if (!overrideActive[ch]) {
+              targetDuty[ch] = values[ch];
+              slewStartDuty[ch] = currentDuty[ch]; // currently ~100%
+          }
+      }
+
+      slewStartTime = millis();
+      lastPacketTime = millis();
+      connectionState = STATE_CONNECTED;
+      updateConnectionStatusUI(connectionState);
+
+      // Debug output
+      Serial.println("Received UDP packet (first after fade-in):");
+      for (int i = 0; i < NUM_CHANNELS; i++) {
+        Serial.print("  CH");
+        Serial.print(i);
+        Serial.print(" (");
+        Serial.print(channelLabels[i]);
+        Serial.print("): ");
+        Serial.print(values[i], 2);
+        if (channelUnits[i][0] != '\0') {
+          Serial.print(" ");
+          Serial.print(channelUnits[i]);
+        }
+        Serial.println();
+      }
+      Serial.println();
+  }
+  else if (connectionState == STATE_CONNECTED) {
+      // Normal UDP-driven update
+      for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+          if (!overrideActive[ch]) {
+              targetDuty[ch] = values[ch];
+              slewStartDuty[ch] = currentDuty[ch];
+          }
+      }
+      slewStartTime = millis();
+      lastPacketTime = millis();
+
+      // Debug output
+      Serial.println("Received UDP packet:");
+      for (int i = 0; i < NUM_CHANNELS; i++) {
+        Serial.print("  CH");
+        Serial.print(i);
+        Serial.print(" (");
+        Serial.print(channelLabels[i]);
+        Serial.print("): ");
+        Serial.print(values[i], 2);
+        if (channelUnits[i][0] != '\0') {
+          Serial.print(" ");
+          Serial.print(channelUnits[i]);
+        }
+        Serial.println();
+      }
+      Serial.println();
+  }
+}
+
+// -------------------------------
+// Connection state machine
+// -------------------------------
+void coreUpdateState() {
+  unsigned long now = millis();
+
+  switch (connectionState) {
+
+      case STATE_CONNECTED: {
+          // Check for lost connection
+          if (now - lastPacketTime > watchdogTimeout) {
+              Serial.println("STATE CHANGE: CONNECTED → DISCONNECTED (UDP connection lost)");
+              connectionState = STATE_DISCONNECTED;
+              updateConnectionStatusUI(connectionState);
+              startLightingFade(lightingBrightness, 0, LIGHTING_FADE_OUT_DURATION);
+              break;
+          }
+
+          // Normal slew-rate limiting
+          float progress = (float)(now - slewStartTime) / (float)slewDuration;
+          if (progress > 1.0f) progress = 1.0f;
+
+          for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+              if (!overrideActive[ch]) {
+                  float newDuty = slewStartDuty[ch] + (targetDuty[ch] - slewStartDuty[ch]) * progress;
+                  currentDuty[ch] = newDuty;
+
+                  float calibratedDuty = applyCalibration(ch, newDuty);
+                  int duty = (int)((calibratedDuty / 100.0f) * ((1 << pwmResolution) - 1));
+                  ledcWrite(pwmPins[ch], duty);
+              }
+          }
+      } break;
+
+      case STATE_CONNECTING: {
+          // If we lose packets even while connecting, fall back to DISCONNECTED
+          if (now - lastPacketTime > watchdogTimeout) {
+              Serial.println("STATE CHANGE: CONNECTING → DISCONNECTED (no packets during fade-in)");
+              connectionState = STATE_DISCONNECTED;
+              updateConnectionStatusUI(connectionState);
+              break;
+          }
+
+          // Fade-in animation: 0 → 100% on all non-override channels
+          if (now - lastFadeTime >= FADE_INTERVAL) {
+              lastFadeTime = now;
+
+              bool allReached = true;
+
+              for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+                  if (!overrideActive[ch]) {
+                      float cd = currentDuty[ch];
+
+                      // Exponential approach to 100%
+                      cd = cd * FADE_IN_FACTOR + 100.0f * (1.0f - FADE_IN_FACTOR);
+                      currentDuty[ch] = cd;
+
+                      float calibratedDuty = applyCalibration(ch, cd);
+                      int duty = (int)((calibratedDuty / 100.0f) * ((1 << pwmResolution) - 1));
+                      ledcWrite(pwmPins[ch], duty);
+
+                      // Check if we're close enough to 100%
+                      if (cd < 99.0f) {
+                          allReached = false;
+                      }
+                  }
+              }
+
+              if (allReached) {
+                  Serial.println("STATE CHANGE: CONNECTING → STATE_WAIT_FOR_FIRST_PACKET (fade-in complete)");
+                  connectionState = STATE_WAIT_FOR_FIRST_PACKET;
+                  updateConnectionStatusUI(connectionState);
+              }
+          }
+      } break;
+
+      case STATE_WAIT_FOR_FIRST_PACKET: {
+          // Hold at ~100%, do nothing until first UDP packet arrives
+          // (handled in coreHandleUDP)
+      } break;
+
+      case STATE_DISCONNECTED: {
+          // Watchdog fade-to-zero (always active in this state)
+          if (now - lastFadeTime >= FADE_INTERVAL) {
+              lastFadeTime = now;
+
+              for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+
+                if (currentDuty[ch] > 0.0f) {
+
+                  currentDuty[ch] *= FADE_OUT_FACTOR;
+
+                  if (currentDuty[ch] < 0.01f)
+                    currentDuty[ch] = 0.0f;
+
+                  float calibratedDuty = applyCalibration(ch, currentDuty[ch]);
+                  int duty = (int)((calibratedDuty / 100.0f) * ((1 << pwmResolution) - 1));
+
+                  ledcWrite(pwmPins[ch], duty);
+                }
+              }
+          }
+      } break;
+  }
+
+  if (lightingFading) {
+      unsigned long now = millis();
+      unsigned long elapsed = now - lightingFadeStartTime;
+
+      if (elapsed >= lightingFadeDuration) {
+          // Fade complete
+          lightingBrightness = lightingFadeEnd;
+
+          // If fade-out finished, jump to 0
+          if (lightingFadeEnd == 0) {
+              lightingBrightness = 0;
+          }
+
+          lightingFading = false;
+          applyLighting();
+          return;
+      }
+
+      // Compute normalized progress
+      float t = (float)elapsed / (float)lightingFadeDuration;
+
+      // Gamma correction
+      const float gamma = 2.2f;
+      float t_gamma = pow(t, gamma);
+
+      // Determine effective fade range
+      uint8_t start = lightingFadeStart;
+      uint8_t end   = lightingFadeEnd;
+
+      // Fade-in: 0 → 13 → 100
+      if (start == 0 && end > 0) {
+          start = BRIGHTNESS_MIN_VISIBLE;
+      }
+
+      // Fade-out: 100 → 13 → 0
+      if (end == 0 && start > 0) {
+          end = BRIGHTNESS_MIN_VISIBLE;
+      }
+
+      // Interpolate only within the visible range
+      float raw = start + (end - start) * t_gamma;
+
+      // Apply jump logic:
+      if (lightingFadeStart == 0 && elapsed == 0) {
+          // Fade-in: first frame → jump to 13
+          lightingBrightness = BRIGHTNESS_MIN_VISIBLE;
+      }
+      else if (lightingFadeEnd == 0 && elapsed + 16 >= lightingFadeDuration) {
+          // Fade-out: last frame → jump to 0
+          lightingBrightness = 0;
+      }
+      else {
+          lightingBrightness = raw;
+      }
+
+      applyLighting();
+  }
+}

analog_system_monitor_arduino/Core.h

@@ -0,0 +1,58 @@
+#pragma once
+#include <WiFiUdp.h>
+#include <Preferences.h>
+#include <ESPUI.h>
+#include "Config.h"
+
+// Global objects
+extern WiFiUDP udp;
+extern Preferences prefs;
+extern int udpPort;
+
+// Duty tracking + slew
+extern float currentDuty[NUM_CHANNELS];
+extern float targetDuty[NUM_CHANNELS];
+extern float slewStartDuty[NUM_CHANNELS];
+
+extern unsigned long slewStartTime;
+extern unsigned long lastPacketTime;
+extern unsigned long lastFadeTime;
+
+// Calibration
+extern float logicalPoints[5];
+extern float calibratedPoints[NUM_CHANNELS][5];
+extern bool overrideActive[NUM_CHANNELS];
+
+// Lighting parameters (0–255 range for now)
+extern uint8_t lightingHue;        // 0–255
+extern uint8_t lightingSaturation; // 0–255
+extern uint8_t lightingBrightness; // 0–255
+extern uint8_t lightingBrightnessSaved;
+
+// State
+extern ConnectionState connectionState;
+
+// UI IDs used by Core
+extern uint16_t connectionStatusLabel;
+extern uint16_t calChannelDropdown;
+extern uint16_t calInputs[5];
+extern uint16_t calTestValueInput;
+extern uint16_t calSaveButton;
+extern uint16_t calOverrideSwitch;
+extern uint8_t selectedCalChannel;
+
+// Core API
+void coreInit();          // called from setup()
+void coreHandleUDP();     // called from loop()
+void coreUpdateState();   // called from loop()
+
+// Helpers used by UI
+float applyCalibration(uint8_t ch, float logicalDuty);
+void updateConnectionStatusUI(ConnectionState state);
+
+// Lighting helpers
+void applyLighting();
+void startLightingFade(uint8_t from, uint8_t to);
+
+// Lighting fade state
+extern bool lightingFading;

analog_system_monitor_arduino/UI.h

@@ -0,0 +1,5 @@
+#pragma once
+#include <ESPUI.h>
+#include "Core.h"
+
+void uiInit(uint16_t& tabSettings, uint16_t& tabLighting, uint16_t& tabCalibration);

analog_system_monitor_arduino/Ui.cpp

@@ -0,0 +1,389 @@
+#include <Arduino.h>
+#include "UI.h"
+
+// Local UI control
+static uint16_t portInput;
+
+// -------------------------------
+// Calibration UI helpers & callbacks
+// -------------------------------
+void refreshCalibrationUI() {
+  for (int i = 0; i < 5; i++) {
+    ESPUI.updateControlValue(calInputs[i], String(calibratedPoints[selectedCalChannel][i], 2));
+  }
+}
+
+void calChannelCallback(Control *sender, int type) {
+    // Turn override OFF when switching channels
+    for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+        overrideActive[ch] = false;
+    }
+    ESPUI.updateControlValue(calOverrideSwitch, "0");
+
+    selectedCalChannel = sender->value.toInt();
+    Serial.print("Calibration channel changed to ");
+    Serial.println(selectedCalChannel);
+
+    refreshCalibrationUI();
+}
+
+void calPointCallback(Control *sender, int type) {
+  int index = sender->id - calInputs[0];
+  if (index >= 0 && index < 5) {
+    float val = sender->value.toFloat();
+    calibratedPoints[selectedCalChannel][index] = val;
+    Serial.printf("Cal[%d][%d] = %.2f\n", selectedCalChannel, index, val);
+  }
+}
+
+void calTestCallback(Control *sender, int type) {
+    if (!overrideActive[selectedCalChannel]) return;
+
+    float logical = sender->value.toFloat();   // 0–100 integer
+
+    if (logical < 0) logical = 0;
+    if (logical > 100) logical = 100;
+
+    float calibrated = applyCalibration(selectedCalChannel, logical);
+    int duty = (int)((calibrated / 100.0f) * ((1 << pwmResolution) - 1));
+
+    ledcWrite(pwmPins[selectedCalChannel], duty);
+
+    Serial.printf("Override update CH%d: logical=%.2f calibrated=%.2f duty=%d\n",
+                  selectedCalChannel, logical, calibrated, duty);
+}
+
+void calSaveCallback(Control *sender, int type) {
+  Serial.printf("Saving calibration for CH%d...\n", selectedCalChannel);
+
+  for (int i = 0; i < 5; i++) {
+    String key = "cal_" + String(selectedCalChannel) + "_" + String(i);
+    prefs.putFloat(key.c_str(), calibratedPoints[selectedCalChannel][i]);
+  }
+
+  Serial.println("Calibration saved.");
+}
+
+void calOverrideSwitchCallback(Control *sender, int type) {
+    bool enabled = sender->value.toInt() == 1;
+
+    if (enabled) {
+        Serial.println("Override enabled.");
+
+        // Enable override only for the selected channel
+        for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+            overrideActive[ch] = (ch == selectedCalChannel);
+        }
+
+        // Immediately apply the test value
+        float logical = ESPUI.getControl(calTestValueInput)->value.toFloat();
+        if (logical < 0) logical = 0;
+        if (logical > 100) logical = 100;
+
+        float calibrated = applyCalibration(selectedCalChannel, logical);
+        int duty = (int)((calibrated / 100.0f) * ((1 << pwmResolution) - 1));
+        ledcWrite(pwmPins[selectedCalChannel], duty);
+
+        Serial.printf("Override driving CH%d: logical=%.2f calibrated=%.2f duty=%d\n",
+                      selectedCalChannel, logical, calibrated, duty);
+
+    } else {
+        Serial.println("Override disabled. Returning to UDP control.");
+
+        // Disable all overrides
+        for (int ch = 0; ch < NUM_CHANNELS; ch++) {
+            overrideActive[ch] = false;
+        }
+    }
+}
+void lightingSaveCallback(Control *sender, int type) {
+    if (type != B_UP) return;  // avoid double-trigger
+
+    prefs.putUChar("light_hue",    lightingHue);
+    prefs.putUChar("light_sat",    lightingSaturation);
+    prefs.putUChar("light_bright", lightingBrightnessSaved);
+
+    Serial.printf("Lighting saved (0–255): H=%d S=%d B=%d\n",
+                  lightingHue, lightingSaturation, lightingBrightness);
+}
+
+static int toSlider(uint8_t v) {
+    return (int)((v / 255.0f) * 100.0f);
+}
+
+static uint8_t fromSlider(int v) {
+    return (uint8_t)((v / 100.0f) * 255.0f);
+}
+
+// -------------------------------
+// UI init
+// -------------------------------
+void uiInit(uint16_t& tabSettings, uint16_t& tabLighting, uint16_t& tabCalibration) {
+
+  // Create tabs
+  tabSettings   = ESPUI.addControl(ControlType::Tab, "Settings", "Settings");
+  tabLighting   = ESPUI.addControl(ControlType::Tab, "Lighting", "Lighting");
+  tabCalibration= ESPUI.addControl(ControlType::Tab, "Calibration", "Calibration");
+
+  // Restart button callback
+  auto restartCallback = [](Control *sender, int type) {
+      ESP.restart();
+  };
+
+  // Port input callback
+  auto portInputCallback = [](Control *sender, int type) {
+      Serial.print("Port input changed to: ");
+      Serial.println(sender->value);
+  };
+
+  // Save & Apply callback
+  auto savePortCallback = [](Control *sender, int type) {
+      if (type != B_UP) return;   // Prevent double-trigger
+
+      Control* c = ESPUI.getControl(portInput);
+      int newPort = c->value.toInt();
+
+      if (newPort < 1024 || newPort > 65535) {
+          Serial.println("Invalid port (1024–65535)");
+          return;
+      }
+
+      prefs.putInt("udpPort", newPort);
+      udpPort = newPort;
+
+      udp.stop();
+      udp.begin(udpPort);
+
+      Serial.print("New UDP port applied: ");
+      Serial.println(udpPort);
+
+      ESPUI.updateControlValue(portInput, String(newPort));
+  };
+
+  // -------------------------------------------
+  // Connection Status section
+  // -------------------------------------------
+  ESPUI.addControl(
+      ControlType::Separator,
+      "Connection Status",
+      "",
+      ControlColor::None,
+      tabSettings
+  );
+
+  // Live-updating connection status label
+  connectionStatusLabel = ESPUI.addControl(
+      ControlType::Label,
+      "Status",
+      "Disconnected",
+      ControlColor::Wetasphalt,
+      tabSettings
+  );
+
+  // -------------------------------------------
+  // UDP Telemetry Connection Settings section
+  // -------------------------------------------
+
+  ESPUI.addControl(
+      ControlType::Separator,
+      "UDP Telemetry Connection Settings",
+      "",
+      ControlColor::None,
+      tabSettings
+  );
+
+  // UDP Port Number input
+  portInput = ESPUI.addControl(
+      ControlType::Number,
+      "UDP Port",
+      String(udpPort),
+      ControlColor::Peterriver,
+      tabSettings,
+      portInputCallback
+  );
+
+  // Save & Apply button
+  ESPUI.addControl(
+      ControlType::Button,
+      "UDP Port",
+      "Save & Apply",
+      ControlColor::Emerald,
+      tabSettings,
+      savePortCallback
+  );
+
+  // Existing separator (leave as-is)
+  ESPUI.addControl(
+      ControlType::Separator,
+      "",
+      "",
+      ControlColor::None,
+      tabSettings
+  );
+
+  // Restart button (unchanged)
+  ESPUI.addControl(
+      ControlType::Button,
+      "Restart ESP32",
+      "Restart",
+      ControlColor::Alizarin,
+      tabSettings,
+      restartCallback
+  );
+
+  // -------------------------------
+  // Lighting Controls
+  // -------------------------------
+
+  // Hue slider (0–360)
+  ESPUI.addControl(
+      ControlType::Slider,
+      "Hue",
+      String(toSlider(lightingHue)),
+      ControlColor::Sunflower,
+      tabLighting,
+      [](Control *sender, int type) {
+          int sliderVal = sender->value.toInt(); // 0–100
+          lightingHue = fromSlider(sliderVal); // convert to 0–255
+          Serial.printf("Lighting Hue changed (RAM only): %d\n", lightingHue);
+          lightingFading = false; // cancel fade if user moves slider
+          applyLighting();
+      }
+  );
+
+  // Saturation slider (0–100)
+  ESPUI.addControl(
+      ControlType::Slider,
+      "Saturation",
+      String(toSlider(lightingSaturation)),
+      ControlColor::Carrot,
+      tabLighting,
+      [](Control *sender, int type) {
+          int sliderVal = sender->value.toInt(); // 0–100
+          lightingSaturation = fromSlider(sliderVal);
+          Serial.printf("Lighting Saturation updated (RAM only): %d\n", lightingSaturation);
+          lightingFading = false; // cancel fade if user moves slider
+          applyLighting();
+      }
+  );
+
+  // Brightness slider (0–100)
+  ESPUI.addControl(
+      ControlType::Slider,
+      "Brightness",
+      String(toSlider(lightingBrightness)),
+      ControlColor::Emerald,
+      tabLighting,
+      [](Control *sender, int type) {
+          int sliderVal = sender->value.toInt(); // 0–100
+          lightingBrightnessSaved = fromSlider(sliderVal);
+          lightingBrightness = lightingBrightnessSaved;
+          Serial.printf("Lighting Brightness updated (RAM only): %d\n", lightingBrightness);
+          lightingFading = false; // cancel fade if user moves slider
+          applyLighting();
+      }
+  );
+  ESPUI.addControl(
+      ControlType::Button,
+      "Save Lighting Settings",
+      "Save",
+      ControlColor::Emerald,
+      tabLighting,
+      lightingSaveCallback
+  );
+
+  // -------------------------------
+  // Calibration tab UI
+  // -------------------------------
+
+  // Channel selector
+  calChannelDropdown = ESPUI.addControl(
+      ControlType::Select,
+      "Selected Channel",
+      "0",
+      ControlColor::Peterriver,
+      tabCalibration,
+      calChannelCallback
+  );
+
+  // Add options 0–7
+  for (int i = 0; i < NUM_CHANNELS; i++) {
+      char value[8];
+      snprintf(value, sizeof(value), "%d", i);
+
+      ESPUI.addControl(
+          ControlType::Option,
+          channelDropdownLabels[i],   // static label
+          value,                      // static-ish value (OK)
+          ControlColor::None,
+          calChannelDropdown
+      );
+  }
+
+  ESPUI.addControl(
+      ControlType::Separator,
+      "",
+      "",
+      ControlColor::None,
+      tabCalibration
+  );
+
+  // Calibration inputs
+  const char* calNames[5] = {"0%", "25%", "50%", "75%", "100%"};
+
+  for (int i = 0; i < 5; i++) {
+    calInputs[i] = ESPUI.addControl(
+        ControlType::Number,
+        calNames[i],
+        String(calibratedPoints[0][i], 2),
+        ControlColor::Wetasphalt,
+        tabCalibration,
+        calPointCallback
+    );
+  }
+
+  ESPUI.addControl(
+      ControlType::Separator,
+      "",
+      "",
+      ControlColor::None,
+      tabCalibration
+  );
+
+  // Test value input
+  calTestValueInput = ESPUI.addControl(
+      ControlType::Slider,
+      "Test Value",
+      "50",
+      ControlColor::Carrot,
+      tabCalibration,
+      calTestCallback
+  );
+
+  calOverrideSwitch = ESPUI.addControl(
+      ControlType::Switcher,
+      "Override",
+      "0",  // default OFF
+      ControlColor::Alizarin,
+      tabCalibration,
+      calOverrideSwitchCallback
+  );
+
+  ESPUI.addControl(
+      ControlType::Separator,
+      "",
+      "",
+      ControlColor::None,
+      tabCalibration
+  );
+
+  // Save button
+  calSaveButton = ESPUI.addControl(
+      ControlType::Button,
+      "Save Calibration",
+      "Save",
+      ControlColor::Emerald,
+      tabCalibration,
+      calSaveCallback
+  );
+}

analog_system_monitor_arduino/analog_system_monitor_arduino.ino

@@ -1,95 +1,26 @@
+//
+// IMPORTANT:
+//  before flashing this the first time,
+//  upload the "prepareFilesystem.ino" example sketch from ESPUI
+//  without that critical files are missing
+//
+//  This was done to reduce the PROGMEM footprint of this program
+//
+
 #include <Arduino.h>
 #include <WiFi.h>
-#include <WiFiUdp.h>
 #include <WiFiManager.h>
 
-// -------------------------------
+#include <AsyncTCP.h>
-// Firmware version
+#include <ESPAsyncWebServer.h>
-// -------------------------------
+#include <ESPUI.h>
-const char* FIRMWARE_VERSION = "V2.4_UDP_LEDC_WM_SLEW";
 
-// -------------------------------
+#include "Config.h"
-// UDP
+#include "Core.h"
-// -------------------------------
+#include "UI.h"
-WiFiUDP udp;
-const int listenPort = 12345;   // Must match PC config.json
 
-// -------------------------------
+AsyncWebServer server(80);
-// PWM setup (LEDC, ESP32 Core 3.x)
-// -------------------------------
-const uint8_t NUM_CHANNELS = 8;
 
-uint8_t pwmPins[NUM_CHANNELS] = {
-    26, // D0
-    22, // D1
-    21, // D2
-    17, // D3
-    16, // D4
-    5,  // D5
-    18, // D6
-    19  // D7
-    // 23 (D8) remains as a spare
-};
-
-const uint32_t pwmFrequency = 25000; // 25 kHz
-const uint8_t pwmResolution = 10;    // 10-bit resolution (0–1023)
-
-// -------------------------------
-// Calibration tables
-// -------------------------------
-float logicalPoints[5] = {0, 25, 50, 75, 100};
-
-float calibratedPoints[NUM_CHANNELS][5] = {
-  {0, 25, 50, 75, 99},
-  {0, 24, 49, 74, 98},
-  {0, 26, 51, 76, 99},
-  {0, 25, 50, 75, 97},
-  {0, 25, 50, 75, 99},
-  {0, 24, 50, 74, 98},
-  {0, 25, 49, 75, 97},
-  {0, 26, 50, 76, 99}
-};
-
-// -------------------------------
-// Duty tracking + Slew system
-// -------------------------------
-float currentDuty[NUM_CHANNELS] = {0.0f};
-float targetDuty[NUM_CHANNELS]  = {0.0f};
-float slewStartDuty[NUM_CHANNELS] = {0.0f};
-
-unsigned long slewStartTime = 0;
-const unsigned long slewDuration = 1000; // 1 second smooth transition
-
-// -------------------------------
-// Watchdog (UDP-based)
-// -------------------------------
-unsigned long lastPacketTime = 0;
-const unsigned long watchdogTimeout = 5000;  // 5 seconds
-unsigned long lastFadeTime = 0;
-
-// -------------------------------
-// Calibration interpolation
-// -------------------------------
-float applyCalibration(uint8_t ch, float logicalDuty) {
-  if (logicalDuty <= 0.0f) return calibratedPoints[ch][0];
-  if (logicalDuty >= 100.0f) return calibratedPoints[ch][4];
-
-  for (int i = 0; i < 4; i++) {
-    if (logicalDuty >= logicalPoints[i] && logicalDuty <= logicalPoints[i+1]) {
-      float x0 = logicalPoints[i];
-      float x1 = logicalPoints[i+1];
-      float y0 = calibratedPoints[ch][i];
-      float y1 = calibratedPoints[ch][i+1];
-      float t = (logicalDuty - x0) / (x1 - x0);
-      return y0 + t * (y1 - y0);
-    }
-  }
-  return calibratedPoints[ch][4];
-}
-
-// -------------------------------
-// Setup
-// -------------------------------
 void setup() {
   Serial.begin(115200);
   delay(300);
@@ -98,26 +29,12 @@ void setup() {
   Serial.print("Firmware: ");
   Serial.println(FIRMWARE_VERSION);
 
-  // LEDC PWM init (ESP32 Core 3.x API)
+  // WiFi Manager
-  for (int ch = 0; ch < NUM_CHANNELS; ch++) {
-    bool ok = ledcAttach(pwmPins[ch], pwmFrequency, pwmResolution);
-    if (!ok) {
-      Serial.print("LEDC attach failed on pin ");
-      Serial.println(pwmPins[ch]);
-    }
-    ledcWrite(pwmPins[ch], 0);  // duty = 0%
-  }
-
-  // -------------------------------
-  // WiFi Manager (Captive Portal)
-  // -------------------------------
   WiFiManager wm;
-
   wm.setHostname("AnalogMonitor");
-  wm.setTimeout(180);  // 3 minutes before giving up
+  wm.setTimeout(180);
 
   Serial.println("Starting WiFiManager...");
-
   bool res = wm.autoConnect("AnalogMonitor-Setup");
 
   if (!res) {
@@ -130,98 +47,20 @@ void setup() {
   Serial.print("IP: ");
   Serial.println(WiFi.localIP());
 
-  // UDP init
+  // Core init (PWM, prefs, UDP, calibration, state)
-  udp.begin(listenPort);
+  coreInit();
-  Serial.print("Listening on UDP port ");
-  Serial.println(listenPort);
 
-  lastPacketTime = millis();
+  // ESPUI Web Interface
+  ESPUI.setVerbosity(Verbosity::Verbose);
+
+  uint16_t tabSettings, tabLighting, tabCalibration;
+  uiInit(tabSettings, tabLighting, tabCalibration);
+
+  ESPUI.sliderContinuous = true;   // enables live slider updates
+  ESPUI.beginLITTLEFS("Analog System Monitor UI");
 }
 
-// -------------------------------
-// Loop
-// -------------------------------
 void loop() {
-
+  coreHandleUDP();
-  // -------- UDP parsing --------
+  coreUpdateState();
-  int packetSize = udp.parsePacket();
-  if (packetSize > 0) {
-    char buf[256];
-    int len = udp.read(buf, sizeof(buf) - 1);
-    buf[len] = '\0';
-
-    float values[NUM_CHANNELS] = {0};
-    int idx = 0;
-
-    char* token = strtok(buf, ",");
-    while (token != nullptr && idx < NUM_CHANNELS) {
-      values[idx] = atof(token);
-      idx++;
-      token = strtok(nullptr, ",");
-    }
-
-    if (idx == NUM_CHANNELS) {
-
-      // Start a new slew toward the target
-      for (int ch = 0; ch < NUM_CHANNELS; ch++) {
-        targetDuty[ch] = values[ch];
-        slewStartDuty[ch] = currentDuty[ch];
-      }
-      slewStartTime = millis();
-
-      lastPacketTime = millis();
-
-      // Debug output
-      Serial.println("Received UDP packet:");
-      for (int i = 0; i < NUM_CHANNELS; i++) {
-        Serial.print("  CH");
-        Serial.print(i);
-        Serial.print(": ");
-        Serial.println(values[i]);
-      }
-      Serial.println();
-    }
-  }
-
-  // -------- Slew-rate limiting (smooth 1-second transitions) --------
-  unsigned long now = millis();
-  float progress = (float)(now - slewStartTime) / (float)slewDuration;
-  if (progress > 1.0f) progress = 1.0f;
-
-  for (int ch = 0; ch < NUM_CHANNELS; ch++) {
-    float newDuty = slewStartDuty[ch] + (targetDuty[ch] - slewStartDuty[ch]) * progress;
-    currentDuty[ch] = newDuty;
-
-    float calibratedDuty = applyCalibration(ch, newDuty);
-    int duty = (int)((calibratedDuty / 100.0f) * ((1 << pwmResolution) - 1));
-
-    ledcWrite(pwmPins[ch], duty);
-  }
-
-  // -------- Watchdog fade-to-zero (UDP-based) --------
-  if (millis() - lastPacketTime > watchdogTimeout) {
-
-    const unsigned long fadeInterval = 1;
-
-    if (millis() - lastFadeTime >= fadeInterval) {
-      lastFadeTime = millis();
-
-      for (int ch = 0; ch < NUM_CHANNELS; ch++) {
-
-        if (currentDuty[ch] > 0.0f) {
-
-          const float fadeFactor = 0.999f;
-          currentDuty[ch] *= fadeFactor;
-
-          if (currentDuty[ch] < 0.01f)
-            currentDuty[ch] = 0.0f;
-
-          float calibratedDuty = applyCalibration(ch, currentDuty[ch]);
-          int duty = (int)((calibratedDuty / 100.0f) * ((1 << pwmResolution) - 1));
-
-          ledcWrite(pwmPins[ch], duty);
-        }
-      }
-    }
-  }
 }

analog_system_monitor_dotnet/Telemetry.cs

@@ -10,7 +10,7 @@ public class Telemetry : IDisposable
     public int UpdateRateMs => UpdateRateDefaultMs;
 
     private readonly UdpSender udp = new UdpSender();
-    private readonly Computer computer = new Computer();
+    private Computer computer = new Computer();
 
     private IHardware? cpuHw;
     private IHardware? gpuHw;
@@ -29,18 +29,70 @@ public class Telemetry : IDisposable
 
     private static readonly CultureInfo CI = CultureInfo.InvariantCulture;
 
+    // Restart LHM every 30 minutes
+    private readonly TimeSpan restartInterval = TimeSpan.FromMinutes(30);
+    private DateTime lastRestart = DateTime.UtcNow;
+
     public void Initialize()
+    {
+        ConfigureComputer();
+        computer.Open();
+        CacheHardwareAndSensors();
+    }
+
+    private void ConfigureComputer()
     {
         computer.IsCpuEnabled = true;
         computer.IsGpuEnabled = true;
         computer.IsMemoryEnabled = true;
 
+        // True minimal mode
+        computer.IsMotherboardEnabled = false;
+        computer.IsControllerEnabled = false;
+        computer.IsNetworkEnabled = false;
+        computer.IsStorageEnabled = false;
+        computer.IsBatteryEnabled = false;
+    }
+
+    private void RestartComputerIfNeeded()
+    {
+        if (DateTime.UtcNow - lastRestart < restartInterval)
+            return;
+
+        lastRestart = DateTime.UtcNow;
+
+        try
+        {
+            computer.Close();
+        }
+        catch
+        {
+            // ignore
+        }
+
+        computer = new Computer();
+        ConfigureComputer();
         computer.Open();
         CacheHardwareAndSensors();
     }
 
     private void CacheHardwareAndSensors()
     {
+        cpuHw = null;
+        gpuHw = null;
+        memHw = null;
+
+        cpuLoadSensors = Array.Empty<ISensor>();
+        cpuTempSensor = null;
+
+        gpu3DLoadSensor = null;
+        gpuTempSensor = null;
+        gpuVramUsedSensor = null;
+        gpuVramTotalSensor = null;
+
+        memUsedSensor = null;
+        memAvailSensor = null;
+
         foreach (var hw in computer.Hardware)
         {
             hw.Update();
@@ -134,9 +186,14 @@ public class Telemetry : IDisposable
 
     public void UpdateAndSend()
     {
-        cpuHw?.Update();
+        RestartComputerIfNeeded();
-        gpuHw?.Update();
+
-        memHw?.Update();
+        //cpuHw?.Update();
+        //gpuHw?.Update();
+        //memHw?.Update();
+		// Single-pass update: update ALL enabled hardware in one loop
+		foreach (var hw in computer.Hardware)
+			hw.Update();
 
         float cpu = GetCpuLoadPercent();
         float cpuTemp = GetCpuTemperaturePercent();
@@ -145,7 +202,6 @@ public class Telemetry : IDisposable
         float gpuTemp = GetGpuTemperaturePercent();
         float vram = GetGpuVramPercent();
 
-        // Prepare 8 floats (future‑proof)
         float[] packet =
         {
             cpu,
@@ -154,8 +210,8 @@ public class Telemetry : IDisposable
             gpu3d,
             gpuTemp,
             vram,
-            0f,   // reserved for future use
+            0f,
-            0f    // reserved for future use
+            0f
         };
 
         udp.SendFloats(packet);

analog_system_monitor_dotnet/TrayApp.cs

@@ -1,13 +1,18 @@
 #nullable enable
 
 using System;
+using System.Diagnostics;
 using System.Drawing;
+using System.IO;
 using System.Windows.Forms;
+using Microsoft.Win32;
 
 public class TrayApp : ApplicationContext
 {
     private NotifyIcon trayIcon;
     private Telemetry telemetry;
+    private System.Windows.Forms.Timer timer;
+    private bool telemetryPaused = false;
 
     public TrayApp()
     {
@@ -22,13 +27,116 @@ public class TrayApp : ApplicationContext
         };
 
         var menu = new ContextMenuStrip();
+
+        // Show config.json
+        menu.Items.Add("Show Config", null, OnShowConfig);
+
+        // Reload config
+        menu.Items.Add("Reload Config", null, OnReloadConfig);
+
+        // Separator
+        menu.Items.Add(new ToolStripSeparator());
+
+        // Exit
         menu.Items.Add("Exit", null, OnExit);
+
         trayIcon.ContextMenuStrip = menu;
 
-        var timer = new System.Windows.Forms.Timer();
+        // Main telemetry timer
+        timer = new System.Windows.Forms.Timer();
         timer.Interval = 1000;
-        timer.Tick += (s, e) => telemetry.UpdateAndSend();
+        timer.Tick += (s, e) =>
+        {
+            if (!telemetryPaused)
+                telemetry.UpdateAndSend();
+        };
         timer.Start();
+
+        // Detect system sleep/wake
+        SystemEvents.PowerModeChanged += OnPowerModeChanged;
+    }
+
+    private void OnPowerModeChanged(object? sender, PowerModeChangedEventArgs e)
+    {
+        if (e.Mode == PowerModes.Suspend)
+        {
+            telemetryPaused = true;
+        }
+        else if (e.Mode == PowerModes.Resume)
+        {
+            telemetryPaused = true;
+
+            // Give Windows time to restore networking
+            var resumeTimer = new System.Windows.Forms.Timer();
+            resumeTimer.Interval = 3000; // 3 seconds
+            resumeTimer.Tick += (s, ev) =>
+            {
+                telemetryPaused = false;
+                resumeTimer.Stop();
+                resumeTimer.Dispose();
+            };
+            resumeTimer.Start();
+        }
+    }
+
+    // Show config.json in Explorer
+    private void OnShowConfig(object? sender, EventArgs e)
+    {
+        try
+        {
+            string exeDir = AppContext.BaseDirectory;
+            string cfgPath = Path.Combine(exeDir, "config.json");
+
+            if (File.Exists(cfgPath))
+            {
+                Process.Start("explorer.exe", $"/select,\"{cfgPath}\"");
+            }
+            else
+            {
+                MessageBox.Show(
+                    "config.json not found.",
+                    "Show Config",
+                    MessageBoxButtons.OK,
+                    MessageBoxIcon.Warning
+                );
+            }
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show(
+                $"Failed to open config.json:\n{ex.Message}",
+                "Show Config Error",
+                MessageBoxButtons.OK,
+                MessageBoxIcon.Error
+            );
+        }
+    }
+
+    // Reload config handler
+    private void OnReloadConfig(object? sender, EventArgs e)
+    {
+        try
+        {
+            telemetry.Dispose();
+            telemetry = new Telemetry();
+            telemetry.Initialize();
+
+            MessageBox.Show(
+                "Configuration reloaded successfully.",
+                "Reload Config",
+                MessageBoxButtons.OK,
+                MessageBoxIcon.Information
+            );
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show(
+                $"Failed to reload configuration:\n{ex.Message}",
+                "Reload Config Error",
+                MessageBoxButtons.OK,
+                MessageBoxIcon.Error
+            );
+        }
     }
 
     private void OnExit(object? sender, EventArgs e)

analog_system_monitor_dotnet/UdpSender.cs

@@ -46,9 +46,30 @@ public class UdpSender : IDisposable
 
     public void SendFloats(float[] values)
     {
-        string packet = string.Join(",", values);
+        try
-        byte[] data = System.Text.Encoding.ASCII.GetBytes(packet);
+        {
-        client.Send(data, data.Length, endpoint);
+            string packet = string.Join(",", values);
+            byte[] data = System.Text.Encoding.ASCII.GetBytes(packet);
+
+            client.Send(data, data.Length, endpoint);
+        }
+        catch (SocketException ex) when (
+            ex.SocketErrorCode == SocketError.NetworkUnreachable ||
+            ex.SocketErrorCode == SocketError.HostUnreachable ||
+            ex.SocketErrorCode == SocketError.NetworkDown ||
+            ex.SocketErrorCode == SocketError.AddressNotAvailable)
+        {
+            // Network not ready (sleep, reconnecting, etc.)
+            // Skip this tick silently.
+        }
+        catch (ObjectDisposedException)
+        {
+            // App is shutting down — ignore.
+        }
+        catch (Exception)
+        {
+            // Any other unexpected error — swallow to avoid crashing the tray app.
+        }
     }
 
     public void Dispose()