Ran npm install

* added setCircuitRuntimeById function

.github/workflows/nodejs.yml

@@ -0,0 +1,29 @@
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - run: npm ci
+    - run: npm run build --if-present
+    - run: npm run pretest

.vscode/launch.json

@@ -7,8 +7,11 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Launch Program",
-            "program": "${workspaceFolder}\\example.js"
+            "name": "Example",
+            "program": "${workspaceFolder}/example.js",
+            "skipFiles": [
+                "<node_internals>/**"
+            ]
         }
     ]
 }

CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v1.5.0 - 2020-06-06
+### Added
+* Added support for adding, deleting, listing, and updating scheduled events
+* Added egg timer support
+
+## v1.4.0 - 2020-05-25
+### Added
+* Support for controlling the salt cell generator's output levels.
+* Helper methods for interpreting `controllerType`.
+* Experimental support for an Equipment Configuration message (not documented as of yet - `SLEquipmentConfigurationMessage` / `getEquipmentConfiguration()`). This message returns arrays of various information about the equipment, but I don't know how to interpret the information in those arrays yet. Any assistance with decoding this information would be hugely helpful.
+* `error` handler on all objects for reacting to unhandled node errors.
+
+### Fixed
+* VSCode "Example" configuration can now be launched on non-Windows platforms.
+
+### Changed
+* Minor memory/performance optimizations.
+* Running tests no longer changes any state of any pool equipment.
+
+## v1.3.1 - 2019-12-27
+### Added
+* Several methods added to SLControllerConfigMessage for interpreting the equipFlags value.
+
+### Fixed
+* server.gatewayName no longer cuts off the last character of the name. #14 - thanks @mikemucc
+
 ## v1.3.0 - 2019-11-26
 ### Added
 * Ability to set heat setpoint.

README.md

@@ -99,6 +99,8 @@ finder.on('serverFound', function(server) {
 })
 ```
 
+* `error` - Indicates that an unhandled error was caught (such as the connection timing out)
+
 ## RemoteLogin
 
 ### constructor(systemName)
@@ -123,6 +125,7 @@ Closes the connection
 ### Events
 
 * `gatewayFound` - Indicates that the search for the named unit has completed (may or may not be successful). Event handler receives a [`SLGetGatewayDataMessage`](#slgetgatewaydatamessage) argument.
+* `error` - Indicates that an unhandled error was caught (such as the connection timing out)
 
 ## UnitConnection
 
@@ -206,6 +209,10 @@ Sends a lighting command. See [`SLLightControlMessage`](#sllightcontrolmessage)
 
 Note that better/more complete handling of lighting is desired, but I have yet to find all the commands I need to implement to make that happen. This currently sends each command to all lights and there is no ability to send to an individual light. Pull requests adding more functionality here would be most welcome.
 
+### setSaltCellOutput(controllerId, poolOutput, spaOutput)
+
+Sets the salt cell's output levels. See [`SLSetSaltCellConfigMessage`](#slsetsaltcellconfigmessage) documentation for argument values. Emits the `setSaltCellConfig` event when response is acknowledged.
+
 ### Events
 
 * `loggedIn` - Indicates that a connection to the server has been established and the login process completed. `get` methods can be called once this event has been emitted.
@@ -216,9 +223,17 @@ Note that better/more complete handling of lighting is desired, but I have yet t
 * `controllerConfig` - Indicates that a response to `getControllerConfig()` has been received. Event handler receives a [`SLControllerConfigMessage`](#slcontrollerconfigmessage) object.
 * `circuitStateChanged` - Indicates that a response to `setCircuitState()` has been received. Event handler receives a [`SLSetCircuitStateMessage`](#slsetcircuitstatemessage) object.
 * `setPointChanged` - Indicates that a response to `setSetPoint()` has been received. Event handler receives a [`SLSetHeatSetPointMessage`](#slsetheatsetpointmessage) object.
+* `heatModeChanged` - Indicates that a response to `setHeatMode()` has been received. Event handler receives a [`SLSetHeatModeMessage`](#slsetheatmodemessage) object.
 * `sentLightCommand` - Indicates that a response to `sendLightCommand()` has been received. Event handler receives a [`SLLightControlMessage`](#sllightcontrolmessage) object.
+* `setSaltCellConfig` - Indicates that a response to `setSaltCellOutput()` has been received. Event handler receives a [`SLSetSaltCellConfigMessage`](#slsetsaltcellconfigmessage) object.
 * `loginFailed` - Indicates that a remote login attempt via supplying a system address and password to `UnitConnection` has failed likely due to the incorrect password being used.
 * `badParameter` - Indicates that a bad parameter has been supplied to a function. This can be triggered, for example, by sending the wrong controller ID to a `set` function.
+* `error` - Indicates that an unhandled error was caught (such as the connection timing out)
+* `addNewScheduleEvent` - will return a [`SLAddNewScheduleEvent`](#sladdnewscheduleevent) object. which contains the created `scheduleId` to be used later for setting up the properties
+* `deleteScheduleById` - Indicates a response to the `deleteScheduleById()` command has been received.
+* `getScheduleData` - will return a [`SLGetScheduleData`](#slgetscheduledata) object. which contains a list of events of the specified type
+* `setScheduleEventById` - Indicates a response to the `setScheduleEventById()` command has been received.
+* `setCircuitRuntimeById` - Indicates a response to the `setCircuitRuntimeById()` command has been received.
 
 ### Properties
 
@@ -320,17 +335,48 @@ Passed as an argument to the emitted `saltCellConfig` event handler.
 ### Properties
 
 * `installed` - boolean indicating whether a salt cell is installed or not
-* `status` - integer
-* `level1` - integer
-* `level2` - integer
+* `status` - integer bitmask
+* `level1` - integer indicating the output level of the salt cell for the pool. I believe this operates on a 0-100 scale
+* `level2` - integer indicating the output level of the salt cell for the spa. I believe this operates on a 0-100 scale
 * `salt` - integer indicating salt level in parts-per-million
-* `flags` - integer
+* `flags` - integer bitmask
 * `superChlorTimer` - integer
 
+## SLSetSaltCellConfigMessage
+
+Passed as an argument to the emitted `setSaltCellConfig` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the set command.
+
+### Properties
+
+* `controllerId` - integer indicating the ID of the controller to send this command to.
+  * Note that while `SLControllerConfigMessage` includes a controllerId, this ID, in my experience, should always be 0.
+* `poolOutput` - integer indicating the output level of the salt cell for the pool. I believe this operates on a 0-100 scale.
+* `spaOutput` - integer indicating the output level of the salt cell for the spa. I believe this operates on a 0-100 scale.
+
 ## SLControllerConfigMessage
 
 Passed as an argument to the emitted `controllerConfig` event handler.
 
+### hasSolar()
+
+Returns a bool indicating whether the system has solar present. (Helper method for interpreting the value in `equipFlags`.)
+
+### hasSolarAsHeatpump()
+
+Returns a bool indicating whether the system has a solar heatpump (UltraTemp, ThermalFlo) present. (Helper method for interpreting the value in `equipFlags`.)
+
+### hasChlorinator()
+
+Returns a bool indicating whether the system has a chlorinator present. (Helper method for interpreting the value in `equipFlags`.)
+
+### hasCooling()
+
+Returns a bool indicating whether the system has a cooler present. (Helper method for interpreting the value in `equipFlags`.)
+
+### hasIntellichem()
+
+Returns a bool indicating whether the system has an IntelliChem chemical management system present. (Helper method for interpreting the value in `equipFlags`.)
+
 ### Properties
 
 * `controllerId` - integer indicating the controller's ID
@@ -340,7 +386,7 @@ Passed as an argument to the emitted `controllerConfig` event handler.
 * `controllerType` - byte
 * `hwType` - byte
 * `controllerData` - byte
-* `equipFlags` - integer
+* `equipFlags` - integer indicating the type(s) of equipment present in the system (see helper methods above for interpreting these values)
 * `genCircuitName` - string indicating the circuit name
 * `bodyArray` - array (size number-of-circuits) holding circuit data
   * `circuitId` - integer indicating circuit ID (e.g.: 500 is spa, 505 is pool)
@@ -386,7 +432,7 @@ Passed as an argument to the emitted `setPointChanged` event. The passed version
 
 ## SLSetHeatModeMessage
 
-Passed as an argument to the emitted `setHeatMode` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the set command.
+Passed as an argument to the emitted `heatModeChanged` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the set command.
 
 ### Properties
 
@@ -435,3 +481,57 @@ Passed as an argument to the emitted `gatewayFound` event. Contains information
 * `port` - number containing the port to connect to the unit
 * `portOpen` - boolean indicating whether or not the port is open and able to be connected to
 * `relayOn` - boolean indicating whether the relay is on (unsure what exactly this indicates; it's always been false in my tests)
+
+## SLAddNewScheduleEvent
+
+Adds a new event to the specified schedule type, either 0 for regular events or 1 for one-time events
+
+### Properties
+
+* `scheduleType` - 0 - indicates regular scheduled events, 1 - indicates a run-once event
+
+## SLDeleteScheduleEventById
+
+Deletes a scheduled event with specified id
+
+### Properties
+
+* `scheduleId` - the scheduleId of the schedule to be deleted
+
+## SLGetScheduleData
+
+Retrieves a list of schedule events of the specified type, either 0 for regular events or 1 for one-time events
+
+### Properties
+
+* `scheduleType` - 0 - indicates regular scheduled events, 1 - indicates a run-once event
+
+## SLSetScheduleEventById
+
+Configures an event with properties as described below
+
+### Properties
+
+* `scheduleId` - id of a schedule previously created, see [`SLAddNewScheduleEvent`](#sladdnewscheduleevent)
+* `circuitId` - id of the circuit to which this event applies to
+* `startTime` - the start time of the event, specified as minutes since midnight
+	* example: 6:00am would be 360
+	* example: 6:15am would be 375
+* `stopTime` - the stop time of the event, specified as minutes since midnight, format is the same as startTime
+* `dayMask`
+	* 7-bit mask that determines which days the schedule is active for, MSB is always 0, valid numbers 1-127
+* `flags`
+	* bit 0 is the schedule type, if 0 then regular event, if 1 its a run-once
+	* bit 1 indicates whether heat setPoint should be changed 
+	* only valid values i've seen are 0,1,2,3
+* `heatCmd` - integer indicating the desired heater mode. Valid values are: 0: "Off", 1: "Solar", 2 : "Solar Preferred", 3 : "Heat Pump", 4: "Don't Change"
+* `heatSetPoint` - the temperature set point if heat is to be changed (ignored if bit 1 of flags is 0)
+
+## SLSetCircuitRuntimeById
+
+Configures default run-time of a circuit, usually referred to as the 'egg timer', this also applies to 'run-once' programs as this will set the length of the program
+
+### Properties
+
+* `circuitId` - id of the circuit to which this event applies to
+* `runTime` - integer specifying the minutes of runTime

index.js

@@ -15,6 +15,8 @@ class FindUnits extends EventEmitter {
       _this.foundServer(message, remote);
     }).on('close', function() {
       // console.log('finder closed');
+    }).on('error', function(e) {
+      _this.emit('error', e);
     });
   }
 
@@ -36,7 +38,7 @@ class FindUnits extends EventEmitter {
         port: message.readInt16LE(8),
         gatewayType: message.readUInt8(10),
         gatewaySubtype: message.readUInt8(11),
-        gatewayName: message.toString('utf8', 12, 28),
+        gatewayName: message.toString('utf8', 12, 29),
       };
 
       // console.log('  type: ' + server.type + ', host: ' + server.address + ':' + server.port + ',
@@ -70,6 +72,8 @@ class RemoteLogin extends EventEmitter {
       _this.onClientMessage(msg);
     }).on('close', function(had_error) {
       // console.log('remote login server connection closed');
+    }).on('error', function(e) {
+      _this.emit('error', e);
     });
   }
 
@@ -146,6 +150,8 @@ class UnitConnection extends EventEmitter {
       }
     }).on('close', function(had_error) {
       // console.log('unit connection closed');
+    }).on('error', function(e) {
+      _this.emit('error', e);
     });
   }
 
@@ -202,6 +208,10 @@ class UnitConnection extends EventEmitter {
     this.client.write(new messages.SLVersionMessage().toBuffer());
   }
 
+  getEquipmentConfiguration() {
+    this.client.write(new messages.SLEquipmentConfigurationMessage().toBuffer());
+  }
+
   setCircuitState(controllerId, circuitId, circuitState) {
     this.client.write(new messages.SLSetCircuitStateMessage(controllerId, circuitId, circuitState).toBuffer());
   }
@@ -218,6 +228,31 @@ class UnitConnection extends EventEmitter {
     this.client.write(new messages.SLLightControlMessage(controllerId, command).toBuffer());
   }
 
+  setSaltCellOutput(controllerId, poolOutput, spaOutput) {
+    this.client.write(new messages.SLSetSaltCellConfigMessage(controllerId, poolOutput, spaOutput).toBuffer());
+  }
+
+  getScheduleData(scheduleType) {
+    this.client.write(new messages.SLGetScheduleData(null, scheduleType).toBuffer());
+  }
+
+  addNewScheduleEvent(scheduleType) {
+    this.client.write(new messages.SLAddNewScheduleEvent(null, scheduleType).toBuffer());
+  }
+
+  deleteScheduleEventById(scheduleId) {
+    this.client.write(new messages.SLDeleteScheduleEventById(scheduleId).toBuffer());
+  }
+
+  setScheduleEventById(scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint) {
+    this.client.write(new messages.SLSetScheduleEventById(null, scheduleId, circuitId, startTime, stopTime,
+      dayMask, flags, heatCmd, heatSetPoint).toBuffer());
+  }
+
+  setCircuitRuntimebyId(circuitId, runTime) {
+    this.client.write(new messages.SLSetCircuitRuntimeById(circuitId, runTime).toBuffer());
+  }
+
   onClientMessage(msg) {
     // console.log('received message of length ' + msg.length);
     if (msg.length < 4) {
@@ -271,6 +306,28 @@ class UnitConnection extends EventEmitter {
         // console.log("  it's a light control ack");
         this.emit('sentLightCommand', new messages.SLLightControlMessage());
         break;
+      case messages.SLSetSaltCellConfigMessage.getResponseId():
+        // console.log("  it's a set salt cell config ack");
+        this.emit('setSaltCellConfig', new messages.SLSetSaltCellConfigMessage());
+        break;
+      case messages.SLEquipmentConfigurationMessage.getResponseId():
+        this.emit('equipmentConfiguration', new messages.SLEquipmentConfigurationMessage(msg));
+        break;
+      case messages.SLGetScheduleData.getResponseId():
+        this.emit('getScheduleData', new messages.SLGetScheduleData(msg));
+        break;
+      case messages.SLAddNewScheduleEvent.getResponseId():
+        this.emit('addNewScheduleEvent', new messages.SLAddNewScheduleEvent(msg));
+        break;
+      case messages.SLDeleteScheduleEventById.getResponseId():
+        this.emit('deleteScheduleEventById', new messages.SLDeleteScheduleEventById(msg));
+        break;
+      case messages.SLSetScheduleEventById.getResponseId():
+        this.emit('setScheduleEventById', new messages.SLSetScheduleEventById(msg));
+        break;
+      case messages.SLSetCircuitRuntimeById.getResponseId():
+        this.emit('setCircuitRuntimebyId', new messages.SLSetCircuitRuntimeById());
+        break;
       case 13:
         // console.log("  it's a login failure.");
         this.emit('loginFailed');

messages/SLAddNewScheduleEvent.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12544;
+
+
+exports.SLAddNewScheduleEvent = class SLAddNewScheduleEvent extends SLMessage {
+  constructor(buf, scheduleType) {
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
+
+    if (!buf) {
+      // console.log('Requested Schedule type = ', scheduleType);
+      this.writeInt32LE(0);
+      this.writeInt32LE(scheduleType);
+    } else {
+      this._wroteSize = true;
+      this.writeBuffer(buf, 0);
+
+      this.decode();
+    }
+  }
+
+  decode() {
+    super.decode();
+
+    this.scheduleId = this.readUInt32LE();
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};

messages/SLChallengeMessage.js

@@ -6,7 +6,11 @@ const MSG_ID = 14;
 
 exports.SLChallengeMessage = class SLChallengeMessage extends SLMessage {
   constructor(buf) {
-    super(0, MSG_ID);
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
 
     if (buf) {
       this._wroteSize = true;

messages/SLChemDataMessage.js

@@ -6,7 +6,12 @@ const MSG_ID = 12592;
 
 exports.SLChemDataMessage = class SLChemDataMessage extends SLMessage {
   constructor(buf) {
-    super(0, MSG_ID);
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
     if (!buf) {
       this.writeInt32LE(0); // controller index
     } else {

messages/SLControllerConfigMessage.js

@@ -6,7 +6,12 @@ const MSG_ID = 12532;
 
 exports.SLControllerConfigMessage = class SLControllerConfigMessage extends SLMessage {
   constructor(buf) {
-    super(0, MSG_ID);
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
     if (!buf) {
       this.writeInt32LE(0);
       this.writeInt32LE(0);
@@ -82,4 +87,44 @@ exports.SLControllerConfigMessage = class SLControllerConfigMessage extends SLMe
   static getResponseId() {
     return MSG_ID + 1;
   }
+
+  hasSolar() {
+    return !!(this.equipFlags & 0x1);
+  }
+
+  hasSolarAsHeatpump() {
+    return !!(this.equipFlags & 0x2);
+  }
+
+  hasChlorinator() {
+    return !!(this.equipFlags & 0x4);
+  }
+
+  hasCooling() {
+    return !!(this.equipFlags & 0x800);
+  }
+
+  hasIntellichem() {
+    return !!(this.equipFlags & 0x8000);
+  }
+
+  isEasyTouch() {
+    return this.controllerType === 14 || this.controllerType === 13;
+  }
+
+  isIntelliTouch() {
+    return this.controllerType !== 14 && this.controllerType !== 13 && this.controllerType !== 10;
+  }
+
+  isEasyTouchLite() {
+    return this.controllerType === 13 && (this.hwType & 4) !== 0;
+  }
+
+  isDualBody() {
+    return this.controllerType === 5;
+  }
+
+  isChem2() {
+    return this.controllerType === 252 && this.hwType === 2;
+  }
 };

messages/SLDeleteScheduleEventById.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12546;
+
+exports.SLDeleteScheduleEventById = class SLDeleteScheduleEventById extends SLMessage {
+  constructor(scheduleId) {
+    super(0, MSG_ID);
+
+    this.writeInt32LE(0);
+    this.writeInt32LE(scheduleId);
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};

messages/SLEquipmentConfigurationMessage.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12566;
+
+exports.SLEquipmentConfigurationMessage = class SLEquipmentConfigurationMessage extends SLMessage {
+  constructor(buf) {
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
+    if (!buf) {
+      this.writeInt32LE(0);
+      this.writeInt32LE(0);
+    } else {
+      this._wroteSize = true;
+      this.writeBuffer(buf, 0);
+
+      this.decode();
+    }
+  }
+
+  decode() {
+    super.decode();
+
+    this.controllerType = this.readUInt8();
+    this.hardwareType = this.readUInt8();
+    this.readUInt8();
+    this.readUInt8();
+    this.controllerData = this.readInt32LE();
+    this.versionDataArray = this.readSLArray();
+    this.speedDataArray = this.readSLArray();
+    this.valveDataArray = this.readSLArray();
+    this.remoteDataArray = this.readSLArray();
+    this.sensorDataArray = this.readSLArray();
+    this.delayDataArray = this.readSLArray();
+    this.macroDataArray = this.readSLArray();
+    this.miscDataArray = this.readSLArray();
+    this.lightDataArray = this.readSLArray();
+    this.flowDataArray = this.readSLArray();
+    this.sgDataArray = this.readSLArray();
+    this.spaFlowDataArray = this.readSLArray();
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};

messages/SLGetGatewayDataMessage.js

@@ -6,7 +6,11 @@ const MSG_ID = 18003;
 
 exports.SLGetGatewayDataMessage = class SLGetGatewayDataMessage extends SLMessage {
   constructor(buf) {
-    super(0, MSG_ID);
+    var size;
+    if (buf && typeof buf === 'object') {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
 
     if (typeof buf === 'string') {
       this.writeSLString(buf);

messages/SLGetScheduleData.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12542;
+
+exports.SLGetScheduleData = class SLGetScheduleData extends SLMessage {
+  constructor(buf, scheduleType) {
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
+
+    if (!buf) {
+      // console.log('Requested Schedule type = ', scheduleType);
+      this.writeInt32LE(0);
+      this.writeInt32LE(scheduleType);
+    } else {
+      this._wroteSize = true;
+      this.writeBuffer(buf, 0);
+
+      this.decode();
+    }
+  }
+
+  decode() {
+    super.decode();
+
+    this.eventCount = this.readUInt32LE();
+
+    this.events = new Array(this.eventCount);
+
+    for (var i = 0; i < this.events.length; i++) {
+      this.events[i] = {};
+
+      this.events[i].scheduleId = this.readUInt32LE();
+      this.events[i].circuitId = this.readUInt32LE();
+      this.events[i].startTime = this.readTime(this.readUInt32LE());
+      this.events[i].stopTime = this.readTime(this.readUInt32LE());
+      this.events[i].dayMask = this.readUInt32LE();
+      this.events[i].flags = this.readUInt32LE();
+      this.events[i].heatCmd = this.readUInt32LE();
+      this.events[i].heatSetPoint = this.readUInt32LE();
+
+    }
+  }
+
+  readTime(rawTime) {
+    var retVal;
+
+    retVal = Math.floor(rawTime / 60) * 100 + rawTime % 60;
+
+    retVal = String(retVal).padStart(4, '0');
+
+    return retVal;
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};

messages/SLMessage.js

@@ -3,12 +3,27 @@
 const SmartBuffer = require('smart-buffer').SmartBuffer;
 
 exports.SLMessage = class SLMessage extends SmartBuffer {
-  constructor(senderId, messageId) {
-    super();
-    this.writeUInt16LE(senderId);
-    this.writeUInt16LE(messageId);
+  constructor(senderId, messageId, size) {
+    var options;
+    if (size) {
+      options = {
+        size: size,
+      };
+    }
+    super(options);
 
-    this._wroteSize = false;
+    if (typeof senderId === 'number' || typeof senderId === 'undefined') {
+      this.writeUInt16LE(senderId || 0);
+      this.writeUInt16LE(messageId || 0);
+
+      this._wroteSize = false;
+    } else if (senderId) {
+      this._wroteSize = true;
+      var buffer = senderId;
+      this.writeBuffer(buffer, 0);
+
+      this.decode();
+    }
   }
 
   toBuffer() {
@@ -27,17 +42,13 @@ exports.SLMessage = class SLMessage extends SmartBuffer {
   writeSLString(str) {
     this.writeInt32LE(str.length);
     this.writeString(str);
-    if (str.length % 4 !== 0) {
-      this.skipWrite(4 - str.length % 4);
-    }
+    this.skipWrite(SLMessage.slackForAlignment(str.length));
   }
 
   readSLString() {
     var len = this.readInt32LE();
     var str = this.readString(len);
-    if (len % 4 !== 0) {
-      this.readOffset += 4 - len % 4;
-    }
+    this.readOffset += SLMessage.slackForAlignment(len);
     return str;
   }
 
@@ -48,9 +59,25 @@ exports.SLMessage = class SLMessage extends SmartBuffer {
 
   writeSLArray(arr) {
     this.writeInt32LE(arr.length);
+
     for (var i = 0; i < arr.length; i++) {
       this.writeUInt8(arr[i]);
     }
+
+    this.skipWrite(SLMessage.slackForAlignment(arr.length));
+  }
+
+  readSLArray() {
+    var len = this.readInt32LE();
+
+    var retval = new Array(len);
+    for (var i = 0; i < len; i++) {
+      retval[i] = this.readUInt8();
+    }
+
+    this.readOffset += SLMessage.slackForAlignment(len);
+
+    return retval;
   }
 
   skipWrite(num) {
@@ -66,5 +93,9 @@ exports.SLMessage = class SLMessage extends SmartBuffer {
     this.dataLength = this.readInt32LE();
   }
 
+  static slackForAlignment(val) {
+    return (4 - val % 4) % 4;
+  }
+
   encode() {}
 };

messages/SLPoolStatusMessage.js

@@ -9,7 +9,12 @@ const POOL_CIRCUIT_ID = 505;
 
 exports.SLPoolStatusMessage = class SLPoolStatusMessage extends SLMessage {
   constructor(buf) {
-    super(0, MSG_ID);
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
     if (!buf) {
       this.writeInt32LE(0);
     } else {

messages/SLSaltCellConfigMessage.js

@@ -6,7 +6,12 @@ const MSG_ID = 12572;
 
 exports.SLSaltCellConfigMessage = class SLSaltCellConfigMessage extends SLMessage {
   constructor(buf) {
-    super(0, MSG_ID);
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
     if (!buf) {
       this.writeInt32LE(0); // controller index
     } else {

messages/SLSetCircuitRuntimeById.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12550;
+
+
+exports.SLSetCircuitRuntimeById = class SLSetCircuitRuntimeById extends SLMessage {
+  constructor(circuitId, runTime) {
+    super(0, MSG_ID);
+
+    this.circuitId = circuitId;
+    this.runTime = runTime;
+  }
+
+  encode() {
+    this.writeInt32LE(0);
+    this.writeInt32LE(this.circuitId);
+    this.writeInt32LE(this.runTime);
+
+    super.encode();
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};

messages/SLSetSaltCellConfigMessage.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12576;
+
+exports.SLSetSaltCellConfigMessage = class SLSetSaltCellConfigMessage extends SLMessage {
+  constructor(controllerIndex, poolOutput, spaOutput) {
+    super(0, MSG_ID);
+
+    this.controllerIndex = controllerIndex;
+    this.poolOutput = poolOutput;
+    this.spaOutput = spaOutput;
+  }
+
+  encode() {
+    this.writeInt32LE(this.controllerIndex || 0);
+    this.writeInt32LE(this.poolOutput || 0);
+    this.writeInt32LE(this.spaOutput || 0);
+    this.writeInt32LE(0);
+    this.writeInt32LE(0);
+
+    super.encode();
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};

messages/SLSetScheduleEventById.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12548;
+
+
+exports.SLSetScheduleEventById = class SLSetScheduleEventById extends SLMessage {
+  constructor(buf, scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint) {
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
+
+    if (!buf) {
+      this.writeInt32LE(0);
+      this.writeInt32LE(scheduleId);
+      this.writeInt32LE(circuitId);
+      this.writeInt32LE(startTime);
+      this.writeInt32LE(stopTime);
+      this.writeInt32LE(dayMask);
+      this.writeInt32LE(flags);
+      this.writeInt32LE(heatCmd);
+      this.writeInt32LE(heatSetPoint);
+    } else {
+      this._wroteSize = true;
+      this.writeBuffer(buf, 0);
+
+      this.decode();
+    }
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};

messages/SLVersionMessage.js

@@ -6,7 +6,12 @@ const MSG_ID = 8120;
 
 exports.SLVersionMessage = class SLVersionMessage extends SLMessage {
   constructor(buf) {
-    super(0, MSG_ID);
+    var size;
+    if (buf) {
+      size = buf.readInt32LE(4) + 8;
+    }
+    super(0, MSG_ID, size);
+
     if (buf) {
       this._wroteSize = true;
       this.writeBuffer(buf, 0);

messages/index.js

@@ -12,3 +12,11 @@ exports.SLGetGatewayDataMessage = require('./SLGetGatewayDataMessage.js').SLGetG
 exports.SLSetHeatSetPointMessage = require('./SLSetHeatSetPoint.js').SLSetHeatSetPoint;
 exports.SLSetHeatModeMessage = require('./SLSetHeatMode.js').SLSetHeatMode;
 exports.SLLightControlMessage = require('./SLLightControl.js').SLLightControl;
+exports.SLSetSaltCellConfigMessage = require('./SLSetSaltCellConfigMessage.js').SLSetSaltCellConfigMessage;
+exports.SLEquipmentConfigurationMessage =
+    require('./SLEquipmentConfigurationMessage.js').SLEquipmentConfigurationMessage;
+exports.SLGetScheduleData = require('./SLGetScheduleData.js').SLGetScheduleData;
+exports.SLAddNewScheduleEvent = require('./SLAddNewScheduleEvent.js').SLAddNewScheduleEvent;
+exports.SLDeleteScheduleEventById = require('./SLDeleteScheduleEventById.js').SLDeleteScheduleEventById;
+exports.SLSetScheduleEventById = require('./SLSetScheduleEventById.js').SLSetScheduleEventById;
+exports.SLSetCircuitRuntimeById = require('./SLSetCircuitRuntimeById.js').SLSetCircuitRuntimeById;

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "node-screenlogic",
 	"description": "Tool for connecting to Pentair ScreenLogic systems on the local network",
-	"version": "1.3.0",
+	"version": "1.5.0",
 	"main": "index.js",
 	"license": "MIT",
 	"repository": "https://github.com/parnic/node-screenlogic.git",
@@ -12,12 +12,12 @@
 		"swimmingpool"
 	],
 	"dependencies": {
-		"smart-buffer": "~4.0.1"
+		"smart-buffer": "~4.1.0"
 	},
 	"devDependencies": {
-		"eslint": "^4.19.1",
+		"eslint": "^7.2.0",
 		"eslint-config-strongloop": "^2.1.0",
-		"mocha": "^5.1.1"
+		"mocha": "^7.2.0"
 	},
 	"scripts": {
 		"test": "mocha test/*.spec.js",

test/slmessage.spec.js

@@ -0,0 +1,175 @@
+'use strict';
+
+const SLMessage = require('../messages/SLMessage.js').SLMessage;
+const assert = require('assert');
+
+function slMessageLen(str) {
+  // strings have length prefixed on them as an int32 for an additional 4b.
+  // strings are dword aligned, so if str.length is 21, dword alignment pushes it up to 24
+  return 4 + str.length + SLMessage.slackForAlignment(str.length);
+}
+
+describe('SLMessage utilities', () => {
+  // message header = senderId, messageId, bodyLen.
+  // senderId and messageId are int16's, so 2b each. bodyLen is an int32, so 4b. total 8b.
+  let msgHeaderLen = 8;
+
+  it('sets senderId and messageId properly', function() {
+    {
+      let msg = new SLMessage(123, 456);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.senderId, 123);
+      assert.strictEqual(decodedMsg.messageId, 456);
+      assert.strictEqual(decodedMsg.dataLength, 0);
+    }
+
+    {
+      let msg = new SLMessage(0, 65534);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.senderId, 0);
+      assert.strictEqual(decodedMsg.messageId, 65534);
+      assert.strictEqual(decodedMsg.dataLength, 0);
+    }
+
+    {
+      let msg = new SLMessage();
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.senderId, 0);
+      assert.strictEqual(decodedMsg.messageId, 0);
+      assert.strictEqual(decodedMsg.dataLength, 0);
+    }
+
+    {
+      let msg = new SLMessage(123);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.senderId, 123);
+      assert.strictEqual(decodedMsg.messageId, 0);
+      assert.strictEqual(decodedMsg.dataLength, 0);
+    }
+
+    {
+      let msg = new SLMessage(0);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.senderId, 0);
+      assert.strictEqual(decodedMsg.messageId, 0);
+      assert.strictEqual(decodedMsg.dataLength, 0);
+    }
+  });
+
+  it('encodes and decodes SLStrings', function() {
+    {
+      let msg = new SLMessage();
+      let testStr = 'this is a test string';
+      msg.writeSLString(testStr);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.readSLString(), testStr, 'did not receive serialized message properly');
+      assert.strictEqual(SLMessage.slackForAlignment(testStr.length), 3);
+      // SLString byte length = 4 + 21 + 3 = 28b
+      assert.strictEqual(slMessageLen(testStr),
+        4 + testStr.length + SLMessage.slackForAlignment(testStr.length));
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(testStr), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let testStr = '1';
+      msg.writeSLString(testStr);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.readSLString(), testStr, 'did not receive serialized message properly');
+      assert.strictEqual(SLMessage.slackForAlignment(testStr.length), 3);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(testStr), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let testStr = '12';
+      msg.writeSLString(testStr);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.readSLString(), testStr, 'did not receive serialized message properly');
+      assert.strictEqual(SLMessage.slackForAlignment(testStr.length), 2);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(testStr), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let testStr = '123';
+      msg.writeSLString(testStr);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.readSLString(), testStr, 'did not receive serialized message properly');
+      assert.strictEqual(SLMessage.slackForAlignment(testStr.length), 1);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(testStr), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let testStr = '1234';
+      msg.writeSLString(testStr);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.strictEqual(decodedMsg.readSLString(), testStr, 'did not receive serialized message properly');
+      assert.strictEqual(SLMessage.slackForAlignment(testStr.length), 0);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(testStr), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+  });
+
+  it('encodes and decodes SLArrays', function() {
+    {
+      let msg = new SLMessage();
+      let list = [];
+      msg.writeSLArray(list);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.deepStrictEqual(decodedMsg.readSLArray(), list);
+      assert.strictEqual(SLMessage.slackForAlignment(list.length), 0);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(list), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let list = [1];
+      msg.writeSLArray(list);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.deepStrictEqual(decodedMsg.readSLArray(), list);
+      assert.strictEqual(SLMessage.slackForAlignment(list.length), 3);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(list), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let list = [1, 2];
+      msg.writeSLArray(list);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.deepStrictEqual(decodedMsg.readSLArray(), list);
+      assert.strictEqual(SLMessage.slackForAlignment(list.length), 2);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(list), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let list = [1, 2, 3];
+      msg.writeSLArray(list);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.deepStrictEqual(decodedMsg.readSLArray(), list);
+      assert.strictEqual(SLMessage.slackForAlignment(list.length), 1);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(list), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+
+    {
+      let msg = new SLMessage();
+      let list = [1, 2, 3, 4];
+      msg.writeSLArray(list);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      assert.deepStrictEqual(decodedMsg.readSLArray(), list);
+      assert.strictEqual(SLMessage.slackForAlignment(list.length), 0);
+      assert.strictEqual(decodedMsg.readOffset, msgHeaderLen + slMessageLen(list), 'read offset was invalid');
+      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
+    }
+  });
+});

test/unit.spec.js

@@ -25,10 +25,10 @@ describe('Unit', () => {
     unit.close();
   });
 
-  let circuit;
+  // let circuit;
   it('gets pool status', done => {
     unit.on('poolStatus', status => {
-      circuit = status.circuitArray[0];
+      /* circuit = */status.circuitArray[0];
       done();
     });
 
@@ -63,10 +63,12 @@ describe('Unit', () => {
     unit.getVersion();
   });
 
+  /* uncomment this and the `circuit` stuff above to test setting state
   it('sets circuit state', done => {
     unit.on('circuitStateChanged', () => {
       done();
     });
     unit.setCircuitState(0, circuit.id, circuit.state);
   });
+  */
 });