homebridge-texecom-full 4.3.1-beta.3 → 4.4.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 This change log documents all release versions of homebridge-texecom
 
+### 4.4.0 (2026-10-07)
+
+Rolls up the 4.3.1 and 4.4.0 betas below. Coming from 4.2.8, existing accessories carry over with their rooms, names and automations. Coming from 4.3.0, turn on `external_accessories` to keep the accessories that release published outside the bridge, see 4.3.1-beta.3.
+
+- **FEATURE** - Combined areas. One accessory can arm and disarm several areas at once, set up under `area_groups`.
+- **FEATURE** - Panel clock sync. `time_sync_interval` sets how often, in hours, the panel clock is checked against the machine running Homebridge and corrected. Off by default.
+- **FEATURE** - `external_accessories` lets installs that ran 4.3.0 keep their accessories.
+- **FEATURE** - How an arm is reported to HomeKit is configurable via `remote_users`, `app_users` and `default_arm_state` (#25).
+- **FIX** - Accessories are bridged again, as in 4.2.8 and earlier, and are cached across restarts.
+- **FIX** - Arming or disarming areas 5 to 8 addressed the wrong areas, and area 8 sent a malformed command. Present since 4.2.8.
+- **FIX** - The first arm or disarm from a HomeKit button is no longer ignored (#26).
+- **FIX** - A full arm no longer changes to Night in the Home app a minute later (#25).
+- **FIX** - The arm/disarm command is retried once if the panel ignores it, and the retry timer is cleared once the panel answers.
+- **FIX** - Areas and zones sharing a number no longer share a serial number.
+- **TWEAK** - Runs on Homebridge 1.x again as well as 2.x.
+
+### 4.4.0-beta.1 (2026-08-26)
+
+- **FEATURE** - Panel clock sync. Set `time_sync_interval` to the number of hours between checks and the plugin reads the panel clock, comparing it against the machine running Homebridge, and sets it when the two have drifted apart. Anything from every hour to once every 31 days, 0 leaves the panel clock alone and is the default. The panel is also checked shortly after Homebridge connects, so a panel that lost its clock in a power cut is put right without waiting for the interval. Needs a UDL, as arming does.
+- **FIX** - Commands are written a byte at a time rather than as text. Arming or disarming area 8, or any combined area including it, sent the bitmask as two bytes because the byte the panel wanted was 0x80 and the default encoding turns anything from 128 up into a pair. The panel would have read that as a different command. Areas 1 to 7 on their own were unaffected. Present since 4.2.8.
+
+### 4.4.0-beta.0 (2026-08-19)
+
+- **FEATURE** - Combined areas. One accessory can arm and disarm several areas at once, set up under `area_groups`. The panel addresses areas as a bitmask, so they go in a single command rather than one after another. A combined area reports armed only once every one of its areas is armed, showing as arming until then, and an alarm in any of them shows through straight away. The areas keep their own accessories, and an area can belong to more than one combined area.
+
 ### 4.3.1-beta.3 (2026-08-19)
 
 - **FEATURE** - `external_accessories` for installs that ran 4.3.0. That release published accessories outside the bridge, and HomeKit gives no way to move a standalone accessory onto a bridge without it counting as a new accessory, so the scenes, buttons and automations built on them would all have to be set up again. Turning this on republishes them the way 4.3.0 did, with the same identities, and they carry on working. Off by default, so a fresh install or one coming from 4.2.8 gets bridged accessories.

package/README.md

@@ -108,6 +108,24 @@ When an area is armed the panel reports the area and the user number, but not wh
 
 When the arm was started from HomeKit the plugin already knows what was asked for and reports that, whatever the user number. These settings only come into play for an arm that started somewhere else.
 
+### Panel Clock
+
+The panel keeps its own clock, and nothing corrects it once it drifts apart from an engineer at the keypad. This checks it against the clock on the machine running Homebridge and sets it when the two have come apart.
+
+| Key | Default | Description |
+| --- | --- | --- |
+| `time_sync_interval` | 0 | How often to check the panel clock, in hours. `1` checks every hour, `24` once a day, `744` once every 31 days, and anything in between works. `0` turns it off and leaves the panel clock alone. |
+
+```json
+"time_sync_interval": 24
+```
+
+It is off unless you set it. A UDL is needed, the same one arming uses, because the panel asks to be logged into before it will give up its clock or take a new time.
+
+The panel is checked shortly after Homebridge connects to it as well as on the interval, so a panel that lost its clock in a power cut is put right without waiting for the next check. A difference of a minute is left alone: the panel only counts whole minutes, so a check landing either side of a minute boundary can look a minute out when it is really in step. Anything beyond that is set. The panel carries a two digit year, so it is read as being in this century.
+
+Once a day is plenty for a panel that keeps reasonable time. Checking every hour is there for a panel that drifts badly, and costs two short commands each time.
+
 ### Upgrading from 4.3.0
 
 **Only relevant if you ran 4.3.0.** Skip this if you came from 4.2.8 or earlier, or are installing fresh.
@@ -125,6 +143,34 @@ If you set all that up under 4.3.0 and would rather keep it:
 That republishes them exactly as 4.3.0 did, with the same identities, so everything keeps working untouched. The trade-off is that they stay outside the bridge, so a zone added later still has to be paired by hand.
 
 Leaving it off, or leaving it out entirely, gives bridged accessories.
+### Combined Areas
+
+A combined area is a single accessory that arms or disarms several areas at once. The panel addresses areas as a bitmask, so all of them are armed with one command rather than several in a row.
+
+```json
+"area_groups": [
+    {
+        "name": "Everything",
+        "areas": [1, 2, 3, 4, 5],
+        "dwell": 0
+    },
+    {
+        "name": "House and Garage",
+        "areas": [1, 2],
+        "dwell": 0
+    }
+]
+```
+
+| Key | Default | Description |
+| --- | --- | --- |
+| `name` | N/A | The name of the combined area as it will appear in HomeKit |
+| `areas` | N/A | The area numbers to arm and disarm together. The panel supports areas 1 to 8 |
+| `dwell` | 0 | The amount of time in ms before a cleared state is applied |
+
+The areas can also still be listed under `areas` and keep their own accessories, and an area may belong to more than one combined area.
+
+A combined area shows as armed only once every one of its areas is armed, so it never reports the house as set while part of it is still open. Until they are all armed HomeKit shows it arming. An alarm in any one of its areas shows through immediately.
 
 ### Per-zone Configuration
 

package/RELEASE_NOTES.md

@@ -0,0 +1,36 @@
+## Highlights
+
+- **Combined areas.** One accessory can arm and disarm several areas at once, set up under `area_groups`. The areas go to the panel in a single command. A combined area shows as armed once all its areas are armed, and an alarm in any of them shows straight away.
+- **Panel clock sync.** Set `time_sync_interval` to the number of hours between checks, from 1 up to 744 (31 days). The plugin compares the panel clock with the machine running Homebridge and corrects any drift. It also checks shortly after connecting, so a panel that lost its time in a power cut is put right. Off by default. Needs a UDL, as arming does.
+- **Configurable arm reporting.** `remote_users`, `app_users` and `default_arm_state` decide how an arm is reported to HomeKit, instead of user numbers fixed in code (#25).
+
+## Upgrading
+
+- **From 4.2.8 or earlier:** nothing to do. Accessories carry over with their rooms, names and automations.
+- **From 4.3.0:** 4.3.0 published accessories outside the bridge. To keep them and the scenes and automations built on them, turn on `external_accessories`. Leave it off to get bridged accessories, which will need setting up again in the Home app.
+
+## Fixes
+
+- Accessories are bridged again, as in 4.2.8 and earlier, and are cached across restarts. Accessories removed from the config are unregistered.
+- Arming or disarming areas 5 to 8 addressed the wrong areas, and area 8 sent a malformed command. Present since 4.2.8.
+- The first arm or disarm from a HomeKit button is no longer ignored (#26).
+- A full arm no longer changes to Night in the Home app a minute later (#25).
+- The arm/disarm command is retried once when the panel ignores the first write, and the retry timer is cleared once the panel answers. Before, every command also sent a second login two seconds later.
+- Areas and zones that share a number no longer share a serial number.
+- User numbers over 99 are no longer truncated.
+- Areas are matched by area number rather than by their position in the config.
+
+## Other
+
+- Runs on Homebridge 1.x again as well as 2.x.
+- Removed the unused `crypto-js` dependency.
+
+## Contributors
+
+- @K1LL3R234 - development and maintenance of this release
+- @badgertastic - reported and helped test #25 and #26
+- @max-christian - original author of homebridge-texecom
+- @kieranmjones - code contributions
+- @garethflowers - code contributions
+
+Full details in the [changelog](https://github.com/K1LL3R234/homebridge-texecom/blob/master/CHANGELOG.md).

package/config.schema.json

@@ -46,6 +46,14 @@
                 "maxLength": 6,
                 "title": "UDL"
             },
+            "time_sync_interval": {
+                "type": "integer",
+                "default": 0,
+                "minimum": 0,
+                "maximum": 744,
+                "title": "Panel Clock Sync (hours)",
+                "description": "How often to check the panel clock against the clock on this machine, in hours, and set it if it has drifted. 1 checks every hour, 24 once a day, 744 once every 31 days. 0 turns it off and leaves the panel clock alone. Needs a UDL."
+            },
             "remote_users": {
                 "type": "array",
                 "title": "Remote / Keyfob Users",
@@ -161,6 +169,40 @@
                 "default": false,
                 "description": "Only for installs that ran 4.3.0. That release published every zone and area outside the bridge, so they had to be added to the Home app by hand. Turn this on to keep publishing them that way, with the same identities, so the scenes, buttons and automations built on them keep working. Leave it off otherwise."
             },
+            "area_groups": {
+                "type": "array",
+                "title": "Combined Areas",
+                "description": "One accessory that arms or disarms several areas together. The panel takes them all in a single command.",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                            "title": "Name"
+                        },
+                        "areas": {
+                            "type": "array",
+                            "title": "Areas",
+                            "description": "The area numbers to arm and disarm together, for example 1 and 2.",
+                            "items": {
+                                "type": "integer",
+                                "minimum": 1,
+                                "maximum": 8,
+                                "title": "Area Number"
+                            }
+                        },
+                        "dwell": {
+                            "type": "integer",
+                            "minimum": 0,
+                            "title": "Dwell Time"
+                        }
+                    },
+                    "required": [
+                        "name",
+                        "areas"
+                    ]
+                }
+            },
             "debug":{
                 "type":"boolean",
                 "title":"Debug",

package/index.js

@@ -45,6 +45,10 @@ class TexecomPlatform {
         // to a bridged one, whatever we do at this end.
         this.external_accessories = config["external_accessories"] === true;
 
+        // Combined areas: one accessory that arms or disarms several areas
+        // at once. The panel takes them all in a single command.
+        this.area_groups = config["area_groups"] || [];
+
         // Which panel user numbers mean what when the panel reports an area as
         // armed. The panel does not say whether that was a full or a part arm,
         // so the user number is the only hint we get.
@@ -52,6 +56,10 @@ class TexecomPlatform {
         this.app_users = parseUserList(config["app_users"]);
         this.default_arm_state = String(config["default_arm_state"] || "away").toLowerCase();
 
+        // How often to check the panel clock against this machine's, in hours.
+        // 0 leaves the panel clock alone.
+        this.time_sync_interval = parseSyncInterval(config["time_sync_interval"]);
+
         // Accessories restored from the Homebridge cache, keyed by UUID.
         this.cachedAccessories = new Map();
 
@@ -63,6 +71,10 @@ class TexecomPlatform {
     // Called once for every accessory Homebridge has cached for this platform,
     // before didFinishLaunching. Hold on to them so they are reused rather than
     // recreated, which is what keeps them in place in the Home app.
+    findAreaAccessory(area_number) {
+        return (this._areaAccessories || []).find(a => Number(a.zone_number) === Number(area_number));
+    }
+
     configureAccessory(accessory) {
         this.log.debug(`Restoring cached accessory ${accessory.displayName}`);
         this.cachedAccessories.set(accessory.UUID, accessory);
@@ -72,11 +84,52 @@ class TexecomPlatform {
         const platform = this;
         const { hap, api } = this;
 
-        const zoneAccessories = this.zones.map(z => new TexecomAccessory(this.log, z, hap));
-        const areaAccessories = this.areas.map(a => new TexecomAccessory(this.log, a, hap));
+        const zoneAccessories = this.zones.map(z => new TexecomAccessory(this.log, z, hap, "zone"));
+        const areaAccessories = this.areas.map(a => new TexecomAccessory(this.log, a, hap, "area"));
+        const groupAccessories = this.area_groups.map(g => new TexecomAccessory(this.log, g, hap, "group"));
         const zoneCount = zoneAccessories.length;
         const areaCount = areaAccessories.length;
 
+        this._areaAccessories = areaAccessories;
+
+        // The last state we heard for each area, whether or not that area has
+        // an accessory of its own. Combined areas are worked out from this.
+        const areaStates = new Map();
+
+        // A combined area counts as armed only when every one of its areas is
+        // armed, so it never claims to be set while part of it is open. An
+        // alarm in any one of them shows through regardless.
+        function refreshGroups() {
+            const Characteristic = hap.Characteristic;
+
+            groupAccessories.forEach(group => {
+                const states = group.area_numbers.map(n => areaStates.get(n));
+
+                if (states.some(s => s === Characteristic.SecuritySystemCurrentState.ALARM_TRIGGERED)) {
+                    group.changeHandler(Characteristic.SecuritySystemCurrentState.ALARM_TRIGGERED);
+                    return;
+                }
+
+                const armed = states.filter(s => s !== undefined && s !== Characteristic.SecuritySystemCurrentState.DISARMED);
+                if (states.length === 0 || armed.length !== states.length) {
+                    group.changeHandler(Characteristic.SecuritySystemCurrentState.DISARMED);
+                    return;
+                }
+
+                // Everything is armed. Use what was asked for from HomeKit if we
+                // know it, then a state the areas agree on, otherwise call it away.
+                var stateValue;
+                if (group.pending_target_state != null) {
+                    stateValue = targetToCurrentState(Characteristic, group.pending_target_state);
+                } else if (armed.every(s => s === armed[0])) {
+                    stateValue = armed[0];
+                } else {
+                    stateValue = Characteristic.SecuritySystemCurrentState.AWAY_ARM;
+                }
+                group.changeHandler(stateValue);
+            });
+        }
+
         const activeUUIDs = new Set();
 
         // Accessories are published through the Homebridge bridge, so they turn
@@ -117,7 +170,9 @@ class TexecomPlatform {
 
         // Reproduces 4.3.0 exactly: the same UUID, from the same serial number,
         // so Homebridge gives the accessory back the pairing it already had and
-        // the Home app carries on as though nothing happened.
+        // the Home app carries on as though nothing happened. A combined area
+        // is new in 4.4.0, so it has no 4.3.0 identity to preserve, but it is
+        // published the same way so the whole install stays off the bridge.
         const publishExternal = (acc, typePrefix) => {
             const uuid = hap.uuid.generate(`${typePrefix}:${acc.legacy_sn}`);
             const hapAccessory = new api.platformAccessory(acc.name, uuid);
@@ -133,6 +188,7 @@ class TexecomPlatform {
 
             zoneAccessories.forEach(acc => publishExternal(acc, "zone"));
             areaAccessories.forEach(acc => publishExternal(acc, "area"));
+            groupAccessories.forEach(acc => publishExternal(acc, "group"));
 
             // Nothing is on the bridge in this mode, so anything left in the
             // cache from a bridged run is no longer being served by us and
@@ -147,6 +203,7 @@ class TexecomPlatform {
         } else {
             zoneAccessories.forEach(attachAccessory);
             areaAccessories.forEach(attachAccessory);
+            groupAccessories.forEach(attachAccessory);
 
             // Anything cached that is no longer in the config has to go, otherwise
             // it lingers in the Home app as an unresponsive accessory.
@@ -189,6 +246,8 @@ class TexecomPlatform {
                                             var stateValue = hap.Characteristic.SecuritySystemCurrentState.ALARM_TRIGGERED;
                                             platform.log.log(`Area ${areaAccessories[a].zone_number} manual triggered`);
                                             areaAccessories[a].changeHandler(stateValue);
+                                            areaStates.set(Number(areaAccessories[a].zone_number), stateValue);
+                                            refreshGroups();
                                         }
                                     });
                                 } catch (e) {
@@ -234,6 +293,11 @@ class TexecomPlatform {
                         if (area) {
                             area.pending_target_state = null;
                         }
+                        groupAccessories.forEach(g => {
+                            if (g.area_numbers.includes(updated_area)) {
+                                g.pending_target_state = null;
+                            }
+                        });
                         break;
 
                     case "A":
@@ -262,6 +326,9 @@ class TexecomPlatform {
                     area.changeHandler(stateValue, user);
                 }
 
+                areaStates.set(updated_area, stateValue);
+                refreshGroups();
+
             } else {
                 platform.log.debug(`Unknown string from Texecom: ${S(data)}`);
             }
@@ -274,10 +341,14 @@ class TexecomPlatform {
             var connection = net.createConnection(platform.ip_port, platform.ip_address);
             connection.setNoDelay(true);
 
-            connection.on('connect', () => platform.log.log('Connected via IP'));
+            connection.on('connect', () => {
+                platform.log.log('Connected via IP');
+                platform._panelConnected();
+            });
 
             connection.on('data', function (data) {
                 platform.log.debug(`IP data received: ${data}`);
+                responseEmitter.emit('raw', data);
                 responseEmitter.emit('data', data);
                 processData(data);
             });
@@ -305,9 +376,17 @@ class TexecomPlatform {
             const sp = new SerialPort({ path: this.serial_device, baudRate: this.baud_rate });
             const parser = sp.pipe(new ReadlineParser({ delimiter: '\n' }));
 
-            sp.on("open", () => platform.log.log("Serial port opened"));
+            sp.on("open", () => {
+                platform.log.log("Serial port opened");
+                platform._panelConnected();
+            });
             sp.on("error", (err) => platform.log.error("Serial port error:", err.message));
 
+            // The parser splits on 0x0A, which the panel clock reply can carry
+            // inside it - the 10th of a month, or ten minutes past. Reading the
+            // clock works off the bytes as they arrive instead.
+            sp.on('data', (data) => responseEmitter.emit('raw', data));
+
             parser.on('data', function (data) {
                 platform.log.debug(`Serial data received: ${data}`);
                 responseEmitter.emit('data', data);
@@ -322,6 +401,110 @@ class TexecomPlatform {
         } else {
             this.log.log("Must set either serial_device or ip_address in configuration.");
         }
+
+        this._startClockSync();
+    }
+
+    // ── Panel clock ──────────────────────────────────────────────────────────
+    _startClockSync() {
+        if (this.time_sync_interval <= 0) {
+            this.log.debug("Panel clock sync is off");
+            return;
+        }
+
+        if (this.udl == null) {
+            this.log.log("Panel clock sync needs a UDL. Add one to the config, or set the sync interval to 0 to turn it off.");
+            this.time_sync_interval = 0;
+            return;
+        }
+
+        this.log.log(`Checking the panel clock every ${describeInterval(this.time_sync_interval)}`);
+
+        // The next check is timed from the end of the last one rather than by a
+        // repeating interval, so a check that is slow to answer cannot have the
+        // next one land on top of it.
+        const period = this.time_sync_interval * 60 * 60 * 1000;
+        const again = () => scheduleAfter(period, () => this._syncPanelClock().then(again));
+        again();
+    }
+
+    // The panel is checked shortly after the connection comes up as well as on
+    // the interval, so a panel that lost its clock in a power cut is put right
+    // without waiting for the next check. A dropped IP connection reconnects, so
+    // this can run again; the pending check is replaced rather than stacked up.
+    _panelConnected() {
+        if (this.time_sync_interval <= 0) {
+            return;
+        }
+
+        if (this._clock_sync_pending) {
+            clearTimeout(this._clock_sync_pending);
+        }
+
+        this._clock_sync_pending = setTimeout(() => this._syncPanelClock(), 5000);
+        if (this._clock_sync_pending.unref) {
+            this._clock_sync_pending.unref();
+        }
+    }
+
+    _syncPanelClock() {
+        const platform = this;
+
+        if (this._clock_sync_running) {
+            this.log.debug("Panel clock check still running, skipping this one");
+            return Promise.resolve();
+        }
+
+        const connection = this.texecomConnection;
+        if (!connection) {
+            this.log.debug("Not connected to the panel, skipping the clock check");
+            return Promise.resolve();
+        }
+
+        this._clock_sync_running = true;
+
+        return writeCommandAndWaitForOK(connection, `W${this.udl}`)
+            .then(() => readPanelTime(connection))
+            .then(panel => {
+                const now = new Date();
+                const drift = clockDriftMinutes(panel, now);
+
+                platform._clock_sync_failing = false;
+
+                if (Math.abs(drift) <= CLOCK_TOLERANCE_MINUTES) {
+                    platform.log.debug(`Panel clock reads ${formatPanelTime(panel)}, in step`);
+                    return;
+                }
+
+                if (shouldDeferClockSet(now)) {
+                    platform.log.debug(`Panel clock is ${describeDrift(drift)}, waiting a minute to set it: 47 minutes past would put a framing character inside the command`);
+                    scheduleAfter(61000, () => platform._syncPanelClock());
+                    return;
+                }
+
+                platform.log.log(`Panel clock reads ${formatPanelTime(panel)}, ${describeDrift(drift)}. Setting it to ${formatPanelTime(localPanelTime(now))}`);
+
+                // Logging in again rather than leaning on the session opened for
+                // the read, which is what the panel asks for and costs one
+                // command at most once an interval.
+                return writeCommandAndWaitForOK(connection, `W${platform.udl}`)
+                    .then(() => writeCommandAndWaitForOK(connection, panelTimeCommand(now)))
+                    .then(() => platform.log.log("Panel clock set"));
+            })
+            .catch(err => {
+                // Said once when it starts going wrong rather than on every
+                // pass, so a panel that cannot be reached does not fill the log
+                // with the same line for as long as it is left running.
+                if (platform._clock_sync_failing) {
+                    platform.log.debug(`Panel clock check failed: ${err.message}`);
+                } else {
+                    platform._clock_sync_failing = true;
+                    platform.log.log(`Panel clock check failed: ${err.message}. Further failures are only logged with debug on.`);
+                }
+            })
+            .then(() => {
+                platform._clock_sync_running = false;
+            });
     }
 }
 
@@ -421,16 +604,28 @@ function normaliseUser(value) {
 }
 
 // ─── Accessory ───────────────────────────────────────────────────────────────
-function TexecomAccessory(log, config, hap) {
+const MODELS = { zone: "Zone", area: "Area", group: "Combined Area" };
+
+function TexecomAccessory(log, config, hap, kind) {
     this.log = log;
     this.hap = hap;
+    this.kind = kind || "zone";
 
-    this.zone_number = zpad(config["zone_number"] || config["area_number"], 3);
     this.name = config["name"];
-    this.zone_type = config["zone_type"] || config["area_type"] || "motion";
     this.dwell_time = config["dwell"] || 0;
     this.dwell_timer = null;
 
+    if (this.kind === "group") {
+        // A combined area is addressed as several area numbers at once.
+        this.area_numbers = (config["areas"] || []).map(Number).filter(n => !Number.isNaN(n));
+        this.zone_number = this.area_numbers.join("+");
+        this.zone_type = "securitysystem";
+    } else {
+        this.zone_number = zpad(config["zone_number"] || config["area_number"], 3);
+        this.zone_type = config["zone_type"] || config["area_type"] || "motion";
+        this.area_numbers = this.zone_type === "securitysystem" ? [Number(this.zone_number)] : [];
+    }
+
     // Replaced with the real handler once the accessory has been published.
     this.changeHandler = function () { };
 
@@ -465,7 +660,8 @@ function TexecomAccessory(log, config, hap) {
         // them the same serial number. Only the area side is namespaced so
         // that zone serial numbers stay as they have always been.
         const shasum = crypto.createHash('sha1');
-        shasum.update(this.zone_type === "securitysystem" ? `area:${this.zone_number}` : this.zone_number);
+        shasum.update(this.kind === "group" ? `group:${this.zone_number}`
+            : this.zone_type === "securitysystem" ? `area:${this.zone_number}` : this.zone_number);
         this.sn = shasum.digest('base64');
         log.log(`Computed SN: ${this.sn}`);
     }
@@ -485,7 +681,7 @@ TexecomAccessory.prototype = {
         hapAccessory.getService(Service.AccessoryInformation)
             .setCharacteristic(Characteristic.Name, this.name)
             .setCharacteristic(Characteristic.Manufacturer, "Homebridge")
-            .setCharacteristic(Characteristic.Model, `Texecom ${this.zone_type === "securitysystem" ? "Area" : "Zone"}`)
+            .setCharacteristic(Characteristic.Model, `Texecom ${MODELS[this.kind] || "Zone"}`)
             .setCharacteristic(Characteristic.SerialNumber, serialNumber || this.sn);
 
         var ServiceType, changeAction;
@@ -613,7 +809,7 @@ TexecomAccessory.prototype = {
 function areaTargetSecurityStateSet(platform, accessory, service, value, callback) {
     const { Characteristic } = platform.hap;
 
-    const mask = areaMask([Number(accessory.zone_number)]);
+    const mask = areaMask(accessory.area_numbers);
     if (mask === null) {
         platform.log.error(`Area ${accessory.zone_number} is out of range, the panel only addresses areas 1 to 8`);
         callback(new Error("Area out of range"));
@@ -654,12 +850,29 @@ function areaTargetSecurityStateSet(platform, accessory, service, value, callbac
                 return;
             }
             platform.log.debug(`Area ${accessory.zone_number} → state ${currentState}`);
-            service.getCharacteristic(Characteristic.SecuritySystemCurrentState).updateValue(currentState);
+
+            // A combined area waits for each of its areas to report in, so HomeKit
+            // shows it arming until they all are. Updating it here instead would
+            // make it flick between armed and disarmed as they come in one by one.
+            if (accessory.kind !== "group") {
+                service.getCharacteristic(Characteristic.SecuritySystemCurrentState).updateValue(currentState);
+            }
 
             // Remember what was asked for. The panel reports the area as armed
             // once the exit delay has run, without saying how it was armed, and
             // this is what stops that report being taken for a part arm.
-            accessory.pending_target_state = (value === Characteristic.SecuritySystemTargetState.DISARM) ? null : value;
+            const pending = (value === Characteristic.SecuritySystemTargetState.DISARM) ? null : value;
+            accessory.pending_target_state = pending;
+
+            // A combined area asked on behalf of several areas, so their own
+            // accessories need to know too, otherwise they fall back to the
+            // configured default when the panel reports them armed.
+            accessory.area_numbers.forEach(n => {
+                const member = platform.findAreaAccessory(n);
+                if (member && member !== accessory) {
+                    member.pending_target_state = pending;
+                }
+            });
             callback();
         })
         .catch(err => {
@@ -697,7 +910,7 @@ function writeCommandAndWaitForOK(connection, command, retryCount = 1) {
             }
         }, 2000);
 
-        connection.write(`\\${command}/`, function (err) {
+        connection.write(frameCommand(command), function (err) {
             if (err) {
                 settle(reject, err);
             }
@@ -724,3 +937,220 @@ function areaMask(area_numbers) {
 function is_armed(area_number) {
     return areas_armed.some(v => v === area_number);
 }
+
+function toBuffer(data) {
+    return Buffer.isBuffer(data) ? data : Buffer.from(String(data), "latin1");
+}
+
+// Wraps a command in the \ and / the panel expects. Commands are written as
+// latin1 so that a byte the command carries goes out as that one byte: the area
+// bitmask and the date and time are numbers rather than text, and the default
+// encoding would send anything from 128 up as two bytes.
+function frameCommand(command) {
+    return Buffer.concat([Buffer.from("\\", "latin1"), toBuffer(command), Buffer.from("/", "latin1")]);
+}
+
+// ─── Panel clock ──────────────────────────────────────────────────────────────
+// The panel keeps its own clock and drifts, and nothing corrects it apart from
+// an engineer at the keypad. When time_sync_interval is set the plugin reads the
+// panel clock on that interval and writes the current time back when the two
+// have come apart. Both commands need a UDL login first, exactly as arming does.
+//
+//   read : \T?/            → B1..B5 0x0D 0x0A, or ERROR 0x0D 0x0A
+//   set  : \T B1..B5/      → OK 0x0D 0x0A, or ERROR 0x0D 0x0A
+//
+// B1..B5 are day, month, two digit year, hours and minutes, sent as raw bytes
+// rather than as text.
+
+// The panel clock only counts whole minutes, so a read that lands either side of
+// a minute boundary can look a minute out when it is in step. Anything beyond
+// that is real drift.
+const CLOCK_TOLERANCE_MINUTES = 1;
+
+// The longest an interval can be, in hours: 31 days.
+const MAX_SYNC_INTERVAL_HOURS = 744;
+
+// A timer cannot be given a delay beyond this, roughly 24.8 days. Anything
+// larger wraps round and fires immediately, so a longer wait is walked down in
+// steps rather than asked for in one go.
+const MAX_TIMER_MS = 2147483647;
+
+// Hours, 0 (or anything unusable) turns the sync off, capped at 31 days.
+function parseSyncInterval(value) {
+    if (value === null || value === undefined || value === "") {
+        return 0;
+    }
+    const hours = Math.round(Number(value));
+    if (!Number.isFinite(hours) || hours <= 0) {
+        return 0;
+    }
+    return Math.min(hours, MAX_SYNC_INTERVAL_HOURS);
+}
+
+function describeInterval(hours) {
+    if (hours >= 24 && hours % 24 === 0) {
+        const days = hours / 24;
+        return `${days} day${days === 1 ? "" : "s"}`;
+    }
+    return `${hours} hour${hours === 1 ? "" : "s"}`;
+}
+
+// setTimeout with a delay a timer can actually hold, however long the wait.
+function scheduleAfter(delayMs, run) {
+    const step = Math.min(delayMs, MAX_TIMER_MS);
+    const timer = setTimeout(() => {
+        const remaining = delayMs - step;
+        if (remaining > 0) {
+            scheduleAfter(remaining, run);
+        } else {
+            run();
+        }
+    }, step);
+
+    if (timer.unref) {
+        timer.unref();
+    }
+    return timer;
+}
+
+// Reads the panel clock. The reply is seven raw bytes, and the panel can report
+// a zone or area at any moment, so the answer is picked out of whatever arrived
+// rather than assumed to be the next thing on the wire.
+function readPanelTime(connection, retryCount = 1) {
+    return new Promise((resolve, reject) => {
+        var buffer = Buffer.alloc(0);
+
+        function settle(fn, arg) {
+            clearTimeout(timer);
+            responseEmitter.removeListener('raw', handleRaw);
+            fn(arg);
+        }
+
+        function handleRaw(data) {
+            buffer = Buffer.concat([buffer, toBuffer(data)]);
+
+            // Only the tail can hold the reply, the rest is panel chatter that
+            // arrived while we were waiting.
+            if (buffer.length > 64) {
+                buffer = buffer.subarray(buffer.length - 64);
+            }
+
+            if (buffer.includes("ERROR")) {
+                settle(reject, new Error("the panel refused the request, check the UDL"));
+                return;
+            }
+
+            const reply = findPanelTimeReply(buffer);
+            if (reply) {
+                settle(resolve, reply);
+            }
+        }
+
+        responseEmitter.on('raw', handleRaw);
+
+        const timer = setTimeout(() => {
+            responseEmitter.removeListener('raw', handleRaw);
+            if (retryCount > 0) {
+                readPanelTime(connection, retryCount - 1).then(resolve).catch(reject);
+            } else {
+                reject(new Error("timed out reading the panel clock"));
+            }
+        }, 2000);
+
+        connection.write(frameCommand("T?"), function (err) {
+            if (err) {
+                settle(reject, err);
+            }
+        });
+    });
+}
+
+// Finds the seven byte reply in the bytes read back. The terminator on its own
+// is not enough to go on: a day of the 13th and a month of October are 0x0D and
+// 0x0A, so a reply can carry what looks like a terminator inside it. Every field
+// is range checked as well, which is also what keeps a zone or area message from
+// being mistaken for a time - those are text, and no printable character is a
+// month between 1 and 12.
+function findPanelTimeReply(buffer) {
+    for (var i = 0; i + 7 <= buffer.length; i++) {
+        if (buffer[i + 5] !== 0x0D || buffer[i + 6] !== 0x0A) {
+            continue;
+        }
+
+        const reply = {
+            day: buffer[i],
+            month: buffer[i + 1],
+            year: buffer[i + 2],
+            hours: buffer[i + 3],
+            minutes: buffer[i + 4]
+        };
+
+        if (isPlausiblePanelTime(reply)) {
+            return reply;
+        }
+    }
+    return null;
+}
+
+function isPlausiblePanelTime(time) {
+    return time.day >= 1 && time.day <= 31
+        && time.month >= 1 && time.month <= 12
+        && time.year <= 99
+        && time.hours <= 23
+        && time.minutes <= 59;
+}
+
+// The panel carries a two digit year, so it is read against the century we are
+// in. A panel that has lost its clock altogether reads as wildly out and is set.
+function panelTimeToDate(time, now) {
+    const century = Math.floor(now.getFullYear() / 100) * 100;
+    return new Date(century + time.year, time.month - 1, time.day, time.hours, time.minutes, 0, 0);
+}
+
+function localPanelTime(now) {
+    return {
+        day: now.getDate(),
+        month: now.getMonth() + 1,
+        year: now.getFullYear() % 100,
+        hours: now.getHours(),
+        minutes: now.getMinutes()
+    };
+}
+
+// How far the panel is ahead of us, in whole minutes. Negative means behind.
+function clockDriftMinutes(time, now) {
+    const panel = panelTimeToDate(time, now);
+    const local = new Date(now.getFullYear(), now.getMonth(), now.getDate(), now.getHours(), now.getMinutes(), 0, 0);
+    return Math.round((panel.getTime() - local.getTime()) / 60000);
+}
+
+function formatPanelTime(time) {
+    return `${zpad(time.day, 2)}/${zpad(time.month, 2)}/${zpad(time.year, 2)} ${zpad(time.hours, 2)}:${zpad(time.minutes, 2)}`;
+}
+
+function describeDrift(minutes) {
+    const ahead = minutes > 0;
+    const size = Math.abs(minutes);
+    const amount = size < 120 ? `${size} minute${size === 1 ? "" : "s"}`
+        : size < 2880 ? `${Math.round(size / 60)} hours`
+            : `${Math.round(size / 1440)} days`;
+    return `${amount} ${ahead ? "ahead" : "behind"}`;
+}
+
+// Day, month, two digit year, hours and minutes as raw bytes, all of which are
+// below 0x80 so they survive being written out.
+function panelTimeCommand(now) {
+    const time = localPanelTime(now);
+    return Buffer.from([0x54, time.day, time.month, time.year, time.hours, time.minutes]);
+}
+
+// 0x2F is the / that closes a command and 0x5C the \ that opens one, so a time
+// carrying either puts a framing character inside the command. A panel that
+// counts the five bytes it is expecting reads that correctly, one that scans for
+// the / instead would cut the command short, and there is no way to tell which
+// from here. Of the five, only the minutes can land on one - 47 minutes past -
+// and a minute's wait clears it. The year can too, in 2047 and 2092, and waiting
+// cannot help with that, so the command goes as it is.
+function shouldDeferClockSet(now) {
+    return localPanelTime(now).minutes === 0x2F;
+}

package/package.json

@@ -2,7 +2,7 @@
   "displayName": "Homebridge Texecom",
   "name": "homebridge-texecom-full",
   "description": "A plugin for homebridge to integrate Texecom Premier Elite alarm systems into HomeKit",
-  "version": "4.3.1-beta.3",
+  "version": "4.4.0",
   "author": {
     "name": "Chris Posthumus",
     "email": "chris.posthumus@gmail.com"