signalk-czone 0.3.0-beta.14 → 0.3.0-beta.16

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.3.0-beta.16
+
+- Adds an opt-in Victron GX switch pane for CZone circuits on the GX, Remote Console and VRM (#33).
+- Preserves write-control and confirmation rules, synchronises observed state, and keeps GX names and grouping settings.
+- Resets on circuits when changing to momentary mode; refuses blocked changes and restores the previous type if CZone does not confirm OFF.
+
+## 0.3.0-beta.15
+
+- Preserves plugin settings when uploading a ZCF or selecting a network configuration (#32).
+- Publishes switch-input states for Signal Interface, COI and Control X PLUS modules (#30).
+- Adds the Navico chartplotter touch layout, drag scrolling and reduced redraw cost (#31).
+- Updates the canonical ZCF parser to 0.1.0-beta.2 for newer Configuration Tool layouts and corrected tank settings.
+
 ## 0.3.0-beta.14
 
 - Adds bidirectional CZone links to Shelly Gen2+ switches and Victron GX outputs, with startup, confirmation and relay-function safeguards.

package/README.md

@@ -57,6 +57,28 @@ The existing electrical-monitoring definition endpoint remains:
 GET /plugins/signalk-czone/monitoring
 ```
 
+## Switch inputs
+
+Each switch input in the ZCF (a switch, float switch or signal wired to a CZone module) is published as `electrical.czone.inputs.<input name>.state`, `true` when the input is on. The name is cleaned the same way as circuit names; a repeated name gets `2`, `3` and so on. A value is published when the plugin first hears the module and then only on change.
+
+Where an input's state is read depends on the kind of module (its type in the ZCF):
+
+| Module | Message read | Input `i` is at |
+| --- | --- | --- |
+| Signal Interface | 65284 status and 65308 input message | bit `2i+1` |
+| COI | 65308 input message only (its 65284 is its outputs) | bit `2(i-16)+1` |
+| Control X PLUS | 65284 status only | bit `i`, or `i+1` when wired to switch to negative |
+
+Inputs on other kinds of module are listed but not given a state. Checked on a Signal Interface on a test bench, COIs on SugarShack and a Control X PLUS on Compass Rose (Anchor Up, Ignition, High Bilge Water Alarm). Only one Control X PLUS input wired to negative has been seen.
+
+```text
+GET /plugins/signalk-czone/inputs
+```
+
+lists each input with its module, input number, wiring, module type, state and when it last changed.
+
+The input table needs `signalk-czone-zcf` with `signalInputs` (the newer Configuration Tool layout included).
+
 ## Design
 
 The plugin does **not** modify Signal K Server, canboatjs, n2k-signalk, or any global PGN definitions.
@@ -213,9 +235,21 @@ The switch follows the CZone circuit, and the circuit follows the switch when it
 
 The switch is read every 2 s; a CZone change is acted on as its status message arrives. `GET /plugins/signalk-czone/bridge/status` shows each link; `/bridge/outputs` lists the GX's outputs; `/bridge/shelly?host=&channel=` asks a Shelly. Tested on a bench (Shelly PM1 both ways) and on a boat (GX relay 2 switched from a CZone display; the alarm relay refused).
 
+## Victron switch pane
+
+On a Victron GX (Venus OS 3.60 or later), tick **Show CZone circuits in the Victron switch pane** in the configuration panel and the circuits appear as switches on the GX touch screen, Remote Console and VRM. The plugin registers `com.victronenergy.switch.czone` on the GX's D-Bus, following Victron's switchable-output API.
+
+- **Which circuits:** those the webapp lists, one card per CZone category (the first sub-category, in a fixed priority, when there are several; DC or AC when there are none). A circuit linked to a third-party switch is left out, since that switch is already in the pane.
+- **Both ways:** a tap in the pane switches the circuit with the same code as a Signal K PUT, so it needs **Enable CZone read/write control**, and a circuit set to confirm before turning off (on) is not turned off (on) from the pane unless other apps are allowed to; the pane's switch goes back. A change made anywhere else shows in the pane, from the plugin's own decoded 65284 state, checked every two seconds.
+- **Label:** the circuit name, plus the current while it is on ("Freezer (2.9 A)"; untick **Show circuit current** to leave it off). A reading that only wobbles does not change the label, since every rename makes the GX re-sort its lists. Names, groups, types and the device's name can be edited on the GX and are kept (`victron-switches.json` in the plugin's data folder).
+- **Device list:** Settings > Devices lists each switch as "CZone: name".
+- `GET /plugins/signalk-czone/victron/status` reports whether it is running, which circuits the pane has as on, any that disagree with the plugin, and the last few requests from the pane.
+
+Off a GX, or without `dbus-native` (an optional dependency), it reports that D-Bus is not available and the rest of the plugin is unaffected.
+
 ## Installation
 
-The plugin installs the pinned `signalk-czone-zcf@0.1.0-beta.1` npm dependency automatically. No separate parser installation or Git checkout is required.
+The plugin installs the pinned `signalk-czone-zcf@0.1.0-beta.2` npm dependency automatically. No separate parser installation or Git checkout is required.
 
 ### Signal K App Store
 
@@ -239,11 +273,11 @@ npm install signalk-czone@latest --omit=dev --ignore-scripts
 
 Restart Signal K and follow the configuration steps above. For Docker or appliance installations, use the corresponding container/configuration directory and restart method.
 
-For installation from a maintainer-provided npm tarball, run `npm install /path/to/signalk-czone-0.3.0-beta.9.tgz --omit=dev --ignore-scripts` from the same configuration directory. Its pinned parser dependency must already be published to npm. Do not simply extract the plugin into `node_modules`: that does not install dependencies.
+For installation from a maintainer-provided npm tarball, run `npm install /path/to/signalk-czone-0.3.0-beta.16.tgz --omit=dev --ignore-scripts` from the same configuration directory. Its pinned parser dependency must already be published to npm. Do not simply extract the plugin into `node_modules`: that does not install dependencies.
 
 ### Publishing (maintainers)
 
-Publish `signalk-czone-zcf@0.1.0-beta.1` first. Then run `npm install`, `npm test`, and `npm pack --dry-run` in this repository, verify the runtime files and App Store assets, and run `npm publish --tag latest` after npm authentication.
+Publish `signalk-czone-zcf@0.1.0-beta.2` first. Then run `npm install`, `npm test`, and `npm pack --dry-run` in this repository, verify the runtime files and App Store assets, and run `npm publish --tag latest` after npm authentication.
 
 The package defaults to `latest`, including versions named `-beta.N`. The GitHub publishing workflow runs when `package.json` or the workflow changes on `main`: it tests and packs the release, publishes it if the version is new, and sets and verifies the `latest` tag. If the version already exists, the workflow promotes that existing version without republishing its contents.
 
@@ -442,6 +476,15 @@ Only the installed path is stored in plugin configuration; the binary ZCF is not
 
 The beta is intended for extended real-world testing before a stable `0.3.0` release.
 
+## On a Navico chartplotter (B&G, Simrad, Lowrance)
+
+A Navico plotter shows the webapp in its own browser (Chromium 69), driven by a touch screen whose touches arrive as mouse events. The page recognises the plotter from the parameters the plotter adds to the address (`mfd_name`, `mfd_model_detail`, `brand`), or from the login token left by `signalk-navico-embedder`, and switches to a touch layout. `?layout=mfd` shows it in a desktop browser for testing. Nothing changes anywhere else.
+
+- **Touch layout:** larger rows, buttons and navigation; no banner, overview or category chips; drawn icons in place of emoji and symbol characters the plotter's fonts lack; no shadows, gradients, blur or transitions, which are slow to draw there.
+- **Scrolling:** a drag scrolls the list or the left column instead of selecting text, applied once per frame, and the tap that ends a drag is not taken as a press. Redraws caused by live data wait while a finger is down.
+- **Updates:** the plotter keeps showing the page it first loaded. Once a minute the page checks whether its script has changed on the server and reloads once if so.
+- **Diagnosis:** five taps on the connection line show the last input events, the frame time and the time to redraw the list.
+
 ## Fullscreen and tablet home-screen launch
 
 Open `/signalk-czone/` directly in your browser. The **fullscreen icon** beside

package/index.js

@@ -3,6 +3,7 @@
 const path = require('path')
 const fs = require('fs')
 const zcf = require('./lib/zcf')
+const inputs = require('./lib/inputs')
 const czone = require('./lib/czone')
 const nmea = require('./lib/nmea2000')
 const monitoring = require('./lib/monitoring')
@@ -12,6 +13,7 @@ const confirmOffLib = require('./lib/confirm-off')
 const { createBridge, bridgeEntries } = require('./lib/bridge')
 const { createShellyDriver } = require('./lib/bridge/shelly')
 const { createVictronDriver } = require('./lib/bridge/victron')
+const { createVictronSwitches } = require('./lib/victron/switches')
 
 const MAX_UPLOAD_BYTES = 1024 * 1024
 const CZONE_CONFIG_BLOCK_HEADER = 23
@@ -150,6 +152,44 @@ module.exports = function (app) {
     },
     drivers: bridgeDrivers
   })
+  // Victron switch pane (lib/victron/switches): the CZone circuits as
+  // switches on the GX touch screen, Remote Console and VRM. Off unless
+  // ticked. A tap there switches the circuit through the same code as a
+  // Signal K PUT, so "Enable CZone read/write control" and the confirm-before
+  // rules apply; the state shown is the plugin's own decoded 65284 state.
+  const switchPane = createVictronSwitches(app, {
+    log: m => log(m),
+    version: require('./package.json').version,
+    getCurrent: skPath => {
+      const m = /^electrical\.czone\.([^.]+)\.current$/.exec(skPath || '')
+      const c = m && mapping && mapping.circuits.find(x => x.slug === m[1])
+      const st = c && runtimeState.get(c.name)
+      return st && Number.isFinite(st.current) ? st.current : null
+    },
+    controls: () => ({
+      state: (slug, on) => {
+        const c = circuitByName(slug)
+        if (on) refuseUnconfirmedOn(c)
+        else refuseUnconfirmedOff(c)
+        sendCircuitState(c, on)
+        const st = runtimeState.get(c.name)
+        if (st) st.lastRequested = on ? 'ON' : 'OFF'
+      },
+      brightness: (slug, normalized) => {
+        const c = circuitByName(slug)
+        const st = runtimeState.get(c.name)
+        if (normalized <= 0) refuseUnconfirmedOff(c)
+        else if (!st || st.state !== 'ON') refuseUnconfirmedOn(c)
+        sendCircuitBrightness(c, normalized)
+        if (st) st.lastRequestedPercent = Math.round(normalized * 100)
+      },
+      getState: slug => {
+        const c = mapping && mapping.circuits.find(x => x.slug === slug)
+        const st = c && runtimeState.get(c.name)
+        return st && st.statusObserved ? { state: st.state, percent: st.percent } : null
+      }
+    })
+  })
   let monitoringRuntime = null
   // Trend recording of circuit current (see lib/trends).
   let trends = null
@@ -171,6 +211,10 @@ module.exports = function (app) {
   // Circuits nominated to confirm before switching, by circuit name.
   let confirmOff = new Set()
   let confirmOn = new Set()
+  // Switch inputs of the loaded configuration (lib/inputs) and their last
+  // decoded state, by Signal K path.
+  let switchInputs = []
+  let inputState = new Map()
 
   const configRoot = app.config && app.config.configPath
     ? path.join(app.config.configPath, 'plugin-config-data')
@@ -213,12 +257,16 @@ module.exports = function (app) {
   function loadConfiguredZcf () {
     if (!fs.existsSync(zcfPath())) {
       mapping = null
+      switchInputs = []
+      inputState = new Map()
       return null
     }
     mapping = zcf.load(zcfPath())
     mapping.commandDeviceId = selectCommandDeviceId(mapping)
     publishedCircuitValues.clear()
     monitoringRuntime = monitoring.createRuntime(mapping.meters || [])
+    switchInputs = inputs.switchInputs(mapping)
+    inputState = new Map(switchInputs.map(i => [i.path, { state: null, since: null }]))
     runtimeState = new Map(mapping.circuits.map(c => [c.name, {
       state: null,
       percent: null,
@@ -892,6 +940,25 @@ module.exports = function (app) {
     }
   }
 
+  // Switch inputs: PGN 65284 (module status) and 65308 (input message), each
+  // input read only from the message its kind of module carries it in.
+  function decodeSwitchInputs (frame) {
+    if (!switchInputs.length) return
+    const decoded = inputs.decodeFrame(frame.data)
+    if (!decoded) return
+    for (const input of switchInputs) {
+      if (input.module !== decoded.module) continue
+      const on = inputs.inputState(input.moduleKind, decoded.bitmap, input.input, frame.pgn, input.wiring)
+      if (on === undefined) continue
+      const entry = inputState.get(input.path)
+      if (entry.state === on) continue
+      entry.state = on
+      entry.since = new Date().toISOString()
+      log(`CZone INPUT: ${input.name} ${on ? 'ON' : 'OFF'} (PGN ${frame.pgn} module=0x${decoded.module.toString(16).padStart(2, '0')} bitmap=0x${decoded.bitmap.toString(16).padStart(8, '0')})`)
+      publishDelta(input.path, on)
+    }
+  }
+
   function handleRawFrame (line) {
     const frame = nmea.parseRawLine(line)
     if (!frame) return
@@ -901,7 +968,12 @@ module.exports = function (app) {
       handleConfigFastPacket(frame)
       return
     }
+    if (frame.pgn === inputs.INPUT_PGN) {
+      decodeSwitchInputs(frame)
+      return
+    }
     if (frame.pgn === 65284) {
+      decodeSwitchInputs(frame)
       decodeCzoneCircuitStatus(frame)
       return
     }
@@ -1276,6 +1348,18 @@ module.exports = function (app) {
           default: false,
           description: 'Other Signal K apps switch with a PUT and cannot ask "are you sure?". Unticked, an off from them is refused with a message; the circuit can still be turned off from the webapp or a CZone keypad.'
         },
+        victronSwitches: {
+          type: 'boolean',
+          title: 'Show CZone circuits in the Victron switch pane',
+          default: false,
+          description: 'Victron GX only (Venus OS 3.60 or later). The circuits appear as switches on the GX touch screen, Remote Console and VRM, one card per CZone category. Switching there needs CZone read/write control enabled, and circuits set to confirm before turning off (on) are not turned off (on) from there unless other apps are allowed to.'
+        },
+        victronSwitchCurrent: {
+          type: 'boolean',
+          title: 'Show circuit current in the switch pane',
+          default: true,
+          description: 'Adds the current to a switch\'s label while the circuit is on, for example "Freezer (2.9 A)".'
+        },
         bridges: {
           type: 'array',
           title: 'Third-party switches',
@@ -1317,6 +1401,7 @@ module.exports = function (app) {
       })
       trends.start()
       startBridge()
+      switchPane.start(settings, mapping).catch(err => log(`Victron switch pane: ${err.message}`))
 
       const ready = (reason = 'nmea2000OutAvailable event') => {
         nmeaReady = true
@@ -1393,6 +1478,7 @@ module.exports = function (app) {
       if (trends) trends.stop()
       trends = null
       bridge.stop()
+      switchPane.stop()
       closeBridgeBus()
       reassembler = null
       configFastPacket = null
@@ -1401,6 +1487,8 @@ module.exports = function (app) {
       mapping = null
       runtimeState.clear()
       publishedCircuitValues.clear()
+      switchInputs = []
+      inputState = new Map()
       // Signal K removes PUT handlers when the plugin stops. The plugin
       // factory can be reused on a subsequent enable, so allow start() to
       // register the handlers again instead of treating the stale paths as
@@ -1409,6 +1497,22 @@ module.exports = function (app) {
     },
 
     registerWithRouter: router => {
+      router.get('/inputs', (_req, res) => {
+        res.json({
+          inputs: switchInputs.map(i => ({
+            name: i.name,
+            path: i.path,
+            module: i.module,
+            input: i.input,
+            wiring: i.wiring || null,
+            moduleType: i.decoded ? inputs.LAYOUT[i.moduleKind].name : null,
+            decoded: i.decoded,
+            state: inputState.get(i.path).state,
+            since: inputState.get(i.path).since
+          }))
+        })
+      })
+
       router.get('/status', (_req, res) => {
         res.json({
           sendingEnabled: settings.allowCzoneWrite === true,
@@ -1493,6 +1597,7 @@ module.exports = function (app) {
 
       // Third-party switches: link status, the GX's outputs, a Shelly test.
       router.get('/bridge/status', (_req, res) => res.json({ links: bridge.status() }))
+      router.get('/victron/status', (_req, res) => res.json(switchPane.status()))
       router.get('/bridge/outputs', (_req, res) => {
         bridgeDrivers.victron.list()
           .then(outputs => res.json({ available: true, outputs }))
@@ -1547,11 +1652,9 @@ module.exports = function (app) {
           fs.copyFileSync(source, temp)
           const next = zcf.load(temp)
           try { fs.unlinkSync(temp) } catch (_) {}
-          const newSettings = {
-            allowCzoneWrite: settings.allowCzoneWrite === true,
-            configurationSource: 'networkCache',
-            networkConfigFile: filename
-          }
+          // Only the configuration source changes; every other setting (confirm
+          // before on/off, trends, third-party switches, …) is kept.
+          const newSettings = { ...settings, configurationSource: 'networkCache', networkConfigFile: filename }
           const restartResult = await saveAndRestart(newSettings)
           res.json({ ok: true, file: filename, bytes: next.fileSize, vesselName: next.vesselName || null, configuration: newSettings, restartRequested: restartResult.restartRequested })
         } catch (err) { res.status(400).json({ ok: false, error: err.message }) }
@@ -1579,11 +1682,9 @@ module.exports = function (app) {
                 savedAt: new Date().toISOString()
               }, null, 2))
             } catch (_) {}
-            const newSettings = {
-              allowCzoneWrite: settings.allowCzoneWrite === true,
-              configurationSource: 'installedZcf',
-              networkConfigFile: ''
-            }
+            // Only the configuration source changes; every other setting (confirm
+            // before on/off, trends, third-party switches, …) is kept.
+            const newSettings = { ...settings, configurationSource: 'installedZcf', networkConfigFile: '' }
             const restartResult = await saveAndRestart(newSettings)
             res.json({
               ok: true,
@@ -1686,5 +1787,7 @@ module.exports = function (app) {
 
   // For tests: run one bridge poll now instead of waiting for its timer.
   Object.defineProperty(plugin, '_bridgePoll', { value: () => bridge.poll(), enumerable: false })
+  // For tests: the Victron switch pane.
+  Object.defineProperty(plugin, '_switchPane', { value: switchPane, enumerable: false })
   return plugin
 }

package/lib/inputs.js

@@ -0,0 +1,94 @@
+'use strict'
+
+// CZone switch inputs: ON / OFF of each switch wired to a CZone module, from
+// the module's own messages. The inputs and their wiring come from the ZCF's
+// signal-input table (signalk-czone-zcf parseSignalInputs).
+//
+// PGN 65284 (0xFF04), module status, about every two seconds and on change:
+//   27 99 <module dipswitch> <module kind> <bitmap, 32 bits, low byte first>
+// PGN 65308 (0xFF1C), input message, sent on change:
+//   27 99 <module dipswitch> <variant> <bitmap, 32 bits, low byte first>
+//
+// Where an input sits depends on the kind of module (its type in the ZCF):
+//
+// Signal Interface (0x0D). Test bench, 6 Oct 2026: module 2, five switches on
+// inputs 0-4 closed one after another gave 02 00, 0A 00, 2A 00, AA 00, AA 02:
+// input n (from 0) is bit 2n+1, in 65284 and in 65308 (variant 00). The
+// message comes on change too, so a tap on a momentary switch is caught.
+//
+// COI (0x1F). SugarShack capture, 27 Sep 2026: a COI's 65284 carries its
+// outputs only; its inputs are in 65308 (variant 03), numbered from 16 in
+// the ZCF, input i at bit 2(i-16)+1. Module 1A input 19 -> 80 00, 1A input
+// 20 -> 00 02, 1C input 17 -> 08 00.
+//
+// Control X PLUS (0x36). Compass Rose, 15 Oct 2026, each input operated twice:
+// its 65284 has the outputs in bits 0-15 and the inputs above, input i (from
+// 16 in the ZCF) at bit i when it switches to positive, bit i+1 when it
+// switches to negative. Anchor Up (input 17, to +) bit 17; Ignition (24, to +)
+// bit 24; High Bilge Water Alarm (18, to -) bit 19. Only one input to
+// negative was seen. Its 65308 messages come in four variants (byte 3: 00,
+// 01, 03, 06) and are not read.
+//
+// Other kinds: not decoded (no state rather than a guess).
+
+const STATUS_PGN = 65284
+const INPUT_PGN = 65308
+
+const oddBits = first => input => 2 * (input - first) + 1
+const LAYOUT = {
+  0x0d: { name: 'Signal Interface', pgns: [STATUS_PGN, INPUT_PGN], first: 0, bit: oddBits(0) },
+  0x1f: { name: 'COI', pgns: [INPUT_PGN], first: 16, bit: oddBits(16) },
+  0x36: { name: 'Control X PLUS', pgns: [STATUS_PGN], first: 16, bit: (input, wiring) => input + (wiring === 'switchToNeg' ? 1 : 0) }
+}
+
+// data: 8 bytes of a 65284 or 65308 frame -> { module, variant, bitmap } or null
+function decodeFrame (data) {
+  if (!data || data.length !== 8 || data[0] !== 0x27 || data[1] !== 0x99) return null
+  return { module: data[2], variant: data[3], bitmap: data.readUInt32LE(4) }
+}
+
+// true / false, or undefined when this kind of module or message does not
+// carry the input.
+function inputState (kind, bitmap, input, pgn, wiring) {
+  const layout = LAYOUT[kind]
+  if (!layout || !Number.isInteger(input) || !layout.pgns.includes(pgn)) return undefined
+  if (input < layout.first) return undefined
+  const bit = layout.bit(input, wiring)
+  if (bit > 31) return undefined
+  return ((bitmap >>> bit) & 1) === 1
+}
+
+function slugify (name) {
+  const cleaned = String(name || 'Input').trim().replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '')
+  return cleaned || 'Input'
+}
+
+// The switch inputs of a loaded configuration, each with its Signal K path
+// (electrical.czone.inputs.<name>.state) and its module's kind.
+function switchInputs (mapping) {
+  const table = mapping && mapping.signalInputs
+  if (!table || !Array.isArray(table.inputs)) return []
+  const kinds = new Map((mapping.modules || []).filter(m => Number.isInteger(m.module)).map(m => [m.module, m.type]))
+  const used = new Map()
+  return table.inputs
+    .filter(i => i.type === 'switch' && Number.isInteger(i.module) && i.module !== 0)
+    .map(i => {
+      const base = slugify(i.name)
+      const count = (used.get(base) || 0) + 1
+      used.set(base, count)
+      const slug = count === 1 ? base : `${base}${count}`
+      const kind = kinds.get(i.module)
+      return {
+        name: String(i.name).trim(),
+        slug,
+        path: `electrical.czone.inputs.${slug}.state`,
+        module: i.module,
+        input: i.input,
+        wiring: i.wiring,
+        moduleKind: Number.isInteger(kind) ? kind : null,
+        decoded: Boolean(LAYOUT[kind])
+      }
+    })
+}
+
+module.exports = { STATUS_PGN, INPUT_PGN, LAYOUT, decodeFrame, inputState, switchInputs }