signalk-waveshare-pwm-control 1.0.1

package/README.md

@@ -0,0 +1,23 @@
+This plugin is a work in progress to control waveshare displays that are modified for PWM control of the backlight and was mostly developed with the use of ChatGPT.<br>
+<br>
+Details on the display modification can be found at...<br>
+<br>
+https://www.waveshare.com/wiki/10.4HP-CAPQLED</a>
+<br>
+From the FAQ section...<br>
+The default state is to support software adjustment, it is recommended to check the <a href="#Linux_Software_Brightness_Adjustment">#Linux Software Brightness Adjustment</a>, or you can also use the PWM to control the backlight in the following steps:<br>
+<p>As shown below, first remove the original soldered resistor (shown in the red box), and then connect the lower pad of that resistor (shown in the yellow circle) to the GPIO 18 pin of the Raspberry Pi (Physical Pin 12), then you can use GPIO to control the backlight.<br>
+<br> 
+  <img width="600" height="610" alt="image" src="https://github.com/user-attachments/assets/f90eb62c-4104-40f0-9071-a357c540cb72" />
+<br>
+The daemon needs to be placed in /usr/local/bin and then made executeable by<br>
+sudo chmod +x /usr/local/bin/waveshare_pwm_daemon.py<br>
+then create the systemd service...<br>
+sudo nano /etc/systemd/system/waveshare-pwm.service<br>
+After adding the cotents...<br>
+sudo systemctl daemon-reexec<br>
+sudo systemctl enable waveshare-pwm<br>
+sudo systemctl start waveshare-pwm<br>
+<br>
+Final Notes: The Daemon and service must setup and run on all Pi's connected to the waveshare displays.<br>
+The plan is autonamous dimming based on the sun but with backup by Kip slders. Hope to expand just like the auto B&G display plugin.

package/index.js

@@ -0,0 +1,175 @@
+/*
+ * signalk-waveshare-pwm-control
+ *
+ * Multi-display PWM control with distributed fallback support
+ * Developed with assistance with ChatGPT.
+ */
+
+const net = require("net");
+
+module.exports = function (app) {
+  const plugin = {};
+
+  let timers = [];
+  let unsubscribe = null;
+
+  function send(display, cmd) {
+    return new Promise((resolve, reject) => {
+      const client = net.createConnection({
+        host: display.host,
+        port: display.port,
+      });
+
+      client.on("connect", () => {
+        client.write(JSON.stringify(cmd));
+      });
+
+      client.on("data", (data) => {
+        try {
+          resolve(JSON.parse(data.toString()));
+        } catch {
+          resolve({});
+        }
+        client.end();
+      });
+
+      client.on("error", reject);
+    });
+  }
+
+  function publish(id, value) {
+    app.handleMessage(plugin.id, {
+      updates: [
+        {
+          values: [
+            {
+              path: `environment.display.${id}.currentBacklightLevel`,
+              value,
+            },
+          ],
+        },
+      ],
+    });
+  }
+
+  plugin.start = function (options) {
+    // Initialize each display
+    options.displays.forEach((display) => {
+      send(display, {
+        cmd: "config",
+        gamma: display.gamma,
+        minBrightness: display.minBrightness,
+        debug: options.debug || false,
+      }).catch(() => {});
+
+      const timer = setInterval(async () => {
+        try {
+          const res = await send(display, { cmd: "get" });
+
+          if (res && typeof res.value !== "undefined") {
+            publish(display.id, res.value);
+          }
+        } catch (e) {
+          if (options.debug) {
+            app.debug(`Display ${display.id} unreachable`);
+          }
+        }
+      }, 500);
+
+      timers.push(timer);
+    });
+
+    // -----------------------------
+    // Signal K v2 Subscription API
+    // -----------------------------
+    const sub = {
+      context: "vessels.self",
+      subscribe: [
+        { path: "environment.display.*.backlightLevel" },
+        { path: "environment.sun" },
+      ],
+    };
+
+    unsubscribe = app.subscriptionmanager.subscribe(sub, (delta) => {
+      delta.updates.forEach((update) => {
+        update.values.forEach((v) => {
+          // Per-display brightness control
+          const match = v.path.match(
+            /environment\.display\.(\w+)\.backlightLevel/
+          );
+
+          if (match) {
+            const id = match[1];
+            const display = options.displays.find((d) => d.id === id);
+
+            if (display) {
+              send(display, { cmd: "set", value: v.value }).catch(() => {});
+            }
+          }
+
+          // Global sun control
+          if (v.path === "environment.sun") {
+            options.displays.forEach((display) => {
+              if (!display.sun) return;
+
+              const target = display.sun[v.value];
+              if (typeof target !== "undefined") {
+                send(display, { cmd: "set", value: target }).catch(() => {});
+              }
+            });
+          }
+        });
+      });
+    });
+  };
+
+  plugin.stop = function () {
+    timers.forEach(clearInterval);
+    timers = [];
+
+    if (typeof unsubscribe === "function") {
+      unsubscribe();
+      unsubscribe = null;
+    }
+  };
+
+  plugin.id = "signalk-waveshare-pwm-control";
+  plugin.name = "Waveshare PWM Multi Display Control";
+  plugin.description =
+    "Distributed PWM backlight control with fallback (Signal K v2 API)";
+
+  plugin.schema = {
+    type: "object",
+    properties: {
+      debug: {
+        type: "boolean",
+        title: "Enable Debug Logging",
+        default: false,
+      },
+      displays: {
+        type: "array",
+        title: "Displays",
+        items: {
+          type: "object",
+          properties: {
+            id: { type: "string", title: "Display ID (max 3 chars)" },
+            host: { type: "string", title: "IP Address" },
+            port: { type: "number", default: 8765 },
+            gamma: { type: "number", default: 2.2 },
+            minBrightness: { type: "number", default: 5 },
+            sun: {
+              type: "object",
+              properties: {
+                day: { type: "number", default: 90 },
+                night: { type: "number", default: 20 },
+                twilight: { type: "number", default: 50 },
+              },
+            },
+          },
+        },
+      },
+    },
+  };
+
+  return plugin;
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "signalk-waveshare-pwm-control",
+  "version": "1.0.1",
+  "description": "Waveshare PWM backlight control",
+  "main": "index.js",
+  "keywords": ["signalk-node-server-plugin"],
+  "author": "Rhumb Runner (Chuck Bowers) & ChatGPT",
+  "repository": {
+  "type": "git",
+  "url": "https://github.com/Rhumb-Runner/waveshare-pwm-control"
+},
+  "license": "Apache-2.0"
+}

package/waveshare-pwm.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Waveshare PWM Daemon
+After=pigpiod.service
+Requires=pigpiod.service
+
+[Service]
+ExecStart=/usr/bin/python3 /usr/local/bin/waveshare_pwm_daemon.py
+Restart=always
+
+[Install]
+WantedBy=multi-user.target

package/waveshare_pwm_daemon.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+waveshare_pwm_daemon.py
+
+Features:
+- Hardware PWM via pigpio
+- TCP control
+- Smooth fades
+- Gamma correction
+- Distributed fallback (Signal K watchdog)
+
+Developed with assistance from ChatGPT.
+"""
+
+import socket
+import os
+import json
+import time
+import threading
+import pigpio
+import math
+
+GPIO_PIN = 18
+PWM_FREQ = 10000
+PWM_RANGE = 1024
+
+DEFAULT_BRIGHTNESS = 80
+
+MIN_FADE = 1.0
+MAX_FADE = 3.0
+UPDATE_RATE = 30.0
+
+GAMMA = 2.2
+MIN_BRIGHTNESS = 5
+DEBUG = False
+
+TCP_PORT = 8765
+BIND_ADDRESS = "0.0.0.0"
+
+# Fallback config
+SIGNALK_SERVER = "10.42.0.1"
+SIGNALK_PORT = 80
+HEARTBEAT_INTERVAL = 2
+TIMEOUT = 6  # seconds before fallback
+
+FALLBACK_MODE = "hold"  # "hold" or "dim"
+FALLBACK_BRIGHTNESS = 40
+
+def log(msg):
+    if DEBUG:
+        print("[PWM]", msg)
+
+class PWMDaemon:
+    def __init__(self):
+        self.pi = pigpio.pi()
+        if not self.pi.connected:
+            raise RuntimeError("pigpiod not running")
+
+        self.current_percent = DEFAULT_BRIGHTNESS
+        self.target_percent = DEFAULT_BRIGHTNESS
+
+        self.last_command_time = time.time()
+        self.in_fallback = False
+
+        self.lock = threading.Lock()
+
+        self.pi.set_PWM_frequency(GPIO_PIN, PWM_FREQ)
+        self.pi.set_PWM_range(GPIO_PIN, PWM_RANGE)
+
+        self.apply_pwm(self.current_percent)
+
+        threading.Thread(target=self.fade_loop, daemon=True).start()
+        threading.Thread(target=self.watchdog_loop, daemon=True).start()
+
+    def gamma_correct(self, percent):
+        if percent <= 0:
+            return 0
+        return int(math.pow(percent / 100.0, GAMMA) * PWM_RANGE)
+
+    def apply_pwm(self, percent):
+        if percent > 0:
+            percent = max(percent, MIN_BRIGHTNESS)
+
+        pwm = self.gamma_correct(percent)
+        self.pi.set_PWM_dutycycle(GPIO_PIN, pwm)
+
+    def set_target(self, percent):
+        percent = max(0, min(100, percent))
+
+        with self.lock:
+            self.last_command_time = time.time()
+            self.in_fallback = False
+
+            self.start_percent = self.current_percent
+            self.target_percent = percent
+
+            delta = abs(percent - self.current_percent)
+            duration = max(MIN_FADE, MAX_FADE * (delta / 100.0))
+
+            self.fade_steps = int(duration * UPDATE_RATE)
+            self.step = 0
+
+    def ease(self, t):
+        return 0.5 * (1 - math.cos(math.pi * t))
+
+    def fade_loop(self):
+        while True:
+            time.sleep(1.0 / UPDATE_RATE)
+
+            with self.lock:
+                if self.current_percent == self.target_percent:
+                    continue
+
+                t = self.step / self.fade_steps if self.fade_steps else 1
+                eased = self.ease(t)
+
+                self.current_percent = (
+                    self.start_percent +
+                    (self.target_percent - self.start_percent) * eased
+                )
+
+                self.step += 1
+                if self.step >= self.fade_steps:
+                    self.current_percent = self.target_percent
+
+                self.apply_pwm(self.current_percent)
+
+    def watchdog_loop(self):
+        while True:
+            time.sleep(HEARTBEAT_INTERVAL)
+
+            try:
+                socket.create_connection((SIGNALK_SERVER, SIGNALK_PORT), 1).close()
+                alive = True
+            except:
+                alive = False
+
+            if not alive and (time.time() - self.last_command_time) > TIMEOUT:
+                if not self.in_fallback:
+                    log("Entering fallback mode")
+                    self.in_fallback = True
+
+                    if FALLBACK_MODE == "dim":
+                        self.set_target(FALLBACK_BRIGHTNESS)
+
+    def handle(self, conn):
+        try:
+            msg = json.loads(conn.recv(1024).decode())
+
+            if msg["cmd"] == "set":
+                self.set_target(msg["value"])
+                conn.send(b'{"ok":true}')
+
+            elif msg["cmd"] == "get":
+                conn.send(json.dumps({
+                    "value": self.current_percent
+                }).encode())
+
+            elif msg["cmd"] == "config":
+                global GAMMA, MIN_BRIGHTNESS, DEBUG
+                GAMMA = msg.get("gamma", GAMMA)
+                MIN_BRIGHTNESS = msg.get("minBrightness", MIN_BRIGHTNESS)
+                DEBUG = msg.get("debug", DEBUG)
+                conn.send(b'{"ok":true}')
+
+        except Exception as e:
+            conn.send(json.dumps({"error": str(e)}).encode())
+        finally:
+            conn.close()
+
+    def tcp_server(self):
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.bind((BIND_ADDRESS, TCP_PORT))
+        s.listen(5)
+
+        while True:
+            conn, _ = s.accept()
+            threading.Thread(target=self.handle, args=(conn,), daemon=True).start()
+
+    def run(self):
+        threading.Thread(target=self.tcp_server, daemon=True).start()
+
+        while True:
+            time.sleep(1)
+
+
+if __name__ == "__main__":
+    PWMDaemon().run()