docs: add AT, Modbus RTU, Plantower examples and fix driver-kit stale reference

- Add examples/at-modem-chat — query AT modem identity, signal, registration
- Add examples/modbus-read-holding — read holding registers from Modbus RTU slave
- Add examples/plantower-read — stream PM readings from Plantower sensor
- Update driver-kit README: three flagship → six downstream drivers
- Update root README Examples section with all six examples

Author: ambicuity

README.md

@@ -20,9 +20,12 @@ All drivers consume the published `serialpilot` core toolkit from npm. Each driv
 
 Runnable examples live under [`examples/`](./examples/):
 
+- [`at-modem-chat`](./examples/at-modem-chat/) — query an AT modem for identity, signal, and registration
 - [`gps-live-fix`](./examples/gps-live-fix/) — print live NMEA fixes
 - [`grbl-jog-cli`](./examples/grbl-jog-cli/) — interactive CNC jog control
 - [`esp-flash-blink`](./examples/esp-flash-blink/) — flash a `.bin` to an ESP chip
+- [`modbus-read-holding`](./examples/modbus-read-holding/) — read holding registers from a Modbus RTU slave
+- [`plantower-read`](./examples/plantower-read/) — stream particulate matter readings from a Plantower PM sensor
 
 Each example includes a small `serialPilotTransport.ts` adapter that wraps `SerialPilot`'s callback-style API in the promise-based `Transport` interface that drivers expect.
 

examples/at-modem-chat/README.md

@@ -0,0 +1,16 @@
+# at-modem-chat
+
+Queries an AT-command modem for device identity, signal strength, and network registration, then prints any unsolicited result codes (URCs) that arrive.
+
+```sh
+npm install
+npm start -- /dev/ttyUSB0
+```
+
+Default baud rate is 115200. Adjust in `src/index.ts` if your modem uses a different rate.
+
+## What it shows
+
+- `@serialpilot/driver-at` end-to-end against a real port via `serialpilot`.
+- Standard 3GPP helpers: `getIdentity()`, `getImei()`, `getIccid()`, `getSignalStrength()`, `getNetworkRegistration()`.
+- `'urc'` event handling for inbound unsolicited result codes.

examples/at-modem-chat/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@serialpilot-examples/at-modem-chat",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@serialpilot/driver-at": "*",
+    "@serialpilot/driver-kit": "*",
+    "serialpilot": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.3",
+    "tsx": "4.20.6"
+  }
+}

examples/at-modem-chat/src/index.ts

@@ -0,0 +1,28 @@
+import { AtModem } from '@serialpilot/driver-at'
+import { serialPilotTransport } from './serialPilotTransport.ts'
+
+const path = process.argv[2]
+if (!path) {
+  console.error('usage: at-modem-chat <port>')
+  process.exit(1)
+}
+
+const transport = serialPilotTransport({ path, baudRate: 115200 })
+const modem = new AtModem({ transport })
+
+modem.on('urc', ({ line }) => console.log(`URC: ${line}`))
+
+await modem.open()
+
+console.log('Identity:    ', await modem.getIdentity())
+console.log('IMEI:        ', await modem.getImei())
+console.log('ICCID:       ', await modem.getIccid())
+
+const signal = await modem.getSignalStrength()
+console.log(`Signal:       RSSI=${signal.rssi ?? '?'}  BER=${signal.ber ?? '?'}`)
+
+const reg = await modem.getNetworkRegistration()
+console.log(`Registration: ${reg.status}${reg.lac ? `  LAC=${reg.lac}` : ''}${reg.cellId ? `  Cell=${reg.cellId}` : ''}`)
+
+await modem.close()
+console.log('Done.')

examples/at-modem-chat/src/serialPilotTransport.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'node:events'
+import { SerialPilot } from 'serialpilot'
+import type { Transport } from '@serialpilot/driver-kit'
+
+/**
+ * Adapt a `SerialPilot` (callback-style API) to the promise-based `Transport`
+ * interface that `@serialpilot/driver-*` packages expect. Keeps examples readable
+ * without forcing driver-kit to take a runtime dependency on the core toolkit.
+ */
+export function serialPilotTransport(opts: { path: string, baudRate: number }): Transport {
+  const port = new SerialPilot({ path: opts.path, baudRate: opts.baudRate, autoOpen: false })
+  const emitter = new EventEmitter() as EventEmitter & Transport
+
+  const transport: Transport = Object.assign(emitter, {
+    get isOpen() { return port.isOpen },
+    open() {
+      return new Promise<void>((resolve, reject) => {
+        port.open(err => err ? reject(err) : resolve())
+      })
+    },
+    close() {
+      return new Promise<void>((resolve, reject) => {
+        port.close(err => err ? reject(err) : resolve())
+      })
+    },
+    write(data: Uint8Array | string) {
+      return new Promise<void>((resolve, reject) => {
+        port.write(data as Buffer | string, err => err ? reject(err) : resolve())
+      })
+    },
+    setSignals(signals: { dtr?: boolean, rts?: boolean }) {
+      return new Promise<void>((resolve, reject) => {
+        port.set(signals, err => err ? reject(err) : resolve())
+      })
+    },
+  })
+
+  port.on('data', (chunk: Buffer) => emitter.emit('data', chunk))
+  port.on('error', (err: Error) => emitter.emit('error', err))
+  port.on('close', () => emitter.emit('close'))
+
+  return transport
+}

examples/at-modem-chat/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "noEmit": true
+  },
+  "include": ["src/**/*.ts"]
+}

examples/modbus-read-holding/README.md

@@ -0,0 +1,16 @@
+# modbus-read-holding
+
+Reads holding registers from a Modbus RTU slave device and prints the values.
+
+```sh
+npm install
+npm start -- /dev/ttyUSB0
+```
+
+Default baud rate is 9600 (typical for RS-485 Modbus). Adjust in `src/index.ts` for your bus.
+
+## What it shows
+
+- `@serialpilot/driver-modbus-rtu` end-to-end against a real port via `serialpilot`.
+- `readHoldingRegisters()` with typed error handling.
+- Slave address and register count configurable in source.

examples/modbus-read-holding/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@serialpilot-examples/modbus-read-holding",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "start": "tsx src/index.ts"
+  },
+  "dependencies": {
+    "@serialpilot/driver-kit": "*",
+    "@serialpilot/driver-modbus-rtu": "*",
+    "serialpilot": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.3",
+    "tsx": "4.20.6"
+  }
+}

examples/modbus-read-holding/src/index.ts

@@ -0,0 +1,29 @@
+import { ModbusRtuMaster } from '@serialpilot/driver-modbus-rtu'
+import { serialPilotTransport } from './serialPilotTransport.ts'
+
+const path = process.argv[2]
+if (!path) {
+  console.error('usage: modbus-read-holding <port>')
+  process.exit(1)
+}
+
+const SLAVE = 1
+const START_ADDR = 0
+const QUANTITY = 10
+
+const transport = serialPilotTransport({ path, baudRate: 9600 })
+const modbus = new ModbusRtuMaster({ transport })
+
+await modbus.open()
+
+try {
+  const regs = await modbus.readHoldingRegisters(SLAVE, START_ADDR, QUANTITY)
+  console.log(`Slave ${SLAVE} — holding registers ${START_ADDR}…${START_ADDR + QUANTITY - 1}:`)
+  for (let i = 0; i < regs.length; i++) {
+    console.log(`  ${String(START_ADDR + i).padStart(4)}: ${regs[i]}`)
+  }
+} catch (e) {
+  console.error('Modbus error:', (e as Error).message)
+} finally {
+  await modbus.close()
+}

examples/modbus-read-holding/src/serialPilotTransport.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'node:events'
+import { SerialPilot } from 'serialpilot'
+import type { Transport } from '@serialpilot/driver-kit'
+
+/**
+ * Adapt a `SerialPilot` (callback-style API) to the promise-based `Transport`
+ * interface that `@serialpilot/driver-*` packages expect. Keeps examples readable
+ * without forcing driver-kit to take a runtime dependency on the core toolkit.
+ */
+export function serialPilotTransport(opts: { path: string, baudRate: number }): Transport {
+  const port = new SerialPilot({ path: opts.path, baudRate: opts.baudRate, autoOpen: false })
+  const emitter = new EventEmitter() as EventEmitter & Transport
+
+  const transport: Transport = Object.assign(emitter, {
+    get isOpen() { return port.isOpen },
+    open() {
+      return new Promise<void>((resolve, reject) => {
+        port.open(err => err ? reject(err) : resolve())
+      })
+    },
+    close() {
+      return new Promise<void>((resolve, reject) => {
+        port.close(err => err ? reject(err) : resolve())
+      })
+    },
+    write(data: Uint8Array | string) {
+      return new Promise<void>((resolve, reject) => {
+        port.write(data as Buffer | string, err => err ? reject(err) : resolve())
+      })
+    },
+    setSignals(signals: { dtr?: boolean, rts?: boolean }) {
+      return new Promise<void>((resolve, reject) => {
+        port.set(signals, err => err ? reject(err) : resolve())
+      })
+    },
+  })
+
+  port.on('data', (chunk: Buffer) => emitter.emit('data', chunk))
+  port.on('error', (err: Error) => emitter.emit('error', err))
+  port.on('close', () => emitter.emit('close'))
+
+  return transport
+}