homebridge-philips-dline-sicp 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thomas Dazy
+
+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.

package/README.md

@@ -0,0 +1,162 @@
+# homebridge-philips-dline-sicp
+
+Homebridge plugin to control **Philips D‑Line** signage displays (e.g., **55BDL4511D/00**) over LAN using the **SICP** protocol on **TCP:5000**.  
+Exposes the device as a **HomeKit Television** (power + input selection), with optional per‑input **Switches**.
+
+> ⚠️ This plugin is vendor‑unofficial. Keep your display on a trusted VLAN. No auth is implemented by the display on port 5000.
+
+## Features
+- Power On/Off (SICP `0x18`).
+- Input selection via configurable SICP codes (default HDMI1..4).
+- Optional **per‑input switches** for quick Siri/Home automations.
+- Multiple displays supported (platform plugin).
+
+## Requirements
+- Node.js >= 18.x
+- Homebridge >= 1.6.0
+- Philips D-Line display with **Network Control over RJ45** enabled (OSD menu), and reachable on the LAN.
+- The display should listen on **TCP port 5000** (default for SICP over IP).
+
+## Installation
+1. Copy this folder to your Homebridge environment, then:
+   ```bash
+   cd homebridge-philips-dline-sicp
+   npm install
+   
+   # For local development / manual install:
+   sudo npm i -g .
+   ```
+   *or install from npm once published:*
+   ```bash
+   sudo npm i -g homebridge-philips-dline-sicp
+   ```
+2. In Homebridge UI (Config), add the platform and displays as below.
+
+## Configuration
+Add to your Homebridge `config.json`:
+
+```json
+{
+  "platforms": [
+    {
+      "platform": "PhilipsDLinePlatform",
+      "displays": [
+        {
+          "name": "Salon TV",
+          "host": "192.168.1.120",
+          "port": 5000,
+          "monitorId": 1,
+          "includeGroup": true,
+          "groupId": 0,
+          "pollInterval": 10,
+          "exposeInputSwitches": true,
+          "inputs": [
+            { "label": "HDMI 1", "code": "0x0D", "identifier": 1 },
+            { "label": "HDMI 2", "code": "0x06", "identifier": 2 },
+            { "label": "HDMI 3", "code": "0x0F", "identifier": 3 },
+            { "label": "HDMI 4", "code": "0x19", "identifier": 4 }
+          ],
+          "exposeBrightness": true
+        }
+        }
+      ]
+    }
+  ]
+}
+```
+
+### Notes
+- `monitorId`: use the Monitor ID set in the OSD (often 1). `0` means broadcast (typically no reply).
+- `includeGroup`: some firmwares expect a *Group* byte; leave `true` unless you see no ACK, then try `false`.
+- `inputs`: SICP input codes vary by model/firmware. The defaults work on many D-Line firmwares; adjust if needed.
+- `pollInterval`: seconds between lightweight status refresh attempts. Set `0` to disable polling.
+- `exposeInputSwitches`: creates a `Switch` per input (mutually exclusive) for simple automations.
+- `exposeBrightness`: (Default `true`). Exposes a Lightbulb service for brightness control. **Warning**: If enabled, HomeKit may group this with other lights ("Turn on all lights" -> Turns on TV). Set to `false` if you experience this issue.
+
+## Usage
+- Power: Use the Television tile → On/Off.
+- Input: Change the **input** from the TV tile, or toggle the per‑input switches (if enabled).
+- Siri: “Switch Salon TV to HDMI 2”, “Turn on Salon TV”.
+
+## Troubleshooting
+- **No response / timeouts**: check that the display answers on `tcp/5000` (`telnet IP 5000`), and that “Network control / RJ45” is enabled.
+- **Input won’t change**: some displays require a short delay after power on; the plugin already waits ~300ms but you can increase it in code if needed.
+- **Wrong input codes**: run with debugging, try other codes for `0xAC` (input set). If you have the SICP table for your firmware, copy the exact codes into `inputs`.
+- **Security**: do not expose the port to the Internet. Restrict to your LAN/VLAN.
+
+## License
+MIT
+
+## Volume & Brightness
+
+You can control **volume** (HomeKit TelevisionSpeaker) and **brightness** (as a Lightbulb service named *Backlight*).  
+Because SICP codes may vary by firmware, you can choose between **absolute** and **relative** modes:
+
+### Volume config
+```json
+"volume": {
+  "min": 0,
+  "max": 100,
+  "initial": 15,
+  "setCode": "0x44",          // OPTIONAL: absolute set: [0x44, value 0..100]
+  "upCode": "0x45",           // OPTIONAL: relative up:   [0x45]
+  "downCode": "0x46",         // OPTIONAL: relative down: [0x46]
+  "muteSetCode": "0x47",      // OPTIONAL: absolute mute: [0x47, 0|1]
+  "muteToggleCode": "0x48",   // OPTIONAL: toggle mute:   [0x48]
+  "stepDelayMs": 120          // delay between relative steps
+}
+```
+> Provide either `setCode` **or** (`upCode` and `downCode`). `muteSetCode` or `muteToggleCode` are optional.
+
+### Brightness config
+```json
+"brightness": {
+  "min": 0,
+  "max": 100,
+  "initial": 50,
+  "setCode": "0x10",          // OPTIONAL: absolute set: [0x10, value 0..100]
+  "upCode": "0x11",           // OPTIONAL: relative up:   [0x11]
+  "downCode": "0x12",         // OPTIONAL: relative down: [0x12]
+  "stepDelayMs": 120
+}
+```
+> If your firmware supports DDC-like absolute brightness, use `setCode` (often `0x32` or `0x10`). Otherwise use relative up/down.
+> **Note**: If you do not configure brightness codes, the plugin will attempt a default SICP command (`0x32`) which works on many D-Line models.
+
+### Example full display config
+```json
+{
+  "name": "Salon TV",
+  "host": "192.168.1.120",
+  "port": 5000,
+  "monitorId": 1,
+  "includeGroup": true,
+  "groupId": 0,
+  "pollInterval": 10,
+  "exposeInputSwitches": true,
+  "inputs": [
+    { "label": "HDMI 1", "code": "0x0D", "identifier": 1 },
+    { "label": "HDMI 2", "code": "0x06", "identifier": 2 },
+    { "label": "HDMI 3", "code": "0x0F", "identifier": 3 },
+    { "label": "HDMI 4", "code": "0x19", "identifier": 4 }
+  ],
+  "volume": {
+    "min": 0,
+    "max": 60,
+    "initial": 10,
+    "setCode": "0x44",
+    "muteSetCode": "0x47"
+  },
+  "brightness": {
+    "min": 0,
+    "max": 100,
+    "initial": 50,
+    "setCode": "0x10"
+  }
+}
+```
+
+
+## If it still shows as a switch
+- The plugin now explicitly sets the Accessory Category to `TELEVISION`.
+- If the icon remains a box/switch, try restarting Homebridge or removing/re-adding the accessory (or clearing `cachedAccessories`).

package/config.schema.json

@@ -0,0 +1,116 @@
+{
+  "pluginAlias": "PhilipsDLinePlatform",
+  "pluginType": "platform",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "displays": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string",
+              "title": "Display name"
+            },
+            "host": {
+              "type": "string",
+              "title": "IP / Hostname"
+            },
+            "port": {
+              "type": "number",
+              "title": "TCP port",
+              "default": 5000
+            },
+            "monitorId": {
+              "type": "number",
+              "title": "Monitor ID",
+              "default": 1
+            },
+            "includeGroup": {
+              "type": "boolean",
+              "title": "Include Group byte",
+              "default": true
+            },
+            "groupId": {
+              "type": "number",
+              "title": "Group ID",
+              "default": 0
+            },
+            "pollInterval": {
+              "type": "number",
+              "title": "Poll interval (s)",
+              "default": 10
+            },
+            "exposeInputSwitches": {
+              "type": "boolean",
+              "title": "Expose per-input switches",
+              "default": false
+            },
+            "exposeBrightness": {
+              "type": "boolean",
+              "title": "Expose Brightness (as Lightbulb)",
+              "description": "WARNING: Exposing brightness creates a Lightbulb service. HomeKit may group this with other lights, causing the TV to turn on when you say 'Turn on all lights'. Disable this if you experience unwanted behavior. The setting provides a slider for backlight control.",
+              "default": true
+            },
+            "inputs": {
+              "type": "array",
+              "title": "Inputs",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "label": {
+                    "type": "string",
+                    "title": "Label"
+                  },
+                  "code": {
+                    "type": "string",
+                    "title": "SICP code (e.g., 0x0D)"
+                  },
+                  "identifier": {
+                    "type": "number",
+                    "title": "HomeKit Identifier (1..)"
+                  }
+                },
+                "required": [
+                  "label",
+                  "code",
+                  "identifier"
+                ]
+              },
+              "default": [
+                {
+                  "label": "HDMI 1",
+                  "code": "0x0D",
+                  "identifier": 1
+                },
+                {
+                  "label": "HDMI 2",
+                  "code": "0x06",
+                  "identifier": 2
+                },
+                {
+                  "label": "HDMI 3",
+                  "code": "0x0F",
+                  "identifier": 3
+                },
+                {
+                  "label": "HDMI 4",
+                  "code": "0x19",
+                  "identifier": 4
+                }
+              ]
+            }
+          },
+          "required": [
+            "name",
+            "host"
+          ]
+        }
+      }
+    },
+    "required": [
+      "displays"
+    ]
+  }
+}

package/index.js

@@ -0,0 +1,576 @@
+'use strict';
+
+/**
+ * Homebridge plugin to control Philips D-Line signage displays (e.g., 55BDL4511D/00)
+ * over LAN using SICP over TCP (default port 5000).
+ *
+ * Exposes a HomeKit Television with inputs, volume (TelevisionSpeaker), and brightness (as a Lightbulb service).
+ */
+
+const net = require('net');
+let hap;
+
+const PLUGIN_NAME = 'homebridge-philips-dline-sicp';
+const PLATFORM_NAME = 'PhilipsDLinePlatform';
+
+/** Simple promise-based sleep */
+function delay(ms) { return new Promise(res => setTimeout(res, ms)); }
+
+/** Clamp helper */
+function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
+
+/** A light-weight send queue so we don't overlap TCP writes */
+class SendQueue {
+  constructor(sender) {
+    this.sender = sender; // async (buf) => Buffer
+    this.queue = Promise.resolve();
+  }
+  send(buf) {
+    const job = async () => {
+      try {
+        return await this.sender(buf);
+      } catch (e) {
+        throw e;
+      }
+    };
+    const p = this.queue.then(job, job);
+    this.queue = p.catch(() => { });
+    return p;
+  }
+}
+
+/** Build a SICP packet */
+function buildSicpPacket(monitorId, dataBytes, includeGroup = true, groupId = 0x00) {
+  const body = includeGroup ? [monitorId & 0xFF, groupId & 0xFF, ...dataBytes] : [monitorId & 0xFF, ...dataBytes];
+  const msgSize = 1 + body.length + 1; // size + body + checksum
+  const arr = [msgSize & 0xFF, ...body];
+  let checksum = 0x00;
+  for (const b of arr) checksum ^= (b & 0xFF);
+  arr.push(checksum & 0xFF);
+  return Buffer.from(arr);
+}
+
+/** Parse a basic ACK/NACK/NAV (best-effort) */
+function parseReply(buf) {
+  const bytes = [...buf];
+  return {
+    raw: bytes.map(b => '0x' + b.toString(16).padStart(2, '0')).join(' '),
+    ok: bytes.includes(0x06),
+    nack: bytes.includes(0x15),
+    nav: bytes.includes(0x18),
+  };
+}
+
+/** TCP client for SICP */
+class SicpClient {
+  constructor(host, port = 5000, timeoutMs = 1200) {
+    this.host = host;
+    this.port = port;
+    this.timeoutMs = timeoutMs;
+    this.queue = new SendQueue(this._sendOnce.bind(this));
+  }
+
+  async send(pkt) {
+    return this.queue.send(pkt);
+  }
+
+  _sendOnce(pkt) {
+    return new Promise((resolve, reject) => {
+      const socket = new net.Socket();
+      let chunks = [];
+      let done = false;
+
+      const finish = (err, data) => {
+        if (done) return;
+        done = true;
+        try { socket.destroy(); } catch { }
+        if (err) reject(err);
+        else resolve(Buffer.concat(data || []));
+      };
+
+      socket.setTimeout(this.timeoutMs, () => finish(new Error('SICP: timeout'), chunks));
+      socket.once('error', (e) => finish(e, chunks));
+      socket.connect(this.port, this.host, () => {
+        socket.write(pkt);
+      });
+      socket.on('data', (d) => chunks.push(Buffer.from(d)));
+      socket.once('close', () => finish(null, chunks));
+      // Some firmwares keep the socket open; close after a short delay
+      setTimeout(() => { try { socket.end(); } catch { } }, 200);
+    });
+  }
+}
+
+/** Accessory representing one D-Line TV */
+class PhilipsDLineTelevisionAccessory {
+  constructor(platform, accessory, conf) {
+    this.platform = platform;
+    this.accessory = accessory;
+    this.log = platform.log;
+    this.name = conf.name || 'Philips D-Line';
+    this.host = conf.host;
+    this.port = conf.port || 5000;
+    this.monitorId = (conf.monitorId === 0 || conf.monitorId) ? conf.monitorId : 1;
+    this.includeGroup = conf.includeGroup !== false; // default true
+    this.groupId = conf.groupId || 0x00;
+    this.pollInterval = conf.pollInterval || 10; // seconds
+    this.exposeBrightness = conf.exposeBrightness !== false; // default true
+
+    // Inputs config
+    this.inputs = Array.isArray(conf.inputs) && conf.inputs.length ? conf.inputs : [
+      { label: 'HDMI 1', code: '0x0D', identifier: 1 },
+      { label: 'HDMI 2', code: '0x06', identifier: 2 },
+      { label: 'HDMI 3', code: '0x0F', identifier: 3 },
+      { label: 'HDMI 4', code: '0x19', identifier: 4 },
+    ];
+    this.exposeInputSwitches = !!conf.exposeInputSwitches;
+
+    // Volume config (two modes: absolute set, or relative up/down repeat)
+    this.volume = {
+      min: conf.volume?.min ?? 0,
+      max: conf.volume?.max ?? 100,
+      // Absolute set: send [volSetCode, value] if provided
+      setCode: conf.volume?.setCode, // e.g. "0x44"
+      // Relative: send [volUpCode] or [volDownCode] N times
+      upCode: conf.volume?.upCode,
+      downCode: conf.volume?.downCode,
+      // Mute support
+      muteSetCode: conf.volume?.muteSetCode, // absolute mute set [code, 0/1]
+      muteToggleCode: conf.volume?.muteToggleCode, // single code to toggle
+      // UI state
+      current: clamp(conf.volume?.initial ?? 15, conf.volume?.min ?? 0, conf.volume?.max ?? 100),
+      muted: false,
+      stepMs: conf.volume?.stepDelayMs ?? 120, // delay between relative steps
+    };
+
+    // Brightness config (absolute preferred; fallback relative)
+    this.brightness = {
+      min: conf.brightness?.min ?? 0,
+      max: conf.brightness?.max ?? 100,
+      setCode: conf.brightness?.setCode,      // e.g. "0x10"
+      upCode: conf.brightness?.upCode,
+      downCode: conf.brightness?.downCode,
+      current: clamp(conf.brightness?.initial ?? 50, conf.brightness?.min ?? 0, conf.brightness?.max ?? 100),
+      stepMs: conf.brightness?.stepDelayMs ?? 120,
+    };
+
+    // State
+    this.active = 0; // 0=INACTIVE, 1=ACTIVE
+    this.activeIdentifier = this.inputs[0]?.identifier ?? 1;
+
+    this.client = new SicpClient(this.host, this.port);
+    this._setupServices();
+    this._startPolling();
+  }
+
+  _setupServices() {
+    const Service = hap.Service;
+    const Characteristic = hap.Characteristic;
+
+    this.televisionService = this.accessory.getService(Service.Television)
+      || this.accessory.addService(Service.Television, this.name);
+
+    this.televisionService
+      .setCharacteristic(Characteristic.ConfiguredName, this.name)
+      .setCharacteristic(Characteristic.SleepDiscoveryMode, Characteristic.SleepDiscoveryMode.ALWAYS_DISCOVERABLE);
+
+    // Power
+    this.televisionService.getCharacteristic(Characteristic.Active)
+      .onGet(this.handleGetActive.bind(this))
+      .onSet(this.handleSetActive.bind(this));
+
+    // Active input
+    this.televisionService.getCharacteristic(Characteristic.ActiveIdentifier)
+      .onGet(async () => this.activeIdentifier)
+      .onSet(this.handleSetActiveIdentifier.bind(this));
+
+    // Add inputs as InputSource services
+    this.inputs.forEach((inp, idx) => {
+      const id = (typeof inp.identifier === 'number') ? inp.identifier : (idx + 1);
+      const label = inp.label || `Input ${id}`;
+
+      let inputService = this.accessory.getService(label);
+      if (!inputService) {
+        inputService = this.accessory.addService(Service.InputSource, label, 'input-' + id);
+      }
+      inputService
+        .setCharacteristic(Characteristic.Identifier, id)
+        .setCharacteristic(Characteristic.ConfiguredName, label)
+        .setCharacteristic(Characteristic.InputSourceType, Characteristic.InputSourceType.HDMI)
+        .setCharacteristic(Characteristic.IsConfigured, Characteristic.IsConfigured.CONFIGURED)
+        .setCharacteristic(Characteristic.CurrentVisibilityState, Characteristic.CurrentVisibilityState.SHOWN);
+
+      this.televisionService.addLinkedService(inputService);
+    });
+
+    // Optional: expose input switches
+    if (this.exposeInputSwitches) {
+      this.inputs.forEach((inp, idx) => {
+        const id = (typeof inp.identifier === 'number') ? inp.identifier : (idx + 1);
+        const label = `${inp.label || `Input ${id}`} Switch`;
+        const s = this.accessory.addService(Service.Switch, label, 'switch-' + id);
+        s.getCharacteristic(Characteristic.On)
+          .onGet(async () => this.active && (this.activeIdentifier === id))
+          .onSet(async (val) => {
+            if (val) {
+              await this._ensureOn();
+              await this._setInputByIdentifier(id);
+              // Turn off other input switches
+              this.inputs.forEach((other, j) => {
+                const oid = (typeof other.identifier === 'number') ? other.identifier : (j + 1);
+                if (oid !== id) {
+                  const os = this.accessory.getService(`${other.label || `Input ${oid}`} Switch`);
+                  if (os) os.updateCharacteristic(Characteristic.On, false);
+                }
+              });
+            } else {
+              // no-op
+            }
+          });
+      });
+    }
+
+    // --- TelevisionSpeaker (volume & mute) ---
+    this.speakerService = this.accessory.getService(Service.TelevisionSpeaker)
+      || this.accessory.addService(Service.TelevisionSpeaker);
+
+    this.speakerService
+      .setCharacteristic(Characteristic.Active, Characteristic.Active.ACTIVE)
+      .setCharacteristic(Characteristic.VolumeControlType, Characteristic.VolumeControlType.ABSOLUTE); // we emulate absolute
+
+    this.speakerService.getCharacteristic(Characteristic.Mute)
+      .onGet(async () => this.volume.muted)
+      .onSet(this.handleSetMute.bind(this));
+
+    this.speakerService.getCharacteristic(Characteristic.Volume)
+      .onGet(async () => this.volume.current)
+      .onSet(this.handleSetVolume.bind(this));
+
+    // Link speaker to TV
+    this.televisionService.addLinkedService(this.speakerService);
+
+    // --- Brightness as a Lightbulb service ---
+    if (this.exposeBrightness) {
+      this.backlightService = this.accessory.getService('Backlight')
+        || this.accessory.addService(Service.Lightbulb, 'Backlight', 'backlight');
+
+      this.backlightService.getCharacteristic(Characteristic.On)
+        .onGet(async () => this.active === 1 && this.brightness.current > this.brightness.min)
+        .onSet(async (val) => {
+          if (val) {
+            // If TV is OFF, do NOT turn it on automatically just because "All lights" were turned on.
+            if (this.active !== 1) {
+              this.log.info('Ignoring Backlight On request because TV is OFF.');
+              // We can throw an error to indicate failure, or just revert the state.
+              // Throwing an error might be annoying in scenes, but reverting is cleaner.
+              setTimeout(() => {
+                this.backlightService.updateCharacteristic(Characteristic.On, false);
+              }, 100);
+              return;
+            }
+            if (this.brightness.current <= this.brightness.min) {
+              await this._setBrightness(Math.max(this.brightness.min + 1, 10));
+            }
+          } else {
+            // Turning off backlight -> set brightness to min
+            await this._setBrightness(this.brightness.min);
+          }
+        });
+
+      this.backlightService.getCharacteristic(Characteristic.Brightness)
+        .onGet(async () => this.brightness.current)
+        .onSet(async (val) => {
+          // If TV is OFF, ignore brightness set
+          if (this.active !== 1) {
+            this.log.info('Ignoring Brightness Set request because TV is OFF.');
+            return;
+          }
+          await this._setBrightness(val);
+        });
+    } else {
+      // Remove service if it exists (e.g. if user disabled it)
+      const existing = this.accessory.getService('Backlight');
+      if (existing) {
+        this.accessory.removeService(existing);
+      }
+    }
+
+    // Publish Accessory information
+    const info = this.accessory.getService(Service.AccessoryInformation);
+    info
+      .setCharacteristic(Characteristic.Manufacturer, 'Philips (Signage)')
+      .setCharacteristic(Characteristic.Model, 'D-Line (SICP over IP)')
+      .setCharacteristic(Characteristic.SerialNumber, this.host);
+  }
+
+  // ---------------- Handlers ----------------
+
+  async handleGetActive() {
+    try {
+      const pkt = buildSicpPacket(this.monitorId, [0x19], this.includeGroup, this.groupId); // Get Power
+      const reply = await this.client.send(pkt);
+      const parsed = parseReply(reply);
+      // parsed.raw is e.g. "0x06 0x02" where 0x02 is ON.
+      this.platform.log.debug('GetActive reply:', parsed.raw);
+
+      // SICP Get Power Reply: [Len, Mon, Grp, ACK(06), Status] or just [ACK, Status] depending on model.
+      // We need to actually parse the status byte.
+      // Assuming the last byte before checksum or the byte after 0x06 is status.
+      // Let's look for 0x02 (On) or 0x01 (Standby) in the reply.
+      const bytes = [...reply];
+      // Simple heuristic: if it contains 0x02, it's ON. If 0x01, it's OFF.
+      // Note: This matches the Set Power command (0x02=On, 0x01=Off).
+      if (bytes.includes(0x02)) {
+        this.active = 1;
+      } else if (bytes.includes(0x01)) {
+        this.active = 0;
+      }
+      // If we got a reply but couldn't check status, we validly connected at least. 
+      // But typically we should trust the parsed status.
+
+      return this.active;
+    } catch (e) {
+      this.log.warn('GetActive failed (TV unreachable?):', e.message);
+      this.active = 0; // Assume OFF if unreachable
+      return this.active;
+    }
+  }
+
+  async handleSetActive(value) {
+    const on = (value === 1 || value === true);
+    try {
+      const pkt = buildSicpPacket(this.monitorId, [0x18, on ? 0x02 : 0x01], this.includeGroup, this.groupId); // Set Power
+      const reply = await this.client.send(pkt);
+      const parsed = parseReply(reply);
+      this.log.debug('SetActive reply:', parsed.raw);
+      if (parsed.nack || parsed.nav) throw new Error('Device rejected command');
+      this.active = on ? 1 : 0;
+      if (!on && this.exposeInputSwitches) {
+        this.inputs.forEach((inp, idx) => {
+          const id = (typeof inp.identifier === 'number') ? inp.identifier : (idx + 1);
+          const s = this.accessory.getService(`${inp.label || `Input ${id}`} Switch`);
+          if (s) s.updateCharacteristic(hap.Characteristic.On, false);
+        });
+      }
+    } catch (e) {
+      this.log.error('SetActive error:', e.message);
+      this.televisionService.updateCharacteristic(hap.Characteristic.Active, this.active);
+      throw e;
+    }
+  }
+
+  async handleSetActiveIdentifier(identifier) {
+    await this._ensureOn();
+    await this._setInputByIdentifier(identifier);
+  }
+
+  async handleSetVolume(val) {
+    const target = clamp(Number(val), this.volume.min, this.volume.max);
+    await this._ensureOn();
+    if (this.volume.setCode) {
+      // Absolute mode
+      const code = this._parseCode(this.volume.setCode);
+      if (code === 0x44) {
+        // SICP Volume Set: [0x44, SpeakerVol, AudioOutVol]; use 0xFF (no change) for Audio Out
+        await this._send([code, target & 0xFF, 0xFF]);
+      } else {
+        await this._send([code, target & 0xFF]);
+      }
+    } else if (this.volume.upCode && this.volume.downCode) {
+      // Relative mode: step towards target
+      const diff = target - this.volume.current;
+      const stepCode = diff > 0 ? this._parseCode(this.volume.upCode) : this._parseCode(this.volume.downCode);
+      for (let i = 0; i < Math.abs(diff); i++) {
+        await this._send([stepCode]);
+        await delay(this.volume.stepMs);
+      }
+    } else {
+      this.log.warn('Volume codes not configured; ignoring setVolume.');
+    }
+    this.volume.current = target;
+    this.speakerService.updateCharacteristic(hap.Characteristic.Volume, this.volume.current);
+  }
+
+  async handleSetMute(val) {
+    const mute = !!val;
+    await this._ensureOn();
+    if (this.volume.muteSetCode) {
+      const code = this._parseCode(this.volume.muteSetCode);
+      await this._send([code, mute ? 0x01 : 0x00]);
+    } else if (this.volume.muteToggleCode) {
+      const code = this._parseCode(this.volume.muteToggleCode);
+      // If desired state differs, send one toggle
+      if (mute !== this.volume.muted) {
+        await this._send([code]);
+      }
+    } else {
+      this.log.warn('Mute codes not configured; ignoring mute.');
+    }
+    this.volume.muted = mute;
+    this.speakerService.updateCharacteristic(hap.Characteristic.Mute, this.volume.muted);
+  }
+
+  // ---------------- Helpers ----------------
+
+  async _ensureOn() {
+    if (this.active !== 1) {
+      await this.handleSetActive(1);
+      await delay(300);
+    }
+  }
+
+  _codeFromIdentifier(identifier) {
+    const inp = this.inputs.find(x => (x.identifier === identifier));
+    if (!inp) return null;
+    const raw = (typeof inp.code === 'string') ? inp.code : inp.code?.toString();
+    if (!raw) return null;
+    const code = raw.trim().toLowerCase().startsWith('0x') ? parseInt(raw, 16) : parseInt(raw, 10);
+    if (Number.isNaN(code)) return null;
+    return code & 0xFF;
+  }
+
+  _parseCode(raw) {
+    if (typeof raw === 'number') return raw & 0xFF;
+    const s = String(raw).trim().toLowerCase();
+    return (s.startsWith('0x') ? parseInt(s, 16) : parseInt(s, 10)) & 0xFF;
+  }
+
+  async _setInputByIdentifier(identifier) {
+    const code = this._codeFromIdentifier(identifier);
+    if (code == null) {
+      this.log.error('Unknown input identifier:', identifier);
+      return;
+    }
+    const reply = await this._send([0xAC, code]); // Set Input
+    const parsed = parseReply(reply);
+    this.log.debug(`SetInput(${identifier}/0x${code.toString(16)}) reply:`, parsed.raw);
+    if (parsed.nack || parsed.nav) throw new Error('Device rejected input change');
+    this.activeIdentifier = identifier;
+    this.televisionService.updateCharacteristic(hap.Characteristic.ActiveIdentifier, identifier);
+    if (this.exposeInputSwitches) {
+      this.inputs.forEach((inp, idx) => {
+        const id = (typeof inp.identifier === 'number') ? inp.identifier : (idx + 1);
+        const s = this.accessory.getService(`${inp.label || `Input ${id}`} Switch`);
+        if (s) s.updateCharacteristic(hap.Characteristic.On, id === identifier);
+      });
+    }
+  }
+
+  async _setBrightness(val) {
+    const target = clamp(Number(val), this.brightness.min, this.brightness.max);
+    if (this.brightness.setCode) {
+      const code = this._parseCode(this.brightness.setCode);
+      if (code === 0x32) {
+        // SICP Video Parameters Set: [0x32, Brightness, Color, Contrast, Sharpness, Tint, BlackLevel, Gamma]
+        // Use 0xFF for "no change" on other fields (supported since SICP 2.09)
+        await this._send([code, target & 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
+      } else {
+        await this._send([code, target & 0xFF]);
+      }
+    } else if (this.brightness.upCode && this.brightness.downCode) {
+      const diff = target - this.brightness.current;
+      const stepCode = diff > 0 ? this._parseCode(this.brightness.upCode) : this._parseCode(this.brightness.downCode);
+      for (let i = 0; i < Math.abs(diff); i++) {
+        await this._send([stepCode]);
+        await delay(this.brightness.stepMs);
+      }
+    } else {
+      // Fallback: If no brightness setCode or up/down codes, try default 0x32 (Video Parameters)
+      // Many D-Lines support 0x32 for brightness.
+      this.log.debug('No brightness codes configured, attempting default SICP 0x32 command.');
+      try {
+        // [0x32, Brightness, Color, Contrast, Sharpness, Tint, BlackLevel, Gamma]
+        // We'll try just sending [0x32, val]. Some older SICP might accept just valid params.
+        // Or better, use the full safe string:
+        // await this._send([0x32, target & 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
+        // Wait, the code existed but was inside 'if (this.brightness.setCode)'.
+        // Let's force try 0x32 if nothing else is set.
+        await this._send([0x32, target & 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
+      } catch (e) {
+        this.log.warn('Default brightness 0x32 failed:', e.message);
+      }
+    }
+    this.brightness.current = target;
+    if (this.exposeBrightness) {
+      this.backlightService.updateCharacteristic(hap.Characteristic.Brightness, this.brightness.current);
+      this.backlightService.updateCharacteristic(hap.Characteristic.On, this.brightness.current > this.brightness.min);
+    }
+  }
+
+  async _send(dataBytes) {
+    const pkt = buildSicpPacket(this.monitorId, dataBytes, this.includeGroup, this.groupId);
+    const reply = await this.client.send(pkt);
+    return reply;
+  }
+
+  _startPolling() {
+    if (!this.pollInterval || this.pollInterval <= 0) return;
+    const loop = async () => {
+      try {
+        await delay(this.pollInterval * 1000);
+        await this.handleGetActive().catch(() => { });
+      } catch (e) {
+        // ignore
+      } finally {
+        setImmediate(loop);
+      }
+    };
+    loop();
+  }
+}
+
+/** Platform (supports multiple displays) */
+class PhilipsDLinePlatform {
+  constructor(log, config, api) {
+    this.log = log;
+    this.config = config || {};
+    this.api = api;
+    hap = api.hap;
+
+    this.accessories = new Map(); // UUID -> accessory
+
+    if (!this.config.displays || !Array.isArray(this.config.displays) || this.config.displays.length === 0) {
+      this.log.warn('No "displays" configured. Please add at least one display.');
+    }
+
+    api.on('didFinishLaunching', () => {
+      this.discover();
+    });
+  }
+
+  configureAccessory(accessory) {
+    this.accessories.set(accessory.UUID, accessory);
+  }
+
+  discover() {
+    const displays = this.config.displays || [];
+    displays.forEach(conf => {
+      if (!conf || !conf.host) {
+        this.log.warn('Skipping display without "host" field:', conf);
+        return;
+      }
+      const uuid = this.api.hap.uuid.generate(`philips-dline:${conf.host}:${conf.name || ''}`);
+      let accessory = this.accessories.get(uuid);
+      if (!accessory) {
+        accessory = new this.api.platformAccessory(conf.name || 'Philips D-Line', uuid);
+        accessory.context.conf = conf;
+        // Fix for icon issue: Set category to TELEVISION
+        accessory.category = this.api.hap.Categories.TELEVISION;
+
+        this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+        this.accessories.set(uuid, accessory);
+        this.log.info('Registered new display accessory:', conf.name || conf.host);
+      } else {
+        accessory.context.conf = conf;
+        // Ensure category is updated if it was missing
+        accessory.category = this.api.hap.Categories.TELEVISION;
+        this.log.info('Updated display accessory:', conf.name || conf.host);
+      }
+      new PhilipsDLineTelevisionAccessory(this, accessory, conf);
+    });
+  }
+}
+
+module.exports = (api) => {
+  api.registerPlatform(PLATFORM_NAME, PhilipsDLinePlatform);
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "homebridge-philips-dline-sicp",
+  "version": "0.1.3",
+  "description": "Homebridge plugin to control Philips D-Line signage displays (e.g., 55BDL4511D) over LAN using SICP (TCP:5000). Exposes as a HomeKit Television with inputs.",
+  "main": "index.js",
+  "keywords": [
+    "homebridge-plugin",
+    "philips",
+    "d-line",
+    "signage",
+    "television",
+    "sicp"
+  ],
+  "author": "ChatGPT",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0",
+    "homebridge": ">=1.6.0"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "https://example.com/homebridge-philips-dline-sicp.git"
+  },
+  "homepage": "https://github.com/yourname/homebridge-philips-dline-sicp",
+  "bugs": {
+    "url": "https://github.com/yourname/homebridge-philips-dline-sicp/issues"
+  },
+  "contributors": [
+    "Thomas Dazy"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}