adds support for newer Santoker BLE BT/ET

Author: MAKOMO

src/artisanlib/acaia.py

@@ -24,17 +24,12 @@
     from bleak.backends.characteristic import BleakGATTCharacteristic  # pylint: disable=unused-import
 
 
-try:
-    from PyQt6.QtCore import QObject, pyqtSignal # @UnusedImport @Reimport  @UnresolvedImport
-except ImportError:
-    from PyQt5.QtCore import QObject, pyqtSignal # type: ignore # @UnusedImport @Reimport  @UnresolvedImport
-
-
 from artisanlib.ble_port import ClientBLE
 from artisanlib.async_comm import AsyncIterable, IteratorReader
+from artisanlib.scale import Scale
 
 
-_log = logging.getLogger(__name__)
+_log: Final[logging.Logger] = logging.getLogger(__name__)
 
 
 ####
@@ -113,6 +108,19 @@ class ACAIA_TIMER(IntEnum):
 ACAIA_CINCO_NAME:Final[str] = 'CINCO'    # Acaia Cinco
 ACAIA_PYXIS_NAME:Final[str] = 'PYXIS'    # Acaia Pyxis
 
+
+# Acaia scale device name prefixes and product names
+ACAIA_SCALE_NAMES = [
+    (ACAIA_LEGACY_LUNAR_NAME, 'Lunar'), # original Lunar
+    (ACAIA_LUNAR_NAME, 'Lunar'), # Lunar 2021 and later
+    (ACAIA_LEGACY_PEARL_NAME, 'Pearl'), # original Pearl
+    (ACAIA_PEARLS_NAME, 'Pearl S'),
+    (ACAIA_PEARL_NAME, 'Pearl'), # Pearl 2021
+    (ACAIA_CINCO_NAME, 'Cinco'),
+    (ACAIA_PYXIS_NAME, 'Pyxis')]
+
+
+
 class AcaiaBLE(ClientBLE):
 
 
@@ -510,17 +518,25 @@ def battery_changed(self, new_value:int) -> None: # pylint: disable=no-self-use
 
 
 # QObject needs to go first in this mixing and AcaiaBLE and its super class are not allowed to hold __slots__
-class Acaia(QObject, AcaiaBLE): # pyright: ignore [reportGeneralTypeIssues] # Argument to class must be a base class
-
-    weight_changed_signal = pyqtSignal(int)   # delivers new weight in g
-    battery_changed_signal = pyqtSignal(int)  # delivers new batter level in %
-    disconnected_signal = pyqtSignal()        # issued on disconnect
+class Acaia(Scale, AcaiaBLE): # pyright: ignore [reportGeneralTypeIssues] # Argument to class must be a base class
 
     def __init__(self, connected_handler:Optional[Callable[[], None]] = None,
                        disconnected_handler:Optional[Callable[[], None]] = None):
-        QObject.__init__(self)
+        Scale.__init__(self)
         AcaiaBLE.__init__(self, connected_handler = connected_handler, disconnected_handler=disconnected_handler)
+        self.address:Optional[str] = None # if set, connects are restricted to the device with this BLE address
+
+    def set_address(self, address:Optional[str]) -> None:
+        self.address = address
+
+    def get_address(self) -> Optional[str]:
+        return self.address
+
+    def connect(self) -> None:
+        self.start(address=self.address)
 
+    def disconnect(self) -> None:
+        self.stop()
 
     def weight_changed(self, new_value:int) -> None:
         self.weight_changed_signal.emit(new_value)

src/artisanlib/ble_port.py

@@ -79,7 +79,8 @@ async def _scan(self,
             device_descriptions:Dict[Optional[str],Optional[Set[str]]],
             blacklist:Set[str],
             case_sensitive:bool,
-            scan_timeout:float) -> 'Tuple[Optional[BLEDevice], Optional[str]]':
+            scan_timeout:float,
+            address:Optional[str]) -> 'Tuple[Optional[BLEDevice], Optional[str]]':
         try:
             async with asyncio.timeout(scan_timeout): # type:ignore[attr-defined]
                 async with BleakScanner() as scanner:
@@ -88,7 +89,7 @@ async def _scan(self,
                         if self._terminate_scan_event.is_set():
                             return None, None
 #                        _log.debug("device %s, (%s): %s", bd.name, ad.local_name, ad.service_uuids)
-                        if bd.address not in blacklist:
+                        if bd.address not in blacklist and (address is None or bd.address == address):
                             res:bool
                             res_service_uuid:Optional[str]
                             res, res_service_uuid = self.description_match(bd,ad,device_descriptions,case_sensitive)
@@ -106,14 +107,16 @@ async def _scan_and_connect(self,
                 blacklist:Set[str], # client addresses to ignore
                 case_sensitive:bool,
                 disconnected_callback:Optional[Callable[[BleakClient], None]],
-                scan_timeout:float, connect_timeout:float) -> Tuple[Optional[BleakClient], Optional[str]]:
+                scan_timeout:float, connect_timeout:float,
+                address:Optional[str] = None # if given, connect only to the device with this ble address
+                ) -> Tuple[Optional[BleakClient], Optional[str]]:
         async with self._scan_and_connect_lock:
             # the lock ensures that only one scan/connect operation is running at any time
             # as trying to establish a connection to two devices at the same time
             # can cause errors
             discovered_bd:Optional[BLEDevice] = None
             service_uuid:Optional[str] = None
-            discovered_bd, service_uuid = await self._scan(device_descriptions, blacklist, case_sensitive, scan_timeout)
+            discovered_bd, service_uuid = await self._scan(device_descriptions, blacklist, case_sensitive, scan_timeout, address)
             if discovered_bd is None:
                 return None, None
             client = BleakClient(
@@ -159,7 +162,9 @@ def scan_and_connect(self,
             case_sensitive:bool=True,
             disconnected_callback:Optional[Callable[[BleakClient], None]] = None,
             scan_timeout:float=10,
-            connect_timeout:float=3) -> Tuple[Optional[BleakClient], Optional[str]]:
+            connect_timeout:float=3,
+            address:Optional[str] = None # if given, connect only to the device with this ble address
+            ) -> Tuple[Optional[BleakClient], Optional[str]]:
         if hasattr(self, '_asyncLoopThread') and self._asyncLoopThread is None:
             self._asyncLoopThread = AsyncLoopThread()
         assert self._asyncLoopThread is not None
@@ -170,7 +175,8 @@ def scan_and_connect(self,
                     case_sensitive,
                     disconnected_callback,
                     scan_timeout,
-                    connect_timeout),
+                    connect_timeout,
+                    address),
                 self._asyncLoopThread.loop)
         try:
             return fut.result()
@@ -250,8 +256,9 @@ def start_notifications(self) -> None:
                 try:
                     ble.start_notify(self._ble_client, notify_uuid, callback)
                     self._active_notification_uuids.add(notify_uuid)
+                    _log.debug('notification on characteristic %s started', notify_uuid)
                 except BleakCharacteristicNotFoundError:
-                    _log.debug('start_notifications: characteristic {notify_uuid} not found')
+                    _log.debug('start_notifications: characteristic %s not found', notify_uuid)
 
     # Notifications are stopped automatically on disconnect, so this method does not need to be called
     # unless notifications need to be stopped before the device disconnects
@@ -262,7 +269,7 @@ def stop_notifications(self) -> None:
                     ble.stop_notify(self._ble_client, notify_uuid)
                     _log.debug('notifications on %s stopped', notify_uuid)
                 except BleakCharacteristicNotFoundError:
-                    _log.debug('start_notifications: characteristic {notify_uuid} not found')
+                    _log.debug('start_notifications: characteristic %s not found', notify_uuid)
         self._active_notification_uuids = set()
 
     def _disconnect(self) -> None:
@@ -277,7 +284,7 @@ def connected(self) -> Optional[str]:
 
 
     # connect and re-connect while self._running to BLE
-    async def _connect(self, case_sensitive:bool=True, scan_timeout:float=10, connect_timeout:float=4) -> None:
+    async def _connect(self, case_sensitive:bool=True, scan_timeout:float=10, connect_timeout:float=4, address:Optional[str] = None) -> None:
         blacklist:Set[str] = set()
         while self._running:
             # scan and connect
@@ -290,7 +297,8 @@ async def _connect(self, case_sensitive:bool=True, scan_timeout:float=10, connec
                                     case_sensitive,
                                     self.disconnected_callback,
                                     scan_timeout,
-                                    connect_timeout)
+                                    connect_timeout,
+                                    address)
             if service_uuid is not None and self._ble_client is not None and self._ble_client.is_connected:
                 # validate correct service
                 try:
@@ -380,13 +388,13 @@ async def _keep_alive(self) -> None:
             await asyncio.sleep(self._heartbeat_frequency)
             self.heartbeat()
 
-    async def _connect_and_keep_alive(self,case_sensitive:bool,scan_timeout:float, connect_timeout:float) -> None:
+    async def _connect_and_keep_alive(self,case_sensitive:bool,scan_timeout:float, connect_timeout:float, address:Optional[str] = None) -> None:
         await asyncio.gather(
-            self._connect(case_sensitive,scan_timeout,connect_timeout),
+            self._connect(case_sensitive,scan_timeout,connect_timeout, address),
             self._keep_alive())
 
 
-    def start(self, case_sensitive:bool=True, scan_timeout:float=10, connect_timeout:float=4) -> None:
+    def start(self, case_sensitive:bool=True, scan_timeout:float=10, connect_timeout:float=4, address:Optional[str] = None) -> None:
         _log.debug('start')
         if self._running:
             _log.error('BLE client already running')
@@ -397,7 +405,7 @@ def start(self, case_sensitive:bool=True, scan_timeout:float=10, connect_timeout
                     self._async_loop_thread = AsyncLoopThread()
                     # run _connect in async loop
                     asyncio.run_coroutine_threadsafe(
-                        self._connect_and_keep_alive(case_sensitive, scan_timeout, connect_timeout),
+                        self._connect_and_keep_alive(case_sensitive, scan_timeout, connect_timeout, address),
                         self._async_loop_thread.loop)
                     _log.debug('BLE client started')
                     self.on_start()
@@ -480,3 +488,19 @@ def on_stop(self) -> None: # pylint: disable=no-self-use
         ...
     def heartbeat(self) -> None: # pylint: disable=no-self-use
         ...
+
+
+##
+
+# scans for named BLE devices providing any of the provided servie_uuids
+# returns a list of triples (name, address, Optional[BLEDevice])
+def scan_ble(timeout: float = 3.0) -> 'List[Tuple[BLEDevice, AdvertisementData]]':
+    coro = BleakScanner.discover(
+        timeout=timeout,
+        return_adv=True)
+    try:
+        loop = asyncio.get_running_loop()
+        res = asyncio.run_coroutine_threadsafe(coro, loop).result()
+    except RuntimeError:
+        res = asyncio.run(coro)
+    return list(res.values())

src/artisanlib/canvas.py

@@ -5993,7 +5993,7 @@ def playbackevent(self) -> None:
                             # temperatures which are assumed to increase
                             end_reached[event_type] = True
 
-                            if (event_type not in slider_events and # only if the is no slider event of the corresponding type
+                            if (event_type not in slider_events and # only if there is no slider event of the corresponding type
                                     self.specialeventplayback[event_type] and # only replay event types activated for replay
                                     (str(self.etypesf(event_type) == str(self.Betypesf(event_type)))) and
                                     #self.aw.eventslidervisibilities[event_type] and