sok-ble 0.1.0__tar.gz → 0.1.1__tar.gz

{sok_ble-0.1.0 → sok_ble-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sok-ble
-Version: 0.1.0
+Version: 0.1.1
 Summary: SOK BLE battery interface library
 Author-email: Mitchell Carlson <mitchell.carlson.pro@gmail.com>
 License: Apache-2.0

{sok_ble-0.1.0 → sok_ble-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sok-ble"
-version = "0.1.0"
+version = "0.1.1"
 description = "SOK BLE battery interface library"
 readme = "README.md"
 requires-python = ">=3.11"

{sok_ble-0.1.0 → sok_ble-0.1.1}/sok_ble/sok_bluetooth_device.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 from contextlib import asynccontextmanager
 from typing import AsyncIterator, Optional
+import asyncio
+import struct
 import logging
 import statistics
 
@@ -65,32 +67,55 @@ class SokBluetoothDevice:
             await client.disconnect()
             logger.debug("Disconnected from %s", self._ble_device.address)
 
+    async def _send_command(
+        self, client: BleakClientWithServiceCache, cmd: int, expected: int
+    ) -> bytes:
+        """Send a command and return the response bytes with the given header."""
+
+        # If the client supports notifications (real BLE client), prefer that
+        start_notify = getattr(client, "start_notify", None)
+        if start_notify is None:
+            await client.write_gatt_char(UUID_TX, _sok_command(cmd))
+            data = bytes(await client.read_gatt_char(UUID_RX))
+            return data
+
+        queue: asyncio.Queue[bytes] = asyncio.Queue()
+
+        def handler(_: int, data: bytearray) -> None:
+            queue.put_nowait(bytes(data))
+
+        await client.start_notify(UUID_RX, handler)
+        try:
+            await client.write_gatt_char(UUID_TX, _sok_command(cmd))
+            while True:
+                data = await asyncio.wait_for(queue.get(), 5.0)
+                if struct.unpack_from(">H", data)[0] == expected:
+                    return data
+        finally:
+            await client.stop_notify(UUID_RX)
+
     async def async_update(self) -> None:
         """Poll the device for all telemetry and update attributes."""
         responses: dict[int, bytes] = {}
         async with self._connect() as client:
             logger.debug("Send C1")
-            await client.write_gatt_char(UUID_TX, _sok_command(0xC1))
-            data = bytes(await client.read_gatt_char(UUID_RX))
-            logger.debug("Recv 0xCCF0: %s", data.hex())
+            data = await self._send_command(client, 0xC1, 0xCCF0)
+            logger.debug("Recv 0x%04X: %s", struct.unpack_from(">H", data)[0], data.hex())
             responses[0xCCF0] = data
 
             logger.debug("Send C1")
-            await client.write_gatt_char(UUID_TX, _sok_command(0xC1))
-            data = bytes(await client.read_gatt_char(UUID_RX))
-            logger.debug("Recv 0xCCF2: %s", data.hex())
+            data = await self._send_command(client, 0xC1, 0xCCF2)
+            logger.debug("Recv 0x%04X: %s", struct.unpack_from(">H", data)[0], data.hex())
             responses[0xCCF2] = data
 
             logger.debug("Send C2")
-            await client.write_gatt_char(UUID_TX, _sok_command(0xC2))
-            data = bytes(await client.read_gatt_char(UUID_RX))
-            logger.debug("Recv 0xCCF3: %s", data.hex())
+            data = await self._send_command(client, 0xC2, 0xCCF3)
+            logger.debug("Recv 0x%04X: %s", struct.unpack_from(">H", data)[0], data.hex())
             responses[0xCCF3] = data
 
             logger.debug("Send C2")
-            await client.write_gatt_char(UUID_TX, _sok_command(0xC2))
-            data = bytes(await client.read_gatt_char(UUID_RX))
-            logger.debug("Recv 0xCCF4: %s", data.hex())
+            data = await self._send_command(client, 0xC2, 0xCCF4)
+            logger.debug("Recv 0x%04X: %s", struct.unpack_from(">H", data)[0], data.hex())
             responses[0xCCF4] = data
 
         parsed = SokParser.parse_all(responses)

{sok_ble-0.1.0 → sok_ble-0.1.1}/sok_ble/sok_parser.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 import struct
+import statistics
 from typing import Dict, Sequence
 
 from sok_ble.exceptions import InvalidResponseError
@@ -43,27 +44,19 @@ class SokParser:
 
     @staticmethod
     def parse_info(buf: bytes) -> Dict[str, float | int]:
-        """Parse the information frame for voltage, current and SOC."""
+        """Parse the information frame for current, SOC and cycles."""
         logger.debug("parse_info input: %s", buf.hex())
-        if len(buf) < 18:
+        if len(buf) < 20:
             raise InvalidResponseError("Info buffer too short")
 
-        cells = [
-            get_le_ushort(buf, 0),
-            get_le_ushort(buf, 2),
-            get_le_ushort(buf, 4),
-            get_le_ushort(buf, 6),
-        ]
-        voltage = (sum(cells) / len(cells) * 4) / 1000
-
-        current = get_le_int3(buf, 8) / 10
-
-        soc = struct.unpack_from('<H', buf, 16)[0]
+        current = get_le_int3(buf, 5) / 1000
+        num_cycles = get_le_ushort(buf, 14)
+        soc = get_le_ushort(buf, 16)
 
         result = {
-            "voltage": voltage,
             "current": current,
             "soc": soc,
+            "num_cycles": num_cycles,
         }
         logger.debug("parse_info result: %s", result)
         return result
@@ -72,27 +65,23 @@ class SokParser:
     def parse_temps(buf: bytes) -> float:
         """Parse the temperature from the temperature frame."""
         logger.debug("parse_temps input: %s", buf.hex())
-        if len(buf) < 7:
+        if len(buf) < 20:
             raise InvalidResponseError("Temp buffer too short")
 
-        temperature = get_le_short(buf, 5) / 10
+        temperature = get_le_short(buf, 5)
         logger.debug("parse_temps result: %s", temperature)
         return temperature
 
     @staticmethod
     def parse_capacity_cycles(buf: bytes) -> Dict[str, float | int]:
-        """Parse rated capacity and cycle count."""
+        """Parse rated capacity."""
         logger.debug("parse_capacity_cycles input: %s", buf.hex())
-        if len(buf) < 6:
+        if len(buf) < 20:
             raise InvalidResponseError("Capacity buffer too short")
 
-        capacity = get_le_ushort(buf, 0) / 100
-        num_cycles = get_le_ushort(buf, 4)
+        capacity = get_be_uint3(buf, 5) / 128
 
-        result = {
-            "capacity": capacity,
-            "num_cycles": num_cycles,
-        }
+        result = {"capacity": capacity}
         logger.debug("parse_capacity_cycles result: %s", result)
         return result
 
@@ -100,15 +89,13 @@ class SokParser:
     def parse_cells(buf: bytes) -> list[float]:
         """Parse individual cell voltages."""
         logger.debug("parse_cells input: %s", buf.hex())
-        if len(buf) < 8:
+        if len(buf) < 20:
             raise InvalidResponseError("Cells buffer too short")
 
-        cells = [
-            get_le_ushort(buf, 0) / 1000,
-            get_le_ushort(buf, 2) / 1000,
-            get_le_ushort(buf, 4) / 1000,
-            get_le_ushort(buf, 6) / 1000,
-        ]
+        cells = [0.0, 0.0, 0.0, 0.0]
+        for x in range(4):
+            cell_idx = buf[2 + x * 4]
+            cells[cell_idx - 1] = get_le_ushort(buf, 3 + x * 4) / 1000
         logger.debug("parse_cells result: %s", cells)
         return cells
 
@@ -125,10 +112,15 @@ class SokParser:
         capacity_info = cls.parse_capacity_cycles(responses[0xCCF3])
         cells = cls.parse_cells(responses[0xCCF4])
 
+        voltage = statistics.mean(cells) * 4
+
         result = {
-            **info,
+            "voltage": voltage,
+            "current": info["current"],
+            "soc": info["soc"],
             "temperature": temperature,
-            **capacity_info,
+            "capacity": capacity_info["capacity"],
+            "num_cycles": info["num_cycles"],
             "cell_voltages": cells,
         }
         logger.debug("parse_all result: %s", result)

{sok_ble-0.1.0 → sok_ble-0.1.1}/sok_ble.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sok-ble
-Version: 0.1.0
+Version: 0.1.1
 Summary: SOK BLE battery interface library
 Author-email: Mitchell Carlson <mitchell.carlson.pro@gmail.com>
 License: Apache-2.0

{sok_ble-0.1.0 → sok_ble-0.1.1}/sok_ble.egg-info/SOURCES.txt

@@ -15,5 +15,6 @@ tests/test_derived.py
 tests/test_device_full.py
 tests/test_device_minimal.py
 tests/test_exceptions.py
+tests/test_integration_mock.py
 tests/test_parser_full.py
 tests/test_parser_info.py

{sok_ble-0.1.0 → sok_ble-0.1.1}/tests/test_device_full.py

@@ -24,12 +24,10 @@ class DummyClient:
 @pytest.mark.asyncio
 async def test_full_update(monkeypatch):
     responses = [
-        bytes.fromhex(
-            "E4 0C E9 0C EE 0C F3 0C 64 00 00 00 00 00 00 00 41 00"
-        ),
-        bytes.fromhex("00 00 00 00 00 FA 00"),
-        bytes.fromhex("10 27 00 00 32 00 00 00"),
-        bytes.fromhex("E4 0C E9 0C EE 0C F3 0C"),
+        bytes.fromhex("ccf0000000102700000000000000320041000000"),
+        bytes.fromhex("ccf2000000140000000000000000000000000000"),
+        bytes.fromhex("ccf3000000003200000000000000000000000000"),
+        bytes.fromhex("ccf401c50c0002c60c0003bf0c0004c00c000000"),
     ]
 
     dummy = DummyClient(responses)
@@ -42,18 +40,18 @@ async def test_full_update(monkeypatch):
 
     await dev.async_update()
 
-    assert dev.voltage == 13.23
+    assert dev.voltage == pytest.approx(13.066)
     assert dev.current == 10.0
     assert dev.soc == 65
-    assert dev.temperature == 25.0
+    assert dev.temperature == 20.0
     assert dev.capacity == 100.0
     assert dev.num_cycles == 50
-    assert dev.cell_voltages == [3.3, 3.305, 3.31, 3.315]
-    assert dev.power == pytest.approx(132.3)
-    assert dev.cell_voltage_max == 3.315
-    assert dev.cell_voltage_min == 3.3
-    assert dev.cell_voltage_avg == pytest.approx(3.3075)
-    assert dev.cell_voltage_median == pytest.approx(3.3075)
-    assert dev.cell_voltage_delta == pytest.approx(0.015)
-    assert dev.cell_index_max == 3
-    assert dev.cell_index_min == 0
+    assert dev.cell_voltages == [3.269, 3.27, 3.263, 3.264]
+    assert dev.power == pytest.approx(130.66)
+    assert dev.cell_voltage_max == 3.27
+    assert dev.cell_voltage_min == 3.263
+    assert dev.cell_voltage_avg == pytest.approx(3.2665)
+    assert dev.cell_voltage_median == pytest.approx(3.2665)
+    assert dev.cell_voltage_delta == pytest.approx(0.007)
+    assert dev.cell_index_max == 1
+    assert dev.cell_index_min == 2

{sok_ble-0.1.0 → sok_ble-0.1.1}/tests/test_device_minimal.py

@@ -7,7 +7,12 @@ from sok_ble import sok_bluetooth_device as device_mod
 
 class DummyClient:
     def __init__(self, *args, **kwargs):
-        pass
+        self._responses = [
+            bytes.fromhex("ccf0000000102700000000000000320041000000"),
+            bytes.fromhex("ccf2000000140000000000000000000000000000"),
+            bytes.fromhex("ccf3000000003200000000000000000000000000"),
+            bytes.fromhex("ccf401c50c0002c60c0003bf0c0004c00c000000"),
+        ]
 
     async def connect(self):
         return True
@@ -19,10 +24,7 @@ class DummyClient:
         return True
 
     async def read_gatt_char(self, *args, **kwargs):
-        # Response bytes correspond to voltage=13.23V, current=10A, soc=65
-        return bytes.fromhex(
-            "E4 0C E9 0C EE 0C F3 0C 64 00 00 00 00 00 00 00 41 00"
-        )
+        return self._responses.pop(0)
 
 
 @pytest.mark.asyncio
@@ -36,6 +38,6 @@ async def test_minimal_update(monkeypatch):
 
     await dev.async_update()
 
-    assert dev.voltage == 13.23
+    assert dev.voltage == pytest.approx(13.066)
     assert dev.current == 10.0
     assert dev.soc == 65

sok_ble-0.1.1/tests/test_integration_mock.py

@@ -0,0 +1,68 @@
+import pytest
+from bleak.backends.device import BLEDevice
+from contextlib import asynccontextmanager
+
+from sok_ble import sok_bluetooth_device as device_mod
+
+
+class DummyClient:
+    def __init__(self, responses):
+        self._responses = list(responses)
+        self.writes = []
+
+    async def connect(self):
+        return True
+
+    async def disconnect(self):
+        return True
+
+    async def write_gatt_char(self, uuid, data):
+        self.writes.append((uuid, bytes(data)))
+        return True
+
+    async def read_gatt_char(self, uuid):
+        return self._responses.pop(0)
+
+
+@pytest.mark.asyncio
+async def test_async_update_full_flow(monkeypatch):
+    responses = [
+        bytes.fromhex("ccf0000000102700000000000000320041000000"),
+        bytes.fromhex("ccf2000000140000000000000000000000000000"),
+        bytes.fromhex("ccf3000000003200000000000000000000000000"),
+        bytes.fromhex("ccf401c50c0002c60c0003bf0c0004c00c000000"),
+    ]
+
+    @asynccontextmanager
+    async def fake_connect(self):
+        dummy = DummyClient(responses)
+        await dummy.connect()
+        try:
+            yield dummy
+        finally:
+            await dummy.disconnect()
+
+    monkeypatch.setattr(device_mod.SokBluetoothDevice, "_connect", fake_connect)
+
+    dev = device_mod.SokBluetoothDevice(
+        BLEDevice("00:11:22:33:44:55", "Test", None, -60)
+    )
+
+    await dev.async_update()
+
+    assert dev.voltage == pytest.approx(13.066)
+    assert dev.current == 10.0
+    assert dev.soc == 65
+    assert dev.temperature == 20.0
+    assert dev.capacity == 100.0
+    assert dev.num_cycles == 50
+    assert dev.cell_voltages == [3.269, 3.27, 3.263, 3.264]
+    assert dev.power == pytest.approx(130.66)
+    assert dev.cell_voltage_max == 3.27
+    assert dev.cell_voltage_min == 3.263
+    assert dev.cell_voltage_avg == pytest.approx(3.2665)
+    assert dev.cell_voltage_median == pytest.approx(3.2665)
+    assert dev.cell_voltage_delta == pytest.approx(0.007)
+    assert dev.cell_index_max == 1
+    assert dev.cell_index_min == 2
+    assert dev.num_samples == 1

{sok_ble-0.1.0 → sok_ble-0.1.1}/tests/test_parser_full.py

@@ -1,18 +1,19 @@
+import pytest
 from sok_ble.sok_parser import SokParser
 
 
 def test_parse_all():
     info_buf = bytes.fromhex(
-        "E4 0C E9 0C EE 0C F3 0C 64 00 00 00 00 00 00 00 41 00"
+        "ccf0000000102700000000000000320041000000"
     )
     temp_buf = bytes.fromhex(
-        "00 00 00 00 00 FA 00"
+        "ccf2000000140000000000000000000000000000"
     )
     cap_buf = bytes.fromhex(
-        "10 27 00 00 32 00 00 00"
+        "ccf3000000003200000000000000000000000000"
     )
     cell_buf = bytes.fromhex(
-        "E4 0C E9 0C EE 0C F3 0C"
+        "ccf401c50c0002c60c0003bf0c0004c00c000000"
     )
 
     responses = {
@@ -24,12 +25,12 @@ def test_parse_all():
 
     result = SokParser.parse_all(responses)
     assert result == {
-        "voltage": 13.23,
+        "voltage": pytest.approx(13.066, rel=1e-3),
         "current": 10.0,
         "soc": 65,
-        "temperature": 25.0,
+        "temperature": 20.0,
         "capacity": 100.0,
         "num_cycles": 50,
-        "cell_voltages": [3.3, 3.305, 3.31, 3.315],
+        "cell_voltages": [3.269, 3.27, 3.263, 3.264],
     }
 

{sok_ble-0.1.0 → sok_ble-0.1.1}/tests/test_parser_info.py

@@ -3,13 +3,13 @@ from sok_ble.sok_parser import SokParser
 
 def test_parse_info_basic():
     hex_data = bytes.fromhex(
-        "E4 0C E9 0C EE 0C F3 0C 64 00 00 00 00 00 00 00 41 00"
+        "ccf0000000102700000000000000320041000000"
     )
     result = SokParser.parse_info(hex_data)
     assert result == {
-        "voltage": 13.23,
         "current": 10.0,
         "soc": 65,
+        "num_cycles": 50,
     }