@rhizomatics/signalk-bluetti-plugin 1.4.1 → 1.5.0

package/lib/path-mapper.js

@@ -1,9 +1,9 @@
 "use strict";
 
-const { decodeValue } = require("./csv-loader");
+const { decodeValue } = require("./register-loader");
 
 // SignalK requires specific SI units. These conversions handle the most common
-// cases found in Bluetti register maps. The CSV's `unit` column drives the choice.
+// cases found in Bluetti register maps. The YAML field's `unit` key drives the choice.
 const UNIT_CONVERSIONS = {
   // temperature: Bluetti reports in °C or 0.1°C (handled by scale), SignalK wants K
   c: (v) => v + 273.15,
@@ -30,9 +30,9 @@ function convertUnits(value, unit) {
 }
 
 // Canonical field_name → SignalK path for the register names Bluetti's own
-// documentation and the bundled CSVs use. A CSV's `signalk_path` column is an
+// documentation and the bundled register maps use. A field's `path` key is an
 // override on top of this — only needed for a register the code doesn't know
-// about — so bundled/well-known CSVs can leave it blank and just list
+// about — so bundled/well-known register maps can leave it out and just list
 // field_name + register info.
 //
 // ac_input_power, ac_input_voltage, and dc_output_power are intentionally
@@ -69,13 +69,55 @@ const STANDARD_FIELD_PATHS = {
   // registers for them; if not, current is derived (see buildDelta below).
   ac_input_current: "electrical.chargers.{name}.current",
   ac_input_frequency: "electrical.chargers.{name}.frequency",
+  grid_frequency: "electrical.chargers.{name}.frequency", // alias used by 3-phase/home-backup models
+
+  // Lifetime energy generation counter (some models only)
+  power_generation: "electrical.solar.{name}.energyGeneratedTotal",
+
+  // Second PV string (dual-MPPT models) — the primary string uses dc_input_* above
+  pv_s2_power: "electrical.solar.{name}.pv2.panelPower",
+  pv_s2_voltage: "electrical.solar.{name}.pv2.panelVoltage",
+  pv_s2_current: "electrical.solar.{name}.pv2.panelCurrent",
+
+  // Per-phase grid (mains) input — split-phase/3-phase home-backup models
+  grid_p1_power: "electrical.chargers.{name}.L1.power",
+  grid_p1_voltage: "electrical.chargers.{name}.L1.voltage",
+  grid_p1_current: "electrical.chargers.{name}.L1.current",
+  grid_p2_power: "electrical.chargers.{name}.L2.power",
+  grid_p2_voltage: "electrical.chargers.{name}.L2.voltage",
+  grid_p2_current: "electrical.chargers.{name}.L2.current",
+  grid_p3_power: "electrical.chargers.{name}.L3.power",
+  grid_p3_voltage: "electrical.chargers.{name}.L3.voltage",
+  grid_p3_current: "electrical.chargers.{name}.L3.current",
+
+  // Per-phase AC output — split-phase/3-phase home-backup models
+  ac_p1_power: "electrical.inverters.{name}.ac.L1.realPower",
+  ac_p1_voltage: "electrical.inverters.{name}.ac.L1.voltage",
+  ac_p1_current: "electrical.inverters.{name}.ac.L1.current",
+  ac_p2_power: "electrical.inverters.{name}.ac.L2.realPower",
+  ac_p2_voltage: "electrical.inverters.{name}.ac.L2.voltage",
+  ac_p2_current: "electrical.inverters.{name}.ac.L2.current",
+  ac_p3_power: "electrical.inverters.{name}.ac.L3.realPower",
+  ac_p3_voltage: "electrical.inverters.{name}.ac.L3.voltage",
+  ac_p3_current: "electrical.inverters.{name}.ac.L3.current",
+
+  // Smart meter (external CT clamp on the home panel) — home-backup models only
+  sm_p1_power: "electrical.inverters.{name}.smartMeter.L1.power",
+  sm_p1_voltage: "electrical.inverters.{name}.smartMeter.L1.voltage",
+  sm_p1_current: "electrical.inverters.{name}.smartMeter.L1.current",
+  sm_p2_power: "electrical.inverters.{name}.smartMeter.L2.power",
+  sm_p2_voltage: "electrical.inverters.{name}.smartMeter.L2.voltage",
+  sm_p2_current: "electrical.inverters.{name}.smartMeter.L2.current",
+  sm_p3_power: "electrical.inverters.{name}.smartMeter.L3.power",
+  sm_p3_voltage: "electrical.inverters.{name}.smartMeter.L3.voltage",
+  sm_p3_current: "electrical.inverters.{name}.smartMeter.L3.current",
 };
 
 // Fields that feed a derived computation in buildDelta() rather than being
 // published under their own path directly.
 const DERIVED_SOURCE_FIELDS = new Set(["ac_input_power", "ac_input_voltage", "dc_output_power", "dc_output_voltage"]);
 
-// Build a SignalK path for a field: explicit CSV override first, then the
+// Build a SignalK path for a field: explicit `path` override first, then the
 // standard field_name registry above, then a best-effort keyword guess.
 function resolvePath(field, deviceName) {
   if (field.signalkPath) {
@@ -88,7 +130,7 @@ function resolvePath(field, deviceName) {
 
 // Best-effort automatic path generation for common Bluetti field names.
 // Only reached for fields not in STANDARD_FIELD_PATHS above — i.e. a custom
-// CSV using field names the code doesn't recognise and no explicit override.
+// register map using field names the code doesn't recognise and no explicit override.
 function autoPath(fieldName, name) {
   const f = fieldName.toLowerCase();
   if (f.includes("battery") || f.includes("batt") || f.includes("soc")) {
@@ -163,8 +205,8 @@ function buildDelta(registers, fields, deviceName, source, opts = {}) {
   }
 
   // DC output port (e.g. a 12V accessory socket): Bluetti reports power only,
-  // at a fixed nominal voltage that isn't itself a register — the CSV supplies
-  // it as a constant (dc_output_voltage), and current is derived from that.
+  // at a fixed nominal voltage that isn't itself a register — the register map
+  // supplies it as a constant (dc_output_voltage), and current is derived from that.
   if (cache.has("dc_output_power") && cache.has("dc_output_voltage")) {
     const power = cache.get("dc_output_power");
     const voltage = cache.get("dc_output_voltage");
@@ -174,7 +216,7 @@ function buildDelta(registers, fields, deviceName, source, opts = {}) {
 
   // Remaining capacity = nominal capacity × state of charge. Bluetti's own
   // "remaining capacity" register drifts with cell aging and isn't available
-  // on every model; deriving it from a fixed nominal spec (see registers/*.csv)
+  // on every model; deriving it from a fixed nominal spec (see registers/*.yaml)
   // plus the reported SoC is simpler and consistent across models.
   const soc = cache.has("battery_soc") ? cache.get("battery_soc") : cache.has("battery_percent") ? cache.get("battery_percent") : null;
   if (soc !== null && cache.has("total_capacity")) {

package/lib/register-loader.js

@@ -0,0 +1,120 @@
+"use strict";
+
+const fs = require("fs");
+const YAML = require("yaml");
+
+// Parse a register map YAML file and return an array of field descriptors.
+// Each descriptor is either register-backed: { fieldName, register, count, dataType, scale, offset, unit, signalkPath }
+// or a fixed constant (no register on the device): { fieldName, register: null, count: 0, dataType: "const", ..., constantValue }
+//
+// Expected shape:
+//
+//   fields:
+//     battery_soc: { register: 100, type: uint16, unit: "%" }
+//     battery_voltage: { register: 101, type: uint16, scale: 0.1, unit: V }
+//   constants:
+//     battery_chemistry: LiFePO4
+//     total_capacity: { value: 2000, unit: Wh }
+//
+// `type` defaults to uint16, `scale` to 1, `offset` to 0, `count` is inferred
+// from `type` when absent. `path` on a field/constant is an explicit SignalK
+// path override (see lib/path-mapper.js). A constant may be a bare scalar
+// (string or number) or an object with `value` (+ optional `unit`, `path`).
+function loadRegisters(filePath) {
+  const raw = fs.readFileSync(filePath, "utf8");
+  const doc = YAML.parse(raw);
+  if (!doc || typeof doc !== "object") throw new Error(`${filePath}: empty or invalid YAML register map`);
+
+  const fields = [];
+
+  for (const [fieldName, spec] of Object.entries(doc.fields || {})) {
+    if (spec === null || typeof spec !== "object") {
+      throw new Error(`${filePath}: field "${fieldName}" must be a mapping with at least a "register" key`);
+    }
+    const register = parseInt(spec.register, 10);
+    if (isNaN(register)) throw new Error(`${filePath}: field "${fieldName}" is missing a numeric "register" address`);
+
+    const dataType = String(spec.type || "uint16").toLowerCase();
+    const count = Number.isInteger(spec.count) ? spec.count : registersForType(dataType);
+    const scale = spec.scale !== undefined ? Number(spec.scale) : 1;
+    const offset = spec.offset !== undefined ? Number(spec.offset) : 0;
+    const unit = spec.unit !== undefined ? String(spec.unit) : "";
+    const signalkPath = spec.path !== undefined ? String(spec.path) : "";
+
+    fields.push({ fieldName, register, count, dataType, scale, offset, unit, signalkPath });
+  }
+
+  for (const [fieldName, spec] of Object.entries(doc.constants || {})) {
+    const isExpanded = spec !== null && typeof spec === "object" && "value" in spec;
+    const value = isExpanded ? spec.value : spec;
+    const unit = isExpanded && spec.unit !== undefined ? String(spec.unit) : "";
+    const signalkPath = isExpanded && spec.path !== undefined ? String(spec.path) : "";
+    const constantValue = typeof value === "number" ? value : String(value);
+
+    fields.push({ fieldName, register: null, count: 0, dataType: "const", scale: 1, offset: 0, unit, signalkPath, constantValue });
+  }
+
+  if (fields.length === 0) throw new Error(`No fields or constants found in ${filePath}`);
+  return fields;
+}
+
+function registersForType(dataType) {
+  switch (dataType) {
+    case "int32":
+    case "uint32":
+    case "float32":
+      return 2;
+    case "int64":
+    case "uint64":
+      return 4;
+    default:
+      return 1; // uint16, int16, bool, enum
+  }
+}
+
+// Decode a raw register value (or pair of registers for 32-bit types) into a number.
+// rawRegs: Map<addr, uint16>, startAddr: the register address for this field
+function decodeValue(field, rawRegs) {
+  const { register, count, dataType, scale, offset } = field;
+
+  if (dataType === "const") return field.constantValue;
+
+  let raw;
+  if (count === 1) {
+    raw = rawRegs.get(register);
+    if (raw === undefined) return null;
+  } else if (count === 2) {
+    const hi = rawRegs.get(register);
+    const lo = rawRegs.get(register + 1);
+    if (hi === undefined || lo === undefined) return null;
+    raw = (hi << 16) | lo;
+  } else {
+    return null;
+  }
+
+  let value;
+  switch (dataType) {
+    case "int16":
+      value = raw > 0x7fff ? raw - 0x10000 : raw;
+      break;
+    case "int32": {
+      const signed = raw > 0x7fffffff ? raw - 0x100000000 : raw;
+      value = signed;
+      break;
+    }
+    case "float32": {
+      const tmpBuf = Buffer.alloc(4);
+      tmpBuf.writeUInt32BE(raw, 0);
+      value = tmpBuf.readFloatBE(0);
+      break;
+    }
+    case "bool":
+      return raw !== 0 ? 1 : 0;
+    default:
+      value = raw;
+  }
+
+  return value * scale + offset;
+}
+
+module.exports = { loadRegisters, decodeValue };

package/lib/scanner.js

@@ -2,7 +2,7 @@
 
 const EventEmitter = require("events");
 
-const BLUETTI_NAME_PREFIXES = ["BT-TH-", "BLUETTI", "AC", "EP", "EB", "EL"];
+const BLUETTI_NAME_PREFIXES = ["BT-TH-", "BLUETTI", "AC", "EP", "EB", "EL", "PR", "AP"];
 
 // Retry/backoff for BLE adapter init — covers the case where SignalK (and this
 // plugin) starts before bluetoothd/D-Bus is up, e.g. on boot when service

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@rhizomatics/signalk-bluetti-plugin",
-  "version": "1.4.1",
-  "description": "SignalK plugin for Bluetti power station monitoring via Bluetooth LE. Beta, use with caution.",
+  "version": "1.5.0",
+  "description": "SignalK plugin for Bluetti power station monitoring via Bluetooth LE. Comes with configuration for 20+ models.",
   "keywords": [
     "battery",
     "ble",
     "bluetooth",
     "bluetti",
     "electrical",
+    "generator",
     "marine",
+    "signalk",
+    "signalk-category-hardware",
     "signalk-node-plugin",
-    "signalk-node-server-plugin"
+    "signalk-node-server-plugin",
+    "solar"
   ],
   "homepage": "https://github.com/rhizomatics/signalk-bluetti-plugin.git",
   "bugs": {
@@ -29,6 +33,8 @@
     "index.js",
     "cli.js",
     "lib/",
+    "docs/assets/",
+    "docs/examples/",
     "registers/",
     "README.md",
     "CHANGELOG.md"
@@ -45,11 +51,11 @@
   },
   "dependencies": {
     "@naugehyde/node-ble": "^1.13.5",
-    "csv-parse": "^5.5.6"
+    "yaml": "^2.9.0"
   },
   "devDependencies": {
     "oxfmt": "^0.61.0",
-    "oxlint": "^1.76.0",
+    "oxlint": "^1.75.0",
     "oxlint-tsgolint": "^7.0.2001"
   },
   "engines": {
@@ -58,6 +64,7 @@
   },
   "signalk": {
     "displayName": "Bluetti Monitoring",
+    "appIcon": "docs/assets/icon.svg",
     "recommends": [
       "@rhizomatics/signalk-einklabel-plugin"
     ],

package/registers/ac180.yaml

@@ -0,0 +1,58 @@
+# Bluetti AC180 register map
+# Source: https://github.com/Patrick762/bluetti-bt-lib (bluetti_bt_lib/devices/ac180.py)
+#
+# field_name is a standard Bluetti register name — the code maps these to
+# SignalK paths on its own (see lib/path-mapper.js). `path` on a field is an
+# override, only needed if you're exposing a register the code doesn't
+# recognise. `constants` are fixed, non-register facts about this model —
+# a bare scalar (string/number) or { value, unit } for one that needs unit
+# conversion (e.g. total_capacity in Wh -> J). No verified nominal capacity
+# is bundled for most models — add a total_capacity constant yourself if you
+# know it, to enable the derived remaining-capacity calculation.
+#
+
+fields:
+  dc_output_power:
+    register: 140
+    unit: W
+  ac_output_power:
+    register: 142
+    unit: W
+  dc_input_power:
+    register: 144
+    unit: W
+  ac_input_power:
+    register: 146
+    unit: W
+  dc_input_voltage:
+    register: 1213
+    scale: 0.1
+    unit: V
+  dc_input_current:
+    register: 1214
+    scale: 0.1
+    unit: A
+  ac_input_frequency:
+    register: 1300
+    scale: 0.1
+    unit: Hz
+  ac_input_voltage:
+    register: 1314
+    scale: 0.1
+    unit: V
+  ac_input_current:
+    register: 1315
+    scale: 0.1
+    unit: A
+  ac_output_frequency:
+    register: 1500
+    scale: 0.1
+    unit: Hz
+  ac_output_voltage:
+    register: 1511
+    scale: 0.1
+    unit: V
+constants:
+  battery_chemistry: LiFePO4
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC180

package/registers/ac180p.yaml

@@ -0,0 +1,34 @@
+# Bluetti AC180P register map
+# Source: https://github.com/Patrick762/bluetti-bt-lib (bluetti_bt_lib/devices/ac180p.py)
+#
+# field_name is a standard Bluetti register name — the code maps these to
+# SignalK paths on its own (see lib/path-mapper.js). `path` on a field is an
+# override, only needed if you're exposing a register the code doesn't
+# recognise. `constants` are fixed, non-register facts about this model —
+# a bare scalar (string/number) or { value, unit } for one that needs unit
+# conversion (e.g. total_capacity in Wh -> J). No verified nominal capacity
+# is bundled for most models — add a total_capacity constant yourself if you
+# know it, to enable the derived remaining-capacity calculation.
+#
+
+fields:
+  dc_output_power:
+    register: 140
+    unit: W
+  ac_output_power:
+    register: 142
+    unit: W
+  dc_input_power:
+    register: 144
+    unit: W
+  ac_input_power:
+    register: 146
+    unit: W
+  ac_input_voltage:
+    register: 1314
+    scale: 0.1
+    unit: V
+constants:
+  battery_chemistry: LiFePO4
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC180P

package/registers/ac180t.yaml

@@ -0,0 +1,58 @@
+# Bluetti AC180T register map
+# Source: https://github.com/Patrick762/bluetti-bt-lib (bluetti_bt_lib/devices/ac180t.py)
+#
+# field_name is a standard Bluetti register name — the code maps these to
+# SignalK paths on its own (see lib/path-mapper.js). `path` on a field is an
+# override, only needed if you're exposing a register the code doesn't
+# recognise. `constants` are fixed, non-register facts about this model —
+# a bare scalar (string/number) or { value, unit } for one that needs unit
+# conversion (e.g. total_capacity in Wh -> J). No verified nominal capacity
+# is bundled for most models — add a total_capacity constant yourself if you
+# know it, to enable the derived remaining-capacity calculation.
+#
+
+fields:
+  dc_output_power:
+    register: 140
+    unit: W
+  ac_output_power:
+    register: 142
+    unit: W
+  dc_input_power:
+    register: 144
+    unit: W
+  ac_input_power:
+    register: 146
+    unit: W
+  dc_input_voltage:
+    register: 1213
+    scale: 0.1
+    unit: V
+  dc_input_current:
+    register: 1214
+    scale: 0.1
+    unit: A
+  ac_input_frequency:
+    register: 1300
+    scale: 0.1
+    unit: Hz
+  ac_input_voltage:
+    register: 1314
+    scale: 0.1
+    unit: V
+  ac_input_current:
+    register: 1315
+    scale: 0.1
+    unit: A
+  ac_output_frequency:
+    register: 1500
+    scale: 0.1
+    unit: Hz
+  ac_output_voltage:
+    register: 1511
+    scale: 0.1
+    unit: V
+constants:
+  battery_chemistry: LiFePO4
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC180T

package/registers/ac200l.yaml

@@ -0,0 +1,48 @@
+# Bluetti AC200L register map
+# Source: https://github.com/Patrick762/bluetti-bt-lib (bluetti_bt_lib/devices/ac200l.py)
+#
+# field_name is a standard Bluetti register name — the code maps these to
+# SignalK paths on its own (see lib/path-mapper.js). `path` on a field is an
+# override, only needed if you're exposing a register the code doesn't
+# recognise. `constants` are fixed, non-register facts about this model —
+# a bare scalar (string/number) or { value, unit } for one that needs unit
+# conversion (e.g. total_capacity in Wh -> J). No verified nominal capacity
+# is bundled for most models — add a total_capacity constant yourself if you
+# know it, to enable the derived remaining-capacity calculation.
+#
+
+fields:
+  battery_soc:
+    register: 43
+    unit: "%"
+  dc_input_power:
+    register: 36
+    unit: W
+  ac_input_power:
+    register: 37
+    unit: W
+  ac_output_power:
+    register: 38
+    unit: W
+  dc_output_power:
+    register: 39
+    unit: W
+  ac_output_voltage:
+    register: 71
+    unit: V
+  ac_output_frequency:
+    register: 74
+    scale: 0.1
+    unit: Hz
+  dc_input_voltage:
+    register: 86
+    scale: 0.1
+    unit: V
+  dc_input_current:
+    register: 88
+    scale: 0.01
+    unit: A
+constants:
+  battery_chemistry: LiFePO4
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC200L

package/registers/ac200m.yaml

@@ -0,0 +1,48 @@
+# Bluetti AC200M register map
+# Source: https://github.com/Patrick762/bluetti-bt-lib (bluetti_bt_lib/devices/ac200m.py)
+#
+# field_name is a standard Bluetti register name — the code maps these to
+# SignalK paths on its own (see lib/path-mapper.js). `path` on a field is an
+# override, only needed if you're exposing a register the code doesn't
+# recognise. `constants` are fixed, non-register facts about this model —
+# a bare scalar (string/number) or { value, unit } for one that needs unit
+# conversion (e.g. total_capacity in Wh -> J). No verified nominal capacity
+# is bundled for most models — add a total_capacity constant yourself if you
+# know it, to enable the derived remaining-capacity calculation.
+#
+
+fields:
+  battery_soc:
+    register: 43
+    unit: "%"
+  dc_input_power:
+    register: 36
+    unit: W
+  ac_input_power:
+    register: 37
+    unit: W
+  ac_output_power:
+    register: 38
+    unit: W
+  dc_output_power:
+    register: 39
+    unit: W
+  ac_output_voltage:
+    register: 71
+    unit: V
+  ac_output_frequency:
+    register: 74
+    scale: 0.1
+    unit: Hz
+  dc_input_voltage:
+    register: 86
+    scale: 0.1
+    unit: V
+  dc_input_current:
+    register: 88
+    scale: 0.01
+    unit: A
+constants:
+  battery_chemistry: LiFePO4
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC200M

package/registers/ac200p.yaml

@@ -0,0 +1,89 @@
+# Bluetti register map example — based on AC200P / AC200MAX community reverse-engineering.
+# Replace with your device's actual map if you have better data.
+#
+# field_name is a standard Bluetti register name — the code maps these to
+# SignalK paths on its own (see lib/path-mapper.js). `path` on a field is an
+# override, only needed if you're exposing a register the code doesn't
+# recognise. `constants` are fixed, non-register facts about this model —
+# a bare scalar (string/number) or { value, unit } for one that needs unit
+# conversion (e.g. total_capacity in Wh -> J). No verified nominal capacity
+# is bundled for most models — add a total_capacity constant yourself if you
+# know it, to enable the derived remaining-capacity calculation.
+#
+
+fields:
+  battery_percent:
+    register: 100
+    unit: "%"
+  battery_voltage:
+    register: 101
+    scale: 0.1
+    unit: V
+  battery_current:
+    register: 102
+    type: int16
+    scale: 0.1
+    unit: A
+  battery_power:
+    register: 103
+    type: int16
+    unit: W
+  battery_temperature:
+    register: 104
+    scale: 0.1
+    unit: °C
+  dc_input_power:
+    register: 107
+    unit: W
+  dc_input_voltage:
+    register: 108
+    scale: 0.1
+    unit: V
+  dc_input_current:
+    register: 109
+    scale: 0.1
+    unit: A
+  ac_output_power:
+    register: 110
+    unit: W
+  ac_output_voltage:
+    register: 111
+    scale: 0.1
+    unit: V
+  ac_output_current:
+    register: 112
+    scale: 0.1
+    unit: A
+  ac_output_frequency:
+    register: 113
+    scale: 0.1
+    unit: Hz
+  ac_input_power:
+    register: 114
+    unit: W
+  ac_input_voltage:
+    register: 115
+    scale: 0.1
+    unit: V
+  ac_input_current:
+    register: 116
+    scale: 0.1
+    unit: A
+  ac_input_frequency:
+    register: 117
+    scale: 0.1
+    unit: Hz
+  internal_temperature:
+    register: 118
+    scale: 0.1
+    unit: °C
+  time_remaining_minutes:
+    register: 119
+    unit: min
+constants:
+  battery_chemistry: LiFePO4
+  total_capacity:
+    value: 2000
+    unit: Wh
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC200P

package/registers/ac200pl.yaml

@@ -0,0 +1,48 @@
+# Bluetti AC200PL register map
+# Source: https://github.com/Patrick762/bluetti-bt-lib (bluetti_bt_lib/devices/ac200pl.py)
+#
+# field_name is a standard Bluetti register name — the code maps these to
+# SignalK paths on its own (see lib/path-mapper.js). `path` on a field is an
+# override, only needed if you're exposing a register the code doesn't
+# recognise. `constants` are fixed, non-register facts about this model —
+# a bare scalar (string/number) or { value, unit } for one that needs unit
+# conversion (e.g. total_capacity in Wh -> J). No verified nominal capacity
+# is bundled for most models — add a total_capacity constant yourself if you
+# know it, to enable the derived remaining-capacity calculation.
+#
+
+fields:
+  battery_soc:
+    register: 43
+    unit: "%"
+  dc_input_power:
+    register: 36
+    unit: W
+  ac_input_power:
+    register: 37
+    unit: W
+  ac_output_power:
+    register: 38
+    unit: W
+  dc_output_power:
+    register: 39
+    unit: W
+  ac_output_voltage:
+    register: 71
+    unit: V
+  ac_output_frequency:
+    register: 74
+    scale: 0.1
+    unit: Hz
+  dc_input_voltage:
+    register: 86
+    scale: 0.1
+    unit: V
+  dc_input_current:
+    register: 88
+    scale: 0.01
+    unit: A
+constants:
+  battery_chemistry: LiFePO4
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC200PL