faster async disconnects

Author: MAKOMO

doc/help_dialogs/Output_html/energy_help.html

@@ -534,10 +534,10 @@ def __init__(self, model:int, ident:Optional[str], name:Optional[str], connected
         Scale.__init__(self, model, ident, name)
         AcaiaBLE.__init__(self, connected_handler = connected_handler, disconnected_handler=disconnected_handler)
 
-    def connect(self) -> None:
+    def connect_scale(self) -> None:
         self.start(address=self.ident)
 
-    def disconnect(self) -> None:
+    def disconnect_scale(self) -> None:
         self.stop()
 
     def weight_changed(self, new_value:int) -> None:
@@ -549,3 +549,6 @@ def battery_changed(self, new_value:int) -> None:
     def on_disconnect(self) -> None:
         self.disconnected_signal.emit()
         AcaiaBLE.on_disconnect(self)
+
+    def tare_scale(self) -> None:
+        self.send_tare()

doc/help_dialogs/Output_html/keyboardshortcuts_help.html

@@ -60,7 +60,9 @@ def start_background_loop(loop:asyncio.AbstractEventLoop) -> None:
 
     def __del__(self) -> None:
         self.__loop.call_soon_threadsafe(self.__loop.stop)
-        self.__thread.join()
+#        self.__thread.join()
+# WARNING: we don't join and expect the clients running on this thread to stop themself
+# (using self._running) to finally get rid of this thread to prevent hangs
 
     @property
     def loop(self) -> asyncio.AbstractEventLoop:
@@ -139,7 +141,7 @@ async def readuntil(self, separator:bytes = b'\n') -> bytes:
 
 class AsyncComm:
 
-    __slots__ = [ '_asyncLoopThread', '_write_queue', '_host', '_port', '_serial', '_connected_handler', '_disconnected_handler',
+    __slots__ = [ '_asyncLoopThread', '_write_queue', '_running', '_host', '_port', '_serial', '_connected_handler', '_disconnected_handler',
                     '_verify_crc', '_logging' ]
 
     def __init__(self, host:str = '127.0.0.1', port:int = 8080, serial:Optional['SerialSettings'] = None,
@@ -148,6 +150,7 @@ def __init__(self, host:str = '127.0.0.1', port:int = 8080, serial:Optional['Ser
         # internals
         self._asyncLoopThread: Optional[AsyncLoopThread]       = None # the asyncio AsyncLoopThread object
         self._write_queue: 'Optional[asyncio.Queue[bytes]]'    = None # noqa: UP037 # quotes for Python3.8 # the write queue
+        self._running:bool                                     = False              # while True we keep running the thread
 
         # connection
         self._host:str = host
@@ -256,7 +259,7 @@ async def handle_writes(self, writer: asyncio.StreamWriter, queue: 'asyncio.Queu
     # if serial settings are given, host/port are ignore and communication is handled by the given serial port
     async def connect(self, connect_timeout:float=5) -> None:
         writer = None
-        while True:
+        while self._running:
             try:
                 if self._serial is not None:
                     _log.debug('connecting to serial port: %s ...', self._serial['port'])
@@ -311,7 +314,7 @@ async def connect(self, connect_timeout:float=5) -> None:
                 except Exception as e: # pylint: disable=broad-except
                     _log.exception(e)
 
-            await asyncio.sleep(0.7)
+            await asyncio.sleep(0.5)
 
     def send(self, message:bytes) -> None:
         if self.async_loop_thread is not None and self._write_queue is not None:
@@ -324,6 +327,7 @@ def start(self, connect_timeout:float=5) -> None:
         try:
             _log.debug('start sampling')
             if self._asyncLoopThread is None:
+                self._running = True
                 self._asyncLoopThread = AsyncLoopThread()
                 # run sample task in async loop
                 asyncio.run_coroutine_threadsafe(self.connect(connect_timeout), self._asyncLoopThread.loop)
@@ -332,7 +336,7 @@ def start(self, connect_timeout:float=5) -> None:
 
     def stop(self) -> None:
         _log.debug('stop sampling')
-        del self._asyncLoopThread
+        self._running = False
         self._asyncLoopThread = None
         self._write_queue = None
         self.reset_readings()

src/artisanlib/acaia.py

@@ -161,8 +161,8 @@ def scan_and_connect(self,
             blacklist:Set[str], # list of client addresses to ignore as they don't offer the required service
             case_sensitive:bool=True,
             disconnected_callback:Optional[Callable[[BleakClient], None]] = None,
-            scan_timeout:float=10,
-            connect_timeout:float=3,
+            scan_timeout:float=3,
+            connect_timeout:float=2,
             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:
@@ -284,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, address:Optional[str] = None) -> None:
+    async def _connect(self, case_sensitive:bool=True, scan_timeout:float=3, connect_timeout:float=2, address:Optional[str] = None) -> None:
         blacklist:Set[str] = set()
         while self._running:
             # scan and connect
@@ -384,7 +384,7 @@ def read(self, read_characteristic:Optional[str] = None) -> Optional[bytes]:
         return None
 
     async def _keep_alive(self) -> None:
-        while self._heartbeat_frequency > 0:
+        while self._heartbeat_frequency > 0 and self._running:
             await asyncio.sleep(self._heartbeat_frequency)
             self.heartbeat()
 
@@ -394,7 +394,7 @@ async def _connect_and_keep_alive(self,case_sensitive:bool,scan_timeout:float, c
             self._keep_alive())
 
 
-    def start(self, case_sensitive:bool=True, scan_timeout:float=10, connect_timeout:float=4, address:Optional[str] = None) -> None:
+    def start(self, case_sensitive:bool=True, scan_timeout:float=3, connect_timeout:float=2, address:Optional[str] = None) -> None:
         _log.debug('start')
         if self._running:
             _log.error('BLE client already running')
@@ -420,7 +420,6 @@ def stop(self) -> None:
             if self._ble_client is None:
                 ble.terminate_scan() # we stop ongoing scanning
             self._disconnect()
-            #del self._async_loop_thread # on this level the released object should be automatically collected by the GC
             self._async_loop_thread = None
             self._ble_client = None
             self._connected_service_uuid = None

src/artisanlib/async_comm.py

@@ -12825,8 +12825,8 @@ def OnMonitor(self) -> None:
                         # CHARGE handler disactivated to not trigger CHARGE after CHARGE is signalled to the machine by START
                         # NOTE: only after CHARGE the heater
 #                        charge_handler=lambda : (self.markChargeDelaySignal.emit(0) if (self.timeindex[0] == -1) else None),
-                        dry_handler=lambda : (self.markDRYSignal.emit(False) if (self.timeindex[2] == 0) else None),
-                        fcs_handler=lambda : (self.markFCsSignal.emit(False) if (self.timeindex[1] == 0) else None),
+                        dry_handler=lambda : (self.markDRYSignal.emit(False) if (self.timeindex[1] == 0) else None),
+                        fcs_handler=lambda : (self.markFCsSignal.emit(False) if (self.timeindex[2] == 0) else None),
                         scs_handler=lambda : (self.markSCsSignal.emit(False) if (self.timeindex[4] == 0) else None),
                         drop_handler=lambda : (self.markDropSignal.emit(False) if (self.timeindex[6] == 0) else None))
                     self.aw.santoker.setLogging(self.device_logging)

src/artisanlib/ble_port.py

@@ -26,7 +26,8 @@
 if TYPE_CHECKING:
     from artisanlib.main import ApplicationWindow # noqa: F401 # pylint: disable=unused-import
 
-from artisanlib.util import deltaLabelUTF8, setDeviceDebugLogLevel, argb_colorname2rgba_colorname, rgba_colorname2argb_colorname, toInt
+from artisanlib.util import (deltaLabelUTF8, setDeviceDebugLogLevel, argb_colorname2rgba_colorname, rgba_colorname2argb_colorname,
+    toInt, weight_units, convertWeight)
 from artisanlib.dialogs import ArtisanResizeablDialog
 from artisanlib.widgets import MyContentLimitedQComboBox, MyQComboBox, MyQDoubleSpinBox, wait_cursor
 from artisanlib.scale import SUPPORTED_SCALES, ScaleSpecs
@@ -1453,6 +1454,8 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0) ->
 
         self.scale1_devices:ScaleSpecs = [] # discovered scale1 devices
         self.scale2_devices:ScaleSpecs = [] # discovered scale2 devices
+        self.scale1_weight:Optional[float] = None # weight of scale 1 in g
+        self.scale2_weight:Optional[float] = None # weight of scale 2 in g
 
         scale1ModelLabel = QLabel(QApplication.translate('Label','Model'))
         self.scale1ModelComboBox = QComboBox()
@@ -1463,6 +1466,13 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0) ->
         self.scale1NameComboBox.setMinimumWidth(150)
         self.scale1ScanButton = QPushButton(QApplication.translate('Button', 'Scan'))
         self.scale1ScanButton.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.scale1Weight = QLabel() # displays the current reading
+        self.scale1Weight.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        self.scale1Weight.setMinimumWidth(40)
+        self.scale1Weight.setEnabled(False)
+        self.scale1TareButton = QPushButton(QApplication.translate('Button', 'Tare'))
+        self.scale1TareButton.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.scale1TareButton.setEnabled(False)
         if self.aw.scale1_model is None:
             self.scale1NameComboBox.setEnabled(False)
             self.scale1ScanButton.setEnabled(False)
@@ -1475,6 +1485,8 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0) ->
         self.scale1ModelComboBox.currentIndexChanged.connect(self.scale1ModelChanged)
         self.scale1NameComboBox.currentIndexChanged.connect(self.scale1NameChanged)
         self.scale1ScanButton.clicked.connect(self.scanScale1)
+        self.scale1TareButton.clicked.connect(self.tareScale1)
+        self.update_scale1_weight(None)
 
         if self.aw.scale1_name and self.aw.scale1_id:
             self.updateScale1devices([(self.aw.scale1_name, self.aw.scale1_id)])
@@ -1485,11 +1497,18 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0) ->
         scale1Grid.addWidget(self.scale1NameLabel,1,0)
         scale1Grid.addWidget(self.scale1NameComboBox,1,1)
         scale1Grid.addWidget(self.scale1ScanButton,1,2)
+        scale1Grid.addWidget(self.scale1Weight,1,3,Qt.AlignmentFlag.AlignCenter)
+        scale1Grid.addWidget(self.scale1TareButton,1,4,Qt.AlignmentFlag.AlignRight)
+        scale1Grid.setHorizontalSpacing(10)
+        scale1Grid.setVerticalSpacing(10)
+        scale1Grid.setContentsMargins(10,10,10,10)
         scale1HLayout = QHBoxLayout()
         scale1HLayout.addLayout(scale1Grid)
         scale1HLayout.addStretch()
+        scale1HLayout.setContentsMargins(0,0,0,0)
         scale1Layout = QVBoxLayout()
         scale1Layout.addLayout(scale1HLayout)
+        scale1Layout.setContentsMargins(0,0,0,0)
 
         scale2ModelLabel = QLabel(QApplication.translate('Label','Model'))
         self.scale2ModelComboBox = QComboBox()
@@ -1500,6 +1519,13 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0) ->
         self.scale2NameComboBox.setMinimumWidth(150)
         self.scale2ScanButton = QPushButton(QApplication.translate('Button', 'Scan'))
         self.scale2ScanButton.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.scale2Weight = QLabel() # displays the current reading
+        self.scale2Weight.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+        self.scale2Weight.setMinimumWidth(40)
+        self.scale2Weight.setEnabled(False)
+        self.scale2TareButton = QPushButton(QApplication.translate('Button', 'Tare'))
+        self.scale2TareButton.setFocusPolicy(Qt.FocusPolicy.NoFocus)
+        self.scale2TareButton.setEnabled(False)
         if self.aw.scale2_model is None:
             self.scale2NameComboBox.setEnabled(False)
             self.scale2ScanButton.setEnabled(False)
@@ -1512,6 +1538,8 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0) ->
         self.scale2ModelComboBox.currentIndexChanged.connect(self.scale2ModelChanged)
         self.scale2NameComboBox.currentIndexChanged.connect(self.scale2NameChanged)
         self.scale2ScanButton.clicked.connect(self.scanScale2)
+        self.scale2TareButton.clicked.connect(self.tareScale2)
+        self.update_scale2_weight(None)
 
         if self.aw.scale2_name and self.aw.scale2_id:
             self.updateScale2devices([(self.aw.scale2_name, self.aw.scale2_id)])
@@ -1522,11 +1550,18 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0) ->
         scale2Grid.addWidget(self.scale2NameLabel,1,0)
         scale2Grid.addWidget(self.scale2NameComboBox,1,1)
         scale2Grid.addWidget(self.scale2ScanButton,1,2)
+        scale2Grid.addWidget(self.scale2Weight,1,3,Qt.AlignmentFlag.AlignCenter)
+        scale2Grid.addWidget(self.scale2TareButton,1,4,Qt.AlignmentFlag.AlignRight)
+        scale2Grid.setHorizontalSpacing(10)
+        scale2Grid.setVerticalSpacing(10)
+        scale2Grid.setContentsMargins(10,10,10,10)
         scale2HLayout = QHBoxLayout()
+        scale2HLayout.setContentsMargins(0,0,0,0)
         scale2HLayout.addLayout(scale2Grid)
         scale2HLayout.addStretch()
         scale2Layout = QVBoxLayout()
         scale2Layout.addLayout(scale2HLayout)
+        scale2Layout.setContentsMargins(0,0,0,0)
 
         self.taskWebDisplayGreenURL = QLabel()
         self.taskWebDisplayGreenURL.setOpenExternalLinks(True)
@@ -1712,14 +1747,50 @@ def scale1NameChanged(self, i:int) -> None:
             scale = self.aw.scale_manager.get_scale(self.aw.scale1_model, self.aw.scale1_id, self.aw.scale1_name)
             self.aw.scale_manager.set_scale1(scale)
             if scale is not None:
-                scale.set_connected_handler(lambda : self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} connected').format(self.aw.scale1_name),True,None))
-                scale.set_disconnected_handler(lambda : self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} disconnected').format(self.aw.scale1_name),True,None))
-                scale.connect()
+                scale.set_connected_handler(self.scale1connected)
+                scale.set_disconnected_handler(self.scale1disconnected)
+                scale.weight_changed_signal.connect(self.scale1_weight_changed) # type:ignore[call-overload]
+                scale.connect_scale()
         # i == -1 if self.scale1NameComboBox is empty!
         else:
             scale1 = self.aw.scale_manager.get_scale1()
             if scale1 is not None:
-                scale1.disconnect()
+                scale1.weight_changed_signal.disconnect() # type:ignore[call-overload]
+                scale1.disconnect_scale()
+
+    def scale1connected(self) -> None:
+        self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} connected').format(self.aw.scale1_name),True,None)
+        self.scale1Weight.setEnabled(True)
+        self.scale1TareButton.setEnabled(True)
+
+    def scale1disconnected(self) -> None:
+        self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} disconnected').format(self.aw.scale1_name),True,None)
+        self.scale1Weight.setEnabled(False)
+        self.scale1TareButton.setEnabled(False)
+        self.update_scale1_weight(None)
+
+    @pyqtSlot(int)
+    def scale1_weight_changed(self, w:int) -> None:
+        self.update_scale1_weight(w)
+
+    # returns formated weight converted to current weight unit
+    def format_scale_weight(self, w:Optional[float]) -> str:
+        if w is None:
+            return ''
+        unit = weight_units.index(self.aw.qmc.weight[2])
+        if unit == 0: # g selected
+            # metric
+            return f'{w:.0f}g' # never show decimals for g
+        if unit == 1: # kg selected
+            # metric (always keep the accuracy to the g
+            return f'{w/1000:.3f}kg'
+        # non-metric
+        v = convertWeight(w,0,weight_units.index(self.aw.qmc.weight[2]))
+        return f'{v:.2f}{self.aw.qmc.weight[2].lower()}'
+
+    def update_scale1_weight(self, weight:Optional[float]) -> None:
+        self.scale1_weight = weight
+        self.scale1Weight.setText(self.format_scale_weight(self.scale1_weight))
 
     def updateScale1devices(self, devices:ScaleSpecs) -> None:
         self.scale1_devices = devices
@@ -1739,6 +1810,12 @@ def scanScale1(self, _:bool = False) -> None:
                 else:
                     self.scale1NameComboBox.setEnabled(False)
 
+    @pyqtSlot(bool)
+    def tareScale1(self, _:bool = False) -> None:
+        scale = self.aw.scale_manager.get_scale1()
+        if scale is not None:
+            scale.tare_scale()
+
     @pyqtSlot(int)
     def scale2ModelChanged(self, i:int) -> None:
         if i > 0 and len(SUPPORTED_SCALES) > i-1 and len(SUPPORTED_SCALES[i-1]) > 0:
@@ -1760,12 +1837,35 @@ def scale2NameChanged(self, i:int) -> None:
             scale = self.aw.scale_manager.get_scale(self.aw.scale2_model, self.aw.scale2_id, self.aw.scale2_name)
             self.aw.scale_manager.set_scale2(scale)
             if scale is not None:
-                scale.connect()
+                scale.set_connected_handler(self.scale2connected)
+                scale.set_disconnected_handler(self.scale2disconnected)
+                scale.weight_changed_signal.connect(self.scale2_weight_changed) # type:ignore[call-overload]
+                scale.connect_scale()
         # i == -1 if self.scale2NameComboBox is empty!
         else:
             scale2 = self.aw.scale_manager.get_scale2()
             if scale2 is not None:
-                scale2.disconnect()
+                scale2.weight_changed_signal.disconnect() # type:ignore[call-overload]
+                scale2.disconnect_scale()
+
+    @pyqtSlot(int)
+    def scale2_weight_changed(self, w:int) -> None:
+        self.update_scale2_weight(w)
+
+    def update_scale2_weight(self, weight:Optional[float]) -> None:
+        self.scale2_weight = weight
+        self.scale2Weight.setText(self.format_scale_weight(self.scale2_weight))
+
+    def scale2connected(self) -> None:
+        self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} connected').format(self.aw.scale2_name),True,None)
+        self.scale2Weight.setEnabled(True)
+        self.scale2TareButton.setEnabled(True)
+
+    def scale2disconnected(self) -> None:
+        self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} disconnected').format(self.aw.scale2_name),True,None)
+        self.scale2Weight.setEnabled(False)
+        self.scale2TareButton.setEnabled(False)
+        self.update_scale2_weight(None)
 
     def updateScale2devices(self, devices:ScaleSpecs) -> None:
         self.scale2_devices = devices
@@ -1785,6 +1885,11 @@ def scanScale2(self, _:bool = False) -> None:
                 else:
                     self.scale2NameComboBox.setEnabled(False)
 
+    @pyqtSlot(bool)
+    def tareScale2(self, _:bool = False) -> None:
+        scale = self.aw.scale_manager.get_scale2()
+        if scale is not None:
+            scale.tare_scale()
 
     @pyqtSlot(bool)
     def taskWebDisplayGreen(self, b:bool = False) -> None: