homebridge-smartsystem 6.8.13 → 7.0.1

package/WEBSOCKET-API.md

@@ -0,0 +1,303 @@
+# WebSocket Device Control API
+
+## Overview
+
+The SmartApp now includes a WebSocket-based device control system that allows real-time monitoring and control of Duotecno devices with integrated power measurement support.
+
+## Features
+
+- **WebSocket Server**: Runs on same ports as HTTP server (80 and configured port)
+- **Real-time Device Status**: Get current relay states and power measurements
+- **Power Measurement Integration**: Supports P1, Shelly, Smappee, or estimated power
+- **Remote Control**: Toggle device relays by ID
+- **Keep-alive Polling**: Send empty array to get status updates
+
+## WebSocket Endpoint
+
+**URL**: `ws://duotecno-gateway.local/devices`
+
+Or using IP address: `ws://your-server-ip/devices`
+
+## Device Configuration
+
+### Web Interface
+
+1. Navigate to `http://duotecno-gateway.local/devices` (or `http://your-server-ip/devices`)
+2. Click "Add device"
+3. Configure device:
+   - **Name**: Friendly name for the device
+   - **Master**: Select Duotecno master controller
+   - **Unit**: Select or enter unit address (node/unit)
+   - **Power Source**: Choose measurement source:
+     - **Non-measured (Estimated)**: Use fixed power estimate
+     - **P1 Meter**: Read from P1 smart meter
+     - **Shelly PM**: Read from Shelly power meter
+     - **Smappee**: Read from Smappee energy monitor
+   - **Power Channel**: Channel/register for measured sources (e.g., "0", "0+1+2")
+   - **Estimated Power**: Power in watts when not measured (used when relay is ON)
+
+### Device ID Calculation
+
+Device IDs are automatically calculated as:
+```
+Device ID = (Node Number × 256) + Unit Number
+```
+
+Examples:
+- Node 2, Unit 1 → ID = 513
+- Node 1, Unit 2 → ID = 258
+- Node 3, Unit 10 → ID = 778
+
+## WebSocket Protocol
+
+### Message Format
+
+All messages are JSON arrays.
+
+### Client → Server Messages
+
+#### 1. Keep-alive / Status Poll
+
+Send empty array to receive current device status:
+
+```json
+[]
+```
+
+#### 2. Control Relays
+
+Send array of control commands:
+
+```json
+[
+  { "id": 513, "relay": true },   // Turn ON device 513 (node 2, unit 1)
+  { "id": 258, "relay": false }   // Turn OFF device 258 (node 1, unit 2)
+]
+```
+
+### Server → Client Messages
+
+Server always responds with complete device list:
+
+```json
+[
+  {
+    "id": 513,
+    "name": "Airco",
+    "power": 1250.5,      // Current power in watts
+    "energy": 10.5,       // Energy consumption in kWh (future)
+    "voltage": 230.0,     // Voltage
+    "current": 5.44,      // Current in amps (calculated)
+    "relay": true,        // Relay state (ON/OFF)
+    "measured": true      // true = real measurements, false = estimated
+  },
+  {
+    "id": 258,
+    "name": "Zwembad pomp",
+    "power": 0,
+    "energy": 0,
+    "voltage": 230.0,
+    "current": 0,
+    "relay": false,
+    "measured": false
+  }
+]
+```
+
+## Power Measurement Sources
+
+### Smappee
+
+- **Channel Format**: `"0"`, `"1"`, `"0+1+2"` (sum multiple channels)
+- **Data Source**: `this.power.smappee.bindings[].value`
+
+### P1 Meter
+
+- **Channel Format**: `"0"`, `"1"`, `"0+1+2"`
+- **Data Source**: `this.power.p1.bindings[].value`
+
+### Shelly PM
+
+- **Channel Format**: `"0"`, `"1"`, `"0+1+2"`
+- **Data Source**: `this.power.shelly.bindings[].value`
+
+### Non-measured (Estimated)
+
+- **Power Calculation**: Uses `estimatedPower` when relay is ON, 0 when OFF
+- **Use Case**: Devices without power monitoring
+
+## Testing with testWS.ts
+
+### Running the Test Client
+
+```bash
+# Default (localhost:80)
+ts-node testWS.ts
+
+# Custom server
+ts-node testWS.ts ws://192.168.0.99:5002/devices
+
+# Or with compiled JavaScript
+node testWS.js ws://192.168.0.99:5002/devices
+```
+
+### Test Client Features
+
+- **Auto-connect**: Connects to WebSocket server
+- **Keep-alive**: Polls every 5 seconds with `[]`
+- **Random Control**: Toggles 1-3 random relays every 10-15 seconds
+- **Pretty Display**: Shows device status in formatted table
+- **Graceful Shutdown**: Press Ctrl+C to disconnect cleanly
+
+### Example Output
+
+```
+╔════════════════════════════════════════════════════════════════════╗
+║   WebSocket Device Control Test Client                            ║
+║   Press Ctrl+C to exit                                             ║
+╚════════════════════════════════════════════════════════════════════╝
+
+🔌 Connecting to WebSocket server: ws://192.168.0.99:5002/devices
+✅ Connected to WebSocket server
+
+📊 Received 2 device(s):
+════════════════════════════════════════════════════════════════════════════════════════════════════
+ID  | Name                 | Power(W) | Current(A) | Voltage(V) | Relay | Measured
+────────────────────────────────────────────────────────────────────────────────────────────────────
+513 | Airco                |   1250.5 |       5.44 |      230.0 | 🟢 ON  | 📊
+258 | Zwembad pomp         |      0.0 |       0.00 |      230.0 | 🔴 OFF | 📝
+════════════════════════════════════════════════════════════════════════════════════════════════════
+
+⏱️  Sending keep-alive poll...
+
+🎲 Sending random control commands:
+   → Airco (node=2, unit=1, id=513): 🔴 OFF
+   → Zwembad pomp (node=1, unit=2, id=258): 🟢 ON
+```
+
+## Configuration Example
+
+Add to your `config.json`:
+
+```json
+{
+  "smartapp": {
+    "port": 5002,
+    "devices": [
+      {
+        "name": "Airco",
+        "masterAddress": "192.168.0.97",
+        "masterPort": 5001,
+        "logicalNodeAddress": 2,
+        "logicalAddress": 1,
+        "powerSource": "smappee",
+        "powerChannel": "0",
+        "measured": true
+      },
+      {
+        "name": "Zwembad pomp",
+        "masterAddress": "192.168.0.97",
+        "masterPort": 5001,
+        "logicalNodeAddress": 1,
+        "logicalAddress": 2,
+        "powerSource": "none",
+        "estimatedPower": 750,
+        "measured": false
+      }
+    ]
+  }
+}
+```
+
+## Client Implementation Example
+
+### JavaScript/TypeScript
+
+```typescript
+import * as WebSocket from 'ws';
+
+const ws = new WebSocket('ws://192.168.0.99:5002/devices');
+
+ws.on('open', () => {
+  console.log('Connected');
+  
+  // Poll for status
+  ws.send('[]');
+});
+
+ws.on('message', (data: string) => {
+  const devices = JSON.parse(data.toString());
+  console.log('Devices:', devices);
+  
+  // Control a device
+  ws.send(JSON.stringify([
+    { id: 513, relay: true }
+  ]));
+});
+```
+
+### Python
+
+```python
+import websocket
+import json
+
+def on_message(ws, message):
+    devices = json.loads(message)
+    print(f"Devices: {devices}")
+    
+    # Control device 513
+    ws.send(json.dumps([{"id": 513, "relay": True}]))
+
+def on_open(ws):
+    print("Connected")
+    # Poll for status
+    ws.send("[]")
+
+ws = websocket.WebSocketApp(
+    "ws://192.168.0.99:5002/devices",
+    on_message=on_message,
+    on_open=on_open
+)
+ws.run_forever()
+```
+
+## Error Handling
+
+- Invalid JSON: Server ignores message
+- Non-array messages: Server logs error and ignores
+- Invalid device IDs: Silently ignored (no such device)
+- Connection closed: Automatic cleanup
+
+## Security Considerations
+
+- WebSocket uses same authentication as HTTP (if enabled)
+- No encryption by default (use reverse proxy with WSS for production)
+- Consider rate limiting for control commands
+- Validate device IDs match authorized units
+
+## Troubleshooting
+
+### Connection Refused
+
+- Check server is running
+- Verify port is correct (80 or configured port)
+- Check firewall rules
+
+### Devices Not Updating
+
+- Verify device configuration in web UI
+- Check power source is configured correctly
+- Verify channel numbers match power meter setup
+- Check server logs for errors
+
+### Power Always Zero
+
+- For measured devices: Check power source connection
+- For estimated: Verify `estimatedPower` is set
+- Check relay state is updating correctly
+
+## API Version
+
+Current version: 1.0  
+Last updated: November 2025

package/accessories/accessory.js

@@ -49,8 +49,16 @@ class Accessory {
     getState(next) {
         if (this.unit) {
             this.unit.reqState(unit => {
-                next(null, unit.status);
-                (0, logger_1.log)("accessory", "getState was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status);
+                try {
+                    if (!unit) {
+                        return next(new Error("Unit state not available"));
+                    }
+                    next(null, unit.status);
+                    (0, logger_1.log)("accessory", "getState was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status);
+                }
+                catch (err) {
+                    next(err);
+                }
             }).catch(err => next(err));
         }
         else {
@@ -60,8 +68,16 @@ class Accessory {
     getValue(next) {
         if (this.unit) {
             this.unit.reqState(unit => {
-                next(null, unit.value);
-                (0, logger_1.log)("accessory", "getValue was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+                try {
+                    if (!unit) {
+                        return next(new Error("Unit state not available"));
+                    }
+                    next(null, unit.value);
+                    (0, logger_1.log)("accessory", "getValue was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+                }
+                catch (err) {
+                    next(err);
+                }
             }).catch(err => next(err));
         }
         else {

package/accessories/accessory.ts

@@ -68,8 +68,15 @@ export class Accessory {
   getState(next) {
     if (this.unit) {
       this.unit.reqState(unit => { 
-        next(null, unit.status);
-        log("accessory", "getState was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status);
+        try {
+          if (!unit) {
+            return next(new Error("Unit state not available"));
+          }
+          next(null, unit.status);
+          log("accessory", "getState was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status);
+        } catch(err) {
+          next(err);
+        }
       }).catch(err => next(err));
     } else {
       next( new Error("accessory - getState needs to be overridden if no unit is provided.") );
@@ -79,14 +86,22 @@ export class Accessory {
   getValue(next) {
     if (this.unit) {
       this.unit.reqState(unit => { 
-        next(null, unit.value);
-        log("accessory", "getValue was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+        try {
+          if (!unit) {
+            return next(new Error("Unit state not available"));
+          }
+          next(null, unit.value);
+          log("accessory", "getValue was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+        } catch(err) {
+          next(err);
+        }
       }).catch(err => next(err));
     } else {
       next( new Error("accessory - getState needs to be overridden if no unit is provided.") );
     }
   }
 
+
   setState(value, next) {
     if (this.unit)
       this.unit.setState(value)

package/accessories/bulb.js

@@ -25,11 +25,6 @@ class Bulb extends accessory_1.Accessory {
             .then(() => next())
             .catch(err => next(err));
     }
-    setBrightness(value, next) {
-        this.unit.setState(value)
-            .then(() => next())
-            .catch(err => next(err));
-    }
 }
 exports.Bulb = Bulb;
 //# sourceMappingURL=bulb.js.map

package/accessories/bulb.ts

@@ -34,9 +34,5 @@ export class Bulb extends Accessory {
       .then(() => next())
       .catch(err => next(err))
   }
-  setBrightness(value, next) {
-    this.unit.setState(value)
-      .then(() => next())
-      .catch(err => next(err))
-  }
+  
 }

package/accessories/dimmer.js

@@ -30,12 +30,20 @@ class Dimmer extends accessory_1.Accessory {
     getBrightness(next) {
         if (this.unit) {
             this.unit.reqState(unit => {
-                next(null, unit.value);
-                (0, logger_1.log)("accessory", "getBrightness was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+                try {
+                    if (!unit) {
+                        return next(new Error("Unit state not available"));
+                    }
+                    next(null, unit.value);
+                    (0, logger_1.log)("accessory", "getBrightness was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+                }
+                catch (err) {
+                    next(err);
+                }
             }).catch(err => next(err));
         }
         else {
-            next(new Error("accessory - getState needs to be overridden if no unit is provided."));
+            next(new Error("accessory - getBrightness needs to be overridden if no unit is provided."));
         }
     }
     setPower(powerOn, next) {

package/accessories/dimmer.ts

@@ -41,14 +41,21 @@ export class Dimmer extends Accessory {
   getBrightness(next) {
     if (this.unit) {
       this.unit.reqState(unit => { 
-        next(null, unit.value);
-        log("accessory", "getBrightness was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+        try {
+          if (!unit) {
+            return next(new Error("Unit state not available"));
+          }
+          next(null, unit.value);
+          log("accessory", "getBrightness was called for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+        } catch(err) {
+          next(err);
+        }
       }).catch(err => next(err));
     } else {
-      next( new Error("accessory - getState needs to be overridden if no unit is provided.") );
+      next( new Error("accessory - getBrightness needs to be overridden if no unit is provided.") );
     }
   }
-
+  
   setPower(powerOn, next) {
     this.waitingSetPower = true;
     log("accessory", "setPower: *** waiting *** " + powerOn);

package/accessories/garagedoor.js

@@ -13,7 +13,7 @@ const accessory_1 = require("./accessory");
 class GarageDoor extends accessory_1.Accessory {
     constructor(homebridge, unit) {
         super(homebridge, unit);
-        this.targetState = this.homebridge.Characteristic.CurrentDoorState.STOPPED;
+        this.targetState = this.homebridge.Characteristic.TargetDoorState.CLOSED;
     }
     getAccessoryServices() {
         // GarageDoorOpener needs authentication
@@ -39,13 +39,15 @@ class GarageDoor extends accessory_1.Accessory {
             return this.homebridge.Characteristic.CurrentDoorState.OPENING;
         else if (status == types_1.UnitState.kStopped)
             return this.homebridge.Characteristic.CurrentDoorState.STOPPED;
-        else
-            return this.homebridge.Characteristic.CurrentDoorState.STOPPED; // ????
+        else {
+            (0, logger_1.log)("accessory", `Unknown Door/UnitState ${status}, defaulting to STOPPED`);
+            return this.homebridge.Characteristic.CurrentDoorState.STOPPED;
+        }
     }
     HB2DT(state) {
-        if (state == this.homebridge.Characteristic.CurrentDoorState.OPEN)
+        if (state == this.homebridge.Characteristic.TargetDoorState.OPEN)
             return types_1.UnitMotorCmd.kOpen;
-        else if (state == this.homebridge.Characteristic.CurrentDoorState.CLOSED)
+        else if (state == this.homebridge.Characteristic.TargetDoorState.CLOSED)
             return types_1.UnitMotorCmd.kClose;
         else if (state == this.homebridge.Characteristic.CurrentDoorState.STOPPED)
             return types_1.UnitMotorCmd.kStop;
@@ -56,7 +58,7 @@ class GarageDoor extends accessory_1.Accessory {
         try {
             this.unit.reqState(unit => {
                 const hb = this.DT2HB(unit.status);
-                (0, logger_1.log)("accessory", "Get TargetDoorState of " + this.name + " = " + unit.status + " -> " + hb);
+                (0, logger_1.log)("accessory", "Get CurrentDoorState of " + this.name + " = " + unit.status + " -> " + hb);
                 next(null, hb);
             });
         }
@@ -86,9 +88,17 @@ class GarageDoor extends accessory_1.Accessory {
     }
     // in response to Duotecno status messages
     updateState() {
-        const value = this.DT2HB(this.unit.status);
-        (0, logger_1.log)("accessory", "Received updateState -> Homekit GarageDoor for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status + " / " + this.unit.value + " -> passing to HB: " + value);
-        this.me.getCharacteristic(this.homebridge.Characteristic.CurrentDoorState).updateValue(value);
+        const current = this.DT2HB(this.unit.status);
+        const target = current === this.homebridge.Characteristic.CurrentDoorState.OPEN
+            ? this.homebridge.Characteristic.TargetDoorState.OPEN
+            : this.homebridge.Characteristic.TargetDoorState.CLOSED;
+        (0, logger_1.log)("accessory", "Received updateState -> Homekit GarageDoor for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status + " -> passing to HB (current/target): " + current + " / " + target);
+        this.me
+            .getCharacteristic(this.homebridge.Characteristic.CurrentDoorState)
+            .updateValue(current);
+        this.me
+            .getCharacteristic(this.homebridge.Characteristic.TargetDoorState)
+            .updateValue(target);
     }
 }
 exports.GarageDoor = GarageDoor;

package/accessories/garagedoor.ts

@@ -14,7 +14,7 @@ import { Accessory } from "./accessory";
 
 
 export class GarageDoor extends Accessory {
-  targetState = this.homebridge.Characteristic.CurrentDoorState.STOPPED;
+  targetState = this.homebridge.Characteristic.TargetDoorState.CLOSED;
 
   constructor(homebridge: API, unit: Unit) {
     super(homebridge, unit);
@@ -56,15 +56,17 @@ export class GarageDoor extends Accessory {
     else if (status == UnitState.kStopped) 
       return this.homebridge.Characteristic.CurrentDoorState.STOPPED;
 
-    else 
-      return this.homebridge.Characteristic.CurrentDoorState.STOPPED;  // ????
+    else {
+      log("accessory", `Unknown Door/UnitState ${status}, defaulting to STOPPED`);
+      return this.homebridge.Characteristic.CurrentDoorState.STOPPED;
+    }
   }
 
   HB2DT(state): UnitMotorCmd | null {
-    if (state == this.homebridge.Characteristic.CurrentDoorState.OPEN)
+    if (state == this.homebridge.Characteristic.TargetDoorState.OPEN)
       return UnitMotorCmd.kOpen;
       
-    else if (state == this.homebridge.Characteristic.CurrentDoorState.CLOSED)
+    else if (state == this.homebridge.Characteristic.TargetDoorState.CLOSED)
       return UnitMotorCmd.kClose;
 
     else if (state == this.homebridge.Characteristic.CurrentDoorState.STOPPED)
@@ -78,7 +80,7 @@ export class GarageDoor extends Accessory {
     try {
       this.unit.reqState(unit => {
         const hb = this.DT2HB(unit.status);
-        log("accessory", "Get TargetDoorState of " + this.name + " = " + unit.status + " -> " + hb);
+        log("accessory", "Get CurrentDoorState of " + this.name + " = " + unit.status + " -> " + hb);
         next(null, hb);
       });
 
@@ -114,9 +116,19 @@ export class GarageDoor extends Accessory {
 
   // in response to Duotecno status messages
   updateState() {
-    const value = this.DT2HB(this.unit.status);
-    log("accessory", "Received updateState -> Homekit GarageDoor for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status + " / " + this.unit.value + " -> passing to HB: " + value);
-    this.me.getCharacteristic(this.homebridge.Characteristic.CurrentDoorState).updateValue(value);
+    const current = this.DT2HB(this.unit.status);
+      const target =
+        current === this.homebridge.Characteristic.CurrentDoorState.OPEN
+          ? this.homebridge.Characteristic.TargetDoorState.OPEN
+          : this.homebridge.Characteristic.TargetDoorState.CLOSED;
+
+    log("accessory", "Received updateState -> Homekit GarageDoor for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.status + " -> passing to HB (current/target): " + current + " / " + target);
+    this.me
+        .getCharacteristic(this.homebridge.Characteristic.CurrentDoorState)
+        .updateValue(current);
+    this.me
+      .getCharacteristic(this.homebridge.Characteristic.TargetDoorState)
+      .updateValue(target);
   }
 
 }

package/accessories/lock.js

@@ -63,9 +63,17 @@ class Lock extends accessory_1.Accessory {
     }
     getCurrent(next) {
         this.unit.reqState(unit => {
-            (0, logger_1.log)("accessory", "HB getting current state of lock = " + this.unit.status + " of " + this.unit.getDescription());
-            next(null, !!this.unit.status);
-        });
+            try {
+                if (!unit) {
+                    return next(new Error("Unit state not available"));
+                }
+                (0, logger_1.log)("accessory", "HB getting current state of lock = " + this.unit.status + " of " + this.unit.getDescription());
+                next(null, !!this.unit.status);
+            }
+            catch (err) {
+                next(err);
+            }
+        }).catch(err => next(err));
     }
     // in response to Duotecno status messages
     updateState() {

package/accessories/lock.ts

@@ -81,9 +81,16 @@ export class Lock extends Accessory {
 
   getCurrent(next) {
     this.unit.reqState(unit => {
-      log("accessory", "HB getting current state of lock = " + this.unit.status + " of " + this.unit.getDescription());
-      next(null, !!this.unit.status);
-    });
+      try {
+        if (!unit) {
+          return next(new Error("Unit state not available"));
+        }
+        log("accessory", "HB getting current state of lock = " + this.unit.status + " of " + this.unit.getDescription());
+        next(null, !!this.unit.status);
+      } catch(err) {
+        next(err);
+      }
+    }).catch(err => next(err));
   }
 
 

package/accessories/temperature.js

@@ -23,8 +23,16 @@ class Temperature extends accessory_1.Accessory {
     getTemperature(next) {
         if (this.unit) {
             this.unit.reqState(unit => {
-                (0, logger_1.log)("accessory", "reqState/getTemperature returned a value for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
-                next(null, unit.value / 10.0);
+                try {
+                    if (!unit) {
+                        return next(new Error("Unit state not available"));
+                    }
+                    (0, logger_1.log)("accessory", "reqState/getTemperature returned a value for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+                    next(null, unit.value / 10.0);
+                }
+                catch (err) {
+                    next(err);
+                }
             })
                 .catch(err => next(err));
         }

package/accessories/temperature.ts

@@ -31,8 +31,15 @@ export class Temperature extends Accessory {
   getTemperature(next) {
     if (this.unit) {
       this.unit.reqState(unit => {
-        log("accessory", "reqState/getTemperature returned a value for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
-        next(null, <number>unit.value / 10.0);
+        try {
+          if (!unit) {
+            return next(new Error("Unit state not available"));
+          }
+          log("accessory", "reqState/getTemperature returned a value for " + this.unit.node.getName() + " - " + this.unit.getName() + " -> " + this.unit.value);
+          next(null, <number>unit.value / 10.0);
+        } catch(err) {
+          next(err);
+        }
       })
       .catch(err => next(err));
     } else {