signalk-czone 0.3.0-beta.17 → 0.3.0-beta.19

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.3.0-beta.19
+
+- Adds opt-in Monitoring for meters, tanks, temperatures, humidity, pressure and switch inputs, with expanded trends and circuit temperature chips (#36, thanks @superstar76).
+- Fixes meter-table loading, fast-packet monitoring and unavailable-value handling; supports direct monitoring reads on Victron GX.
+- Keeps Monitoring search within the tab and restores circuit search wording when returning to circuits (#37).
+
+## 0.3.0-beta.18
+
+- Adds in-page Signal K sign-in for browser and installed home-screen apps, without leaving CZone (#35, thanks @superstar76).
+- Remembers login across app restarts, preserves the form during refreshes, and shows clear login errors with the Admin UI login retained as a fallback.
+
 ## 0.3.0-beta.17
 
 - Prompts for Signal K login when CZone circuit requests are unauthorized, returning to the webapp after sign-in (#34).

package/README.md

@@ -189,11 +189,44 @@ The dimmed encoding has been checked against controlled observations at 60%, 75%
 
 The decoded secondary state and percentage are retained in the plugin diagnostics for each tracked DC circuit. The public Signal K current path remains unchanged (`electrical.czone.<circuit>.current`).
 
+## Monitoring
+
+Off by default: tick **Show the Monitoring tab** in the configuration panel to turn it on. Meter readings are published to Signal K either way. When on, the webapp's **Monitoring** tab lists every meter and sender in the ZCF, live, with nothing else to set up:
+
+| Group | From the ZCF | NMEA 2000 |
+| --- | --- | --- |
+| Batteries, Solar, Alternators, Converters, Wind Generators | DC meters, by their DC type | 127508 (volts, amps, temperature), 127506 (state of charge) |
+| AC Power | AC meters | 127744 / 127747, or 127503 / 127504 |
+| Tanks | tank senders, wired or third-party (capacity from the tank settings) | 127505 |
+| Temperatures | temperature senders, wired or third-party | 130312 / 130316, and 130313 humidity on the same instance |
+| Environment | pressure senders | 130314 |
+| Inputs | switch inputs | (see Switch inputs) |
+
+A reading is matched by the NMEA 2000 instance set in the Configuration Tool, and the temperature or pressure source or tank fluid type. Each row says **LIVE**, or **NOT ON BUS** with the instance nothing is sending ("Nothing is sending instance 3 on NMEA 2000"), which is the number to set on the sending device. NMEA 2000 "not available" values are never shown as readings.
+
+**Which device.** Instances are not unique across devices: a Victron charger sends a battery status on the battery's instance as well as the shunt, and a wired meter can share an instance with another device. So each reading comes from one device:
+
+1. A meter or sender wired to a CZone module is read only from that module's own address, learned from its status messages.
+2. A third-party meter or sender is never read from a CZone module's address.
+3. A third-party DC meter: where devices say what they are (127506), only one of the meter's DC type is used, and for a battery one that reports a state of charge beats one that does not, so a shunt beats a charger. Ties go to the lowest address, so the choice is the same after a restart.
+4. Otherwise the first device heard keeps the reading until it has been quiet for two minutes.
+
+Values are published under `electrical.czone.monitoring.<name>.*`, as the meters already were: `voltage`, `current`, `power`, `capacity.stateOfCharge`, `frequency`, `temperature`, `relativeHumidity`, `pressure`, `currentLevel`, `currentVolume`, `capacity`. **DC power** (watts) is volts × amps of the same 127508 message, so solar, alternator and wind output can be seen and trended.
+
+**Senders bridged onto NMEA 2000 by the same machine.** Signal K does not pass a plugin its own transmissions, or a GX's:
+
+- A reading sent by Signal K's **Signal K to NMEA 2000** plugin (for example a Ruuvi tag from a Bluetooth plugin) is taken from what that plugin hands Signal K to send.
+- On a **Victron GX**, readings Venus OS itself sends (a Ruuvi tag or a GX tank input bridged by the GX) are read straight off the CAN interface with `candump`, as a CZone display sees them. While it delivers, the copies from Signal K are not used. Setting: **On a Victron GX, read monitoring messages straight off the CAN interface** (on; interface `vecan0`).
+
+**A circuit's temperature.** A temperature sender named after a circuit ("Freezer Temperature" or "Freezer Temp" for the circuit "Freezer", ignoring case and punctuation) is shown as a chip beside the circuit's name, and in its Victron switch pane label: "Freezer (-18.2 °C, 2.9 A)". A name two senders share pairs with nothing. The temperature is dropped after five minutes without a reading.
+
+With **Record trends** on, a value on the Monitoring tab, or the temperature chip, opens that value's trend.
+
 ## Trends
 
-Off by default: tick **Record circuit current trends** in the configuration panel to turn it on. Boats that already send Signal K data to a database (for example InfluxDB with Grafana) can leave it off. When on, the plugin records each circuit's current and the webapp charts it: the arrow at the end of a circuit row opens that circuit's trend at the top of the page, for the last 1 h, 24 h, 7 d, 31 d, 90 d or 1 y, or for a period of up to 366 days chosen under **Custom**.
+Off by default: tick **Record trends** in the configuration panel to turn it on. Boats that already send Signal K data to a database (for example InfluxDB with Grafana) can leave it off. When on, the plugin records each circuit's current and every monitored value, and the webapp charts them: the arrow at the end of a circuit row, or a value on the Monitoring tab, opens that trend in a window in the middle of the page (the page under it stays where it was; the window can be made full screen, and fills the screen on a phone), for the last 1 h, 24 h, 7 d, 31 d, 90 d or 1 y, or for a period of up to 366 days chosen under **Custom**.
 
-**What is stored.** The latest value of every `electrical.czone.<circuit>.current` path is sampled every 10 seconds, however often CZone repeats it, and written to plain CSV files in two tiers:
+**What is stored.** The latest value of every `electrical.czone.<circuit>.current` path, and of every monitored value, is sampled every 10 seconds, however often CZone repeats it, and written to plain CSV files in two tiers:
 
 | Tier | File | Row | Used for |
 | --- | --- | --- | --- |

package/index.js

@@ -7,6 +7,9 @@ const inputs = require('./lib/inputs')
 const czone = require('./lib/czone')
 const nmea = require('./lib/nmea2000')
 const monitoring = require('./lib/monitoring')
+const sensors = require('./lib/sensors')
+const { createCandump, PGNS: CANDUMP_PGNS } = require('./lib/candump')
+const { createSourcePicker } = require('./lib/sources')
 const { createTrends } = require('./lib/trends')
 const signalk = require('./lib/signalk')
 const confirmOffLib = require('./lib/confirm-off')
@@ -20,6 +23,12 @@ const CZONE_CONFIG_BLOCK_HEADER = 23
 const CZONE_CONFIG_BLOCK_SIZE = 200
 const CZONE_CONFIG_READ_TIMEOUT_MS = 45000
 const PLUGIN_ID = 'signalk-czone'
+// A monitored value older than this is no longer live (NOT ON BUS).
+const MONITOR_LIVE_MS = 120e3
+// A circuit's temperature is dropped after this long without a reading.
+const TEMPERATURE_STALE_MS = 300e3
+const MONITOR_GROUPS = { battery: 'Batteries', solar: 'Solar', alternator: 'Alternators', converter: 'Converters', wind: 'Wind Generators' }
+const MONITORED_PGNS = new Set(CANDUMP_PGNS)
 const NMEA_READY_RETRY_MS = 500
 const NMEA_READY_RETRY_LIMIT = 40
 
@@ -160,6 +169,10 @@ module.exports = function (app) {
   const switchPane = createVictronSwitches(app, {
     log: m => log(m),
     version: require('./package.json').version,
+    getTemperature: slug => {
+      const t = circuitTemperature(slug)
+      return t ? t.kelvin : null
+    },
     getCurrent: skPath => {
       const m = /^electrical\.czone\.([^.]+)\.current$/.exec(skPath || '')
       const c = m && mapping && mapping.circuits.find(x => x.slug === m[1])
@@ -191,6 +204,17 @@ module.exports = function (app) {
     })
   })
   let monitoringRuntime = null
+  // Tank, temperature and pressure senders (lib/sensors), the latest value
+  // and time of every monitored path, and when each meter or sender was last
+  // heard from.
+  let sensorRuntime = null
+  let monitorValues = new Map()
+  let circuitTemps = new Map()
+  let monitorFastPacket = null
+  let candump = null
+  let jsonOutListener = null
+  // Which device each meter and sender is read from (lib/sources).
+  const sourcePicker = createSourcePicker()
   // Trend recording of circuit current (see lib/trends).
   let trends = null
   // Server-side change cache for circuit state/brightness notifications.
@@ -264,7 +288,17 @@ module.exports = function (app) {
     mapping = zcf.load(zcfPath())
     mapping.commandDeviceId = selectCommandDeviceId(mapping)
     publishedCircuitValues.clear()
-    monitoringRuntime = monitoring.createRuntime(mapping.meters || [])
+    // The parser gives { meters: [...] } with the table's details; older
+    // versions gave the list itself.
+    const meterList = Array.isArray(mapping.meters) ? mapping.meters : ((mapping.meters && mapping.meters.meters) || [])
+    monitoringRuntime = monitoring.createRuntime(meterList)
+    // Tank, temperature and pressure senders, the Monitoring tab and a
+    // circuit's temperature only when "Monitoring" is ticked (off by default).
+    // The meters are published either way.
+    const senderList = settings.monitoringEnabled === true ? sensors.senders(mapping, new Set(monitoringRuntime.meters.map(m => m.slug))) : []
+    sensorRuntime = sensors.createSensorRuntime(senderList)
+    circuitTemps = sensors.circuitTemperatures(mapping.circuits, sensorRuntime.senders)
+    monitorValues = new Map()
     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, {
@@ -920,17 +954,126 @@ module.exports = function (app) {
 
   function publishMonitoringDelta (meter, pathName, value, source) {
     if (!monitoringRuntime || !Number.isFinite(value)) return
+    // Kept for the Monitoring tab (live or not) and handed to the trends
+    // before the change check: a steady reading is still a live one.
+    monitorValues.set(pathName, { value, at: Date.now() })
+    if (trends && !/\.capacity$/.test(pathName)) trends.observe(pathName, value)
     if (!monitoringRuntime.publishable(pathName, value)) return
     const delta = signalk.delta(pathName, value, source)
     if (typeof app.handleMessage === 'function') app.handleMessage(PLUGIN_ID, delta)
     else if (typeof app.emit === 'function') app.emit('delta', delta)
   }
 
-  function handleMonitoringFrame (frame) {
-    if (!monitoringRuntime) return
+  // Monitoring frames come from Signal K (canboatjs:rawoutput) or, on a GX,
+  // from candump. While candump delivers, it has every one of them, so the
+  // copies from Signal K are left alone.
+  function handleMonitoringFrame (frame, fromCandump = false) {
+    if (!monitoringRuntime || !MONITORED_PGNS.has(frame.pgn)) return
+    if (!fromCandump && candump && candump.delivering()) return
+    if (monitoring.FAST_PACKET_PGNS.has(frame.pgn)) {
+      if (monitorFastPacket) monitorFastPacket.accept(frame)
+      return
+    }
+    observeMeters(frame)
+    observeSensors(sensors.decodeSensorFrame(frame.pgn, frame.data), frame.source, frame.pgn)
+  }
+
+  // `device` is the sender's NMEA 2000 address, or 'signalk' for a reading
+  // Signal K itself sends.
+  function observeSensors (readings, device, pgn) {
+    if (!sensorRuntime || !readings.length) return
+    const source = { label: 'NMEA2000', type: 'NMEA2000', src: String(device), pgn }
+    for (const r of sensorRuntime.accept(readings, device, Date.now(), sourcePicker.allowed)) publishMonitoringDelta(null, r.path, r.value, source)
+  }
+
+  // A reading Signal K itself sends onto NMEA 2000 (the "Signal K to NMEA
+  // 2000" plugin, e.g. a Ruuvi tag bridged by a Bluetooth plugin).
+  function handleJsonOut (message) {
+    if (candump && candump.delivering()) return // candump sees it on the wire
+    observeSensors(sensors.decodeSensorJson(message), 'signalk', message && Number(message.pgn))
+  }
+
+  // On a Victron GX only (Venus OS ships candump), and only with senders or
+  // meters to read. `app._czoneSpawn` lets the tests stand in for candump.
+  function startCandump () {
+    const onVenus = typeof app._czoneSpawn === 'function' || fs.existsSync('/opt/victronenergy')
+    const wanted = monitoringRuntime && (monitoringRuntime.meters.length || sensorRuntime.senders.length)
+    if (settings.monitoringEnabled !== true || !onVenus || !wanted || settings.monitorCandump === false) return
+    candump = createCandump({
+      device: settings.monitorCanDevice || 'vecan0',
+      log,
+      spawnFn: typeof app._czoneSpawn === 'function' ? app._czoneSpawn : undefined,
+      onLine: line => {
+        const frame = nmea.parseRawLine(line)
+        if (frame) handleMonitoringFrame(frame, true)
+      }
+    })
+    candump.start()
+  }
+
+  // The temperature paired with a circuit (lib/sensors circuitTemperatures),
+  // while it is fresh.
+  function circuitTemperature (slug) {
+    const s = circuitTemps.get(slug)
+    const v = s && monitorValues.get(s.signalK.temperature)
+    if (!v || Date.now() - v.at > TEMPERATURE_STALE_MS) return null
+    return { kelvin: v.value, path: s.signalK.temperature, name: s.name }
+  }
+
+  // Everything the Monitoring tab shows: meters, senders and switch inputs,
+  // grouped, each with its readings and whether it is live.
+  function monitoringLive () {
+    if (settings.monitoringEnabled !== true) return { enabled: false, file: mapping ? mapping.fileName : null, trendsEnabled: settings.trendsEnabled === true, candump: null, items: [], temperatures: {} }
+    const now = Date.now()
+    const reading = (path, field) => {
+      const v = monitorValues.get(path)
+      return { field, path, value: v ? v.value : null, at: v ? new Date(v.at).toISOString() : null, live: !!v && now - v.at < MONITOR_LIVE_MS }
+    }
+    const item = (group, kind, x, fields) => {
+      const readings = fields.filter(f => x.signalK[f]).map(f => reading(x.signalK[f], f))
+      return { group, kind, name: x.name, slug: x.slug, instance: x.instance, thirdParty: x.thirdParty === true || x.virtual === true, live: readings.some(r => r.live), readings: readings.filter(r => r.value !== null) }
+    }
+    const items = []
+    for (const m of monitoringRuntime ? monitoringRuntime.meters : []) {
+      if (m.type === 'AC') items.push(item('AC Power', 'ac', m, ['voltage', 'current', 'power', 'frequency']))
+      else items.push(item(MONITOR_GROUPS[m.dcType] || 'DC', 'dc', m, ['voltage', 'current', 'power', 'stateOfCharge', 'temperature']))
+    }
+    for (const s of sensorRuntime ? sensorRuntime.senders : []) {
+      const group = s.kind === 'tank' ? 'Tanks' : s.kind === 'temperature' ? 'Temperatures' : 'Environment'
+      const x = item(group, s.kind, s, Object.keys(s.signalK))
+      x.source = s.source // temperature or pressure source, tank fluid type
+      if (s.kind === 'tank' && s.capacity && !x.readings.some(r => r.field === 'capacity')) x.capacity = s.capacity
+      items.push(x)
+    }
+    for (const i of switchInputs) {
+      const st = inputState.get(i.path) || {}
+      items.push({ group: 'Inputs', kind: 'input', name: i.name, slug: i.slug, path: i.path, decoded: i.decoded, live: st.state !== null && st.state !== undefined, state: st.state === undefined ? null : st.state, since: st.since || null, readings: [] })
+    }
+    const temperatures = {}
+    for (const slug of circuitTemps.keys()) {
+      const t = circuitTemperature(slug)
+      if (t) temperatures[slug] = t
+    }
+    return {
+      enabled: true,
+      file: mapping ? mapping.fileName : null,
+      trendsEnabled: settings.trendsEnabled === true,
+      candump: candump ? candump.status() : null,
+      items,
+      temperatures
+    }
+  }
+
+  function observeMeters (frame) {
+    // What each device says it is, for choosing between devices on one instance.
+    if (frame.pgn === monitoring.PGN_DC_DETAILED && frame.data && frame.data.length >= 4) {
+      sourcePicker.noteDcDetailed(frame.data[1], frame.source, frame.data[2], frame.data[3] <= 100)
+    }
     const observations = monitoringRuntime.observe(frame)
     for (const observation of observations) {
       const meter = observation.meter
+      const pick = { key: `meter:${meter.slug}`, module: meter.module, virtual: meter.virtual, instance: meter.instance, dcType: meter.type === 'DC' ? meter.dcType : null }
+      if (!sourcePicker.allowed(pick, frame.source)) continue
       for (const [field, value] of Object.entries(observation.values)) {
         if (!Number.isFinite(value)) continue
         const pathName = meter.signalK[field]
@@ -962,6 +1105,7 @@ module.exports = function (app) {
   function handleRawFrame (line) {
     const frame = nmea.parseRawLine(line)
     if (!frame) return
+    sourcePicker.learn(frame)
     observeModeCommand(frame)
     handleMonitoringFrame(frame)
     if (frame.pgn === nmea.CZONE_DATABLOCK_PGN) {
@@ -1266,9 +1410,9 @@ module.exports = function (app) {
         },
         trendsEnabled: {
           type: 'boolean',
-          title: 'Record circuit current trends',
+          title: 'Record trends',
           default: false,
-          description: 'Off by default. Stores each circuit\'s current every 10 seconds as plain CSV files, for the trend charts in the webapp. Not needed if the data already goes to a database such as InfluxDB. On a Victron GX trends go to an SD card or USB stick only, never to internal flash; without a writable card nothing is recorded.'
+          description: 'Off by default. Stores each circuit\'s current and every monitored value (meters, tanks, temperatures, pressure) every 10 seconds as plain CSV files, for the trend charts in the webapp. Not needed if the data already goes to a database such as InfluxDB. On a Victron GX trends go to an SD card or USB stick only, never to internal flash; without a writable card nothing is recorded.'
         },
         trendDirectory: {
           type: 'string',
@@ -1354,6 +1498,24 @@ module.exports = function (app) {
           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.'
         },
+        monitoringEnabled: {
+          type: 'boolean',
+          title: 'Monitoring',
+          default: false,
+          description: 'Off by default. Adds the Monitoring tab to the webapp: every meter, tank, temperature, humidity and pressure sender in the ZCF, live, with DC watts, and a circuit\'s temperature beside its name and in its switch pane label. Meter readings are published to Signal K either way.'
+        },
+        monitorCandump: {
+          type: 'boolean',
+          title: 'On a Victron GX, read monitoring messages straight off the CAN interface',
+          default: true,
+          description: 'Signal K does not pass on what the GX itself sends onto NMEA 2000, such as a Ruuvi tag or a GX tank input bridged by Venus OS. With this on, the plugin reads those messages (tank, temperature, humidity, pressure, battery and AC) with candump, as a CZone display sees them. Only on Venus OS.'
+        },
+        monitorCanDevice: {
+          type: 'string',
+          title: 'CAN interface for the above',
+          default: 'vecan0',
+          description: 'vecan0 is the GX\'s VE.Can / NMEA 2000 port.'
+        },
         victronSwitchCurrent: {
           type: 'boolean',
           title: 'Show circuit current in the switch pane',
@@ -1440,9 +1602,15 @@ module.exports = function (app) {
           decodeCurrentPacket(packet)
           if (packet.pgn === CURRENT_PGN_DC) decodeDcStatePacket(packet)
         })
+        monitorFastPacket = nmea.createFastPacketReassembler(packet => {
+          if (monitoringRuntime) observeMeters({ pgn: packet.pgn, source: packet.source, data: packet.payload })
+        }, { pgns: monitoring.FAST_PACKET_PGNS })
         rawListener = handleRawFrame
         app.on('canboatjs:rawoutput', rawListener)
+        jsonOutListener = handleJsonOut
+        app.on('nmea2000JsonOut', jsonOutListener)
       }
+      startCandump()
 
       startupModeInferenceDone = false
       if (startupModeInferenceTimer) clearTimeout(startupModeInferenceTimer)
@@ -1472,6 +1640,16 @@ module.exports = function (app) {
       lastNmeaOutput = null
       if (rawListener && typeof app.removeListener === 'function') app.removeListener('canboatjs:rawoutput', rawListener)
       rawListener = null
+      if (jsonOutListener && typeof app.removeListener === 'function') app.removeListener('nmea2000JsonOut', jsonOutListener)
+      jsonOutListener = null
+      if (candump) candump.stop()
+      candump = null
+      if (monitorFastPacket) monitorFastPacket.clear()
+      monitorFastPacket = null
+      sourcePicker.clear()
+      sensorRuntime = null
+      monitorValues = new Map()
+      circuitTemps = new Map()
       if (reassembler) reassembler.clear()
       if (monitoringRuntime) monitoringRuntime.clear()
       monitoringRuntime = null
@@ -1532,6 +1710,8 @@ module.exports = function (app) {
         })
       })
 
+      router.get('/monitoring/live', (_req, res) => res.json(monitoringLive()))
+
       router.get('/monitoring/tanks', (_req, res) => {
         res.json({
           file: mapping ? mapping.fileName : null,

package/lib/candump.js

@@ -0,0 +1,103 @@
+'use strict'
+
+// Monitoring PGNs read straight off a GX's CAN interface with candump.
+//
+// Signal K hands plugins the frames it receives from other devices, but not
+// the frames the GX itself transmits. A Ruuvi tag or other sensor that Venus
+// OS sends onto NMEA 2000 (bench, 1 Oct 2026: Ruuvi and Victron temperature
+// sensors sent by the Cerbo at address 0x65 as 130312 / 130316) is seen by
+// CZone displays and by candump, but never reaches the plugin's
+// canboatjs:rawoutput listener. candump sees the wire as a CZone display
+// does. The kernel filter passes only the monitoring PGNs, a few frames a
+// second.
+//
+// Only on Venus OS, which ships candump. Anywhere else this is not started.
+
+const { spawn } = require('child_process')
+
+// PGNs: 130312 130313 130314 130316 127505 127506 127508 127503 127504
+// 127744-127749. <can_id>:<mask> on data page + PF + PS.
+const PGNS = [0x1FD08, 0x1FD09, 0x1FD0A, 0x1FD0C, 0x1F211, 0x1F212, 0x1F214, 0x1F20F, 0x1F210, 0x1F300, 0x1F301, 0x1F302, 0x1F303, 0x1F304, 0x1F305]
+const FILTERS = PGNS.map(pgn => `${(pgn << 8).toString(16).toUpperCase().padStart(8, '0')}:01FFFF00`)
+const LINE = /\s([0-9A-Fa-f]{8})\s+\[(\d)\]\s+((?:[0-9A-Fa-f]{2}\s*)+)$/
+
+// "  vecan0  0DF21465   [8]  02 2F 05 E7 FF FF FF 00" -> the raw line format
+// the plugin already reads ("<time> R <can id> <bytes>").
+function parseCandumpLine (line) {
+  const m = LINE.exec(String(line).trimEnd())
+  if (!m) return null
+  return `0 R ${m[1].toUpperCase()} ${m[3].trim()}`
+}
+
+function createCandump ({ device = 'vecan0', onLine, log = () => {}, spawnFn = spawn } = {}) {
+  let child = null
+  let stopped = true
+  let restartTimer = null
+  let buffer = ''
+  const state = { running: false, device, lines: 0, lastLineAt: 0, error: null }
+
+  function launch () {
+    if (stopped) return
+    try {
+      child = spawnFn('candump', [`${device},${FILTERS.join(',')}`], { stdio: ['ignore', 'pipe', 'pipe'] })
+    } catch (err) {
+      state.running = false
+      state.error = err.message
+      return
+    }
+    state.error = null
+    child.on('spawn', () => { state.running = true })
+    child.stdout.on('data', chunk => {
+      buffer += chunk.toString()
+      let nl
+      while ((nl = buffer.indexOf('\n')) >= 0) {
+        const raw = parseCandumpLine(buffer.slice(0, nl))
+        buffer = buffer.slice(nl + 1)
+        if (!raw) continue
+        state.lines++
+        state.lastLineAt = Date.now()
+        try { onLine(raw) } catch (_) {}
+      }
+    })
+    child.stderr.on('data', d => { state.error = d.toString().trim().slice(0, 200) })
+    child.on('error', err => {
+      state.running = false
+      state.error = err.code === 'ENOENT' ? 'candump not installed' : err.message
+      child = null
+      if (err.code !== 'ENOENT') scheduleRestart()
+    })
+    child.on('exit', code => {
+      state.running = false
+      child = null
+      if (!stopped && state.error !== 'candump not installed') {
+        log(`candump on ${device} exited (${code}); restarting in 30 s`)
+        scheduleRestart()
+      }
+    })
+  }
+
+  function scheduleRestart () {
+    clearTimeout(restartTimer)
+    if (!stopped) restartTimer = setTimeout(launch, 30e3)
+  }
+
+  function start () { stopped = false; launch() }
+
+  function stop () {
+    stopped = true
+    clearTimeout(restartTimer)
+    // Never signal without a real pid: a failed spawn can leave pid 0, and
+    // kill(0) would hit the whole process group.
+    if (child && child.pid > 0) { try { child.kill() } catch (_) {} }
+    child = null
+    state.running = false
+  }
+
+  // Delivering frames now: running, and a frame within the last minute (a
+  // candump that started but sees nothing must not hide the other route).
+  const delivering = (now = Date.now()) => state.running && now - state.lastLineAt < 60e3
+
+  return { start, stop, delivering, status: () => ({ ...state }) }
+}
+
+module.exports = { createCandump, parseCandumpLine, FILTERS, PGNS }

package/lib/monitoring.js

@@ -17,6 +17,25 @@ const DC_TYPE_NAMES = Object.freeze({
   4: 'wind'
 })
 
+// The older AC messages, fast packets: instance, number of lines, then per
+// line (18 bytes) line/flags, voltage u16 0.01 V, current u16 0.1 A,
+// frequency u16 0.01 Hz, breaker u16, real power u32 1 W, reactive power u32,
+// power factor. CZone and many chartplotters use these; Victron equipment
+// sends 127744-127749. Both feed the same AC meter, by its instance.
+const PGN_AC_INPUT_STATUS = 127503
+const PGN_AC_OUTPUT_STATUS = 127504
+// Reassembled from fast packets before they reach observe().
+const FAST_PACKET_PGNS = new Set([PGN_DC_DETAILED, PGN_AC_INPUT_STATUS, PGN_AC_OUTPUT_STATUS])
+
+// The top values of every NMEA 2000 field mean "no data" (not available, out
+// of range, reserved). None of them is a reading.
+const naU = (v, bits) => v >= 2 ** bits - 3
+const naI = (v, bits) => v >= 2 ** (bits - 1) - 3
+// Scaled without floating-point dust (1320 x 0.01 = 13.2, not 13.200000000000001).
+const scaled = (v, scale) => Math.round(v * scale * 1e6) / 1e6
+const u16 = (b, at, scale) => { const v = b.readUInt16LE(at); return naU(v, 16) ? null : scaled(v, scale) }
+const i16 = (b, at, scale) => { const v = b.readInt16LE(at); return naI(v, 16) ? null : scaled(v, scale) }
+
 const AC_POWER_PGNS = new Set([PGN_AC_POWER_A, PGN_AC_POWER_B, PGN_AC_POWER_C])
 const AC_VOLTAGE_PGNS = new Set([PGN_AC_VOLTAGE_A, PGN_AC_VOLTAGE_B, PGN_AC_VOLTAGE_C])
 
@@ -29,9 +48,9 @@ function decodeDcDetailed (payload) {
     dcType: DC_TYPE_NAMES[payload[2]] || null,
     stateOfCharge: payload[3] <= 100 ? payload[3] / 100 : null,
     stateOfHealth: payload[4] <= 100 ? payload[4] / 100 : null,
-    timeRemaining: payload.readUInt16LE(5) * 60,
-    rippleVoltage: payload.readUInt16LE(7) * 0.01,
-    ampHours: payload.readUInt16LE(9) * 0.1
+    timeRemaining: u16(payload, 5, 60),
+    rippleVoltage: u16(payload, 7, 0.01),
+    ampHours: u16(payload, 9, 0.1)
   }
 }
 
@@ -39,9 +58,9 @@ function decodeBatteryStatus (payload) {
   if (!Buffer.isBuffer(payload) || payload.length < 8) return null
   return {
     instance: payload[0],
-    voltage: payload.readUInt16LE(1) * 0.01,
-    current: payload.readInt16LE(3) * 0.1,
-    temperature: payload.readUInt16LE(5) * 0.01,
+    voltage: u16(payload, 1, 0.01),
+    current: i16(payload, 3, 0.1),
+    temperature: u16(payload, 5, 0.01),
     sid: payload[7]
   }
 }
@@ -51,8 +70,8 @@ function decodeAcPower (payload, pgn) {
   return {
     sid: payload[0],
     connection: payload[1],
-    current: payload.readUInt16LE(2) * 0.1,
-    power: payload.readInt32LE(4),
+    current: u16(payload, 2, 0.1),
+    power: naI(payload.readInt32LE(4), 32) ? null : payload.readInt32LE(4),
     phase: pgn - PGN_AC_POWER_A
   }
 }
@@ -62,13 +81,26 @@ function decodeAcVoltage (payload, pgn) {
   return {
     sid: payload[0],
     connection: payload[1],
-    voltage: payload.readUInt16LE(2) * 0.1,
-    lineToLineVoltage: payload.readUInt16LE(4) * 0.1,
-    frequency: payload.readUInt16LE(6) * 0.1,
+    voltage: u16(payload, 2, 0.1),
+    lineToLineVoltage: u16(payload, 4, 0.1),
+    frequency: u16(payload, 6, 0.1),
     phase: pgn - PGN_AC_VOLTAGE_A
   }
 }
 
+// Line 1 of 127503 / 127504 (a reassembled packet).
+function decodeAcStatus (payload) {
+  if (!Buffer.isBuffer(payload) || payload.length < 15 || payload[1] === 0 || payload[1] === 0xff) return null
+  const watts = payload.readUInt32LE(11)
+  return {
+    connection: payload[0],
+    voltage: u16(payload, 3, 0.01),
+    current: u16(payload, 5, 0.1),
+    frequency: u16(payload, 7, 0.01),
+    power: naU(watts, 32) ? null : watts
+  }
+}
+
 function signalKPaths (meter) {
   const slug = meter.slug
   const base = `electrical.czone.monitoring.${slug}`
@@ -165,11 +197,17 @@ function createRuntime (meters) {
       decoded = decodeBatteryStatus(frame.data)
       if (!decoded) return []
       meters = selectDc(decoded)
+      // DC watts (solar, alternator, wind, battery): volts x amps of the
+      // same message, so the two always belong together.
+      const power = decoded.voltage !== null && decoded.current !== null
+        ? Math.round(decoded.voltage * decoded.current * 10) / 10
+        : null
       return meters.map(meter => ({
         meter,
         values: {
           voltage: decoded.voltage,
           current: decoded.current,
+          power,
           temperature: decoded.temperature
         },
         source: { label: 'NMEA2000', type: 'NMEA2000', src: String(frame.source), pgn: frame.pgn }
@@ -187,6 +225,17 @@ function createRuntime (meters) {
       }))
     }
 
+    if (frame.pgn === PGN_AC_INPUT_STATUS || frame.pgn === PGN_AC_OUTPUT_STATUS) {
+      decoded = decodeAcStatus(frame.data)
+      if (!decoded) return []
+      meters = acCandidates(decoded.connection)
+      return meters.map(meter => ({
+        meter,
+        values: { voltage: decoded.voltage, current: decoded.current, frequency: decoded.frequency, power: decoded.power },
+        source: { label: 'NMEA2000', type: 'NMEA2000', src: String(frame.source), pgn: frame.pgn }
+      }))
+    }
+
     if (AC_VOLTAGE_PGNS.has(frame.pgn)) {
       decoded = decodeAcVoltage(frame.data, frame.pgn)
       if (!decoded) return []
@@ -229,6 +278,10 @@ module.exports = {
   PGN_AC_VOLTAGE_A,
   PGN_AC_VOLTAGE_B,
   PGN_AC_VOLTAGE_C,
+  PGN_AC_INPUT_STATUS,
+  PGN_AC_OUTPUT_STATUS,
+  FAST_PACKET_PGNS,
+  decodeAcStatus,
   decodeDcDetailed,
   decodeBatteryStatus,
   decodeAcPower,

package/lib/nmea2000.js

@@ -114,6 +114,8 @@ function isCzoneCommandFrame (frame) {
 function createFastPacketReassembler (onPacket, options = {}) {
   const packets = new Map()
   const timeoutMs = options.timeoutMs || 2000
+  // Which PGNs to reassemble: the CZone current tables unless given.
+  const wanted = options.pgns instanceof Set ? pgn => options.pgns.has(pgn) : isCzoneCurrentPgn
 
   function expire () {
     const now = Date.now()
@@ -121,7 +123,7 @@ function createFastPacketReassembler (onPacket, options = {}) {
   }
 
   function accept (frame) {
-    if (!frame || !isCzoneCurrentPgn(frame.pgn) || !frame.data || frame.data.length < 2) return
+    if (!frame || !wanted(frame.pgn) || !frame.data || frame.data.length < 2) return
     expire()
     const control = frame.data[0]
     const packetId = control >>> 4