Prepare for 1.8.0 release

Fix day-of-week handling again
Saturday isn't 0, it's 7. Add tests to make sure this is working now and forever!
2022-04-17 10:47:56 -05:00 · 2022-04-17 10:47:45 -05:00 · 2022-04-15 16:38:29 -05:00 · 2022-04-15 16:38:24 -05:00 · 2022-04-15 16:24:33 -05:00 · 2022-04-15 16:17:18 -05:00
36 changed files with 3752 additions and 2140 deletions
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@ -0,0 +1,69 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+name: "CodeQL"
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [main]
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        # Override automatic language detection by changing the below list
+        # Supported options are ['csharp', 'cpp', 'go', 'java', 'javascript', 'python']
+        language: ['javascript']
+        # Learn more...
+        # https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#overriding-automatic-language-detection
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+      with:
+        # We must fetch at least the immediate parents so that if this is
+        # a pull request then we can checkout the head.
+        fetch-depth: 2
+
+    # If this run was triggered by a pull request event, then checkout
+    # the head of the pull request instead of the merge commit.
+    - run: git checkout HEAD^2
+      if: ${{ github.event_name == 'pull_request' }}
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file. 
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1
--- a/.github/workflows/nodejs.yml
+++ b/.github/workflows/nodejs.yml
@ -5,9 +5,9 @@ name: Node.js CI

 on:
  push:
-    branches: [ master ]
+    branches: [ main ]
  pull_request:
-    branches: [ master ]
+    branches: [ main ]

 jobs:
  build:
@ -16,7 +16,7 @@ jobs:

    strategy:
      matrix:
-        node-version: [10.x, 12.x]
+        node-version: [12.x, 14.x, 16.x]

    steps:
    - uses: actions/checkout@v2
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -5,7 +5,40 @@ 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.6.0 - 2020-06-14
+## v1.8.0 - 2022-04-17
+
+### Added
+
+* Added support for reading ScreenLogic time packets.
+* Added support for getting system history data. This includes temperature readings over time as well as circuit on/off changes over time.
+
+### Fixed
+
+* Updated dependencies to safer versions of some packages.
+* Fixed day-of-week conversion from Javascript Date objects to ScreenLogic times (SLTimes are 1-based starting on Sunday).
+
+### Changed
+
+* Alphabetized the readme.
+
+## v1.7.0 - 2021-10-13
+
+### Added
+
+* Added handling/documentation for the scheduleChanged event (#44).
+* Added support for getting and setting the system date/time.
+
+### Fixed
+
+* Documentation updates for `SLGetScheduleData`, more linkage for easy navigation, `addClient`/`removeClient` methods, clarified `coolSetPoint` for spas.
+
+## v1.6.1 - 2020-11-23
+
+### Added
+
+* Every call now can optionally specify an ID that will be returned with the result, allowing tracking of simultaneous commands.
+
+## v1.6.0 - 2020-07-14

 ### Added

@ -20,7 +53,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * ScreenLogic.HEAT_MODE_DONTCHANGE
 * Debug logs using the "debug" NPM package. You'll need to run an `npm install` after updating to this version.
 * Ability to cancel delays in pool equipment. #20 - thanks @bshep
-* Ability to register for push messages from the equipment so the connection can be kept open instead of repeatedly reconnecting and polling for changes. See the `addClient()` and `removeClient()` functions on the `UnitConnection` docs.
+* Ability to register for push messages from the equipment so the connection can be kept open instead of repeatedly reconnecting and polling for changes. See the `addClient()` and `removeClient()` functions on the `UnitConnection` docs. Thanks @bshep

 ## v1.5.0 - 2020-06-06

--- a/README.md
+++ b/README.md
@ -2,7 +2,40 @@

 This is a Node.JS library for interfacing with Pentair ScreenLogic systems over your local network or remotely through the Pentair dispatcher. Local connections require a Pentair ScreenLogic device on the same network (a network which supports UDP broadcasts).

-Tested on node v8.11.1, v10.15.1 with a system on firmware versions 5.2 Build 736.0 Rel, 5.2 Build 738.0 Rel
+Tested with a Pentair ScreenLogic system on firmware versions 5.2 Build 736.0 Rel, 5.2 Build 738.0 Rel
+
+* [Usage](#usage)
+* [Notes](#notes)
+* [Packet format](#packet-format)
+* [API reference](#api-reference)
+  * [FindUnits](#findunits)
+  * [RemoteLogin](#remotelogin)
+  * [UnitConnection](#unitconnection)
+  * [All messages](#all-messages)
+    * [SLAddClient](#sladdclient)
+    * [SLAddNewScheduleEvent](#sladdnewscheduleevent)
+    * [SLCancelDelay](#slcanceldelay)
+    * [SLChemDataMessage](#slchemdatamessage)
+    * [SLControllerConfigMessage](#slcontrollerconfigmessage)
+    * [SLDeleteScheduleEventById](#sldeletescheduleeventbyid)
+    * [SLGetGatewayDataMessage](#slgetgatewaydatamessage)
+    * [SLGetHistoryData](#slgethistorydata)
+    * [SLGetPumpStatus](#slgetpumpstatus)
+    * [SLGetScheduleData](#slgetscheduledata)
+    * [SLGetSystemTime](#slgetsystemtime)
+    * [SLLightControlMessage](#sllightcontrolmessage)
+    * [SLPoolStatusMessage](#slpoolstatusmessage)
+    * [SLRemoveClient](#slremoveclient)
+    * [SLSaltCellConfigMessage](#slsaltcellconfigmessage)
+    * [SLSetCircuitRuntimeById](#slsetcircuitruntimebyid)
+    * [SLSetCircuitStateMessage](#slsetcircuitstatemessage)
+    * [SLSetHeatModeMessage](#slsetheatmodemessage)
+    * [SLSetHeatSetPointMessage](#slsetheatsetpointmessage)
+    * [SLSetPumpFlow](#slsetpumpflow)
+    * [SLSetSaltCellConfigMessage](#slsetsaltcellconfigmessage)
+    * [SLSetScheduleEventById](#slsetscheduleeventbyid)
+    * [SLSetSystemTime](#slsetsystemtime)
+    * [SLVersionMessage](#slversionmessage)

 ## Usage

@ -178,113 +211,132 @@ client.connect();

 Closes the connection.

-#### getVersion()
+#### addClient(clientId, senderId)

-Requests the system version string from the connected unit. Emits the `version` event when the response comes back.
+Registers to receive updates from controller when something changes. Takes a random number `clientId` to identify the client. Emits the `poolStatus` event when something changes on the controller, and the `addClient` event when the request to add a client is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### getPoolStatus()
+#### addNewScheduleEvent(scheduleType, senderId)

-Requests pool status from the connected unit. Emits the `poolStatus` event when the response comes back.
+Adds a new event to the specified schedule type. See [`SLAddNewScheduleEvent`](#sladdnewscheduleevent) documentation for argument values. Emits either the `addNewScheduleEvent` or `scheduleChanged` event when response is acknowledged (listen for both). `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### getChemicalData()
+#### cancelDelay(senderId)

-Requests chemical data from the connected unit (may require an IntelliChem or similar). Emits the `chemicalData` event when the response comes back.
+Cancels any delays on the system. See [`SLCancelDelay`](#slcanceldelay) documentation. Emits the `cancelDelay` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### getSaltCellConfig()
+#### deleteScheduleEventById(scheduleId, senderId)

-Requests salt cell status/configuration from the connected unit (requires an IntelliChlor or compatible salt cell). Emits the `saltCellConfig` event when the response comes back.
+Deletes a scheduled event with specified id. See [`SLDeleteScheduleEventById`](#sldeletescheduleeventbyid) documentation for argument values. Emits the `deleteScheduleById` or `scheduleChanged` event when response is acknowledged (listen for both). `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### getControllerConfig()
+#### getChemicalData(senderId)

-Requests controller configuration from the connected unit. Emits the `controllerConfig` event when the response comes back.
+Requests chemical data from the connected unit (may require an IntelliChem or similar). Emits the `chemicalData` event when the response comes back. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### setCircuitState(controllerId, circuitId, circuitState)
+#### getControllerConfig(senderId)

-Activates or deactivates a circuit. See [`SLSetCircuitStateMessage`](#slsetcircuitstatemessage) documentation for argument values. Emits the `circuitStateChanged` event when response is acknowledged.
+Requests controller configuration from the connected unit. Emits the `controllerConfig` event when the response comes back. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### setSetPoint(controllerId, bodyType, temperature)
+#### getHistoryData(fromTime, toTime, senderId)

-Sets the heating setpoint for any body. See [`SLSetHeatSetPointMessage`](#slsetheatsetpointmessage) documentation for argument values. Emits the `setPointChanged` event when response is acknowledged.
+Requests history data from the connected unit. This is information like what various temperature sensors (air, water) read over time, changes in heat setpoints, and when various circuits (pool, spa, solar, heater, and lights) were turned on and off. `fromTime` is the time (as a Javascript Date object) that you want to get events from and `toTime` is the time (as a Javascript Date object) that you want to get events until. Emits the `getHistoryDataPending` event when the request to get data is confirmed, then the `getHistoryData` event when the history data is actually ready to be handled. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### setHeatMode(controllerId, bodyType, heatMode)
+#### getPoolStatus(senderId)

-Sets the preferred heat mode. See [`SLSetHeatModeMessage`](#slsetheatmodemessage) documentation for argument values. Emits the `heatModeChanged` event when response is acknowledged.
+Requests pool status from the connected unit. Emits the `poolStatus` event when the response comes back. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### sendLightCommand(controllerId, command)
+#### getPumpStatus(pumpId, senderId)

-Sends a lighting command. See [`SLLightControlMessage`](#sllightcontrolmessage) documentation for argument values. Emits the `sentLightCommand` event when response is acknowledged.
+Gets information about the specified pump. See [`SLGetPumpStatus`](#slgetpumpstatus) documentation for argument values. Emits the `getPumpStatus` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.
+
+#### getSaltCellConfig(senderId)
+
+Requests salt cell status/configuration from the connected unit (requires an IntelliChlor or compatible salt cell). Emits the `saltCellConfig` event when the response comes back. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.
+
+#### getScheduleData(scheduleType, senderId)
+
+Retrieves a list of schedule events of the specified type. See [`SLGetScheduleData`](#slgetscheduledata) documentation for argument values. Emits the `getScheduleData` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.
+
+#### getSystemTime(senderId)
+
+Retrieves the current time the system is set to. Emits the `getSystemTime` event when response is received. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.
+
+#### getVersion(senderId)
+
+Requests the system version string from the connected unit. Emits the `version` event when the response comes back. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.
+
+#### removeClient(clientId, senderId)
+
+No longer receive `poolStatus` messages from controller. Emits the `removeClient` event when the request to remove a client is acknowledged. Takes a random number `clientId` that should match a previously registered client with `addClient`. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.
+
+#### sendLightCommand(controllerId, command, senderId)
+
+Sends a lighting command. See [`SLLightControlMessage`](#sllightcontrolmessage) documentation for argument values. Emits the `sentLightCommand` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

 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)
+#### setCircuitRuntimebyId(circuitId, runTime, senderId)

-Sets the salt cell's output levels. See [`SLSetSaltCellConfigMessage`](#slsetsaltcellconfigmessage) documentation for argument values. Emits the `setSaltCellConfig` event when response is acknowledged.
+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. See [`SLSetCircuitRuntimeById`](#slsetcircuitruntimebyid) documentation for argument values. Emits the `setCircuitRuntimeById` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### getScheduleData(scheduleType)
+#### setCircuitState(controllerId, circuitId, circuitState, senderId)

-Retrieves a list of schedule events of the specified type. See [`SLGetScheduleData`](#slgetscheduledata) documentation for argument values. Emits the `getScheduleData` event when response is acknowledged.
+Activates or deactivates a circuit. See [`SLSetCircuitStateMessage`](#slsetcircuitstatemessage) documentation for argument values. Emits the `circuitStateChanged` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### addNewScheduleEvent(scheduleType)
+#### setHeatMode(controllerId, bodyType, heatMode, senderId)

-Adds a new event to the specified schedule type. See [`SLAddNewScheduleEvent`](#sladdnewscheduleevent) documentation for argument values. Emits the `addNewScheduleEvent` event when response is acknowledged.
+Sets the preferred heat mode. See [`SLSetHeatModeMessage`](#slsetheatmodemessage) documentation for argument values. Emits the `heatModeChanged` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### deleteScheduleEventById(scheduleId)
+#### setSaltCellOutput(controllerId, poolOutput, spaOutput, senderId)

-Deletes a scheduled event with specified id. See [`SLDeleteScheduleEventById`](#sldeletescheduleeventbyid) documentation for argument values. Emits the `deleteScheduleById` event when response is acknowledged.
+Sets the salt cell's output levels. See [`SLSetSaltCellConfigMessage`](#slsetsaltcellconfigmessage) documentation for argument values. Emits the `setSaltCellConfig` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### setScheduleEventById(scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint)
+#### setScheduleEventById(scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint, senderId)

-Configures a schedule event. See [`SLSetScheduleEventById`](#slsetscheduleeventbyid) documentation for argument values. Emits the `setScheduleEventById` event when response is acknowledged.
+Configures a schedule event. See [`SLSetScheduleEventById`](#slsetscheduleeventbyid) documentation for argument values. Emits the `setScheduleEventById` or `scheduleChanged` event when response is acknowledged (listen for both). `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### setCircuitRuntimebyId(circuitId, runTime)
+#### setSetPoint(controllerId, bodyType, temperature, senderId)

-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. See [`SLSetCircuitRuntimeById`](#slsetcircuitruntimebyid) documentation for argument values. Emits the `setCircuitRuntimeById` event when response is acknowledged.
+Sets the heating setpoint for any body. See [`SLSetHeatSetPointMessage`](#slsetheatsetpointmessage) documentation for argument values. Emits the `setPointChanged` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### getPumpStatus(pumpId)
+#### setPumpFlow(pumpId, circuitId, setPoint, isRPMs, senderId)

-Gets information about the specified pump. See [`SLGetPumpStatus`](#slgetpumpstatus) documentation for argument values. Emits the `getPumpStatus` event when response is acknowledged.
+Sets flow setting for a pump/circuit combination. See [`SLSetPumpFlow`](#slsetpumpflow) documentation for argument values. Emits the `setPumpFlow` event when response is acknowledged. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

-#### setPumpFlow(pumpId, circuitId, setPoint, isRPMs)
+#### setSystemTime(date, adjustForDST, senderId)

-Sets flow setting for a pump/circuit combination. See [`SLSetPumpFlow`](#slsetpumpflow) documentation for argument values. Emits the `setPumpFlow` event when response is acknowledged.
-
-#### cancelDelay()
-
-Cancels any delays on the system. See [`SLCancelDelay`](#slcanceldelay) documentation. Emits the `cancelDelay` event when response is acknowledged.
-
-#### addClient(senderId)
-
-Registers to receive updates from controller when something changes. Takes a random number `senderId` to identify the client. Emits the `poolStatus` event when something changes on the controller.
-
-#### removeClient(senderId)
-
-No longer receive `poolStatus` messages from controller. Takes a random number `senderId` that should match a previously registered client with `addClient`.
+Sets the current date and time of the ScreenLogic system. Emits the `setSystemTime` event when request is acknowledged. `date` must be a `Date` instance holding the date/time to set, and `adjustForDST` must be a boolean indicating whether the system should adjust for daylight saving time or not. `senderId` is an optional 16-bit integer and will be present as the `senderId` field on the returned message.

 ### 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.
-* `version` - Indicates that a response to `getVersion()` has been received. Event handler receives a [`SLVersionMessage`](#slversionmessage) object.
-* `poolStatus` - Indicates that a response to `getPoolStatus()` has been received. Event handler receives a [`SLPoolStatusMessage`](#slpoolstatusmessage) object.
-* `chemicalData` - Indicates that a response to `getChemicalData()` has been received. Event handler receives a [`SLChemDataMessage`](#slchemdatamessage) object.
-* `saltCellConfig` - Indicates that a response to `getSaltCellConfig()` has been received. Event handler receives a [`SLSaltCellConfigMessage`](#slsaltcellconfigmessage) object.
-* `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.
-* `getScheduleData` - Indicates that a response to `getScheduleData()` has been received. Event handler receives a [`SLGetScheduleData`](#slgetscheduledata) object.
+* `addClient` - Indicates that a response to `addClient()` has been received. Event handler receives a [`SLAddClient`](#sladdclient) object.
 * `addNewScheduleEvent` - Indicates that a response to `addNewScheduleEvent()` has been received which contains the created `scheduleId` to be used later for setting up the properties. Event handler receives a [`SLAddNewScheduleEvent`](#sladdnewscheduleevent) object.
-* `deleteScheduleById` - Indicates that a response to `deleteScheduleById()` has been received. Event handler receives a [`SLDeleteScheduleEventById`](#sldeletescheduleeventbyid) object.
-* `setScheduleEventById` - Indicates that a response to `setScheduleEventById()` has been received. Event handler receives a [`SLSetScheduleEventById`](#slsetscheduleeventbyid) object.
-* `setCircuitRuntimeById` - Indicates that a response to `setCircuitRuntimeById()` has been received. Event handler receives a [`SLSetCircuitRuntimeById`](#slsetcircuitruntimebyid) object.
-* `getPumpStatus` - Indicates that a response to `getPumpStatus()` has been received. Event handler receives a [`SLGetPumpStatus`](#slgetpumpstatus) object.
-* `setPumpFlow` - Indicates that a response to `setPumpFlow()` has been received. Event handler receives a [`SLSetPumpFlow`](#slsetpumpflow) object.
-* `cancelDelay` - Indicates that a response to `cancelDelay()` has been received. Event handler receives a [`SLCancelDelay`](#slcanceldelay) 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.
+* `cancelDelay` - Indicates that a response to `cancelDelay()` has been received. Event handler receives a [`SLCancelDelay`](#slcanceldelay) object.
+* `chemicalData` - Indicates that a response to `getChemicalData()` has been received. Event handler receives a [`SLChemDataMessage`](#slchemdatamessage) object.
+* `circuitStateChanged` - Indicates that a response to `setCircuitState()` has been received. Event handler receives a [`SLSetCircuitStateMessage`](#slsetcircuitstatemessage) object.
+* `controllerConfig` - Indicates that a response to `getControllerConfig()` has been received. Event handler receives a [`SLControllerConfigMessage`](#slcontrollerconfigmessage) object.
+* `deleteScheduleById` - Indicates that a response to `deleteScheduleById()` has been received. Event handler receives a [`SLDeleteScheduleEventById`](#sldeletescheduleeventbyid) object.
 * `error` - Indicates that an unhandled error was caught (such as the connection timing out)
+* `getHistoryData` - Indicates that history data for the requested timeframe is ready. Event handler receives a [`SLGetHistoryData`](#slgethistorydata) object.
+* `getHistoryDataPending` - Indicates that the `getHistoryData()` request has been received and is being processed.
+* `getPumpStatus` - Indicates that a response to `getPumpStatus()` has been received. Event handler receives a [`SLGetPumpStatus`](#slgetpumpstatus) object.
+* `getScheduleData` - Indicates that a response to `getScheduleData()` has been received. Event handler receives a [`SLGetScheduleData`](#slgetscheduledata) object.
+* `getSystemTime` - Indicates that a response to `getSystemTime()` has been received. Event handler receives a [`SLGetSystemTime`](#slgetsystemtime) object.
+* `heatModeChanged` - Indicates that a response to `setHeatMode()` has been received. Event handler receives a [`SLSetHeatModeMessage`](#slsetheatmodemessage) object.
+* `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.
+* `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.
+* `poolStatus` - Indicates that a response to `getPoolStatus()` has been received. Event handler receives a [`SLPoolStatusMessage`](#slpoolstatusmessage) object.
+* `removeClient` - Indicates that a response to `removeClient()` has been received. Event handler receives a [`SLRemoveClient`](#slremoveclient) object.
+* `saltCellConfig` - Indicates that a response to `getSaltCellConfig()` has been received. Event handler receives a [`SLSaltCellConfigMessage`](#slsaltcellconfigmessage) object.
+* `scheduleChanged` - Indicates that a response to adding, deleting, or setting a schedule has been received. Event handler receives nothing. This seems to be arbitrarily returned sometimes instead of a normal ack by the system.
+* `sentLightCommand` - Indicates that a response to `sendLightCommand()` has been received. Event handler receives a [`SLLightControlMessage`](#sllightcontrolmessage) object.
+* `setCircuitRuntimeById` - Indicates that a response to `setCircuitRuntimeById()` has been received. Event handler receives a [`SLSetCircuitRuntimeById`](#slsetcircuitruntimebyid) object.
+* `setPumpFlow` - Indicates that a response to `setPumpFlow()` has been received. Event handler receives a [`SLSetPumpFlow`](#slsetpumpflow) object.
+* `setPointChanged` - Indicates that a response to `setSetPoint()` has been received. Event handler receives a [`SLSetHeatSetPointMessage`](#slsetheatsetpointmessage) object.
+* `setSaltCellConfig` - Indicates that a response to `setSaltCellOutput()` has been received. Event handler receives a [`SLSetSaltCellConfigMessage`](#slsetsaltcellconfigmessage) object.
+* `setScheduleEventById` - Indicates that a response to `setScheduleEventById()` has been received. Event handler receives a [`SLSetScheduleEventById`](#slsetscheduleeventbyid) object.
+* `setSystemTime` - Indicates that a response to `setSystemTime()` has been received. Event handler receives a [`SLSetSystemTime`](#slsetsystemtime) object if the request was valid, or `null` if the request was invalid (input parameters were not of the required types).
 * `unknownCommand` - Indicates that an unknown command was issued to ScreenLogic (should not be possible to trigger when using the supplied `UnitConnection` methods).
+* `version` - Indicates that a response to `getVersion()` has been received. Event handler receives a [`SLVersionMessage`](#slversionmessage) object.

 #### Properties

@ -295,66 +347,64 @@ No longer receive `poolStatus` messages from controller. Takes a random number `
 * `gatewaySubtype` - byte
 * `gatewayName` - string representing the server's name. Will be in the format Pentair: xx-xx-xx

-### SLVersionMessage
+### All messages

-Passed as an argument to the emitted `version` event handler.
+Information about features common to all the below SL Message types.
+
+#### decodeTime(time)
+
+Interprets a time integer recorded as minutes past midnight and returns the ScreenLogic string representation of it in 24-hour time.
+
+#### encodeTime(time)
+
+Interprets the string representing 24-hour time and returns an integer of minutes past midnight.
+
+#### decodeDayMask(mask)
+
+Converts a day mask from, for example, `SLGetScheduleData`'s events[idx].days property into a `DAY_VALUES` array for ease of use.
+
+#### encodeDayMask(days)
+
+Converts an array of DAY_VALUES into a mask used by, for example, `SLGetScheduleData`'s events[idx].days property.
+
+#### getDayValue(dayName)
+
+Returns the value of a given `DAY_VALUES` day name.
+
+`DAY_VALUES` is defined as the following array for simplicity of checking whether a specific day is set in a mask:
+
+```js
+const DAY_VALUES = [
+  ['Mon', 0x1 ],
+  ['Tue', 0x2 ],
+  ['Wed', 0x4 ],
+  ['Thu', 0x8 ],
+  ['Fri', 0x10 ],
+  ['Sat', 0x20 ],
+  ['Sun', 0x40 ],
+];
+```

 #### Properties

-* `version` - a string representing the system's version
+* `senderId` - an integer matching whatever was passed as the `senderId` argument when making the initial request (default 0)
+* `messageId` - an integer indicating the ScreenLogic ID for this message

-### SLPoolStatusMessage
+### SLAddClient

-Passed as an argument to the emitted `poolStatus` event handler.
+Passed as an argument to the emitted `addClient` event.

-#### isDeviceReady()
+### SLAddNewScheduleEvent

-Returns a bool indicating whether the device is in a normal operating state.
-
-#### isDeviceSync()
-
-Returns a bool.
-
-#### isDeviceServiceMode()
-
-Returns a bool indicating whether the device is in service mode or not.
-
-#### isSpaActive()
-
-Returns a bool indicating whether the spa is currently active or not.
-
-#### isPoolActive()
-
-Returns a bool indicating whether the pool is currently active or not.
+Passed as an argument to the emitted `addNewScheduleEvent` event. Adds a new event to the specified schedule type, either 0 for regular events or 1 for one-time events.

 #### Properties

-* `ok` - can be interpreted with `isDevice...` methods.
-* `freezeMode` - byte representing whether the device is in freeze mode or not.
-* `remotes` - byte
-* `poolDelay` - byte
-* `spaDelay` - byte
-* `cleanerDelay` - byte
-* `airTemp` - integer representing the current temperature (check controller config to see if it's in celsius or fahrenheit)
-* `currentTemp` - array of size 0-2 indicating current temperature of each body as an integer (pool: 0, spa: 1) (check controller config to see if it's in celsius or fahrenheit)
-* `heatStatus` - array of size 0-2 indicating whether heat is active or not for each body as an integer (pool: 0, spa: 1)
-* `setPoint` - array of size 0-2 holding the heating set point for each body as an integer (pool: 0, spa: 1) (check controller config to see if it's in celsius or fahrenheit)
-* `coolSetPoint` - array of size 0-2 holding the cooling set point for each body as an integer (pool: 0, spa: 1) (check controller config to see if it's in celsius or fahrenheit)
-* `heatMode` - array of size 0-2 indicating whether heating is enabled or not for each body as an integer (pool: 0, spa: 1)
-* `circuitArray` - array holding all circuits in the system
-  * `id` - integer representing the circuit's ID (spa is 500, pool is 505)
-  * `state` - integer indicating whether the circuit is on or not (0/1)
-  * `colorSet` - byte
-  * `colorPos` - byte
-  * `colorStagger` - byte
-  * `delay` - byte
-* `pH` - float indicating the current pH level (e.g.: 7.62)
-* `orp` - integer indicating the current ORP value if available (e.g.: 650)
-* `saturation` - float indicating the water balance/saturation level (e.g.: -0.13)
-* `saltPPM` - integer indicating the salt level in parts-per-million (e.g.: 3000)
-* `pHTank` - integer indicating the fill level of the pH tank (e.g.: 4)
-* `orpTank` - integer indicating the fill level of the ORP tank
-* `alarms` - integer indicating how many alarms are currently active
+* `scheduleType` - 0 indicates regular scheduled events, 1 indicates a run-once event
+
+### SLCancelDelay
+
+Passed as an argument to the emitted `cancelDelay` event.

 ### SLChemDataMessage

@ -379,31 +429,6 @@ Passed as an argument to the emitted `chemicalData` event handler.
 * `scaling` - boolean indicating whether the water balance is scaling or not
 * `error` - boolean indicating whether there's currently an error in the chem system or not

-### SLSaltCellConfigMessage
-
-Passed as an argument to the emitted `saltCellConfig` event handler.
-
-#### Properties
-
-* `installed` - boolean indicating whether a salt cell is installed or not
-* `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 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.
@ -482,72 +507,13 @@ Returns the `bodyArray` entry for the circuit matching the given device id. This
 * `interfaceTabFlags` - integer
 * `showAlarms` - integer

-### SLSetCircuitStateMessage
+### SLDeleteScheduleEventById

-Passed as an argument to the emitted `circuitStateChanged` 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 `deleteScheduleEventById` event. Deletes a scheduled event with specified id.

 #### 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.
-* `circuitId` - integer indicating the ID of the circuit to set the state of.
-  * This ID can be retrieved from `SLControllerConfigMessage`'s `bodyArray` property.
-* `circuitState` - integer indicating whether to switch the circuit on (`1`) or off (`0`).
-
-### SLSetHeatSetPointMessage
-
-Passed as an argument to the emitted `setPointChanged` 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.
-* `bodyType` - integer indicating the type of body to set the setpoint of. The pool is body `0` and the spa is body `1`.
-* `temperature` - integer indicating the desired setpoint. This is presumably in whatever units your system is set to (celsius or fahrenheit).
-
-### SLSetHeatModeMessage
-
-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
-
-* `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.
-* `bodyType` - integer indicating the type of body to set the setpoint of. The pool is body `0` and the spa is body `1`.
-* `heatMode` - integer indicating the desired heater mode. Valid values are:
-  * ScreenLogic.HEAT_MODE_OFF
-  * ScreenLogic.HEAT_MODE_SOLAR
-  * ScreenLogic.HEAT_MODE_SOLARPREFERRED
-  * ScreenLogic.HEAT_MODE_HEATPUMP
-  * ScreenLogic.HEAT_MODE_DONTCHANGE
-
-### SLLightControlMessage
-
-Passed as an argument to the emitted `sentLightCommand` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the light 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.
-* `command` - integer indicating which command to send to the lights. Valid values are:
-  * ScreenLogic.LIGHT_CMD_LIGHTS_OFF
-  * ScreenLogic.LIGHT_CMD_LIGHTS_ON
-  * ScreenLogic.LIGHT_CMD_COLOR_SET
-  * ScreenLogic.LIGHT_CMD_COLOR_SYNC
-  * ScreenLogic.LIGHT_CMD_COLOR_SWIM
-  * ScreenLogic.LIGHT_CMD_COLOR_MODE_PARTY
-  * ScreenLogic.LIGHT_CMD_COLOR_MODE_ROMANCE
-  * ScreenLogic.LIGHT_CMD_COLOR_MODE_CARIBBEAN
-  * ScreenLogic.LIGHT_CMD_COLOR_MODE_AMERICAN
-  * ScreenLogic.LIGHT_CMD_COLOR_MODE_SUNSET
-  * ScreenLogic.LIGHT_CMD_COLOR_MODE_ROYAL
-  * ScreenLogic.LIGHT_CMD_COLOR_SET_SAVE
-  * ScreenLogic.LIGHT_CMD_COLOR_SET_RECALL
-  * ScreenLogic.LIGHT_CMD_COLOR_BLUE
-  * ScreenLogic.LIGHT_CMD_COLOR_GREEN
-  * ScreenLogic.LIGHT_CMD_COLOR_RED
-  * ScreenLogic.LIGHT_CMD_COLOR_WHITE
-  * ScreenLogic.LIGHT_CMD_COLOR_PURPLE
+* `scheduleId` - the scheduleId of the schedule to be deleted

 ### SLGetGatewayDataMessage

@ -562,63 +528,22 @@ Passed as an argument to the emitted `gatewayFound` event. Contains information
 * `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
+### SLGetHistoryData

-Passed as an argument to the emitted `addNewScheduleEvent` event. Adds a new event to the specified schedule type, either 0 for regular events or 1 for one-time events.
+Passed as an argument to the emitted `getHistoryData` event. Contains information about the remote unit's temperature and circuit on/off times over time.

 #### Properties

-* `scheduleType` - 0 indicates regular scheduled events, 1 indicates a run-once event
-
-### SLDeleteScheduleEventById
-
-Passed as an argument to the emitted `deleteScheduleEventById` event. Deletes a scheduled event with specified id.
-
-#### Properties
-
-* `scheduleId` - the scheduleId of the schedule to be deleted
-
-### SLGetScheduleData
-
-Passed as an argument to the emitted `getScheduleData` event. 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
-
-Passed as an argument to the emitted `setScheduleEventById` event. 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
-* `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
-* `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
-* `heatCmd` - integer indicating the desired heater mode. Valid values are:
-  * ScreenLogic.HEAT_MODE_OFF
-  * ScreenLogic.HEAT_MODE_SOLAR
-  * ScreenLogic.HEAT_MODE_SOLARPREFERRED
-  * ScreenLogic.HEAT_MODE_HEATPUMP
-  * ScreenLogic.HEAT_MODE_DONTCHANGE
-* `heatSetPoint` - the temperature set point if heat is to be changed (ignored if bit 1 of flags is 0)
-
-### SLSetCircuitRuntimeById
-
-Passed as an argument to the emitted `setCircuitRuntimebyId` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the set command. 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 run time in minutes
+* `airTemps` - array of objects containing the air temperature over time. Each object contains a `time` key containing a Javascript Date object, and a `temp` key containing the temperature as an integer.
+* `poolTemps` - array of objects containing the pool temperature over time. Each object contains a `time` key containing a Javascript Date object, and a `temp` key containing the temperature as an integer.
+* `poolSetPointTemps` - array of objects containing the pool setpoint over time. Each object contains a `time` key containing a Javascript Date object, and a `temp` key containing the temperature as an integer.
+* `spaTemps` - array of objects containing the spa temperature over time. Each object contains a `time` key containing a Javascript Date object, and a `temp` key containing the temperature as an integer.
+* `spaSetPointTemps` - array of objects containing the spa setpoint over time. Each object contains a `time` key containing a Javascript Date object, and a `temp` key containing the temperature as an integer.
+* `poolRuns` - array of objects containing the pool on/off times over time. Each object contains an `on` key containing a Javascript Date object for when the circuit turned on, and an `off` key containing a Javascript Date object for when the circuit turned off.
+* `spaRuns` - array of objects containing the spa on/off times over time. Each object contains an `on` key containing a Javascript Date object for when the circuit turned on, and an `off` key containing a Javascript Date object for when the circuit turned off.
+* `solarRuns` - array of objects containing the solar on/off times over time. Each object contains an `on` key containing a Javascript Date object for when the circuit turned on, and an `off` key containing a Javascript Date object for when the circuit turned off.
+* `heaterRuns` - array of objects containing the heater on/off times over time. Each object contains an `on` key containing a Javascript Date object for when the circuit turned on, and an `off` key containing a Javascript Date object for when the circuit turned off.
+* `lightRuns` - array of objects containing the light on/off times over time. Each object contains an `on` key containing a Javascript Date object for when the circuit turned on, and an `off` key containing a Javascript Date object for when the circuit turned off.

 ### SLGetPumpStatus

@ -645,9 +570,198 @@ Passed as an argument to the emitted `getPumpStatus` event. Gets information abo
 * `pumpUnknown1` - unknown data; always 0
 * `pumpUnknown2` - unknown data; always 255

+### SLGetScheduleData
+
+Passed as an argument to the emitted `getScheduleData` event. Retrieves a list of schedule events of the specified type, either 0 for regular events or 1 for one-time events.
+
+#### Properties
+
+* `eventCount` - the number of `events` returned
+* `events` - array containing:
+  * `scheduleId` - the associated scheduleId
+  * `circuitId` - the circuit this schedule affects
+  * `startTime` - the start time of the event, specified as a string in 24-hour time, so, for example, 6:00AM would be '0600' (see [conversion functions](#decodetimetime))
+  * `stopTime` - the stop time of the event, specified as a string in 24-hour time, so, for example, 6:00AM would be '0600' (see [conversion functions](#decodetimetime))
+  * `dayMask` - 7-bit mask that determines which days the schedule is active for, MSB is always 0, valid numbers 1-127 (see [conversion functions](#decodedaymaskmask))
+  * `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
+  * `heatCmd` - integer indicating the desired heater mode. Valid values are:
+    * ScreenLogic.HEAT_MODE_OFF
+    * ScreenLogic.HEAT_MODE_SOLAR
+    * ScreenLogic.HEAT_MODE_SOLARPREFERRED
+    * ScreenLogic.HEAT_MODE_HEATPUMP
+    * ScreenLogic.HEAT_MODE_DONTCHANGE
+  * `heatSetPoint` - the temperature set point if heat is to be changed (ignored if bit 1 of flags is 0)
+  * `days` - which days this schedule is active for; this is just the `dayMask` property run through [`decodeDayMask()`](#decodedaymaskmask) for convenience
+
+### SLGetSystemTime
+
+Contains information about the system's current time and date. Passed as an argument to the emitted `getSystemTime` event.
+
+#### Properties
+
+* `date` - `Date` instance representing the current system datetime (preferred, the other properties are derived from this one and provided for backward compatibility purposes)
+* `year` - short representing current system year
+* `month` - short representing current system month (where 1 is January, 2 is February, etc.)
+* `day` - short representing current system day of the month
+* `dayOfWeek` - short representing current system day of the week (where 1 is Sunday and 7 is Saturday)
+* `hour` - short representing current system hour (24-hour time where 0 is midnight, 13 is 1PM, etc.)
+* `minute` - short representing current system minute
+* `second` - short representing current system second
+* `millisecond` - short representing current system millisecond
+* `adjustForDST` - bool indicating whether the system should adjust for daylight saving time or not
+
+### SLLightControlMessage
+
+Passed as an argument to the emitted `sentLightCommand` event.
+
+#### 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.
+* `command` - integer indicating which command to send to the lights. Valid values are:
+  * ScreenLogic.LIGHT_CMD_LIGHTS_OFF
+  * ScreenLogic.LIGHT_CMD_LIGHTS_ON
+  * ScreenLogic.LIGHT_CMD_COLOR_SET
+  * ScreenLogic.LIGHT_CMD_COLOR_SYNC
+  * ScreenLogic.LIGHT_CMD_COLOR_SWIM
+  * ScreenLogic.LIGHT_CMD_COLOR_MODE_PARTY
+  * ScreenLogic.LIGHT_CMD_COLOR_MODE_ROMANCE
+  * ScreenLogic.LIGHT_CMD_COLOR_MODE_CARIBBEAN
+  * ScreenLogic.LIGHT_CMD_COLOR_MODE_AMERICAN
+  * ScreenLogic.LIGHT_CMD_COLOR_MODE_SUNSET
+  * ScreenLogic.LIGHT_CMD_COLOR_MODE_ROYAL
+  * ScreenLogic.LIGHT_CMD_COLOR_SET_SAVE
+  * ScreenLogic.LIGHT_CMD_COLOR_SET_RECALL
+  * ScreenLogic.LIGHT_CMD_COLOR_BLUE
+  * ScreenLogic.LIGHT_CMD_COLOR_GREEN
+  * ScreenLogic.LIGHT_CMD_COLOR_RED
+  * ScreenLogic.LIGHT_CMD_COLOR_WHITE
+  * ScreenLogic.LIGHT_CMD_COLOR_PURPLE
+
+### SLPoolStatusMessage
+
+Passed as an argument to the emitted `poolStatus` event handler.
+
+#### isDeviceReady()
+
+Returns a bool indicating whether the device is in a normal operating state.
+
+#### isDeviceSync()
+
+Returns a bool.
+
+#### isDeviceServiceMode()
+
+Returns a bool indicating whether the device is in service mode or not.
+
+#### isSpaActive()
+
+Returns a bool indicating whether the spa is currently active or not.
+
+#### isPoolActive()
+
+Returns a bool indicating whether the pool is currently active or not.
+
+#### Properties
+
+* `ok` - can be interpreted with `isDevice...` methods.
+* `freezeMode` - byte representing whether the device is in freeze mode or not.
+* `remotes` - byte
+* `poolDelay` - byte
+* `spaDelay` - byte
+* `cleanerDelay` - byte
+* `airTemp` - integer representing the current temperature (check controller config to see if it's in celsius or fahrenheit)
+* `currentTemp` - array of size 0-2 indicating current temperature of each body as an integer (pool: 0, spa: 1) (check controller config to see if it's in celsius or fahrenheit)
+* `heatStatus` - array of size 0-2 indicating whether heat is active or not for each body as an integer (pool: 0, spa: 1)
+* `setPoint` - array of size 0-2 holding the heating set point for each body as an integer (pool: 0, spa: 1) (check controller config to see if it's in celsius or fahrenheit)
+* `coolSetPoint` - array of size 0-2 holding the cooling set point for each body as an integer (pool: 0, spa: 1; the spa seems to always track air temperature for this, however) (check controller config to see if it's in celsius or fahrenheit)
+* `heatMode` - array of size 0-2 indicating whether heating is enabled or not for each body as an integer (pool: 0, spa: 1)
+* `circuitArray` - array holding all circuits in the system
+  * `id` - integer representing the circuit's ID (spa is 500, pool is 505)
+  * `state` - integer indicating whether the circuit is on or not (0/1)
+  * `colorSet` - byte
+  * `colorPos` - byte
+  * `colorStagger` - byte
+  * `delay` - byte
+* `pH` - float indicating the current pH level (e.g.: 7.62)
+* `orp` - integer indicating the current ORP value if available (e.g.: 650)
+* `saturation` - float indicating the water balance/saturation level (e.g.: -0.13)
+* `saltPPM` - integer indicating the salt level in parts-per-million (e.g.: 3000)
+* `pHTank` - integer indicating the fill level of the pH tank (e.g.: 4)
+* `orpTank` - integer indicating the fill level of the ORP tank
+* `alarms` - integer indicating how many alarms are currently active
+
+### SLRemoveClient
+
+Passed as an argument to the emitted `removeClient` event.
+
+### SLSaltCellConfigMessage
+
+Passed as an argument to the emitted `saltCellConfig` event handler.
+
+#### Properties
+
+* `installed` - boolean indicating whether a salt cell is installed or not
+* `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 bitmask
+* `superChlorTimer` - integer
+
+### SLSetCircuitRuntimeById
+
+Passed as an argument to the emitted `setCircuitRuntimebyId` event. 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 run time in minutes
+
+### SLSetCircuitStateMessage
+
+Passed as an argument to the emitted `circuitStateChanged` event.
+
+#### 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.
+* `circuitId` - integer indicating the ID of the circuit to set the state of.
+  * This ID can be retrieved from `SLControllerConfigMessage`'s `bodyArray` property.
+* `circuitState` - integer indicating whether to switch the circuit on (`1`) or off (`0`).
+
+### SLSetHeatModeMessage
+
+Passed as an argument to the emitted `heatModeChanged` event.
+
+#### 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.
+* `bodyType` - integer indicating the type of body to set the setpoint of. The pool is body `0` and the spa is body `1`.
+* `heatMode` - integer indicating the desired heater mode. Valid values are:
+  * ScreenLogic.HEAT_MODE_OFF
+  * ScreenLogic.HEAT_MODE_SOLAR
+  * ScreenLogic.HEAT_MODE_SOLARPREFERRED
+  * ScreenLogic.HEAT_MODE_HEATPUMP
+  * ScreenLogic.HEAT_MODE_DONTCHANGE
+
+### SLSetHeatSetPointMessage
+
+Passed as an argument to the emitted `setPointChanged` event.
+
+#### 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.
+* `bodyType` - integer indicating the type of body to set the setpoint of. The pool is body `0` and the spa is body `1`.
+* `temperature` - integer indicating the desired setpoint. This is presumably in whatever units your system is set to (celsius or fahrenheit).
+
 ### SLSetPumpFlow

-Passed as an argument to the emitted `setPumpFlow` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the set command. Sets flow setting for a pump/circuit combination.
+Passed as an argument to the emitted `setPumpFlow` event. Sets flow setting for a pump/circuit combination.

 #### Properties

@ -656,14 +770,50 @@ Passed as an argument to the emitted `setPumpFlow` event. The passed version is
 * `setPoint` - the value for which to set the pump/circuit combo
 * `isRPMs` - boolean, `true` for RPMs, `false` for GPMs

-### SLCancelDelay
+### SLSetSaltCellConfigMessage

-Passed as an argument to the emitted `cancelDelay` 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 `setSaltCellConfig` event.

-### SLAddClient
+#### Properties

-Passed as an argument to the emitted `addClient` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the command.
+* `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.

-### SLRemoveClient
+### SLSetScheduleEventById

-Passed as an argument to the emitted `removeClient` event. The passed version is empty, however, since the response is just an acknowledgement of receipt of the command.
+Passed as an argument to the emitted `setScheduleEventById` event. 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
+* `startTime` - the start time of the event, specified as minutes since midnight (see [conversion functions](#encodetimetime))
+  * example: 6:00am would be 360
+  * example: 6:15am would be 375
+* `stopTime` - the stop time of the event, specified as minutes since midnight (see [conversion functions](#encodetimetime))
+* `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
+* `heatCmd` - integer indicating the desired heater mode. Valid values are:
+  * ScreenLogic.HEAT_MODE_OFF
+  * ScreenLogic.HEAT_MODE_SOLAR
+  * ScreenLogic.HEAT_MODE_SOLARPREFERRED
+  * ScreenLogic.HEAT_MODE_HEATPUMP
+  * ScreenLogic.HEAT_MODE_DONTCHANGE
+* `heatSetPoint` - the temperature set point if heat is to be changed (ignored if bit 1 of flags is 0)
+
+### SLSetSystemTime
+
+Passed as an argument to the emitted `setSystemTime` event.
+
+### SLVersionMessage
+
+Passed as an argument to the emitted `version` event handler.
+
+#### Properties
+
+* `version` - a string representing the system's version
--- a/index.js
+++ b/index.js
@ -191,110 +191,137 @@ class UnitConnection extends EventEmitter {
    this.client.write(new messages.SLLoginMessage(password).toBuffer());
  }

-  getPoolStatus() {
-    debugUnit('sending pool status query...');
-    this.client.write(new messages.SLPoolStatusMessage().toBuffer());
+  getPoolStatus(senderId) {
+    debugUnit('[%d] sending pool status query...', senderId || 0);
+    this.client.write(new messages.SLPoolStatusMessage(null, senderId).toBuffer());
  }

-  getControllerConfig() {
-    debugUnit('sending controller config query...');
-    this.client.write(new messages.SLControllerConfigMessage().toBuffer());
+  getControllerConfig(senderId) {
+    debugUnit('[%d] sending controller config query...', senderId || 0);
+    this.client.write(new messages.SLControllerConfigMessage(null, senderId).toBuffer());
  }

-  getChemicalData() {
-    debugUnit('sending chemical data query...');
-    this.client.write(new messages.SLChemDataMessage().toBuffer());
+  getChemicalData(senderId) {
+    debugUnit('[%d] sending chemical data query...', senderId || 0);
+    this.client.write(new messages.SLChemDataMessage(null, senderId).toBuffer());
  }

-  getSaltCellConfig() {
-    debugUnit('sending salt cell config query...');
-    this.client.write(new messages.SLSaltCellConfigMessage().toBuffer());
+  getSaltCellConfig(senderId) {
+    debugUnit('[%d] sending salt cell config query...', senderId || 0);
+    this.client.write(new messages.SLSaltCellConfigMessage(null, senderId).toBuffer());
  }

-  getVersion() {
-    debugUnit('sending version query...');
-    this.client.write(new messages.SLVersionMessage().toBuffer());
+  getVersion(senderId) {
+    debugUnit('[%d] sending version query...', senderId || 0);
+    this.client.write(new messages.SLVersionMessage(null, senderId).toBuffer());
  }

-  getEquipmentConfiguration() {
-    debugUnit('sending equipment configuration query...');
-    this.client.write(new messages.SLEquipmentConfigurationMessage().toBuffer());
+  getEquipmentConfiguration(senderId) {
+    debugUnit('[%d] sending equipment configuration query...', senderId || 0);
+    this.client.write(new messages.SLEquipmentConfigurationMessage(null, senderId).toBuffer());
  }

-  setCircuitState(controllerId, circuitId, circuitState) {
-    debugUnit('sending set circuit state command: controllerId: %d, circuitId: %d, circuitState: %d...', controllerId, circuitId, circuitState);
-    this.client.write(new messages.SLSetCircuitStateMessage(controllerId, circuitId, circuitState).toBuffer());
+  setCircuitState(controllerId, circuitId, circuitState, senderId) {
+    debugUnit('[%d] sending set circuit state command: controllerId: %d, circuitId: %d, circuitState: %d...', senderId || 0, controllerId, circuitId, circuitState);
+    this.client.write(new messages.SLSetCircuitStateMessage(controllerId, circuitId, circuitState, senderId).toBuffer());
  }

-  setSetPoint(controllerId, bodyType, temperature) {
-    debugUnit('sending set setpoint command: controllerId: %d, bodyType: %d, temperature: %d...', controllerId, bodyType, temperature);
-    this.client.write(new messages.SLSetHeatSetPointMessage(controllerId, bodyType, temperature).toBuffer());
+  setSetPoint(controllerId, bodyType, temperature, senderId) {
+    debugUnit('[%d] sending set setpoint command: controllerId: %d, bodyType: %d, temperature: %d...', senderId || 0, controllerId, bodyType, temperature);
+    this.client.write(new messages.SLSetHeatSetPointMessage(controllerId, bodyType, temperature, senderId).toBuffer());
  }

-  setHeatMode(controllerId, bodyType, heatMode) {
-    debugUnit('sending set heatmode command: controllerId: %d, bodyType: %d, heatMode: %d...', controllerId, bodyType, heatMode);
-    this.client.write(new messages.SLSetHeatModeMessage(controllerId, bodyType, heatMode).toBuffer());
+  setHeatMode(controllerId, bodyType, heatMode, senderId) {
+    debugUnit('[%d] sending set heatmode command: controllerId: %d, bodyType: %d, heatMode: %d...', senderId || 0, controllerId, bodyType, heatMode);
+    this.client.write(new messages.SLSetHeatModeMessage(controllerId, bodyType, heatMode, senderId).toBuffer());
  }

-  sendLightCommand(controllerId, command) {
-    debugUnit('sending light command: controllerId: %d, command: %d...', controllerId, command);
-    this.client.write(new messages.SLLightControlMessage(controllerId, command).toBuffer());
+  sendLightCommand(controllerId, command, senderId) {
+    debugUnit('[%d] sending light command: controllerId: %d, command: %d...', senderId || 0, controllerId, command);
+    this.client.write(new messages.SLLightControlMessage(controllerId, command, senderId).toBuffer());
  }

-  setSaltCellOutput(controllerId, poolOutput, spaOutput) {
-    debugUnit('sending set saltcell output command: controllerId: %d, poolOutput: %d, spaOutput: %d...', controllerId, poolOutput, spaOutput);
-    this.client.write(new messages.SLSetSaltCellConfigMessage(controllerId, poolOutput, spaOutput).toBuffer());
+  setSaltCellOutput(controllerId, poolOutput, spaOutput, senderId) {
+    debugUnit('[%d] sending set saltcell output command: controllerId: %d, poolOutput: %d, spaOutput: %d...', senderId || 0, controllerId, poolOutput, spaOutput);
+    this.client.write(new messages.SLSetSaltCellConfigMessage(controllerId, poolOutput, spaOutput, senderId).toBuffer());
  }

-  getScheduleData(scheduleType) {
-    debugUnit('sending set schedule data query for scheduleType: %d...', scheduleType);
-    this.client.write(new messages.SLGetScheduleData(null, scheduleType).toBuffer());
+  getScheduleData(scheduleType, senderId) {
+    debugUnit('[%d] sending set schedule data query for scheduleType: %d...', senderId || 0, scheduleType);
+    this.client.write(new messages.SLGetScheduleData(null, scheduleType, senderId).toBuffer());
  }

-  addNewScheduleEvent(scheduleType) {
-    debugUnit('sending add new schedule event command for scheduleType: %d...', scheduleType);
-    this.client.write(new messages.SLAddNewScheduleEvent(null, scheduleType).toBuffer());
+  addNewScheduleEvent(scheduleType, senderId) {
+    debugUnit('[%d] sending add new schedule event command for scheduleType: %d...', senderId || 0, scheduleType);
+    this.client.write(new messages.SLAddNewScheduleEvent(null, scheduleType, senderId).toBuffer());
  }

-  deleteScheduleEventById(scheduleId) {
-    debugUnit('sending delete schedule event command for scheduleId: %d...', scheduleId);
-    this.client.write(new messages.SLDeleteScheduleEventById(scheduleId).toBuffer());
+  deleteScheduleEventById(scheduleId, senderId) {
+    debugUnit('[%d] sending delete schedule event command for scheduleId: %d...', senderId || 0, scheduleId);
+    this.client.write(new messages.SLDeleteScheduleEventById(scheduleId, senderId).toBuffer());
  }

  // todo: should this just accept a SLSetScheduleEventById message instead of all these args?
-  setScheduleEventById(scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint) {
-    debugUnit('sending set schedule event command for scheduleId: %d, circuitId: %d, startTime: %d, stopTime: %d, dayMask: %d, flags: %d, heatCmd: %d, heatSetPoint: %d...', scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint);
-    this.client.write(new messages.SLSetScheduleEventById(null, scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint).toBuffer());
+  setScheduleEventById(scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint, senderId) {
+    debugUnit('[%d] sending set schedule event command for scheduleId: %d, circuitId: %d, startTime: %d, stopTime: %d, dayMask: %d, flags: %d, heatCmd: %d, heatSetPoint: %d...', senderId || 0, scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint);
+    this.client.write(new messages.SLSetScheduleEventById(null, scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint, senderId).toBuffer());
  }

-  setCircuitRuntimebyId(circuitId, runTime) {
-    debugUnit('sending set circuit runtime command for circuitId: %d, runTime: %d...', circuitId, runTime);
-    this.client.write(new messages.SLSetCircuitRuntimeById(circuitId, runTime).toBuffer());
+  setCircuitRuntimebyId(circuitId, runTime, senderId) {
+    debugUnit('[%d] sending set circuit runtime command for circuitId: %d, runTime: %d...', senderId || 0, circuitId, runTime);
+    this.client.write(new messages.SLSetCircuitRuntimeById(circuitId, runTime, senderId).toBuffer());
  }

-  getPumpStatus(pumpId) {
-    debugUnit('sending get pump status command for pumpId: %d...', pumpId);
-    this.client.write(new messages.SLGetPumpStatus(null, pumpId).toBuffer());
+  getPumpStatus(pumpId, senderId) {
+    debugUnit('[%d] sending get pump status command for pumpId: %d...', senderId || 0, pumpId);
+    this.client.write(new messages.SLGetPumpStatus(null, pumpId, senderId).toBuffer());
  }

-  setPumpFlow(pumpId, circuitId, setPoint, isRPMs) {
-    debugUnit('sending set pump flow command for pumpId: %d, circuitId: %d, setPoint: %d, isRPMs: %d...', pumpId, circuitId, setPoint, isRPMs);
-    this.client.write(new messages.SLSetPumpFlow(pumpId, circuitId, setPoint, isRPMs).toBuffer());
+  setPumpFlow(pumpId, circuitId, setPoint, isRPMs, senderId) {
+    debugUnit('[%d] sending set pump flow command for pumpId: %d, circuitId: %d, setPoint: %d, isRPMs: %d...', senderId || 0, pumpId, circuitId, setPoint, isRPMs);
+    this.client.write(new messages.SLSetPumpFlow(pumpId, circuitId, setPoint, isRPMs, senderId).toBuffer());
  }

-  cancelDelay() {
-    debugUnit('sending cancel delay command...');
-    this.client.write(new messages.SLCancelDelay().toBuffer());
+  cancelDelay(senderId) {
+    debugUnit('[%d] sending cancel delay command...', senderId || 0);
+    this.client.write(new messages.SLCancelDelay(senderId).toBuffer());
  }

-  addClient(senderId) {
-    debugUnit('sending add client command...');
-    this.client.write(new messages.SLAddClient(senderId).toBuffer());
+  addClient(clientId, senderId) {
+    debugUnit('[%d] sending add client command, clientId %d...', senderId || 0, clientId);
+    this.client.write(new messages.SLAddClient(clientId, senderId).toBuffer());
  }

-  removeClient(senderId) {
-    debugUnit('sending remove client command...');
-    this.client.write(new messages.SLRemoveClient(senderId).toBuffer());
+  removeClient(clientId, senderId) {
+    debugUnit('[%d] sending remove client command, clientId %d...', senderId || 0, clientId);
+    this.client.write(new messages.SLRemoveClient(clientId, senderId).toBuffer());
+  }
+
+  getSystemTime(senderId) {
+    debugUnit('[%d] sending get system time query...', senderId || 0);
+    this.client.write(new messages.SLGetSystemTime(null, senderId).toBuffer());
+  }
+
+  setSystemTime(date, shouldAdjustForDST, senderId) {
+    if (!(date instanceof Date)) {
+      debugUnit('setSystemTime() must receive valid Date object for the date argument');
+      this.emit('setSystemTime', null);
+      return;
+    }
+
+    if (typeof shouldAdjustForDST !== 'boolean') {
+      debugUnit('setSystemTime() must receive a boolean for the shouldAdjustForDST argument');
+      this.emit('setSystemTime', null);
+      return;
+    }
+
+    debugUnit('[%d] sending set system time command...', senderId || 0);
+    this.client.write(new messages.SLSetSystemTime(null, date, shouldAdjustForDST, senderId).toBuffer());
+  }
+
+  getHistoryData(fromTime, toTime, senderId) {
+    debugUnit('[%d] requesting history data from `%s` to `%s`', senderId || 0, fromTime || new Date(), toTime || new Date());
+    this.client.write(new messages.SLGetHistoryData(null, fromTime, toTime, senderId).toBuffer());
  }

  onClientMessage(msg) {
@ -336,23 +363,23 @@ class UnitConnection extends EventEmitter {
        break;
      case messages.SLSetCircuitStateMessage.getResponseId():
        debugUnit("  it's circuit toggle ack");
-        this.emit('circuitStateChanged', new messages.SLSetCircuitStateMessage());
+        this.emit('circuitStateChanged', new messages.SLSetCircuitStateMessage(msg));
        break;
      case messages.SLSetHeatSetPointMessage.getResponseId():
        debugUnit("  it's a setpoint ack");
-        this.emit('setPointChanged', new messages.SLSetHeatSetPointMessage());
+        this.emit('setPointChanged', new messages.SLSetHeatSetPointMessage(msg));
        break;
      case messages.SLSetHeatModeMessage.getResponseId():
        debugUnit("  it's a heater mode ack");
-        this.emit('heatModeChanged', new messages.SLSetHeatModeMessage());
+        this.emit('heatModeChanged', new messages.SLSetHeatModeMessage(msg));
        break;
      case messages.SLLightControlMessage.getResponseId():
        debugUnit("  it's a light control ack");
-        this.emit('sentLightCommand', new messages.SLLightControlMessage());
+        this.emit('sentLightCommand', new messages.SLLightControlMessage(msg));
        break;
      case messages.SLSetSaltCellConfigMessage.getResponseId():
        debugUnit("  it's a set salt cell config ack");
-        this.emit('setSaltCellConfig', new messages.SLSetSaltCellConfigMessage());
+        this.emit('setSaltCellConfig', new messages.SLSetSaltCellConfigMessage(msg));
        break;
      case messages.SLEquipmentConfigurationMessage.getResponseId():
        debugUnit("  it's equipment configuration");
@ -376,7 +403,7 @@ class UnitConnection extends EventEmitter {
        break;
      case messages.SLSetCircuitRuntimeById.getResponseId():
        debugUnit("  it's a set circuit runtime ack");
-        this.emit('setCircuitRuntimebyId', new messages.SLSetCircuitRuntimeById());
+        this.emit('setCircuitRuntimebyId', new messages.SLSetCircuitRuntimeById(msg));
        break;
      case messages.SLGetPumpStatus.getResponseId():
        debugUnit("  it's pump status");
@ -384,24 +411,44 @@ class UnitConnection extends EventEmitter {
        break;
      case messages.SLSetPumpFlow.getResponseId():
        debugUnit("  it's a set pump flow ack");
-        this.emit('setPumpFlow', new messages.SLSetPumpFlow());
+        this.emit('setPumpFlow', new messages.SLSetPumpFlow(msg));
        break;
      case messages.SLCancelDelay.getResponseId():
        debugUnit("  it's a cancel delay ack");
-        this.emit('cancelDelay', new messages.SLCancelDelay());
+        this.emit('cancelDelay', new messages.SLCancelDelay(msg));
        break;
      case messages.SLAddClient.getResponseId():
        debugUnit("  it's an add client ack");
-        this.emit('addClient', new messages.SLCancelDelay());
+        this.emit('addClient', new messages.SLAddClient(msg));
        break;
      case messages.SLRemoveClient.getResponseId():
        debugUnit("  it's a remove client ack");
-        this.emit('removeClient', new messages.SLCancelDelay());
+        this.emit('removeClient', new messages.SLRemoveClient(msg));
        break;
      case messages.SLPoolStatusMessage.getAsyncResponseId():
        debugUnit("  it's async pool status");
        this.emit('poolStatus', new messages.SLPoolStatusMessage(msg));
        break;
+      case messages.SLGetSystemTime.getResponseId():
+        debugUnit("  it's system time");
+        this.emit('getSystemTime', new messages.SLGetSystemTime(msg));
+        break;
+      case messages.SLSetSystemTime.getResponseId():
+        debugUnit("  it's a set system time ack");
+        this.emit('setSystemTime', new messages.SLSetSystemTime(msg));
+        break;
+      case messages.SLGetHistoryData.getResponseId():
+        debugUnit("  it's a history data query ack");
+        this.emit('getHistoryDataPending');
+        break;
+      case messages.SLGetHistoryData.getPayloadId():
+        debugUnit("  it's a history data payload");
+        this.emit('getHistoryData', new messages.SLGetHistoryData(msg));
+        break;
+      case 12501:
+        debugUnit("  it's a schedule changed notification");
+        this.emit('scheduleChanged');
+        break;
      case 13:
        debugUnit("  it's a login failure.");
        this.emit('loginFailed');
--- a/messages/SLAddClient.js
+++ b/messages/SLAddClient.js
@ -5,15 +5,20 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12522;

 exports.SLAddClient = class SLAddClient extends SLMessage {
-  constructor(senderId) {
-    super(0, MSG_ID);
+  constructor(clientId, senderId) {
+    if (typeof clientId === 'object') {
+      var size = clientId.readInt32LE(4) + 8;
+      super(clientId, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.senderId = senderId;
+      this.clientId = clientId;
+    }
  }

  encode() {
    this.writeInt32LE(0);
-    this.writeInt32LE(this.senderId);
+    this.writeInt32LE(this.clientId);

    super.encode();
  }
--- a/messages/SLAddNewScheduleEvent.js
+++ b/messages/SLAddNewScheduleEvent.js
@ -6,23 +6,15 @@ const MSG_ID = 12544;


 exports.SLAddNewScheduleEvent = class SLAddNewScheduleEvent extends SLMessage {
-  constructor(buf, scheduleType) {
-    var size;
+  constructor(buf, scheduleType, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-
-    if (!buf) {
-      // console.log('Requested Schedule type = ', scheduleType);
      this.writeInt32LE(0);
      this.writeInt32LE(scheduleType);
-    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
-
-      this.decode();
    }
  }

--- a/messages/SLCancelDelay.js
+++ b/messages/SLCancelDelay.js
@ -5,9 +5,8 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12580;

 exports.SLCancelDelay = class SLCancelDelay extends SLMessage {
-  constructor() {
-    super(0, MSG_ID);
-
+  constructor(senderId) {
+    super(senderId, MSG_ID);
  }

  encode() {
--- a/messages/SLChemDataMessage.js
+++ b/messages/SLChemDataMessage.js
@ -5,20 +5,14 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12592;

 exports.SLChemDataMessage = class SLChemDataMessage extends SLMessage {
-  constructor(buf) {
-    var size;
+  constructor(buf, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
-
-    if (!buf) {
-      this.writeInt32LE(0); // controller index
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
+      super(senderId, MSG_ID);

-      this.decode();
+      this.writeInt32LE(0); // controller index
    }
  }

--- a/messages/SLControllerConfigMessage.js
+++ b/messages/SLControllerConfigMessage.js
@ -13,21 +13,15 @@ const CIRCUIT_NAME_VALUE_MAP = [
 ];

 exports.SLControllerConfigMessage = class SLControllerConfigMessage extends SLMessage {
-  constructor(buf) {
-    var size;
+  constructor(buf, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
-
-    if (!buf) {
-      this.writeInt32LE(0);
-      this.writeInt32LE(0);
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
+      super(senderId, MSG_ID);

-      this.decode();
+      this.writeInt32LE(0);
+      this.writeInt32LE(0);
    }
  }

--- a/messages/SLDeleteScheduleEventById.js
+++ b/messages/SLDeleteScheduleEventById.js
@ -5,8 +5,8 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12546;

 exports.SLDeleteScheduleEventById = class SLDeleteScheduleEventById extends SLMessage {
-  constructor(scheduleId) {
-    super(0, MSG_ID);
+  constructor(scheduleId, senderId) {
+    super(senderId, MSG_ID);

    this.writeInt32LE(0);
    this.writeInt32LE(scheduleId);
--- a/messages/SLEquipmentConfigurationMessage.js
+++ b/messages/SLEquipmentConfigurationMessage.js
@ -5,21 +5,15 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12566;

 exports.SLEquipmentConfigurationMessage = class SLEquipmentConfigurationMessage extends SLMessage {
-  constructor(buf) {
-    var size;
+  constructor(buf, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
-
-    if (!buf) {
-      this.writeInt32LE(0);
-      this.writeInt32LE(0);
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
+      super(senderId, MSG_ID);

-      this.decode();
+      this.writeInt32LE(0);
+      this.writeInt32LE(0);
    }
  }

--- a/messages/SLGetHistoryData.js
+++ b/messages/SLGetHistoryData.js
@ -0,0 +1,87 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 12534;
+const PAYLOAD_MSG_ID = 12502;
+
+exports.SLGetHistoryData = class SLGetHistoryData extends SLMessage {
+  constructor(buf, fromTime, toTime, senderId) {
+    if (buf) {
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);
+
+      this.writeInt32LE(0);
+      this.writeSLDateTime(fromTime);
+      this.writeSLDateTime(toTime);
+      this.writeInt32LE(senderId || 0);
+    }
+  }
+
+  decode() {
+    super.decode();
+
+    this.airTemps = this.readTimeTempPointsPairs();
+    this.poolTemps = this.readTimeTempPointsPairs();
+    this.poolSetPointTemps = this.readTimeTempPointsPairs();
+    this.spaTemps = this.readTimeTempPointsPairs();
+    this.spaSetPointTemps = this.readTimeTempPointsPairs();
+    this.poolRuns = this.readTimeTimePointsPairs();
+    this.spaRuns = this.readTimeTimePointsPairs();
+    this.solarRuns = this.readTimeTimePointsPairs();
+    this.heaterRuns = this.readTimeTimePointsPairs();
+    this.lightRuns = this.readTimeTimePointsPairs();
+  }
+
+  readTimeTempPointsPairs() {
+    let retval = [];
+    // 4 bytes for the length
+    if (this.length >= this.readOffset + 4) {
+      let points = this.readInt32LE();
+      // 16 bytes per time, 4 bytes per temperature
+      if (this.length >= this.readOffset + (points * (16 + 4))) {
+        for (let i = 0; i < points; i++) {
+          let time = this.readSLDateTime();
+          let temp = this.readInt32LE();
+          retval.push({
+            time: time,
+            temp: temp,
+          });
+        }
+      }
+    }
+
+    return retval;
+  }
+
+  readTimeTimePointsPairs() {
+    let retval = [];
+    // 4 bytes for the length
+    if (this.length >= this.readOffset + 4) {
+      let points = this.readInt32LE();
+      // 16 bytes per on time, 16 bytes per off time
+      if (this.length >= this.readOffset + (points * (16 + 16))) {
+        for (let i = 0; i < points; i++) {
+          let onTime = this.readSLDateTime();
+          let offTime = this.readSLDateTime();
+          retval.push({
+            on: onTime,
+            off: offTime,
+          });
+        }
+      }
+    }
+
+    return retval;
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+
+  static getPayloadId() {
+    return PAYLOAD_MSG_ID;
+  }
+};
--- a/messages/SLGetPumpStatus.js
+++ b/messages/SLGetPumpStatus.js
@ -5,21 +5,15 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12584;

 exports.SLGetPumpStatus = class SLGetPumpStatus extends SLMessage {
-  constructor(buf, pumpId) {
-    var size;
+  constructor(buf, pumpId, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    if (!buf) {
      this.writeInt32LE(0);
      this.writeInt32LE(pumpId);
-    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
-
-      this.decode();
    }
  }

--- a/messages/SLGetScheduleData.js
+++ b/messages/SLGetScheduleData.js
@ -5,22 +5,15 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12542;

 exports.SLGetScheduleData = class SLGetScheduleData extends SLMessage {
-  constructor(buf, scheduleType) {
-    var size;
+  constructor(buf, scheduleType, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-
-    if (!buf) {
      this.writeInt32LE(0);
      this.writeInt32LE(scheduleType);
-    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
-
-      this.decode();
    }
  }

--- a/messages/SLGetSystemTime.js
+++ b/messages/SLGetSystemTime.js
@ -0,0 +1,37 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 8110;
+
+exports.SLGetSystemTime = class SLGetSystemTime extends SLMessage {
+  constructor(buf, senderId) {
+    if (buf) {
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);
+    }
+  }
+
+  decode() {
+    super.decode();
+
+    this.date = this.readSLDateTime();
+    this.year = this.date.getFullYear();
+    this.month = this.date.getMonth() + 1; // + 1 is for backward compatibility, SLTime represents months as 1-based
+    this.dayOfWeek = this.date.getDay(); // should probably be tweaked to adjust what days are 0-6 as SLTime and Javascript start on different days of the week
+    this.day = this.date.getDate();
+    this.hour = this.date.getHours();
+    this.minute = this.date.getMinutes();
+    this.second = this.date.getSeconds();
+    this.millisecond = this.date.getMilliseconds();
+
+    var adjustForDST = this.readInt32LE();
+    this.adjustForDST = adjustForDST === 1;
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};
--- a/messages/SLLightControl.js
+++ b/messages/SLLightControl.js
@ -5,11 +5,16 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12556;

 exports.SLLightControl = class SLLightControl extends SLMessage {
-  constructor(controllerIndex, command) {
-    super(0, MSG_ID);
+  constructor(controllerIndex, command, senderId) {
+    if (typeof controllerIndex === 'object') {
+      var size = controllerIndex.readInt32LE(4) + 8;
+      super(controllerIndex, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.controllerIndex = controllerIndex;
-    this.command = command;
+      this.controllerIndex = controllerIndex;
+      this.command = command;
+    }
  }

  encode() {
--- a/messages/SLMessage.js
+++ b/messages/SLMessage.js
@ -27,7 +27,7 @@ exports.SLMessage = class SLMessage extends SmartBuffer {
      this.writeUInt16LE(messageId || 0);

      this._wroteSize = false;
-    } else if (senderId) {
+    } else if (typeof senderId === 'object') {
      this._wroteSize = true;
      var buffer = senderId;
      this.writeBuffer(buffer, 0);
@ -150,6 +150,31 @@ exports.SLMessage = class SLMessage extends SmartBuffer {
    return 0;
  }

+  writeSLDateTime(date) {
+    this.writeInt16LE(date.getFullYear());
+    this.writeInt16LE(date.getMonth() + 1);
+    this.writeInt16LE(date.getDay() + 1);
+    this.writeInt16LE(date.getDate());
+    this.writeInt16LE(date.getHours());
+    this.writeInt16LE(date.getMinutes());
+    this.writeInt16LE(date.getSeconds());
+    this.writeInt16LE(date.getMilliseconds());
+  }
+
+  readSLDateTime() {
+    let date = new Date();
+    date.setFullYear(this.readInt16LE());
+    date.setMonth(this.readInt16LE() - 1);
+    this.readInt16LE();
+    date.setDate(this.readInt16LE());
+    date.setHours(this.readInt16LE());
+    date.setMinutes(this.readInt16LE());
+    date.setSeconds(this.readInt16LE());
+    date.setMilliseconds(this.readInt16LE());
+
+    return date;
+  }
+
  static slackForAlignment(val) {
    return (4 - val % 4) % 4;
  }
--- a/messages/SLPoolStatusMessage.js
+++ b/messages/SLPoolStatusMessage.js
@ -9,20 +9,14 @@ const SPA_CIRCUIT_ID = 500;
 const POOL_CIRCUIT_ID = 505;

 exports.SLPoolStatusMessage = class SLPoolStatusMessage extends SLMessage {
-  constructor(buf) {
-    var size;
+  constructor(buf, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
-
-    if (!buf) {
-      this.writeInt32LE(0);
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
+      super(senderId, MSG_ID);

-      this.decode();
+      this.writeInt32LE(0);
    }
  }

--- a/messages/SLRemoveClient.js
+++ b/messages/SLRemoveClient.js
@ -5,15 +5,20 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12524;

 exports.SLRemoveClient = class SLRemoveClient extends SLMessage {
-  constructor(senderId) {
-    super(0, MSG_ID);
+  constructor(clientId, senderId) {
+    if (typeof clientId === 'object') {
+      var size = clientId.readInt32LE(4) + 8;
+      super(clientId, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.senderId = senderId;
+      this.clientId = clientId;
+    }
  }

  encode() {
    this.writeInt32LE(0);
-    this.writeInt32LE(this.senderId);
+    this.writeInt32LE(this.clientId);

    super.encode();
  }
--- a/messages/SLSaltCellConfigMessage.js
+++ b/messages/SLSaltCellConfigMessage.js
@ -5,20 +5,14 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12572;

 exports.SLSaltCellConfigMessage = class SLSaltCellConfigMessage extends SLMessage {
-  constructor(buf) {
-    var size;
+  constructor(buf, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
-
-    if (!buf) {
-      this.writeInt32LE(0); // controller index
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
+      super(senderId, MSG_ID);

-      this.decode();
+      this.writeInt32LE(0); // controller index
    }
  }

--- a/messages/SLSetCircuitRuntimeById.js
+++ b/messages/SLSetCircuitRuntimeById.js
@ -6,11 +6,16 @@ const MSG_ID = 12550;


 exports.SLSetCircuitRuntimeById = class SLSetCircuitRuntimeById extends SLMessage {
-  constructor(circuitId, runTime) {
-    super(0, MSG_ID);
+  constructor(circuitId, runTime, senderId) {
+    if (typeof circuitId === 'object') {
+      var size = circuitId.readInt32LE(4) + 8;
+      super(circuitId, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.circuitId = circuitId;
-    this.runTime = runTime;
+      this.circuitId = circuitId;
+      this.runTime = runTime;
+    }
  }

  encode() {
--- a/messages/SLSetCircuitStateMessage.js
+++ b/messages/SLSetCircuitStateMessage.js
@ -5,12 +5,17 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12530;

 exports.SLSetCircuitStateMessage = class SLSetCircuitStateMessage extends SLMessage {
-  constructor(controllerId, circuitId, circuitState) {
-    super(0, MSG_ID);
+  constructor(controllerId, circuitId, circuitState, senderId) {
+    if (typeof controllerId === 'object') {
+      var size = controllerId.readInt32LE(4) + 8;
+      super(controllerId, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.controllerId = controllerId;
-    this.circuitId = circuitId;
-    this.circuitState = circuitState;
+      this.controllerId = controllerId;
+      this.circuitId = circuitId;
+      this.circuitState = circuitState;
+    }
  }

  encode() {
--- a/messages/SLSetHeatMode.js
+++ b/messages/SLSetHeatMode.js
@ -5,14 +5,17 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12538;

 exports.SLSetHeatMode = class SLSetHeatMode extends SLMessage {
-  constructor(controllerIndex, bodyType, heatMode) {
-    super(0, MSG_ID);
+  constructor(controllerIndex, bodyType, heatMode, senderId) {
+    if (typeof controllerIndex === 'object') {
+      var size = controllerIndex.readInt32LE(4) + 8;
+      super(controllerIndex, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.controllerIndex = controllerIndex;
-    this.bodyType = bodyType;
-    this.heatMode = heatMode;
-    // heatmodes:
-    // 0: "Off", 1: "Solar", 2 : "Solar Preferred", 3 : "Heat Pump", 4: "Don't Change"
+      this.controllerIndex = controllerIndex;
+      this.bodyType = bodyType;
+      this.heatMode = heatMode;
+    }
  }

  encode() {
--- a/messages/SLSetHeatSetPoint.js
+++ b/messages/SLSetHeatSetPoint.js
@ -5,12 +5,17 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12528;

 exports.SLSetHeatSetPoint = class SLSetHeatSetPoint extends SLMessage {
-  constructor(controllerIndex, bodyType, temperature) {
-    super(0, MSG_ID);
+  constructor(controllerIndex, bodyType, temperature, senderId) {
+    if (typeof controllerIndex === 'object') {
+      var size = controllerIndex.readInt32LE(4) + 8;
+      super(controllerIndex, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.controllerIndex = controllerIndex;
-    this.bodyType = bodyType;
-    this.temperature = temperature;
+      this.controllerIndex = controllerIndex;
+      this.bodyType = bodyType;
+      this.temperature = temperature;
+    }
  }

  encode() {
--- a/messages/SLSetPumpFlow.js
+++ b/messages/SLSetPumpFlow.js
@ -5,16 +5,22 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12586;

 exports.SLSetPumpFlow = class SLSetPumpFlow extends SLMessage {
-  constructor(pumpId, circuitId, setPoint, isRPMs) {
-    super(0, MSG_ID);
-    this.pumpId = pumpId;
-    this.circuitId = circuitId;
-    this.setPoint = setPoint;
-
-    if (isRPMs === true) {
-      this.isRPMs = 1;
+  constructor(pumpId, circuitId, setPoint, isRPMs, senderId) {
+    if (typeof pumpId === 'object') {
+      var size = pumpId.readInt32LE(4) + 8;
+      super(pumpId, MSG_ID, size);
    } else {
-      this.isRPMs = 0;
+      super(senderId, MSG_ID);
+
+      this.pumpId = pumpId;
+      this.circuitId = circuitId;
+      this.setPoint = setPoint;
+
+      if (isRPMs === true) {
+        this.isRPMs = 1;
+      } else {
+        this.isRPMs = 0;
+      }
    }
  }

--- a/messages/SLSetSaltCellConfigMessage.js
+++ b/messages/SLSetSaltCellConfigMessage.js
@ -5,12 +5,17 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 12576;

 exports.SLSetSaltCellConfigMessage = class SLSetSaltCellConfigMessage extends SLMessage {
-  constructor(controllerIndex, poolOutput, spaOutput) {
-    super(0, MSG_ID);
+  constructor(controllerIndex, poolOutput, spaOutput, senderId) {
+    if (typeof controllerIndex === 'object') {
+      var size = controllerIndex.readInt32LE(4) + 8;
+      super(controllerIndex, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-    this.controllerIndex = controllerIndex;
-    this.poolOutput = poolOutput;
-    this.spaOutput = spaOutput;
+      this.controllerIndex = controllerIndex;
+      this.poolOutput = poolOutput;
+      this.spaOutput = spaOutput;
+    }
  }

  encode() {
--- a/messages/SLSetScheduleEventById.js
+++ b/messages/SLSetScheduleEventById.js
@ -6,15 +6,13 @@ const MSG_ID = 12548;


 exports.SLSetScheduleEventById = class SLSetScheduleEventById extends SLMessage {
-  constructor(buf, scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint) {
-    var size;
+  constructor(buf, scheduleId, circuitId, startTime, stopTime, dayMask, flags, heatCmd, heatSetPoint, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);

-
-    if (!buf) {
      this.writeInt32LE(0);
      this.writeInt32LE(scheduleId);
      this.writeInt32LE(circuitId);
@ -24,11 +22,6 @@ exports.SLSetScheduleEventById = class SLSetScheduleEventById extends SLMessage
      this.writeInt32LE(flags);
      this.writeInt32LE(heatCmd);
      this.writeInt32LE(heatSetPoint);
-    } else {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
-
-      this.decode();
    }
  }

--- a/messages/SLSetSystemTime.js
+++ b/messages/SLSetSystemTime.js
@ -0,0 +1,28 @@
+'use strict';
+
+const SLMessage = require('./SLMessage.js').SLMessage;
+
+const MSG_ID = 8112;
+
+exports.SLSetSystemTime = class SLSetSystemTime extends SLMessage {
+  constructor(buf, date, shouldAdjustForDST, senderId) {
+    if (buf) {
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);
+
+      this.date = date;
+      this.shouldAdjustForDST = shouldAdjustForDST;
+    }
+  }
+
+  encode() {
+    this.writeSLDateTime(this.date);
+    this.writeInt32LE(this.shouldAdjustForDST ? 1 : 0);
+  }
+
+  static getResponseId() {
+    return MSG_ID + 1;
+  }
+};
--- a/messages/SLVersionMessage.js
+++ b/messages/SLVersionMessage.js
@ -5,18 +5,12 @@ const SLMessage = require('./SLMessage.js').SLMessage;
 const MSG_ID = 8120;

 exports.SLVersionMessage = class SLVersionMessage extends SLMessage {
-  constructor(buf) {
-    var size;
+  constructor(buf, senderId) {
    if (buf) {
-      size = buf.readInt32LE(4) + 8;
-    }
-    super(0, MSG_ID, size);
-
-    if (buf) {
-      this._wroteSize = true;
-      this.writeBuffer(buf, 0);
-
-      this.decode();
+      var size = buf.readInt32LE(4) + 8;
+      super(buf, MSG_ID, size);
+    } else {
+      super(senderId, MSG_ID);
    }
  }

--- a/messages/index.js
+++ b/messages/index.js
@ -25,3 +25,6 @@ exports.SLSetPumpFlow = require('./SLSetPumpFlow.js').SLSetPumpFlow;
 exports.SLCancelDelay = require('./SLCancelDelay.js').SLCancelDelay;
 exports.SLAddClient = require('./SLAddClient.js').SLAddClient;
 exports.SLRemoveClient = require('./SLRemoveClient.js').SLRemoveClient;
+exports.SLGetSystemTime = require('./SLGetSystemTime.js').SLGetSystemTime;
+exports.SLSetSystemTime = require('./SLSetSystemTime.js').SLSetSystemTime;
+exports.SLGetHistoryData = require('./SLGetHistoryData.js').SLGetHistoryData;
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,28 +1,28 @@
 {
-	"name": "node-screenlogic",
-	"description": "Tool for connecting to Pentair ScreenLogic systems on the local network",
-	"version": "1.6.0",
-	"main": "index.js",
-	"license": "MIT",
-	"repository": "https://github.com/parnic/node-screenlogic.git",
-	"keywords": [
-		"pentair",
-		"pool",
-		"screenlogic",
-		"swimmingpool"
-	],
-	"dependencies": {
-		"debug": "^4.1.1",
-		"smart-buffer": "~4.1.0"
-	},
-	"devDependencies": {
-		"eslint": "^7.4.0",
-		"eslint-config-strongloop": "^2.1.0",
-		"mocha": "^8.0.0"
-	},
-	"scripts": {
-		"test": "mocha test/*.spec.js",
-		"pretest": "eslint --ignore-path .gitignore .",
-		"test-slmessage": "mocha test/slmessage.spec.js"
-	}
+    "name": "node-screenlogic",
+    "description": "Tool for connecting to Pentair ScreenLogic systems on the local network",
+    "version": "1.8.0",
+    "main": "index.js",
+    "license": "MIT",
+    "repository": "https://github.com/parnic/node-screenlogic.git",
+    "keywords": [
+        "pentair",
+        "pool",
+        "screenlogic",
+        "swimmingpool"
+    ],
+    "dependencies": {
+        "debug": "^4.3.2",
+        "smart-buffer": "^4.2.0"
+    },
+    "devDependencies": {
+        "eslint": "^8.0.0",
+        "eslint-config-strongloop": "^2.1.0",
+        "mocha": "^9.1.2"
+    },
+    "scripts": {
+        "test": "mocha test/*.spec.js",
+        "pretest": "eslint --ignore-path .gitignore .",
+        "test-slmessage": "mocha test/slmessage.spec.js"
+    }
 }
--- a/test/find.spec.js
+++ b/test/find.spec.js
@ -3,8 +3,8 @@
 const ScreenLogic = require('../index');

 // you'll need a ScreenLogic-enabled device on your network for this to succeed
-describe('Finder', () => {
-  it('finds a server', done => {
+describe('Finder', function() {
+  it('finds a server', function(done) {
    let finder = new ScreenLogic.FindUnits();
    finder.on('serverFound', server => {
      finder.close();
--- a/test/slmessage.spec.js
+++ b/test/slmessage.spec.js
@ -9,7 +9,7 @@ function slMessageLen(str) {
  return 4 + str.length + SLMessage.slackForAlignment(str.length);
 }

-describe('SLMessage utilities', () => {
+describe('SLMessage utilities', function() {
  // 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;
@ -172,4 +172,62 @@ describe('SLMessage utilities', () => {
      assert.strictEqual(decodedMsg.dataLength, decodedMsg.readOffset - 8);
    }
  });
+
+  it('encodes Date as SLTime', function() {
+    let msg = new SLMessage();
+    let date = new Date(2021, 8, 6, 22, 8, 5);
+    msg.writeSLDateTime(date);
+    let decodedMsg = new SLMessage(msg.toBuffer());
+    assert.equal(decodedMsg.readUInt16LE(), 2021);
+    // javascript Date() month is 0-based, ScreenLogic month matches the calendar
+    assert.equal(decodedMsg.readUInt16LE(), 9);
+    // ScreenLogic day-of-week starts with Sunday as 1
+    assert.equal(decodedMsg.readUInt16LE(), 2);
+    assert.equal(decodedMsg.readUInt16LE(), 6);
+    assert.equal(decodedMsg.readUInt16LE(), 22);
+    assert.equal(decodedMsg.readUInt16LE(), 8);
+    assert.equal(decodedMsg.readUInt16LE(), 5);
+    assert.equal(decodedMsg.readUInt16LE(), 0);
+  });
+
+  it('decodes SLTime as Date', function() {
+    let msg = new SLMessage();
+    let date = new Date(2021, 8, 6, 22, 8, 5);
+    msg.writeSLDateTime(date);
+    let decodedMsg = new SLMessage(msg.toBuffer());
+    let decodedDate = decodedMsg.readSLDateTime();
+    assert.equal(date.getFullYear(), decodedDate.getFullYear());
+    assert.equal(date.getMonth(), decodedDate.getMonth());
+    assert.equal(date.getDate(), decodedDate.getDate());
+    assert.equal(date.getHours(), decodedDate.getHours());
+    assert.equal(date.getMinutes(), decodedDate.getMinutes());
+    assert.equal(date.getSeconds(), decodedDate.getSeconds());
+    assert.equal(date.getMilliseconds(), decodedDate.getMilliseconds());
+  });
+
+  it('writes the appropriate day of week', function() {
+    let handler = function(inDate) {
+      let msg = new SLMessage();
+      msg.writeSLDateTime(inDate);
+      let decodedMsg = new SLMessage(msg.toBuffer());
+      decodedMsg.readUInt16LE();
+      decodedMsg.readUInt16LE();
+      return decodedMsg.readUInt16LE();
+    }
+
+    let dow = handler(new Date(2022, 3, 17, 10, 3, 0));
+    assert.equal(dow, 1);
+    dow = handler(new Date(2022, 3, 18, 10, 3, 0));
+    assert.equal(dow, 2);
+    dow = handler(new Date(2022, 3, 19, 10, 3, 0));
+    assert.equal(dow, 3);
+    dow = handler(new Date(2022, 3, 20, 10, 3, 0));
+    assert.equal(dow, 4);
+    dow = handler(new Date(2022, 3, 21, 10, 3, 0));
+    assert.equal(dow, 5);
+    dow = handler(new Date(2022, 3, 22, 10, 3, 0));
+    assert.equal(dow, 6);
+    dow = handler(new Date(2022, 3, 23, 10, 3, 0));
+    assert.equal(dow, 7);
+  });
 });
--- a/test/unit.spec.js
+++ b/test/unit.spec.js
@ -1,11 +1,12 @@
 'use strict';

 const ScreenLogic = require('../index');
+var assert = require('assert');

 // you'll need a ScreenLogic-enabled device on your network for this to succeed
-describe('Unit', () => {
+describe('Unit', function() {
  let unit;
-  before(done => {
+  before(function(done) {
    let finder = new ScreenLogic.FindUnits();
    finder.on('serverFound', server => {
      finder.close();
@ -21,50 +22,57 @@ describe('Unit', () => {
    finder.search();
  });

-  after(() => {
+  after(function() {
    unit.close();
  });

-  // let circuit;
-  it('gets pool status', done => {
+  it('gets pool status', function(done) {
    unit.on('poolStatus', status => {
-      /* circuit = */status.circuitArray[0];
+      assert.equal(status.senderId, 0);
      done();
    });

    unit.getPoolStatus();
  });

-  it('gets controller config', done => {
+  it('gets controller config', function(done) {
    unit.on('controllerConfig', config => {
+      assert.equal(config.senderId, 42);
      done();
    });
-    unit.getControllerConfig();
+
+    unit.getControllerConfig(42);
  });

-  it('gets chemical data', done => {
-    unit.on('chemicalData', () => {
+  it('gets chemical data', function(done) {
+    unit.on('chemicalData', chemData => {
+      assert.equal(chemData.senderId, 123);
      done();
    });
-    unit.getChemicalData();
+
+    unit.getChemicalData(123);
  });

-  it('gets salt cell config', done => {
-    unit.on('saltCellConfig', () => {
+  it('gets salt cell config', function(done) {
+    unit.on('saltCellConfig', saltConfig => {
+      assert.equal(saltConfig.senderId, 0);
      done();
    });
+
    unit.getSaltCellConfig();
  });

-  it('gets version', done => {
-    unit.on('version', () => {
+  it('gets version', function(done) {
+    unit.on('version', version => {
+      assert.equal(version.senderId, 41239);
      done();
    });
-    unit.getVersion();
+
+    unit.getVersion(41239);
  });

  /* uncomment this and the `circuit` stuff above to test setting state
-  it('sets circuit state', done => {
+  it('sets circuit state', function(done) {
    unit.on('circuitStateChanged', () => {
      done();
    });
Author	SHA1	Message	Date
Parnic	b2faf57d09	Prepare for 1.8.0 release	2022-04-17 10:47:56 -05:00
Parnic	c95c9f8ce5	Fix day-of-week handling again Saturday isn't 0, it's 7. Add tests to make sure this is working now and forever!	2022-04-17 10:47:45 -05:00
Parnic	79bff51c17	Satisfy linter	2022-04-15 16:38:29 -05:00
Parnic	485b494ea8	Add support for reading unit history data unit.getHistoryData(fromTime, toTime) will request data about sensor and circuit changes over time, then `getHistoryData` will be emitted when the data is ready to be handled. Fixes #59	2022-04-15 16:38:24 -05:00
Parnic	4de8a63140	Fix readme typo	2022-04-15 16:24:33 -05:00
Parnic	e0136a01cd	Fix SLDateTime day-of-week calculation Turns out we were offsetting the wrong direction. This offsets the correct way (verified against a Wireshark capture of the official app).	2022-04-15 16:17:18 -05:00
Parnic	de8bba63a0	Alphabetize most of the readme sections And indent the individual messages a bit to help the layout presentation.	2022-04-15 16:13:50 -05:00
Parnic	77b034ce57	Add reading of SLTimes	2022-04-15 14:55:26 -05:00
Parnic	0db9e4945e	Run npm update	2022-02-01 09:35:32 -06:00
Parnic	ada16cd355	Run npm audit fix	2022-02-01 09:33:38 -06:00
Parnic	cbe64bbb2e	Update dependencies	2022-01-07 14:34:40 -06:00
Parnic	4cfffdd9df	Drop support for nodejs 10.x, add 14.x and 16.x Update package.json version	2021-10-13 14:14:41 -05:00
Parnic	ba6dac4399	Update changelog, dependencies	2021-10-13 14:12:05 -05:00
Parnic	f406bccb5d	Update coolSetPoint documentation per user findings Closes #57	2021-09-06 23:09:44 -05:00
Parnic	a5d207d3aa	Add support for setting the current system date/time #56	2021-09-06 23:02:02 -05:00
Parnic	f271554d89	Add DateTime writing support to SLMessages There may be some value in providing a read version of this as well, but it is comprised of so many properties that I'm leaving that out for now. If it becomes a need in the future, it will be straightforward to add.	2021-09-06 23:01:42 -05:00
Parnic	37d40b3386	Add support for retrieving the current system date/time #56	2021-09-06 23:00:51 -05:00
Parnic	6f1ee3c13f	Add info about add/remove client function events	2021-09-06 22:56:16 -05:00
Parnic	0b990bbc28	Add links to time conversion functions	2021-09-06 21:51:50 -05:00
Parnic	2aa14cc114	Fix SLGetScheduleData documentation	2021-09-06 21:51:50 -05:00
dependabot[bot]	bef8e6a379	Bump glob-parent from 5.1.1 to 5.1.2 Bumps [glob-parent](https://github.com/gulpjs/glob-parent) from 5.1.1 to 5.1.2. - [Release notes](https://github.com/gulpjs/glob-parent/releases) - [Changelog](https://github.com/gulpjs/glob-parent/blob/main/CHANGELOG.md) - [Commits](https://github.com/gulpjs/glob-parent/compare/v5.1.1...v5.1.2) --- updated-dependencies: - dependency-name: glob-parent dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com>	2021-06-11 07:23:37 -05:00
dependabot[bot]	5bbbfb6f41	Bump lodash from 4.17.20 to 4.17.21 Bumps [lodash](https://github.com/lodash/lodash) from 4.17.20 to 4.17.21. - [Release notes](https://github.com/lodash/lodash/releases) - [Commits](https://github.com/lodash/lodash/compare/4.17.20...4.17.21) Signed-off-by: dependabot[bot] <support@github.com>	2021-05-10 22:26:51 -05:00
dependabot[bot]	fa43b3c03e	Bump y18n from 4.0.0 to 4.0.1 Bumps [y18n](https://github.com/yargs/y18n) from 4.0.0 to 4.0.1. - [Release notes](https://github.com/yargs/y18n/releases) - [Changelog](https://github.com/yargs/y18n/blob/master/CHANGELOG.md) - [Commits](https://github.com/yargs/y18n/commits) Signed-off-by: dependabot[bot] <support@github.com>	2021-03-31 14:36:05 -05:00
Parnic	789f75f4a6	Add missing break	2020-12-12 21:14:41 -06:00
Parnic	1ea8548991	Add handling/documentation for the scheduleChanged event See discussion on #44 for more info	2020-12-12 21:12:15 -06:00
Parnic	542d2f3e94	Disabled scheduled CodeQL runs	2020-11-28 19:44:23 -06:00
Parnic	5f5b52f1ab	Tag new version, update dev dependencies	2020-11-23 08:15:44 -06:00
Parnic	7f76cb2a54	Update changelog for release	2020-11-23 08:13:43 -06:00
parnic	863cd7b1e6	Create codeql-analysis.yml	2020-10-01 11:57:43 -05:00
Parnic	a53909eaa2	Add table of contents to readme	2020-08-22 21:33:24 -05:00
Parnic	27bdf0380e	Ensure all messages populate the response senderId Fixed `addClient` and `removeClient` events returning `SLCancelDelay` objects. This shouldn't really make a difference as there are no properties to worry about on one or the other, but it was still incorrect and could cause bugs if stuff was added to those messages in the future.	2020-08-12 08:51:44 -05:00
Parnic	8294947f8c	Update dev dependencies due to vulnerabilities	2020-08-11 22:31:18 -05:00
Parnic	b0225c69bd	Update to point at the new default branch name	2020-08-11 22:28:07 -05:00
Parnic	89b8775ce3	Add support for specifying the sender id to each call This parameter is optional, so compatibility shouldn't be affected. Each SLMessage can set its own sender ID which is present on the returned message. This allows callers to fire multiple requests at once, even of the same type, while being able to identify which response went with which request. If not specified, the default value is 0. Also went ahead and documented some of the helper functions present on SLMessage (so, available on all message instances). Finally, since I was in and messing with each message anyway, I simplified and removed some repeated code from each derived message and had it call into the super to take advantage of shared decoding functionality. The lambdas ("arrow functions") in test functions were removed per advice from Mocha's documentation where the implicit `this` rebinding can apparently cause problems. This should probably have been its own commit, but, again, I was already in there messing with stuff, so...oh well. Closes #43	2020-08-11 22:20:58 -05:00
Parnic	ab36d17a38	Increase version for NPM-specific fix I had local changes to the example script that inadvertently were pushed to npm as part of 1.6.0, so that release on npm didn't match the repo's contents.	2020-07-15 20:58:41 -05:00
Parnic	c36e4cbaa2	Fix changelog release date Time is meaningless these days anyway...	2020-07-14 15:55:34 -05:00
Parnic	df22901ea1	Add another missed attribution	2020-07-14 12:51:05 -05:00
Parnic	b23f488822	Remove specific node versions tested against These change frequently and it's probably not worth documenting anyway. I'm pretty sure these versions were no longer valid anyway since, for example, Mocha no longer supports node v8.	2020-07-14 12:50:50 -05:00