aioacaia 0.1.2__py3-none-any.whl

aioacaia/__init__.py

@@ -0,0 +1 @@
+from .acaiascale import AcaiaScale

aioacaia/acaiascale.py

@@ -0,0 +1,406 @@
+"""Client to interact with Acaia scales."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+
+from collections.abc import Awaitable, Callable
+
+from dataclasses import dataclass
+
+from bleak import BleakClient, BleakGATTCharacteristic, BLEDevice
+from bleak.exc import BleakDeviceNotFoundError, BleakError
+
+from .const import (
+    DEFAULT_CHAR_ID,
+    HEARTBEAT_INTERVAL,
+    NOTIFY_CHAR_ID,
+    OLD_STYLE_CHAR_ID,
+)
+from .exceptions import AcaiaDeviceNotFound, AcaiaError
+from .const import UnitMass
+from .decode import Message, Settings, decode
+from .helpers import encode, encode_id, encode_notification_request
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass(kw_only=True)
+class AcaiaDeviceState:
+    """Data class for acaia scale info data."""
+
+    battery_level: int
+    units: UnitMass
+
+
+class AcaiaScale:
+    """Representation of an acaia scale."""
+
+    _default_char_id = DEFAULT_CHAR_ID
+    _notify_char_id = NOTIFY_CHAR_ID
+
+    _msg_types = {
+        "tare": encode(4, [0]),
+        "startTimer": encode(13, [0, 0]),
+        "stopTimer": encode(13, [0, 2]),
+        "resetTimer": encode(13, [0, 1]),
+        "heartbeat": encode(0, [2, 0]),
+        "getSettings": encode(6, [0] * 16),
+        "notificationRequest": encode_notification_request(),
+    }
+
+    def __init__(
+        self,
+        address_or_ble_device: str | BLEDevice,
+        is_new_style_scale: bool = True,
+        notify_callback: Callable[[], None] | None = None,
+    ) -> None:
+        """Initialize the scale."""
+
+        self._is_new_style_scale = is_new_style_scale
+        self._client: BleakClient | None = None
+
+        self.address_or_ble_device = address_or_ble_device
+
+        # tasks
+        self.heartbeat_task: asyncio.Task | None = None
+        self.process_queue_task: asyncio.Task | None = None
+
+        # timer related
+        self.timer_running = False
+        self._timer_start: float | None = None
+        self._timer_stop: float | None = None
+
+        # connection diagnostics
+        self.connected = False
+        self._timestamp_last_command: float | None = None
+        self.last_disconnect_time: float | None = None
+
+        self._device_state: AcaiaDeviceState | None = None
+        self._weight: float | None = None
+
+        # queue
+        self._queue: asyncio.Queue = asyncio.Queue()
+        self._add_to_queue_lock = asyncio.Lock()
+
+        self._msg_types["auth"] = encode_id(is_pyxis_style=is_new_style_scale)
+
+        if not is_new_style_scale:
+            # for old style scales, the default char id is the same as the notify char id
+            self._default_char_id = self._notify_char_id = OLD_STYLE_CHAR_ID
+
+        self._notify_callback: Callable[[], None] | None = notify_callback
+
+    @property
+    def mac(self) -> str:
+        """Return the mac address of the scale in upper case."""
+        return (
+            self.address_or_ble_device.upper()
+            if isinstance(self.address_or_ble_device, str)
+            else self.address_or_ble_device.address.upper()
+        )
+
+    @property
+    def device_state(self) -> AcaiaDeviceState | None:
+        """Return the device info of the scale."""
+        return self._device_state
+
+    @property
+    def weight(self) -> float | None:
+        """Return the weight of the scale."""
+        return self._weight
+
+    @property
+    def timer(self) -> int:
+        """Return the current timer value in seconds."""
+        if self._timer_start is None:
+            return 0
+        if self.timer_running:
+            return int(time.time() - self._timer_start)
+        if self._timer_stop is None:
+            return 0
+
+        return int(self._timer_stop - self._timer_start)
+
+    def device_disconnected_handler(
+        self,
+        client: BleakClient | None = None,  # pylint: disable=unused-argument
+        notify: bool = True,
+    ) -> None:
+        """Callback for device disconnected."""
+
+        _LOGGER.debug(
+            "Scale with address %s disconnected through disconnect handler",
+            self.mac,
+        )
+        self.timer_running = False
+        self.connected = False
+        self.last_disconnect_time = time.time()
+        self.async_empty_queue_and_cancel_tasks()
+        if notify and self._notify_callback:
+            self._notify_callback()
+
+    async def _write_msg(self, char_id: str, payload: bytearray) -> None:
+        """wrapper for writing to the device."""
+        if self._client is None:
+            raise AcaiaError("Client not initialized")
+        try:
+            await self._client.write_gatt_char(char_id, payload)
+            self._timestamp_last_command = time.time()
+        except BleakDeviceNotFoundError as ex:
+            self.connected = False
+            raise AcaiaDeviceNotFound("Device not found") from ex
+        except BleakError as ex:
+            self.connected = False
+            raise AcaiaError("Error writing to device") from ex
+        except TimeoutError as ex:
+            self.connected = False
+            raise AcaiaError("Timeout writing to device") from ex
+        except Exception as ex:
+            self.connected = False
+            raise AcaiaError("Unknown error writing to device") from ex
+
+    def async_empty_queue_and_cancel_tasks(self) -> None:
+        """Empty the queue."""
+
+        while not self._queue.empty():
+            self._queue.get_nowait()
+            self._queue.task_done()
+
+        if self.heartbeat_task and not self.heartbeat_task.done():
+            self.heartbeat_task.cancel()
+
+        if self.process_queue_task and not self.process_queue_task.done():
+            self.process_queue_task.cancel()
+
+    async def process_queue(self) -> None:
+        """Task to process the queue in the background."""
+        while True:
+            try:
+                if not self.connected:
+                    self.async_empty_queue_and_cancel_tasks()
+                    return
+
+                char_id, payload = await self._queue.get()
+                await self._write_msg(char_id, payload)
+                self._queue.task_done()
+                await asyncio.sleep(0.1)
+
+            except asyncio.CancelledError:
+                self.connected = False
+                return
+            except (AcaiaDeviceNotFound, AcaiaError) as ex:
+                self.connected = False
+                _LOGGER.debug("Error writing to device: %s", ex)
+                return
+
+    async def connect(
+        self,
+        callback: (
+            Callable[[BleakGATTCharacteristic, bytearray], Awaitable[None] | None]
+            | None
+        ) = None,
+        setup_tasks: bool = True,
+    ) -> None:
+        """Connect the bluetooth client."""
+
+        if self.connected:
+            return
+
+        if self.last_disconnect_time and self.last_disconnect_time > (time.time() - 15):
+            _LOGGER.debug(
+                "Scale has recently been disconnected, waiting 15 seconds before reconnecting"
+            )
+            return
+
+        self._client = BleakClient(
+            address_or_ble_device=self.address_or_ble_device,
+            disconnected_callback=self.device_disconnected_handler,
+        )
+        self._client.get_services()
+        try:
+            await self._client.connect()
+        except BleakError as ex:
+            msg = "Error during connecting to device"
+            _LOGGER.debug("%s: %s", msg, ex)
+            raise AcaiaError(msg) from ex
+        except TimeoutError as ex:
+            msg = "Timeout during connecting to device"
+            _LOGGER.debug("%s: %s", msg, ex)
+            raise AcaiaError(msg) from ex
+        except Exception as ex:
+            msg = "Unknown error during connecting to device"
+            _LOGGER.debug("%s: %s", msg, ex)
+            raise AcaiaError(msg) from ex
+
+        self.connected = True
+        _LOGGER.debug("Connected to Acaia scale")
+
+        if callback is None:
+            callback = self.on_bluetooth_data_received
+        try:
+            await self._client.start_notify(
+                char_specifier=self._notify_char_id,
+                callback=(
+                    self.on_bluetooth_data_received if callback is None else callback
+                ),
+            )
+            await asyncio.sleep(0.1)
+        except BleakError as ex:
+            msg = "Error subscribing to notifications"
+            _LOGGER.debug("%s: %s", msg, ex)
+            raise AcaiaError(msg) from ex
+
+        try:
+            await self.auth()
+            if callback is not None:
+                await self.send_weight_notification_request()
+        except BleakDeviceNotFoundError as ex:
+            raise AcaiaDeviceNotFound("Device not found") from ex
+        except BleakError as ex:
+            raise AcaiaError("Error during authentication") from ex
+
+        if setup_tasks:
+            self._setup_tasks()
+
+    def _setup_tasks(self) -> None:
+        """Setup background tasks"""
+        if not self.heartbeat_task or self.heartbeat_task.done():
+            self.heartbeat_task = asyncio.create_task(self.send_heartbeats())
+        if not self.process_queue_task or self.process_queue_task.done():
+            self.process_queue_task = asyncio.create_task(self.process_queue())
+
+    async def auth(self) -> None:
+        """Send auth message to scale, if subscribed to notifications returns Settings object"""
+        await self._queue.put((self._default_char_id, self._msg_types["auth"]))
+
+    async def send_weight_notification_request(self) -> None:
+        """Tell the scale to send weight notifications"""
+
+        await self._queue.put(
+            (self._default_char_id, self._msg_types["notificationRequest"])
+        )
+
+    async def send_heartbeats(self) -> None:
+        """Task to send heartbeats in the background."""
+        while True:
+            try:
+                if not self.connected:
+                    return
+
+                async with self._add_to_queue_lock:
+                    _LOGGER.debug("Sending heartbeat")
+                    if self._is_new_style_scale:
+                        await self._queue.put(
+                            (self._default_char_id, self._msg_types["auth"])
+                        )
+
+                    await self._queue.put(
+                        (self._default_char_id, self._msg_types["heartbeat"])
+                    )
+
+                    if self._is_new_style_scale:
+                        await self._queue.put(
+                            (self._default_char_id, self._msg_types["getSettings"])
+                        )
+                await asyncio.sleep(
+                    HEARTBEAT_INTERVAL if not self._is_new_style_scale else 1,
+                )
+            except asyncio.CancelledError:
+                self.connected = False
+                return
+            except asyncio.QueueFull as ex:
+                self.connected = False
+                _LOGGER.debug("Error sending heartbeat: %s", ex)
+                return
+
+    async def disconnect(self) -> None:
+        """Clean disconnect from the scale"""
+
+        _LOGGER.debug("Disconnecting from scale")
+        self.connected = False
+        await self._queue.join()
+        if not self._client:
+            return
+        try:
+            await self._client.disconnect()
+        except BleakError as ex:
+            _LOGGER.debug("Error disconnecting from device: %s", ex)
+        else:
+            _LOGGER.debug("Disconnected from scale")
+
+    async def tare(self) -> None:
+        """Tare the scale."""
+        if not self.connected:
+            await self.connect()
+        async with self._add_to_queue_lock:
+            await self._queue.put((self._default_char_id, self._msg_types["tare"]))
+
+    async def start_stop_timer(self) -> None:
+        """Start/Stop the timer."""
+        if not self.connected:
+            await self.connect()
+
+        if not self.timer_running:
+            _LOGGER.debug('Sending "start" message.')
+
+            async with self._add_to_queue_lock:
+                await self._queue.put(
+                    (self._default_char_id, self._msg_types["startTimer"])
+                )
+            self.timer_running = True
+            if not self._timer_start:
+                self._timer_start = time.time()
+        else:
+            _LOGGER.debug('Sending "stop" message.')
+            async with self._add_to_queue_lock:
+                await self._queue.put(
+                    (self._default_char_id, self._msg_types["stopTimer"])
+                )
+            self.timer_running = False
+            self._timer_stop = time.time()
+
+    async def reset_timer(self) -> None:
+        """Reset the timer."""
+        if not self.connected:
+            await self.connect()
+        async with self._add_to_queue_lock:
+            await self._queue.put(
+                (self._default_char_id, self._msg_types["resetTimer"])
+            )
+        self._timer_start = None
+        self._timer_stop = None
+
+        if self.timer_running:
+            async with self._add_to_queue_lock:
+                await self._queue.put(
+                    (self._default_char_id, self._msg_types["startTimer"])
+                )
+            self._timer_start = time.time()
+
+    async def on_bluetooth_data_received(
+        self,
+        characteristic: BleakGATTCharacteristic,  # pylint: disable=unused-argument
+        data: bytearray,
+    ) -> None:
+        """Receive data from scale."""
+        msg = decode(data)[0]
+
+        if isinstance(msg, Settings):
+            self._device_state = AcaiaDeviceState(
+                battery_level=msg.battery, units=UnitMass(msg.units)
+            )
+            _LOGGER.debug(
+                "Got battery level %s, units %s", str(msg.battery), str(msg.units)
+            )
+
+        elif isinstance(msg, Message):
+            self._weight = msg.value
+            if msg.timer_running is not None:
+                self.timer_running = msg.timer_running
+            _LOGGER.debug("Got weight %s", str(msg.value))
+
+        if self._notify_callback is not None:
+            self._notify_callback()

aioacaia/const.py

@@ -0,0 +1,19 @@
+"""Constants for aioacaia."""
+
+from typing import Final
+from enum import StrEnum
+
+DEFAULT_CHAR_ID: Final = "49535343-8841-43f4-a8d4-ecbe34729bb3"
+NOTIFY_CHAR_ID: Final = "49535343-1e4d-4bd9-ba61-23c647249616"
+OLD_STYLE_CHAR_ID: Final = "00002a80-0000-1000-8000-00805f9b34fb"
+HEADER1: Final = 0xEF
+HEADER2: Final = 0xDD
+HEARTBEAT_INTERVAL: Final = 5
+SCALE_START_NAMES: Final = ["ACAIA", "PYXIS", "LUNAR", "PROCH"]
+
+
+class UnitMass(StrEnum):
+    """Unit of mass."""
+
+    GRAMS = "grams"
+    OUNCES = "ounces"

aioacaia/decode.py

@@ -0,0 +1,189 @@
+"""Message decoding functions, taken from pyacaia."""
+import logging
+
+from bleak import BleakGATTCharacteristic
+
+from .const import HEADER1, HEADER2
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class Message:
+    """Representation of a message from the scale."""
+
+    def __init__(self, msg_type: int, payload: bytearray | list[int]) -> None:
+        self.msg_type = msg_type
+        self.payload = payload
+        self.value: float | None = None
+        self.button: str | None = None
+        self.time: int | None = None
+        self.timer_running: bool | None = None
+
+        if self.msg_type == 5:
+            self.value = self._decode_weight(payload)
+
+        elif self.msg_type == 11:
+            if payload[2] == 5:
+                self.value = self._decode_weight(payload[3:])
+            elif payload[2] == 7:
+                self.time = self._decode_time(payload[3:])
+            _LOGGER.debug(
+                "heartbeat response (weight: %s, time: %s)", self.value, self.time
+            )
+
+        elif self.msg_type == 7:
+            self.time = self._decode_time(payload)
+            _LOGGER.debug("timer: %s", self.time)
+
+        elif self.msg_type == 8:
+            if payload[0] == 0 and payload[1] == 5:
+                self.button = "tare"
+                self.value = self._decode_weight(payload[2:])
+                _LOGGER.debug("tare (weight: %s)", self.value)
+            elif payload[0] == 8 and payload[1] == 5:
+                self.button = "start"
+                self.timer_running = True
+                self.value = self._decode_weight(payload[2:])
+                _LOGGER.debug("start (weight: %s)", self.value)
+            elif payload[0] == 10 and payload[1] == 7:
+                self.button = "stop"
+                self.timer_running = False
+                self.time = self._decode_time(payload[2:])
+                self.value = self._decode_weight(payload[6:])
+                _LOGGER.debug("stop time: %s, weight: %s", self.time, self.value)
+            elif payload[0] == 10 and payload[1] == 5:  # stop for new scale
+                self.button = "stop"
+                self.timer_running = False
+            elif payload[0] == 9 and payload[1] == 7:
+                self.button = "reset"
+                self.time = self._decode_time(payload[2:])
+                self.value = self._decode_weight(payload[6:])
+                _LOGGER.debug("reset time: %s, weight: %s", self.time, self.value)
+            else:
+                self.button = "unknownbutton"
+                _LOGGER.debug("unknownbutton %s", str(payload))
+
+        else:
+            _LOGGER.debug("message: %s, payload %s", msg_type, payload)
+
+    def _decode_weight(self, weight_payload):
+        value = ((weight_payload[1] & 0xFF) << 8) + (weight_payload[0] & 0xFF)
+        unit = weight_payload[4] & 0xFF
+        if unit == 1:
+            value /= 10.0
+        elif unit == 2:
+            value /= 100.0
+        elif unit == 3:
+            value /= 1000.0
+        elif unit == 4:
+            value /= 10000.0
+        else:
+            raise ValueError(f"unit value not in range {unit}")
+
+        if (weight_payload[5] & 0x02) == 0x02:
+            value *= -1
+        return value
+
+    def _decode_time(self, time_payload):
+        value = (time_payload[0] & 0xFF) * 60
+        value = value + (time_payload[1])
+        value = value + (time_payload[2] / 10.0)
+        return value
+
+
+class Settings:
+    """Representation of the settings from the scale."""
+
+    def __init__(self, payload: bytearray) -> None:
+        # payload[0] is unknown
+        self.battery = payload[1] & 0x7F
+        if payload[2] == 2:
+            self.units = "grams"
+        elif payload[2] == 5:
+            self.units = "ounces"
+        else:
+            self.units = "grams"
+        # payload[2 and 3] is unknown
+        self.auto_off = payload[4] * 5
+        # payload[5] is unknown
+        self.beep_on = payload[6] == 1
+        # payload[7-9] unknown
+        _LOGGER.debug(
+            "settings: battery=%s %s, auto_off=%s, beep=%s",
+            self.battery,
+            self.units,
+            self.auto_off,
+            self.beep_on,
+        )
+        _LOGGER.debug(
+            "unknown settings: %s",
+            str(
+                [
+                    payload[0],
+                    payload[1] & 0x80,
+                    payload[3],
+                    payload[5],
+                    payload[7],
+                    payload[8],
+                    payload[9],
+                ]
+            ),
+        )
+
+
+def decode(byte_msg: bytearray):
+    """Return a tuple - first element is the message, or None
+    if one not yet found.  Second is are the remaining
+    bytes, which can be empty
+    Messages are encoded as the encode() function above,
+    min message length is 6 bytes
+    HEADER1 (0xef)
+    HEADER1 (0xdd)
+    command
+    length  (including this byte, excluding checksum)
+    payload of length-1 bytes
+    checksum byte1
+    checksum byte2
+
+    """
+    msg_start = -1
+
+    for i in range(len(byte_msg) - 1):
+        if byte_msg[i] == HEADER1 and byte_msg[i + 1] == HEADER2:
+            msg_start = i
+            break
+    if msg_start < 0 or len(byte_msg) - msg_start < 6:
+        return (None, byte_msg)
+
+    msg_end = msg_start + byte_msg[msg_start + 3] + 5
+
+    if msg_end > len(byte_msg):
+        return (None, byte_msg)
+
+    if msg_start > 0:
+        _LOGGER.debug("Ignoring %s bytes before header", i)
+
+    cmd = byte_msg[msg_start + 2]
+    if cmd == 12:
+        msg_type = byte_msg[msg_start + 4]
+        payload_in = byte_msg[msg_start + 5 : msg_end]
+        return (Message(msg_type, payload_in), byte_msg[msg_end:])
+    if cmd == 8:
+        return (Settings(byte_msg[msg_start + 3 :]), byte_msg[msg_end:])
+
+    _LOGGER.debug(
+        "Non event notification message command %s %s",
+        str(cmd),
+        str(byte_msg[msg_start:msg_end]),
+    )
+    return (None, byte_msg[msg_end:])
+
+
+def notification_handler(sender: BleakGATTCharacteristic, data: bytearray) -> None:
+    """Sample for callback for handling incoming notifications from the scale."""
+    msg = decode(data)[0]
+    if isinstance(msg, Settings):
+        print(f"Battery: {msg.battery}")
+        print(f"Units: {msg.units}")
+    elif isinstance(msg, Message):
+        print(f"Weight: {msg.value}")

aioacaia/exceptions.py

@@ -0,0 +1,19 @@
+"""Exceptions for aioacaia."""
+
+from bleak.exc import BleakDeviceNotFoundError, BleakError
+
+
+class AcaiaScaleException(Exception):
+    """Base class for exceptions in this module."""
+
+
+class AcaiaDeviceNotFound(BleakDeviceNotFoundError):
+    """Exception when no device is found."""
+
+
+class AcaiaError(BleakError):
+    """Exception for general bleak errors."""
+
+
+class AcaiaUnknownDevice(Exception):
+    """Exception for unknown devices."""