@evops/lightwaverf 0.0.5 → 0.0.9

package/src/LightwaveRFClient.ts

@@ -0,0 +1,236 @@
+import dgram from 'dgram';
+import events from 'events';
+import Debug, { Debugger } from 'debug';
+import LightwaveMessageProcessor from './LightwaveMessageProcessor';
+import LightwaveTextMessageProcessor from './LightwaveTextMessageProcessor';
+import { LightwaveJsonMessageProcessor } from './LightwaveJsonMessageProcessor';
+import { LightwaveTransaction } from './LightwaveTransaction';
+import { Queue } from './Queue';
+
+declare interface LightwaveRFClientInterface {
+  on(event: 'ready', listener: (client: LightwaveRFClient) => void): this;
+  on(event: 'deviceTurnedOn', listener: (room: number, device: number) => void): this;
+  on(event: 'deviceTurnedOff', listener: (room: number, device: number) => void): this;
+  on(event: 'deviceDimmed', listener: (room: number, device: number, dimPercentage: number) => void): this;
+}
+
+export class LightwaveRFClient extends events.EventEmitter implements LightwaveRFClientInterface {
+  private senderSocket: dgram.Socket;
+  private receiverSocket: dgram.Socket;
+
+  private senderSocketReady: boolean = false;
+  private receiverSocketReady: boolean = false;
+
+  private commandQueue: Queue<LightwaveTransaction> = new Queue<LightwaveTransaction>();
+
+  private messageProcessors: LightwaveMessageProcessor[] = [];
+
+  private debug: Debug.Debugger;
+  private ip: string;
+  private transactionListeners: Map<number, any> = new Map();
+  delay: number = 125;
+
+  constructor(debug: Debugger, ip: string = "255.255.255.255", port: number = 9761) {
+    super();
+
+    this.ip = ip;
+    this.debug = debug.extend('client');
+    this.senderSocket = dgram.createSocket('udp4');
+    this.receiverSocket = dgram.createSocket('udp4');
+
+    this.messageProcessors.push(new LightwaveJsonMessageProcessor(this.debug));
+    this.messageProcessors.push(new LightwaveTextMessageProcessor(this.debug));
+
+    this.receiverSocket.on('message', (buffer: Buffer) => {
+      this.debug("RAW: %o", buffer.toString('utf-8'));
+    });
+    this.receiverSocket.on('message', this.processRawMessage.bind(this));
+
+    this.receiverSocket.once('listening', () => {
+      this.debug("Receiver socket bound", this.receiverSocket.address());
+      this.receiverSocketReady = true
+    });
+    this.receiverSocket.once('listening', this.socketReady.bind(this));
+
+    this.senderSocket.once('listening', () => {
+      this.debug("Sender socket bound", this.senderSocket.address());
+      this.senderSocketReady = true
+    });
+    this.senderSocket.once('listening', this.socketReady.bind(this));
+
+    this.senderSocket.unref();
+
+    this.senderSocket.bind();
+
+    this.debug("Binding receiver socket on address %s and port %d", ip, port);
+    this.receiverSocket.bind(port);
+
+    this.receiverSocket.on('error', () => {
+      throw new Error("Error binding receiver socket");
+    })
+
+    process.on('SIGINT', () => {
+      this.debug("\nClosing sockets");
+      this.stop();
+      process.exit();
+    })
+  }
+
+  public stop() {
+    try {
+      this.receiverSocket.close();
+    } catch { }
+  }
+
+  private socketReady() {
+    if (!this.senderSocketReady) return;
+    if (!this.receiverSocketReady) return;
+
+    this.checkRegistration();
+    this.processQueue();
+  }
+
+  private checkRegistration() {
+    this.debug("Checking registration");
+    this.send("@H", (transaction: LightwaveTransaction | null, error: Error) => {
+      if (error) {
+        this.debug('Error: %o', error);
+      }
+
+      this.debug(transaction);
+      this.emit('ready');
+    });
+  }
+
+  public send(message: (string | Buffer), callback: (transaction: LightwaveTransaction | null, error: Error) => void) {
+    const transaction = Math.round(Math.random() * Math.pow(10, 8));
+    const messageWithTransaction = `${transaction},!${message}`;
+    const transactionDebug = this.debug.extend("transaction:" + transaction);
+
+    this.transactionListeners.set(transaction, {
+      message: message,
+      debug: transactionDebug,
+      delay: this.delay,
+      callback: callback
+    })
+
+    this.debug("Queueing message: %s", messageWithTransaction);
+
+    this.commandQueue.add(<LightwaveTransaction>{
+      id: transaction,
+      message: messageWithTransaction,
+      debug: transactionDebug,
+      callback
+    });
+
+    this.processQueue();
+  }
+
+  private async processQueue() {
+    if (this.commandQueue.busy) {
+      setTimeout(this.processQueue.bind(this), this.delay);
+      return
+    };
+
+    const command = this.commandQueue.receive();
+    if (!command) return;
+
+    this.commandQueue.busy = true;
+    const transactionListener = this.transactionListeners.get(command.id);
+    const originalCallback = transactionListener.callback;
+
+    transactionListener.callback = (transaction: LightwaveTransaction, error: Error) => {
+      this.commandQueue.busy = false;
+      setTimeout(this.processQueue.bind(this), this.delay);
+      originalCallback(transaction, error);
+    }
+
+    setTimeout(() => {
+      const listener = this.transactionListeners.get(command.id);
+      if (!listener) return;
+
+      originalCallback(null, new Error("Execution expired"));
+      this.transactionListeners.delete(command.id);
+      this.processQueue();
+    }, 5000)
+
+
+    const transactionDebug = this.debug.extend(`transaction:${command?.id}`);
+    transactionDebug("Starting new transaction");
+    this.exec(command!.message, (message: LightwaveTransaction | null, error: Error) => { });
+  }
+
+  private exec(message: (Buffer | string | undefined), callback: (message: LightwaveTransaction | null, error: Error) => void) {
+    if (message === undefined) return;
+
+    this.debug("Sending message: %s to %s on port %d", message, this.ip, 9760);
+    this.senderSocket.setBroadcast(this.ip === "255.255.255.255");
+    this.senderSocket.send(message, 9760, this.ip, (error: Error | null, bytes: number) => {
+      if (error) {
+        this.debug("Message send errror: %o", error);
+      }
+      this.debug("Message sent: %s, length: %d", message, bytes);
+    })
+  }
+
+  private processRawMessage(message: Buffer, remoteInfo: dgram.RemoteInfo) {
+    this.debug("Message has come through from %o", remoteInfo);
+    this.debug("Message received: %o", message.toString('ascii'));
+
+    for (const messageProcessor of this.messageProcessors) {
+      if (messageProcessor.canProcess(message)) {
+        this.debug("Message can be processed by %s", messageProcessor.constructor.name);
+        const lightwaveMessage = messageProcessor.process(message);
+        this.processLightwaveMessage(lightwaveMessage);
+        return;
+      }
+    }
+
+    throw "Message cannot be processed";
+  }
+
+  processLightwaveMessage(lightwaveMessage: any) {
+    this.debug("Processing lightwave message: %o", lightwaveMessage);
+    this.debug("Current listeners: %o", this.transactionListeners);
+
+    this.debug("Link response fn", lightwaveMessage.fn)
+    if (lightwaveMessage.fn === "on") {
+      this.emit("deviceTurnedOn", lightwaveMessage.room, lightwaveMessage.dev);
+    }
+
+    if (lightwaveMessage.fn === "off") {
+      this.emit("deviceTurnedOff", lightwaveMessage.room, lightwaveMessage.dev);
+    }
+
+    if (lightwaveMessage.fn === "dim") {
+      this.emit("deviceDimmed", lightwaveMessage.room, lightwaveMessage.dev, Math.round(lightwaveMessage.param / 32 * 100));
+    }
+
+    const listener = this.transactionListeners.get(lightwaveMessage.id);
+    if (!listener) return;
+
+
+    if (lightwaveMessage.error?.match(/^ERR,6,/)) {
+      listener.delay = listener.delay * 2;
+      const msg = `${lightwaveMessage.id},!${listener.message}`
+      this.debug("message errorred, retrying: %o, %o with delay: %o", msg, listener, listener.delay);
+      setTimeout(() => {
+        this.exec(msg, (message: LightwaveTransaction | null, error: Error) => {
+          this.debug("message: %o, error: %o", message, error)
+        });
+      }, Math.round(listener.delay));
+      return;
+    }
+
+    if (listener) {
+      listener.debug("Found transaction listener");
+      listener.callback(lightwaveMessage, null);
+      listener.debug("Transaction completed, removing listener");
+      this.transactionListeners.delete(lightwaveMessage.id);
+      this.commandQueue.busy = false;
+    } else {
+      this.debug("Listener not found for message: %o", lightwaveMessage)
+    }
+
+  }
+}

package/src/LightwaveTextMessageProcessor.ts

@@ -0,0 +1,30 @@
+import { Debugger } from "debug";
+import "./LightwaveTransaction";
+import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
+
+export default class LightwaveTextMessageProcessor implements LightwaveMessageProcessor {
+  debug: Debugger;
+  constructor(debug: Debugger) {
+    this.debug = debug.extend('textMessageProcessor');
+  }
+
+  process(message: Buffer): any {
+    this.debug('Processing message')
+    const textMessage = message.toString('utf-8');
+    var parts = textMessage.split(",");
+    var trans = parts.splice(0, 1);
+    var content = parts.join(",").replace(/(\r\n|\n|\r)/gm, "");
+
+    const response: any = {};
+    response.id = parseInt(trans[0]);
+    response.message = content;
+    response.error = content.match("^ERR") ? content : null;
+    return response;
+  }
+
+  canProcess(message: Buffer): boolean {
+    this.debug("Checking if can process message");
+    return message.toString('utf-8').endsWith("\n");
+  }
+
+}

package/src/LightwaveTransaction.ts

@@ -0,0 +1,9 @@
+import debug from 'debug';
+
+export declare interface LightwaveTransaction {
+  id: number;
+  message: string;
+  error: any;
+  debug: debug.Debugger,
+  callback: (message: LightwaveTransaction, error: Error) => void
+}

package/src/Queue.ts

@@ -0,0 +1,17 @@
+export class Queue<T> {
+  items: T[] = [];
+  busy = false;
+
+  get length(): number {
+    return this.items.length;
+  }
+
+  add(item: T) {
+    this.items.push(item);
+  }
+
+  receive(): T | undefined {
+    return this.items.shift();
+  }
+
+}

package/src/index.ts

@@ -0,0 +1,332 @@
+import { EventEmitter } from 'events';
+import Debug from 'debug';
+import { LightwaveRFClient } from './LightwaveRFClient';
+import { LightwaveAccount } from './LightwaveAccount';
+import { LightwaveDevice } from './LightwaveDevice';
+
+
+class LightwaveRFConfiguration {
+    timeout?: number = 1000;
+    ip?: string;
+    file?: any;
+    host?: any;
+    email?: any;
+    pin?: any;
+}
+
+declare interface ILightwaveRF {
+    on(event: 'deviceTurnedOn', listener: (roomId: number, deviceId: number) => void): this;
+    on(event: 'deviceTurnedOff', listener: (roomId: number, deviceId: number) => void): this;
+    on(event: 'deviceDimmed', listener: (roomId: number, deviceId: number, percentage: number) => void): this;
+}
+
+/** * LightwaveRF API
+ *
+ * @param object config The config
+ *
+ * An instance of the LightwaveRF API
+ */
+export default class LightwaveRF extends EventEmitter implements ILightwaveRF {
+    timeout: number = 1000;
+    queue: any = [];
+    ready = true;
+    awaitRegistrration = false;
+    currentTransactionNumber: number = 4674773;
+    devices: Array<LightwaveDevice> = [];
+    messageCounter = 0;
+    config: LightwaveRFConfiguration = {};
+    responseListeners = new Map<number, any>();
+    lwClient: LightwaveRFClient;
+    debug: Debug.Debugger;
+
+    constructor(config: LightwaveRFConfiguration, callback: (config: any, error: any) => void) {
+        super();
+        this.debug = Debug('lightwaverf');
+
+        this.debug('Initialising LightwaveRF Client')
+        this.lwClient = new LightwaveRFClient(this.debug, config.ip)
+        this.lwClient.on('ready', () => {
+            this.debug('LightwaveRF ready');
+            this.initialiseConfiguration(callback);
+        })
+
+        this.timeout = config.timeout || 1000;
+
+        this.devices = [];//[{roomId:0,roomName:'',
+        //deviceId:0,deviceName:'',
+        //deviceType:''}];
+
+        //Config
+        this.config = config;
+
+        const self = this;
+
+        this.lwClient.on('deviceTurnedOn', function () {
+            self.emit('deviceTurnedOn', ...arguments);
+        })
+        this.lwClient.on('deviceTurnedOff', function () {
+            self.emit('deviceTurnedOff', ...arguments);
+        })
+        this.lwClient.on('deviceDimmed', function () {
+            self.emit('deviceDimmed', ...arguments);
+        })
+
+        //Receive message
+        // this.receiveSocket.on("message", function (message: Buffer, rinfo: dgram.RemoteInfo) {
+        //     // If we were using broadcast IP, we have now
+        //     // discovered Link device IP and can switch off
+        //     // broadcast
+        //     if (self.config.ip == '255.255.255.255') {
+        //         console.log("We have now discovered Link IP address: %s", rinfo.address);
+        //         self.config.ip = rinfo.address
+        //         self.sendSocket.setBroadcast(false)
+        //     }
+
+        //     //Check this came from the lightwave unit
+        //     if (rinfo.address !== self.config.ip) {
+        //         //Came from wrong ip]
+        //         console.warn("Response came from a different IP than our configured", rinfo.address, self.config.ip)
+        //         return false;
+        //     }
+
+        //     const parseResponse = (buffer: Buffer) => {
+        //         const response: any = new Object();
+        //         const message = buffer.toString('utf-8');
+        //         if (message.match(/^\*!/)) {
+        //             const jsonResponse = JSON.parse(message.replace(/^\*!/, ''))
+        //             self.currentTransactionNumber = jsonResponse.trans + 1;
+        //             Object.assign(response, jsonResponse)
+
+        //             response.error = response.pkt === "error" ? response.fn : null;
+        //         } else {
+        //             //Split off the code for the message
+        //             var parts = message.split(",");
+        //             var trans = parts.splice(0, 1);
+        //             var content = parts.join(",").replace(/(\r\n|\n|\r)/gm, "");
+        //             response.trans = parseInt(trans[0]);
+        //             response.message = content;
+        //             response.error = content.match("^ERR") ? content : null;
+        //         }
+
+        //         response.trans = response.trans !== null ? parseInt(response.trans) : null;
+
+        //         return response;
+        //     }
+
+        //     let linkResponse = parseResponse(message)
+        //     debug(">>>>>>>> Received response msg: %s, response: %s, rinfo: %s", message, linkResponse, rinfo);
+        //     if (linkResponse.error === "nonRegistered" && !self.awaitRegistrration) {
+        //         console.warn("Your device is not registered, please accept registration on the Link devices")
+        //         self.register(() => { });
+        //     }
+
+        //     if (linkResponse.msg === "success" && linkResponse.pairType) {
+        //         self.awaitRegistrration = false;
+        //     }
+
+
+
+        //     debug(self.responseListeners);
+        //     var responseListenerData = self.responseListeners.get(linkResponse.trans);
+        //     if (!responseListenerData) {
+        //         debug("We haven't got anyone to respond to, ignoring the message")
+        //         return;
+        //     }
+
+        //     debug(`[Transaction: ${linkResponse.trans}] Processing time: ${new Date().getTime() - responseListenerData.time}`)
+
+        //     responseListenerData.listener(
+        //         linkResponse.error,
+        //         linkResponse.fn,
+        //     );
+
+        //     self.responseListeners.delete(linkResponse.trans);
+        // });
+
+        // this.receiveSocket.on("listening", function () {
+        //     var address = self.receiveSocket.address();
+        //     debug("Receiver socket listening " + address.address + ":" + address.port);
+
+        //     self.send('@H', (code, err) => {
+        //         if (err) {
+        //             console.log('code', code, 'error', err)
+        //             return
+        //         }
+
+        //         self.initialiseConfiguration(callback);
+        //     })
+        // });
+
+        // this.sendSocket.bind();
+
+        // this.sendSocket.on('listening', () => {
+        //     debug("Send socket is ready")
+        //     debug("Setting up receiver socket")
+        //     //Bind to the receive port
+        //     self.receiveSocket.bind(9761);
+        // })
+
+
+        process.on('SIGINT', () => {
+            this.stop();
+            this.lwClient.stop();
+        })
+    }
+
+    stop() {
+        this.debug("Stopping server sockets")
+    }
+
+    initialiseConfiguration(callback: (config: any, error: string) => void) {
+        //Check config
+        const lwAccount = new LightwaveAccount(this.debug, this.lwClient, this.config.email, this.config.pin)
+        lwAccount.getConfiguration(callback)
+    }
+
+
+    /**
+     * Register this device with the Wi-Fi Link
+     *
+     * @param Function callback The callback function
+     *
+     * @return void
+     */
+    register(callback: any) {
+        this.awaitRegistrration = true;
+        this.sendUdp("!F*p", callback);
+    }
+
+    /**
+     * Turn a device off
+     *
+     * @param integer  roomId   The room ID
+     * @param integer  deviceId The device ID
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    turnDeviceOff(roomId: number, deviceId: number, callback?: any) {
+        var state = "0";
+        this.exec("!R" + roomId + "D" + deviceId + "F" + state + "|\0", callback);
+    }
+
+    /**
+     * Turn a device on
+     * 
+     * @param integer  roomId   The room ID
+     * @param integer  deviceId The device ID
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    turnDeviceOn(roomId: number, deviceId: number, callback?: any) {
+        // this.devices.find(d => d.roomId == roomId && d.deviceId == deviceId)?.turnOn();
+    }
+    /**
+     * Set the dim percentage of a device
+     *
+     * @param integer  roomId        The room ID
+     * @param integer  deviceId      The device ID
+     * @param integer  dimPercentage The percentage to set the device dim
+     * @param Function callback      The callback for if there are any errors
+     *
+     * @return void
+     */
+    setDeviceDim(roomId: string, deviceId: string, dimPercentage: number, callback: any) {
+        // var dimAmount = dimPercentage * 0.32; //Dim is on a scale from 0 to 32
+
+        // if (dimAmount === 0) {
+        //     this.turnDeviceOff(roomId, deviceId, callback);
+        // } else {
+        //     this.exec("!R" + roomId + "D" + deviceId + "FdP" + dimAmount + "|\0", callback);
+        // }
+    }
+
+    /**
+     * Get message code
+     *
+     * @return string
+     */
+    private getTransactionNumber(): number {
+        return this.currentTransactionNumber;
+    }
+
+
+    private exec(...args: any[]) {
+        // Check if the queue has a reasonable size
+        if (this.queue.length > 100) {
+            this.queue.pop();
+        }
+
+        this.debug("Ading to queue: " + args.join(" "));
+        this.queue.push(args);
+        this.process();
+    };
+
+    private send(cmd: string, callback: (code: any, err: any) => void) {
+        this.sendUdp(cmd, callback);
+        //if (callback) callback();
+    };
+    /**
+     * Send a message over udp
+     *
+     * @param string   message  The message to send
+     * @param Function callback The callback for if there are any errors
+     *
+     * @return void
+     */
+    private sendUdp(message: string, callback: any) {
+        //Add to message
+        const transactionNumber = this.getTransactionNumber();
+        //Prepend code to message
+        message = `${transactionNumber},${message}`;
+
+        this.debug(`[${this.config.ip}][trans: ${transactionNumber}] Sending message: ${message}`);
+
+        //Create buffer from message
+        const messageBuffer = Buffer.from(message, 'utf-8');
+
+        this.debug("Callback for message: " + message, callback);
+        //Add listener
+        if (callback) {
+            this.debug("Registering call back with transaction number: " + transactionNumber);
+            this.responseListeners.set(transactionNumber, {
+                time: new Date().getTime(),
+                listener: callback
+            });
+
+            this.debug(this.responseListeners)
+
+            // Expire request, trigger retry
+            setTimeout(() => {
+                const listener = this.responseListeners.get(transactionNumber);
+                if (listener) {
+                    this.debug(`[Transaction $(transactionNumber)] The listener is still there, triggering error`);
+                    this.responseListeners.delete(transactionNumber);
+                    callback("ERR:EXPIRED", undefined);
+                }
+            }, 1000);
+        }
+
+        //Broadcast the message
+        // this.sendSocket.send(messageBuffer, 0, messageBuffer.length, 9760, this.config.ip);
+    }
+
+    private process() {
+        this.debug("Checking queue")
+        if (this.queue.length === 0) return;
+        if (!this.ready) return;
+        var self = this;
+        this.ready = false;
+        this.debug("Processing queue...");
+        this.debug("Items in the queue", this.queue.length);
+        this.send.apply(this, this.queue.shift());
+        setTimeout(function () {
+            self.ready = true;
+            self.process();
+        }, this.timeout);
+    };
+
+
+
+}

package/bin/lightwaverf.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-
-const LightwaveRF = require('..');
-
-require('../index');
-
-new LightwaveRF({
-  ip: '255.255.255.255',
-  email: 'stan@wozniak.com',
-  pin: 2212
-}, (devices, lr) => {
-  console.log("Welcome to LightwaveRF V1")
-  lr.turnDeviceOn(1, 1, handleResponse)
-  setTimeout(() => {
-
-    lr.turnDeviceOff(1, 1, handleResponse)
-  }, 1111)
-});
-
-function handleResponse(stringResponse, jsonResponse, err) {
-  if (err) {
-    console.log("We could not turn the device on!", stringResponse, jsonResponse, err)
-    return
-  }
-
-  console.log("Lamp is on!", stringResponse, jsonResponse)
-}