matterbridge-litetouch 1.0.0

package/dist/litetouchConnection.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Litetouch 2000 serial communication handler.
+ *
+ * Protocol:
+ * - ASCII over RS-232, carriage return (\r) terminated
+ * - Commands start with a space, format: " XX YY-Z VVV"
+ *   - XX: command code (10 = set, 18 = query)
+ *   - YY-Z: module-output address (e.g., "01-1", "07-4")
+ *   - VVV: value (000-001 for relays, 000-250 for dimmers)
+ */
+import { EventEmitter } from 'events';
+export interface LoadStatus {
+    address: string;
+    level: number;
+    raw: number;
+}
+export interface LitetouchConfig {
+    serialPort: string;
+    baudRate: number;
+    pollingInterval: number;
+    commandTimeout: number;
+    debug: boolean;
+}
+export type DeviceType = 'dimmer' | 'switch';
+export declare class LitetouchConnection extends EventEmitter {
+    private port;
+    private parser;
+    private commandQueue;
+    private config;
+    private pollingTimer;
+    private loadAddresses;
+    private deviceTypes;
+    private currentPollingIndex;
+    private pendingResponse;
+    private connected;
+    constructor(config: LitetouchConfig);
+    /**
+     * Set the list of load addresses to poll with their device types
+     */
+    setLoadAddresses(addresses: string[], deviceTypes?: Map<string, DeviceType>): void;
+    /**
+     * Open the serial port and start communication
+     */
+    open(): Promise<void>;
+    /**
+     * Set up the readline parser for CR-terminated messages
+     */
+    private setupParser;
+    /**
+     * Handle incoming response from Litetouch
+     */
+    private handleResponse;
+    /**
+     * Parse a status response from Litetouch
+     * Response format: "18 VVV" where VVV is the level (000-250)
+     * The address must be provided since responses don't include it
+     */
+    private parseStatusResponse;
+    /**
+     * Process a command from the queue - sends it to the serial port
+     */
+    private processCommand;
+    /**
+     * Query the status of a load
+     */
+    queryLoad(address: string): Promise<string | null>;
+    /**
+     * Set a relay on or off
+     */
+    setRelay(address: string, on: boolean): Promise<string | null>;
+    /**
+     * Set a dimmer level (0-100 percentage)
+     */
+    setDimmer(address: string, level: number): Promise<string | null>;
+    /**
+     * Start the polling loop to query load statuses
+     */
+    startPolling(): void;
+    /**
+     * Poll the next load in the list
+     */
+    private pollNextLoad;
+    /**
+     * Stop the polling loop
+     */
+    stopPolling(): void;
+    /**
+     * Close the serial port and clean up
+     */
+    close(): Promise<void>;
+    /**
+     * Check if the connection is open
+     */
+    get isConnected(): boolean;
+    /**
+     * Get the command queue length
+     */
+    get queueLength(): number;
+    private log;
+    private debug;
+}
+//# sourceMappingURL=litetouchConnection.d.ts.map

package/dist/litetouchConnection.js

@@ -0,0 +1,284 @@
+/**
+ * Litetouch 2000 serial communication handler.
+ *
+ * Protocol:
+ * - ASCII over RS-232, carriage return (\r) terminated
+ * - Commands start with a space, format: " XX YY-Z VVV"
+ *   - XX: command code (10 = set, 18 = query)
+ *   - YY-Z: module-output address (e.g., "01-1", "07-4")
+ *   - VVV: value (000-001 for relays, 000-250 for dimmers)
+ */
+import { SerialPort } from 'serialport';
+import { ReadlineParser } from '@serialport/parser-readline';
+import { EventEmitter } from 'events';
+import { CommandQueue } from './commandQueue.js';
+export class LitetouchConnection extends EventEmitter {
+    port = null;
+    parser = null;
+    commandQueue;
+    config;
+    pollingTimer = null;
+    loadAddresses = [];
+    deviceTypes = new Map();
+    currentPollingIndex = 0;
+    pendingResponse = null;
+    connected = false;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.commandQueue = new CommandQueue();
+        this.commandQueue.setProcessor(this.processCommand.bind(this));
+    }
+    /**
+     * Set the list of load addresses to poll with their device types
+     */
+    setLoadAddresses(addresses, deviceTypes) {
+        this.loadAddresses = addresses;
+        if (deviceTypes) {
+            this.deviceTypes = deviceTypes;
+        }
+        this.currentPollingIndex = 0;
+    }
+    /**
+     * Open the serial port and start communication
+     */
+    async open() {
+        if (this.port?.isOpen) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.port = new SerialPort({
+                path: this.config.serialPort,
+                baudRate: this.config.baudRate,
+                dataBits: 8,
+                stopBits: 1,
+                parity: 'none',
+            }, (err) => {
+                if (err) {
+                    this.log(`Failed to open serial port: ${err.message}`);
+                    reject(err);
+                    return;
+                }
+                this.log(`Serial port opened: ${this.config.serialPort}`);
+                this.setupParser();
+                this.connected = true;
+                this.emit('connected');
+                resolve();
+            });
+            this.port.on('error', (err) => {
+                this.log(`Serial port error: ${err.message}`);
+                this.stopPolling();
+                this.commandQueue.clear();
+                this.emit('error', err);
+            });
+            this.port.on('close', () => {
+                this.log('Serial port closed');
+                this.connected = false;
+                this.stopPolling();
+                this.commandQueue.clear();
+                this.emit('disconnected');
+            });
+        });
+    }
+    /**
+     * Set up the readline parser for CR-terminated messages
+     */
+    setupParser() {
+        if (!this.port)
+            return;
+        this.parser = this.port.pipe(new ReadlineParser({ delimiter: '\r' }));
+        this.parser.on('data', (data) => {
+            this.handleResponse(data);
+        });
+    }
+    /**
+     * Handle incoming response from Litetouch
+     */
+    handleResponse(data) {
+        const trimmed = data.trim();
+        this.debug(`Received: "${trimmed}"`);
+        // Capture pending address before clearing pendingResponse
+        const pendingAddress = this.pendingResponse?.address;
+        if (this.pendingResponse) {
+            clearTimeout(this.pendingResponse.timeout);
+            this.pendingResponse.resolve(trimmed);
+            this.pendingResponse = null;
+        }
+        // Parse and emit status updates (pass the pending address for correlation)
+        const status = this.parseStatusResponse(trimmed, pendingAddress);
+        if (status) {
+            this.emit('loadStatus', status);
+        }
+    }
+    /**
+     * Parse a status response from Litetouch
+     * Response format: "18 VVV" where VVV is the level (000-250)
+     * The address must be provided since responses don't include it
+     */
+    parseStatusResponse(response, address) {
+        // Match response pattern: 18 VVV (command code echo followed by value)
+        const match = response.match(/^18\s+(\d{3})$/);
+        if (!match || !address) {
+            return null;
+        }
+        const raw = parseInt(match[1], 10);
+        const deviceType = this.deviceTypes.get(address);
+        // Convert raw value to percentage based on device type
+        // Dimmers: 0-250 maps linearly to 0-100%
+        // Switches: 0 = off, 1-250 = on (any non-zero value means on)
+        let level;
+        if (deviceType === 'switch') {
+            level = raw > 0 ? 100 : 0;
+        }
+        else {
+            // Default to dimmer behavior (linear 0-250 -> 0-100)
+            level = Math.round((raw / 250) * 100);
+        }
+        return { address, level, raw };
+    }
+    /**
+     * Process a command from the queue - sends it to the serial port
+     */
+    async processCommand(cmd) {
+        if (!this.port?.isOpen) {
+            throw new Error('Serial port not open');
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutMs = this.config.commandTimeout;
+            // Extract address from query commands (format: " 18 MM-O")
+            let address;
+            const queryMatch = cmd.command.match(/^\s*18\s+(\d{1,2}-\d{1,2})/);
+            if (queryMatch) {
+                address = queryMatch[1];
+            }
+            // Set up timeout for response
+            const timeout = setTimeout(() => {
+                this.pendingResponse = null;
+                this.debug(`Command timeout: "${cmd.command}"`);
+                resolve(null); // Resolve with null on timeout instead of rejecting
+            }, timeoutMs);
+            this.pendingResponse = { resolve, reject, timeout, address };
+            // Send command with carriage return terminator
+            const fullCommand = `${cmd.command}\r`;
+            this.debug(`Sending: "${cmd.command}"`);
+            this.port.write(fullCommand, (err) => {
+                if (err) {
+                    clearTimeout(timeout);
+                    this.pendingResponse = null;
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * Query the status of a load
+     */
+    async queryLoad(address) {
+        const command = ` 18 ${address}`;
+        return this.commandQueue.enqueuePolling(command);
+    }
+    /**
+     * Set a relay on or off
+     */
+    async setRelay(address, on) {
+        const value = on ? '001' : '000';
+        const command = ` 10 ${address} ${value}`;
+        return this.commandQueue.enqueueHighPriority(command);
+    }
+    /**
+     * Set a dimmer level (0-100 percentage)
+     */
+    async setDimmer(address, level) {
+        // Clamp to 0-100 and convert to 0-250 range
+        const clampedLevel = Math.max(0, Math.min(100, level));
+        const rawValue = Math.round((clampedLevel / 100) * 250);
+        const value = rawValue.toString().padStart(3, '0');
+        const command = ` 10 ${address} ${value}`;
+        return this.commandQueue.enqueueHighPriority(command);
+    }
+    /**
+     * Start the polling loop to query load statuses
+     */
+    startPolling() {
+        if (this.pollingTimer) {
+            return;
+        }
+        this.log(`Starting polling loop (${this.loadAddresses.length} loads, ${this.config.pollingInterval}ms interval)`);
+        this.pollNextLoad();
+    }
+    /**
+     * Poll the next load in the list
+     */
+    pollNextLoad() {
+        if (this.loadAddresses.length === 0) {
+            // No loads to poll, check again later
+            this.pollingTimer = setTimeout(() => this.pollNextLoad(), this.config.pollingInterval);
+            return;
+        }
+        const address = this.loadAddresses[this.currentPollingIndex];
+        this.currentPollingIndex = (this.currentPollingIndex + 1) % this.loadAddresses.length;
+        this.queryLoad(address).catch((err) => {
+            this.debug(`Polling error for ${address}: ${err.message}`);
+        });
+        // Schedule next poll
+        this.pollingTimer = setTimeout(() => this.pollNextLoad(), this.config.pollingInterval);
+    }
+    /**
+     * Stop the polling loop
+     */
+    stopPolling() {
+        if (this.pollingTimer) {
+            clearTimeout(this.pollingTimer);
+            this.pollingTimer = null;
+            this.log('Polling stopped');
+        }
+    }
+    /**
+     * Close the serial port and clean up
+     */
+    async close() {
+        this.stopPolling();
+        this.commandQueue.clear();
+        if (this.pendingResponse) {
+            clearTimeout(this.pendingResponse.timeout);
+            this.pendingResponse.reject(new Error('Connection closing'));
+            this.pendingResponse = null;
+        }
+        if (this.port?.isOpen) {
+            return new Promise((resolve) => {
+                this.port.close((err) => {
+                    if (err) {
+                        this.log(`Error closing port: ${err.message}`);
+                    }
+                    this.port = null;
+                    this.parser = null;
+                    this.connected = false;
+                    resolve();
+                });
+            });
+        }
+        this.port = null;
+        this.parser = null;
+    }
+    /**
+     * Check if the connection is open
+     */
+    get isConnected() {
+        return this.connected && !!this.port?.isOpen;
+    }
+    /**
+     * Get the command queue length
+     */
+    get queueLength() {
+        return this.commandQueue.length;
+    }
+    log(message) {
+        console.log(`[Litetouch] ${message}`);
+    }
+    debug(message) {
+        if (this.config.debug) {
+            console.log(`[Litetouch:Debug] ${message}`);
+        }
+    }
+}
+//# sourceMappingURL=litetouchConnection.js.map

package/dist/platform.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Matterbridge Dynamic Platform for Litetouch 2000 Lighting System
+ *
+ * Creates Matter devices for each configured dimmer and switch load,
+ * handles commands from Matter controllers, and polls for status updates.
+ */
+import { MatterbridgeDynamicPlatform, PlatformConfig, PlatformMatterbridge } from 'matterbridge';
+import { AnsiLogger } from 'matterbridge/logger';
+export declare class LitetouchPlatform extends MatterbridgeDynamicPlatform {
+    private connection;
+    private devices;
+    private deviceTypes;
+    private lastDimmerLevels;
+    private pendingOnTimers;
+    constructor(matterbridge: PlatformMatterbridge, log: AnsiLogger, config: PlatformConfig);
+    onStart(reason?: string): Promise<void>;
+    /**
+     * Create Matter devices for all configured loads
+     */
+    private createDevices;
+    /**
+     * Create a dimmable light device
+     */
+    private createDimmerDevice;
+    /**
+     * Create an on/off switch device
+     */
+    private createSwitchDevice;
+    /**
+     * Set dimmer level via serial
+     */
+    private setDimmerLevel;
+    /**
+     * Set switch state via serial
+     */
+    private setSwitch;
+    /**
+     * Handle status updates from polling
+     */
+    private handleLoadStatus;
+    onConfigure(): Promise<void>;
+    onShutdown(reason?: string): Promise<void>;
+}
+//# sourceMappingURL=platform.d.ts.map