@tempivo/sensor-beacon 0.2.0 → 0.3.0

package/README.md

@@ -1,42 +1,94 @@
 # @tempivo/sensor-beacon
 
-Tempivo partner SDK for sensors over BLE. Advertisement decode (manufacturer id **0x026C**) plus GATT session for alert rules, an immediate uplink, and laboratory calibration date.
+BLE for Tempivo sensors. One package for Expo, React Native, Android, iOS, and Node.
+
+## Expo and React Native
+
+Needs a development build (or bare React Native). Expo Go is not supported.
 
 ```bash
-npm install @tempivo/sensor-beacon
+npx expo install @tempivo/sensor-beacon
 ```
 
-| Path | Use |
-|------|-----|
-| `dist/` | Node / TypeScript: advertising decode, QR parse, config JSON |
-| `android/` + `dist/tempivo-sensor-beacon.aar` | Android scan + GATT |
-| `ios/` | iOS Swift Package (scan + session) |
+app.json:
 
-GATT runs on a phone (Android / iOS), not in Node. Always pass the sticker PIN to `connect`. Wrong PIN maps to `invalidPin`.
+```json
+{
+  "expo": {
+    "plugins": ["@tempivo/sensor-beacon"]
+  }
+}
+```
 
-## QR object
+Then rebuild native:
 
-Sticker QR is JSON. Parse with `parseSensorQrJson` (Node) or `TempivoSensorQrParser.parse` (Android / iOS).
+```bash
+npx expo prebuild
+npx expo run:ios
+# or
+npx expo run:android
+```
 
-```json
-{ "sn": "282C024F0012", "pin": "111111", "model": "HC7" }
+Android minSdk is 26. The plugin sets that on prebuild.
+
+Bare React Native (no Expo app yet):
+
+```bash
+npx install-expo-modules@latest
+npm install @tempivo/sensor-beacon
 ```
 
+Add `NSBluetoothAlwaysUsageDescription` on iOS if you do not use Expo prebuild.
+
 ```ts
+import {
+  parseSensorQrJson,
+  startScan,
+  stopScan,
+  addDeviceFoundListener,
+  connect,
+  setConfigurationJson,
+  getConfiguration,
+  triggerTransmission,
+  getCalibration,
+  disconnect,
+} from '@tempivo/sensor-beacon';
+
+const sub = await addDeviceFoundListener((device) => {
+  console.log(device.serialNumber, device.rssi, device.summary);
+});
+
+await startScan();
+
 const qr = parseSensorQrJson(stickerQrText);
+await connect(qr);
+await setConfigurationJson({
+  schedule: { always: true },
+  temperatureAlerts: [
+    {
+      type: 'range',
+      channel: 'probe',
+      lowC: -30,
+      highC: -10,
+      hysteresisC: 0.5,
+    },
+  ],
+});
+await triggerTransmission();
+const applied = await getConfiguration();
+const cal = await getCalibration();
+await disconnect();
+stopScan();
+sub.remove();
 ```
 
-| Field | Type | Meaning |
-|-------|------|---------|
-| `serial` | string | Device serial, 12 hex chars, no colons. From QR `sn`. |
-| `pin` | string | Sticker PIN. Required on `connect`. Also accepted as QR `resetCode`. |
-| `model` | string | Sticker model. Omitted QR `model` becomes **HC7**. `HC5` selects legacy GATT. |
-| `sessionType` | `modern` \| `legacy` | GATT path. HC7 / firmware 7+ is `modern`. HC5 / firmware 6.x is `legacy`. |
-| `bluetoothMac` | string | BLE MAC with colons, derived from `serial`. |
+`startScan` and `connect` request Bluetooth permission. Sticker PIN is required on `connect`. Wrong PIN is `invalidPin`.
+
+If a bundler misses native BLE, import `@tempivo/sensor-beacon/react-native`.
 
-## Config JSON (same as Cellular API)
+## Config JSON
 
-`setConfiguration` / `getConfiguration` use the same `temperatureAlerts` + `schedule` shape as `POST /api/v1/devices/config-profiles`.
+Same as Cellular API config profiles (`temperatureAlerts` + `schedule`). You can build it yourself. Profiles are only for REST reuse.
 
 ```json
 {
@@ -55,19 +107,17 @@ const qr = parseSensorQrJson(stickerQrText);
 }
 ```
 
-**Root**
-
 | Field | Meaning |
-|-------|---------|
-| `temperatureAlerts` | Alert list. Empty array is valid (no temperature alerts). |
-| `schedule` | When alerts are active. `{ "always": true }` is 24/7. |
+|------|---------|
+| `temperatureAlerts` | Alert list. Empty array is valid. |
+| `schedule` | `{ "always": true }` is 24/7. |
 
-Ignored over BLE: `slug`, `name`, `measurementIntervalMinutes`, `transmissionIntervalSeconds`. Do not pass `GET /devices/{serial}/config` (`alarmRules`).
+Ignored over BLE: `slug`, `name`, `measurementIntervalMinutes`, `transmissionIntervalSeconds`. Do not pass `alarmRules`.
 
 **Each `temperatureAlerts[]` item**
 
 | Field | Meaning |
-|-------|---------|
+|------|---------|
 | `type` | `range` (band), `min` (below), or `max` (above). |
 | `channel` | `ambient` or `probe`. |
 | `lowC` / `highC` | Inclusive band for `type: "range"`. |
@@ -80,38 +130,74 @@ Ignored over BLE: `slug`, `name`, `measurementIntervalMinutes`, `transmissionInt
 **`schedule` weekday window** (instead of `always`)
 
 | Field | Meaning |
-|-------|---------|
+|------|---------|
 | `weekdays` | **0 = Monday** … **6 = Sunday**. |
 | `from` / `to` | 24h `HH:MM`. |
 | `utcOffsetMinutes` | Offset from UTC for `from` / `to`. |
 
-## Fetch a profile, apply over BLE
+`GET /api/v1/devices/config-profiles/{slug}` returns `{ "profile": { … } }`. Pass that body or `profile` to `setConfigurationJson`.
 
-`GET /api/v1/devices/config-profiles/{slug}` returns `{ "profile": { … } }`. Pass the GET body or `profile` to `setConfigurationJson`.
+## QR object
 
-```ts
-import { parseSensorQrJson, configurationFromApiProfile } from '@tempivo/sensor-beacon';
+Sticker QR is JSON. Parse with `parseSensorQrJson`.
 
-const qr = parseSensorQrJson(stickerQrText);
-const res = await fetch(
-  `https://app.tempivo.com/api/v1/devices/config-profiles/${slug}`,
-  { headers: { Authorization: `Bearer ${apiKey}` } }
-);
-const body = await res.json();
-const cfg = configurationFromApiProfile(body); // or body.profile
+```json
+{ "sn": "282C024F0012", "pin": "111111", "model": "HC7" }
 ```
 
-On the phone, after `connect(qr)`:
+| Field | Type | Meaning |
+|------|------|---------|
+| `serial` | string | Device serial, 12 hex chars, no colons. From QR `sn`. |
+| `pin` | string | Sticker PIN. Required on `connect`. Also accepted as QR `resetCode`. |
+| `model` | string | Sticker model. Omitted QR `model` becomes **HC7**. `HC5` selects legacy GATT. |
+| `sessionType` | `modern` \| `legacy` | GATT path. HC7 / firmware 7+ is `modern`. HC5 / firmware 6.x is `legacy`. |
+| `bluetoothMac` | string | BLE MAC with colons, derived from `serial`. |
+
+## Scan result
 
-```kotlin
-session.setConfigurationJson(profileJson) // GET body or profile object
-session.triggerTransmission()
-```
+Filter manufacturer data on company id **0x026C**. Active scanning is on so scan-response packets arrive.
+
+| Field | Meaning |
+|------|---------|
+| `deviceId` | Platform BLE id. Often randomized. Not the sticker serial. |
+| `bluetoothMacAddress` | MAC from the advertisement, with colons. |
+| `serialNumber` | 12 hex chars from advertisement frame `0x03`. Same as QR `sn`. |
+| `rssi` | Signal strength in dBm. |
+| `summary` | Short display line. |
+| `telemetry` | Decoded frames `0x03` + `0x04`, or null until enough bytes arrive. |
 
-BLE does not write measurement interval, transmission interval, server, APN, name, or token.
+**`telemetry`**
+
+| Field | Meaning |
+|------|---------|
+| `firmware` | `major.minor.patch`, e.g. `7.3.4`. |
+| `batteryOk` | Battery status flag. |
+| `encryptionEnabled` | Advertisement payload encryption flag. |
+| `cellularStatus` | `ble_only`, `cell_ok`, `no_server`, or `net_issue`. |
+| `readingTimestampUnix` | Sample time as unix seconds, or null. |
+| `readingTimestampIso` | Same instant as UTC ISO-8601, or null. |
+| `measurementIntervalSeconds` | Sample interval, in seconds. |
+| `readings` | Decoded scan-response slots. |
+| `readingsCount` | Number of measurement slots. |
+| `summary` | Same short line as on the device object. |
+| `measurementCounter` | Counter from frame `0x03`, or null. |
+
+**Each `readings[]` slot**
+
+| Field | Meaning |
+|------|---------|
+| `typeHex` | Slot type, e.g. `0x01` temperature, `0x02` humidity. |
+| `raw24` | Undecoded 24-bit payload. |
+| `text` | Display value with unit, e.g. `21.8 °C`. |
+
+`triggerTransmission()` returns `{ ok, supported }`. `supported: false` is not an error.
+
+`getCalibration()` returns `{ laboratoryCalibrationDate, laboratoryCalibrationTimestamp }`. Date is `YYYY-MM-DD`, or null if unset.
 
 ## Node / TypeScript helpers
 
+Decode advertisements and parse QR / config without native BLE.
+
 ```ts
 import {
   normalizeManufacturerBytes,
@@ -127,9 +213,9 @@ const cfg = parseSensorConfigurationJson(/* config JSON above */);
 
 Invalid QR or config throws `TempivoSensorError` (`invalidQr`, `invalidPin`, `invalidConfig`).
 
-## Android (GATT)
+## Android (Kotlin)
 
-`connect` / `setConfigurationJson` / `triggerTransmission` are `suspend`. Request `BLUETOOTH_SCAN` and `BLUETOOTH_CONNECT` (API 31+) or location on older APIs.
+AAR: `dist/tempivo-sensor-beacon.aar` after `npm run build:android`. Sources: `android-aar/library`. Request `BLUETOOTH_SCAN` and `BLUETOOTH_CONNECT` (API 31+) or location on older APIs.
 
 ```kotlin
 val qr = TempivoSensorQrParser.parse(stickerQrText)
@@ -146,23 +232,16 @@ try {
 }
 ```
 
-**`triggerTransmission()`**
-
-| Field | Meaning |
-|-------|---------|
-| `ok` | Device accepted the uplink request. |
-| `supported` | Firmware implements the command. `false` is not an error. |
-
-**`getCalibration()`**
-
-| Field | Meaning |
-|-------|---------|
-| `laboratoryCalibrationDate` | ISO date (`YYYY-MM-DD`), or null if unset. |
-| `laboratoryCalibrationTimestamp` | Same instant as unix seconds, or null. No expiry field on the device. |
+```kotlin
+val scanner = TempivoSensorBeaconScanner(context)
+scanner.startScan { device ->
+    Log.d("scan", "${device.serialNumber} rssi=${device.rssi} ${device.summary}")
+}
+```
 
-## iOS (GATT)
+## iOS (Swift)
 
-Needs a physical device and the native `TempivoSensorBridge` XCFramework (`scripts/build-ios-bridge.sh`). Set **`NSBluetoothAlwaysUsageDescription`** in Info.plist. Simulator can scan advertisements only.
+Needs a physical device for GATT. Simulator can scan advertisements only. Set **`NSBluetoothAlwaysUsageDescription`** in Info.plist.
 
 ```swift
 let qr = try TempivoSensorQrParser.parse(stickerQrText)
@@ -175,57 +254,6 @@ let applied = try session.getConfiguration()
 let cal = try session.getCalibration()
 ```
 
-## Advertising (no pairing)
-
-Filter manufacturer data on company id **0x026C**. Use **active scanning** so scan-response packets arrive. Product model is **not** in the broadcast. Connect uses QR `model` (HC7 is modern GATT).
-
-```kotlin
-val scanner = TempivoSensorBeaconScanner(context)
-scanner.startScan { device ->
-    Log.d("scan", "${device.serialNumber} rssi=${device.rssi} ${device.summary}")
-}
-```
-
-**Android `TempivoSensorBeaconDevice`**
-
-| Field | Meaning |
-|-------|---------|
-| `deviceId` | Android BLE address. Often randomized. Not the sticker serial. |
-| `bluetoothMacAddress` | MAC from the advertisement, with colons. |
-| `serialNumber` | 12 hex chars from advertisement frame `0x03`. Same as QR `sn`. |
-| `rssi` | Signal strength in dBm. |
-| `summary` | Short display line. After scan response: measurement texts joined with ` · `. Before that: serial, or `Adv OK. Wait for scan response (measurements).` |
-| `telemetry` | Decoded frames `0x03` + `0x04`, or null until enough bytes arrive. |
-
-**`telemetry` (Android) / `reading` (iOS and Node)**
-
-| Field | Meaning |
-|-------|---------|
-| `firmware` | `major.minor.patch` from the advertisement, e.g. `7.3.4`. |
-| `batteryOk` | Battery status flag from the advertisement. |
-| `encryptionEnabled` | Advertisement payload encryption flag. |
-| `cellularStatus` | `ble_only`, `cell_ok`, `no_server`, or `net_issue`. |
-| `readingTimestampUnix` | Sample time as unix seconds, or null. |
-| `readingTimestampIso` | Same instant as UTC ISO-8601, or null. |
-| `measurementIntervalSeconds` | Sample interval from the advertisement, in seconds. |
-| `readings` | Decoded scan-response slots (see below). |
-| `readingsCount` | Number of measurement slots. |
-| `summary` | Same short line as on the device object. |
-| `measurementCounter` | Counter from frame `0x03`, or null. |
-
-Node also exposes `serialMac`, `temperatures[]`, `humidity`, and `rawHex`.
-
-**Each `readings[]` / `measurements[]` slot**
-
-| Field | Meaning |
-|-------|---------|
-| `typeHex` | Slot type, e.g. `0x01` temperature, `0x02` humidity. |
-| `raw24` | Undecoded 24-bit payload. |
-| `text` | Display value with unit, e.g. `21.8 °C`. No type name in the string. |
-| `temperatureC` / `humidityPct` | Node only: numeric value when the slot is that type. |
-
-iOS `SensorBeaconDiscovery` has `deviceId`, `rssi`, `serialNumber`, `bluetoothMacAddress`, and `reading` (same telemetry fields).
-
 ```swift
 func sensorBeaconScanner(_ scanner: TempivoSensorBeaconScanner, didDiscover discovery: SensorBeaconDiscovery) {
     print(discovery.serialNumber ?? "", discovery.rssi, discovery.reading?.summary ?? "")

package/android/build.gradle

@@ -1,4 +1,40 @@
 plugins {
-    id "com.android.library" version "8.7.3" apply false
-    id "org.jetbrains.kotlin.android" version "2.2.21" apply false
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'com.tempivo.sensor.beacon'
+version = '0.3.0'
+
+android {
+  namespace "expo.modules.tempivosensorbeacon"
+  defaultConfig {
+    minSdk 26
+    versionCode 1
+    versionName "0.3.0"
+  }
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+  kotlinOptions {
+    jvmTarget = "17"
+    // Native BLE runtime is Kotlin 2.3. Expo 57 compiles with Kotlin 2.1.
+    freeCompilerArgs += ["-Xskip-metadata-version-check"]
+  }
+}
+
+def aarFile = file("libs/tempivo-sensor-beacon.aar")
+if (!aarFile.exists()) {
+  throw new GradleException("Missing android/libs/tempivo-sensor-beacon.aar. From the package root run: npm run build:android")
+}
+
+dependencies {
+  compileOnly files(aarFile)
+  compileOnly "pl.efento.mobile:bluetooth:2.3.0"
+  runtimeOnly files(aarFile)
+  runtimeOnly "pl.efento.mobile:bluetooth:2.3.0"
+  runtimeOnly "androidx.core:core-ktx:1.17.0"
+  runtimeOnly "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.2"
+  runtimeOnly "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2"
 }

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
+  <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
+  <uses-permission
+    android:name="android.permission.BLUETOOTH_SCAN"
+    android:usesPermissionFlags="neverForLocation" />
+  <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />
+  <uses-feature android:name="android.hardware.bluetooth_le" android:required="false" />
+</manifest>

package/android/src/main/java/expo/modules/tempivosensorbeacon/SensorBeaconNative.java

@@ -0,0 +1,233 @@
+package expo.modules.tempivosensorbeacon;
+
+import android.content.Context;
+import com.tempivo.sensor.beacon.TempivoSensorBeaconDevice;
+import com.tempivo.sensor.beacon.TempivoSensorBeaconScanner;
+import com.tempivo.sensor.beacon.TempivoSensorBeaconTelemetry;
+import com.tempivo.sensor.beacon.TempivoSensorCalibration;
+import com.tempivo.sensor.beacon.TempivoSensorException;
+import com.tempivo.sensor.beacon.TempivoSensorQr;
+import com.tempivo.sensor.beacon.TempivoSensorQrParser;
+import com.tempivo.sensor.beacon.TempivoSensorSession;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Java facade so the Expo Kotlin module can compile with Kotlin 2.1 against a Kotlin 2.3 AAR.
+ */
+final class SensorBeaconNative {
+  interface DeviceCallback {
+    void onDevice(Map<String, Object> payload);
+  }
+
+  static final class NativeError extends RuntimeException {
+    final String code;
+
+    NativeError(String code, String message, Throwable cause) {
+      super(message, cause);
+      this.code = code;
+    }
+  }
+
+  private TempivoSensorBeaconScanner scanner;
+  private TempivoSensorSession session;
+
+  void startScan(Context context, DeviceCallback callback) {
+    try {
+      requireScanner(context).startScan(device -> callback.onDevice(deviceMap(device)));
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  void stopScan() {
+    if (scanner != null) {
+      scanner.stopScan();
+    }
+  }
+
+  boolean isScanning() {
+    return scanner != null && scanner.isScanning();
+  }
+
+  Map<String, Object> connect(Context context, String qrJson) {
+    try {
+      TempivoSensorQr qr = TempivoSensorQrParser.INSTANCE.parse(qrJson);
+      requireSession(context).connectBlocking(qr);
+      return qrMap(qr);
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  void disconnect() {
+    try {
+      if (session != null) {
+        session.disconnectBlocking();
+      }
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  String getConfigurationJson() {
+    try {
+      return requireSessionConnected().getConfigurationJsonBlocking();
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  void setConfigurationJson(String json) {
+    try {
+      requireSessionConnected().setConfigurationJsonBlocking(json);
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  Map<String, Object> triggerTransmission() {
+    try {
+      TempivoSensorSession.TriggerResult result = requireSessionConnected().triggerTransmissionBlocking();
+      Map<String, Object> payload = new HashMap<>();
+      payload.put("ok", result.getOk());
+      payload.put("supported", result.getSupported());
+      return payload;
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  Map<String, Object> getCalibration() {
+    try {
+      return calibrationMap(requireSessionConnected().getCalibrationBlocking());
+    } catch (Throwable error) {
+      throw wrap(error);
+    }
+  }
+
+  private TempivoSensorBeaconScanner requireScanner(Context context) {
+    if (scanner == null) {
+      scanner = new TempivoSensorBeaconScanner(context);
+    }
+    return scanner;
+  }
+
+  private TempivoSensorSession requireSession(Context context) {
+    if (session == null) {
+      session = new TempivoSensorSession(context);
+    }
+    return session;
+  }
+
+  private TempivoSensorSession requireSessionConnected() {
+    if (session == null) {
+      throw new NativeError("notConnected", "Not connected.", null);
+    }
+    return session;
+  }
+
+  private static NativeError wrap(Throwable error) {
+    if (error instanceof NativeError) {
+      return (NativeError) error;
+    }
+    TempivoSensorException sensor = findSensor(error);
+    if (sensor != null) {
+      return new NativeError(toJs(sensor.getCode()), sensor.getMessage(), error);
+    }
+    if (error instanceof TempivoSensorBeaconScanner.ScanNotPermittedException) {
+      return new NativeError("runtimeUnavailable", error.getMessage(), error);
+    }
+    String message = error.getMessage();
+    return new NativeError("unknown", message != null ? message : "Sensor request failed.", error);
+  }
+
+  private static TempivoSensorException findSensor(Throwable error) {
+    Throwable current = error;
+    while (current != null) {
+      if (current instanceof TempivoSensorException) {
+        return (TempivoSensorException) current;
+      }
+      current = current.getCause();
+    }
+    return null;
+  }
+
+  private static String toJs(TempivoSensorException.Code code) {
+    switch (code) {
+      case INVALID_PIN:
+        return "invalidPin";
+      case INVALID_QR:
+        return "invalidQr";
+      case INVALID_CONFIG:
+        return "invalidConfig";
+      case NOT_CONNECTED:
+        return "notConnected";
+      case UNSUPPORTED_COMMAND:
+        return "unsupportedCommand";
+      case RUNTIME_UNAVAILABLE:
+        return "runtimeUnavailable";
+      case CONNECT_FAILED:
+        return "connectFailed";
+      default:
+        return "unknown";
+    }
+  }
+
+  private static Map<String, Object> qrMap(TempivoSensorQr qr) {
+    Map<String, Object> payload = new HashMap<>();
+    payload.put("serial", qr.getSerial());
+    payload.put("pin", qr.getPin());
+    payload.put("model", qr.getModel());
+    payload.put(
+        "sessionType",
+        qr.getSessionType() == TempivoSensorSession.SessionType.LEGACY ? "legacy" : "modern");
+    payload.put("bluetoothMac", qr.getBluetoothMac());
+    return payload;
+  }
+
+  private static Map<String, Object> calibrationMap(TempivoSensorCalibration cal) {
+    Map<String, Object> payload = new HashMap<>();
+    payload.put("laboratoryCalibrationDate", cal.getLaboratoryCalibrationDate());
+    payload.put("laboratoryCalibrationTimestamp", cal.getLaboratoryCalibrationTimestamp());
+    return payload;
+  }
+
+  private static Map<String, Object> deviceMap(TempivoSensorBeaconDevice device) {
+    Map<String, Object> payload = new HashMap<>();
+    payload.put("deviceId", device.getDeviceId());
+    payload.put("bluetoothMacAddress", device.getBluetoothMacAddress());
+    payload.put("serialNumber", device.getSerialNumber());
+    payload.put("rssi", device.getRssi());
+    payload.put("summary", device.getSummary());
+    TempivoSensorBeaconTelemetry telemetry = device.getTelemetry();
+    payload.put("telemetry", telemetry == null ? null : telemetryMap(telemetry));
+    return payload;
+  }
+
+  private static Map<String, Object> telemetryMap(TempivoSensorBeaconTelemetry telemetry) {
+    Map<String, Object> payload = new HashMap<>();
+    payload.put("firmware", telemetry.getFirmware());
+    payload.put("batteryOk", telemetry.getBatteryOk());
+    payload.put("encryptionEnabled", telemetry.getEncryptionEnabled());
+    payload.put("cellularStatus", telemetry.getCellularStatus());
+    payload.put("measurementCounter", telemetry.getMeasurementCounter());
+    payload.put("readingTimestampUnix", telemetry.getReadingTimestampUnix());
+    payload.put("readingTimestampIso", telemetry.getReadingTimestampIso());
+    payload.put("measurementIntervalSeconds", telemetry.getMeasurementIntervalSeconds());
+    payload.put("readingsCount", telemetry.getReadingsCount());
+    payload.put("summary", telemetry.getSummary());
+    List<Map<String, Object>> readings = new ArrayList<>();
+    telemetry.getReadings().forEach(reading -> {
+      Map<String, Object> row = new HashMap<>();
+      row.put("typeHex", reading.getTypeHex());
+      row.put("raw24", reading.getRaw24());
+      row.put("text", reading.getText());
+      readings.add(row);
+    });
+    payload.put("readings", readings);
+    return payload;
+  }
+}