@rhizomatics/signalk-bluetti-plugin 1.4.1 → 1.5.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this plugin are documented here. Format loosely follows [Keep a Changelog](https://keepachangelog.com/).
 
+## [1.5.1]
+
+- Simplify the custom device configuration override
+- 'Register Map' is now 'Device Configuration'
+- Bundled register maps moved from `registers/` to `devices/`
+
+## [1.5.0]
+
+- Expanded Bluetti model support, over 20 now with register mappings
+- Configuration moved from CSV to YAML
+- Configurable directory to add YAML files for unsupported Bluetti models
+- CLI `models` command lists supported register maps with field/constant counts
+
 ## [1.4.1]
 
 - Basic test suite

package/README.md

@@ -6,7 +6,7 @@
 ![code style: oxfmt](https://img.shields.io/badge/code_style-oxfmt-blue.svg)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://github.com/rhizomatics/signalk-bluetti-plugin/blob/main/LICENSE)
 
-A SignalK plugin to display data from Bluetti power stations over a Bluetooth Low Energy (BLE) connection. BETA status
+A SignalK plugin to display data from Bluetti power stations over a Bluetooth Low Energy (BLE) connection. Supports 20+ stations, extensible by configuration. Also offers a CLI for easier exploring and debugging.
 
 ![Example Data](docs/assets/screenshots/bluetti_data.png)
 
@@ -73,19 +73,44 @@ node cli.js dump aa:bb:cc:dd:ee:ff --timeout 30   # discovery timeout if device
 Connect to a device and decode its live register values the same way the plugin itself does — same GATT UUIDs, same encryption handshake (including the AES/ECDH handshake used by "V2"-protocol models like the EL100V2), same register parsing. Requires `--registers`. If `mac` is omitted, scans and connects to the first Bluetti-matching device found.
 
 ```bash
-# Decode live registers using a bundled register map (see registers/*.csv for available models)
+# Decode live registers using a bundled device configuration (see devices/*.yaml for available models)
 node cli.js info aa:bb:cc:dd:ee:ff --registers ac200p
 node cli.js info --registers ac200p                # scan and use the first Bluetti device found
 
-# Or a custom CSV, plus an encryption key file for legacy models that XOR-scramble frames
+# Or a custom YAML, plus an encryption key file for legacy models that XOR-scramble frames
 # (not needed for V2-protocol models — those are auto-detected and handshake automatically)
-node cli.js info aa:bb:cc:dd:ee:ff --registers ./my-device-registers.csv --encryption-key ~/19e1646709e0421b755fa9dda74.csv
+node cli.js info aa:bb:cc:dd:ee:ff --registers ./my-device-registers.yaml --encryption-key ~/19e1646709e0421b755fa9dda74.csv
 
 node cli.js info aa:bb:cc:dd:ee:ff --registers ac200p --timeout 30   # discovery timeout if device isn't already known to BlueZ (default: 20)
 ```
 
+### `models`
+
+List every device configuration the CLI (and the plugin) can find — bundled ones plus anything dropped into the custom directory (`~/.signalk/bluetti` by default) — with a field and constant count per model. No device connection needed.
+
+```bash
+node cli.js models
+```
+
 ## FAQ
 
+### Capacity figures show in Joules, how do I make it useful?
+
+SignalK stores all data in SI units rather than any customary units used anywhere, for example temperatures are all held in Kelvin and unit preferences allow them to be converted in the display to C or F.
+
+Unfortunately the default sets of preset unit preferences don't include the `energy` category used for capacity and more unfortunately as of SignalK v2.30.0 there's no easy way to override individual paths.
+
+The fiddly way to do it should be as below (however there's a current [misconfiguration](https://github.com/SignalK/signalk-server/issues/2878) in the SignalK code which gets in the way):
+
+1. Download your preferred set of unit preferences from the [SignalK repo](https://github.com/SignalK/signalk-server/tree/ac368c548fba923db0acf8a314cbdc6552b2b8cf/unitpreferences/presets)
+2. Edit the downloaded file
+
+- Change the `targetUnit` of `energy` category to `Wh`
+- Change the `name` at the top of the file to reflect the change, for example `"Nautical (Metric, Wh capacity)"`
+
+3. Go to the _Unit Preferences_ section of the _Data_ menu in SignalK
+4. Use the _Upload_ button to upload your amended preferences preset and select it in the preset dropdown
+
 ### SignalK starts before the Bluetooth daemon — does the plugin need `bluetoothd` running at boot?
 
 The plugin retries BLE adapter initialisation with backoff (starting at 2s, capping at 30s) if `bluetoothd`/D-Bus isn't up yet when the plugin starts, so a slow-starting Bluetooth stack on boot will no longer strand it — it keeps retrying until the adapter appears rather than failing once and giving up. You'll see `BLE adapter not ready … — retrying in Ns …` in the SignalK logs in the meantime.
@@ -112,3 +137,14 @@ sudo systemctl restart signalk
 ```
 
 This tells systemd to start `bluetoothd` first and wait for it before starting SignalK, rather than relying on both racing to start in parallel at boot.
+
+### My station isn't supported
+
+Additional products can be added using a YAML file mapping modbus registers and providing static values — see [`docs/examples/model_definition.yaml`](docs/examples/model_definition.yaml) in the repo for an annotated template, and `devices/*.yaml` for real examples.
+
+Drop your file into the plugin's **Custom Device Configuration Directory** (a plugin setting, defaulting to `~/.signalk/bluetti`) and it'll appear in the **Device Configuration** dropdown for a device, named after the file (without `.yaml`). A file there takes priority over a bundled one of the same name, so it also doubles as a way to override a built-in map.
+
+Check one of these projects to see if some of the mapping work has been done:
+
+- https://github.com/Patrick762/bluetti-bt-lib
+- https://github.com/warhammerkid/bluetti_mqtt

package/cli.js

@@ -2,22 +2,58 @@
 "use strict";
 
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 
-const REGISTERS_DIR = path.join(__dirname, "registers");
+const DEVICES_DIR = path.join(__dirname, "devices");
+// Same default the plugin itself uses when running under a real SignalK
+// server (see index.js) — lets a user's custom register maps be found by the
+// CLI too, without needing to pass --registers-dir.
+const DEFAULT_USER_DEVICES_DIR = path.join(os.homedir(), ".signalk", "bluetti");
 
-function listBuiltinModels() {
+function listModels(dir) {
   try {
     return fs
-      .readdirSync(REGISTERS_DIR)
-      .filter((f) => f.endsWith(".csv"))
-      .map((f) => f.replace(/\.csv$/, ""))
+      .readdirSync(dir)
+      .filter((f) => /\.ya?ml$/.test(f))
+      .map((f) => f.replace(/\.ya?ml$/, ""))
       .sort();
   } catch {
     return [];
   }
 }
 
+function listBuiltinModels() {
+  return [...new Set([...listModels(DEVICES_DIR), ...listModels(DEFAULT_USER_DEVICES_DIR)])].sort((a, b) => a.localeCompare(b));
+}
+
+// One row per model, checking the custom directory before the bundled one so
+// a user's own file overriding a built-in shows up as "custom" — same
+// resolution order as resolveRegistersArg()/the plugin itself.
+function listModelDetails() {
+  const { loadRegisters } = require("./lib/register-loader");
+
+  return listBuiltinModels().map((model) => {
+    for (const [dir, source] of [
+      [DEFAULT_USER_DEVICES_DIR, "custom"],
+      [DEVICES_DIR, "built-in"],
+    ]) {
+      for (const ext of [".yaml", ".yml"]) {
+        const p = path.join(dir, `${model}${ext}`);
+        if (!fs.existsSync(p)) continue;
+        try {
+          const fields = loadRegisters(p);
+          const constants = fields.filter((f) => f.dataType === "const").length;
+          return { model, fields: fields.length - constants, constants, source, path: p };
+        } catch (err) {
+          return { model, fields: "?", constants: "?", source, path: `${p} (failed to load: ${err.message})` };
+        }
+      }
+    }
+    return { model, fields: "?", constants: "?", source: "?", path: "" };
+  });
+}
+
 function usage() {
   const builtins = listBuiltinModels();
   console.log(`
@@ -41,11 +77,16 @@ Commands:
                                 the plugin does
                                 If mac is omitted, scans and uses the first
                                 Bluetti device found.
-    --registers <model|path>     Built-in model (${builtins.join(", ") || "none bundled"}) or a CSV path (required)
+    --registers <model|path>     Built-in model (${builtins.join(", ") || "none bundled"}) or a register map
+                                  YAML path (required). Also checks
+                                  ${DEFAULT_USER_DEVICES_DIR} for custom models.
     --encryption-key <path>      Path to the Bluetti-provided encryption CSV
                                   (only needed for legacy XOR-scrambled models)
     --timeout <seconds>          Discovery/scan timeout if not already known (default: 20)
 
+  models                       List supported device configurations, with a field and
+                                constant count per model
+
   help                         Show this help
 
 Examples:
@@ -55,6 +96,7 @@ Examples:
   bluetti-cli dump
   bluetti-cli info aa:bb:cc:dd:ee:ff --registers ac200p
   bluetti-cli info --registers ac200p
+  bluetti-cli models
 `);
 }
 
@@ -138,11 +180,15 @@ async function findDevice(adapter, mac, timeoutMs) {
 }
 
 function resolveRegistersArg(value) {
-  const builtinPath = path.join(REGISTERS_DIR, `${value}.csv`);
-  if (fs.existsSync(builtinPath)) return builtinPath;
+  for (const dir of [DEFAULT_USER_DEVICES_DIR, DEVICES_DIR]) {
+    for (const ext of [".yaml", ".yml"]) {
+      const p = path.join(dir, `${value}${ext}`);
+      if (fs.existsSync(p)) return p;
+    }
+  }
   if (fs.existsSync(value)) return value;
   const builtins = listBuiltinModels();
-  throw new Error(`Register map not found: "${value}" (not a built-in model [${builtins.join(", ")}] or an existing file path)`);
+  throw new Error(`Device configuration not found: "${value}" (not a built-in model [${builtins.join(", ")}] or an existing file path)`);
 }
 
 async function printDeviceSummary(bleDevice, mac) {
@@ -212,14 +258,14 @@ async function printGattTree(bleDevice) {
 }
 
 async function printRegisterValues(bleDevice, mac, args) {
-  const { loadCsv, decodeValue } = require("./lib/csv-loader");
+  const { loadRegisters, decodeValue } = require("./lib/register-loader");
   const { resolvePath, convertUnits } = require("./lib/path-mapper");
   const { readEncryptionKey } = require("./lib/encryption");
   const { groupRegisters } = require("./lib/protocol");
   const BluettiDevice = require("./lib/device");
 
   const registerPath = resolveRegistersArg(args.registers);
-  const fields = loadCsv(registerPath);
+  const fields = loadRegisters(registerPath);
   console.log(`\nLoaded ${fields.length} register field(s) from ${registerPath}`);
 
   const addrs = [...new Set(fields.flatMap((f) => Array.from({ length: f.count }, (_, i) => f.register + i)))];
@@ -355,6 +401,17 @@ async function cmdInfo(args) {
   );
 }
 
+// ── models ───────────────────────────────────────────────────────────────
+
+function cmdModels() {
+  const rows = listModelDetails();
+  if (rows.length === 0) {
+    console.log(`No device configurations found (checked ${DEVICES_DIR} and ${DEFAULT_USER_DEVICES_DIR}).`);
+    return;
+  }
+  printTable(rows, ["model", "fields", "constants", "source"]);
+}
+
 // ── main ─────────────────────────────────────────────────────────────────
 
 async function main() {
@@ -371,6 +428,9 @@ async function main() {
     case "info":
       await cmdInfo(args);
       break;
+    case "models":
+      cmdModels();
+      break;
     case "help":
     case "--help":
     case "-h":

package/devices/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/devices/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/devices/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/devices/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/devices/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/devices/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/devices/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

package/devices/ac2a.yaml

@@ -0,0 +1,34 @@
+# Bluetti AC2A register map
+# Source: https://github.com/Patrick762/bluetti-bt-lib (bluetti_bt_lib/devices/ac2a.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
+  power_generation:
+    register: 154
+    scale: 0.1
+    unit: kWh
+constants:
+  battery_chemistry: LiFePO4
+  battery_manufacturer_name: Bluetti
+  battery_manufacturer_model: AC2A