- raise warning on missing bean information while connected plus only once

- minor BLE port improvements
- introduce clear_HUPCL parameter to async serial communication which prevents toggling the dtr/rts lines which might trigger a reboot of the connected device (experimental)
- lib updates

Author: MAKOMO

src/artisanlib/async_comm.py

@@ -13,17 +13,21 @@
 # the GNU General Public License for more details.
 
 # AUTHOR
-# Marko Luther, 2023
+# Marko Luther, 2026
 
+import os
+import sys
 import time
 import logging
+import serial as pyserial
 import asyncio
+import platform
 
 from contextlib import suppress
 from threading import Thread
-from pymodbus.transport.serialtransport import create_serial_connection # patched pyserial-asyncio
+from pymodbus.transport.serialtransport import SerialTransport # patched pyserial-asyncio
 from collections.abc import Callable, AsyncIterator
-from typing import Final, TYPE_CHECKING
+from typing import Final, Any, TYPE_CHECKING
 
 
 if TYPE_CHECKING:
@@ -144,6 +148,107 @@ async def readuntil(self, separator:bytes = b'\n') -> bytes:
                     break
         return res
 
+
+# clone from pymodbus/serialtransport.py extended by parameter 'do_not_open' (default False) which prevents opening the created serial port if set to True
+class ArtisanSerialTransport(SerialTransport):
+    """An asyncio serial transport."""
+
+    force_poll: bool = os.name == 'nt'
+    # async_loop: asyncio.AbstractEventLoop
+
+    def __init__(self, # pylint: disable=super-init-not-called
+            loop:asyncio.AbstractEventLoop,
+            protocol:asyncio.Protocol,
+            url:str,
+            baudrate:int,
+            bytesize:int,
+            parity:str,
+            stopbits:float,
+            timeout:float,
+            do_not_open:bool = False) -> None:
+        """Initialize."""
+        # we call __init__ of async.Transport, but NOT that of pymodbus SerialTransport which would open the port
+        asyncio.Transport.__init__(self) # pylint: disable=non-parent-init-called
+        if 'serial' not in sys.modules:
+            raise RuntimeError(
+                'Serial client requires pyserial '
+                'Please install with "pip install pyserial" and try again.'
+            )
+        self.async_loop = loop
+        self.intern_protocol: asyncio.BaseProtocol = protocol
+        self.sync_serial = pyserial.serial_for_url(url, exclusive=True,
+            baudrate=baudrate, bytesize=bytesize, parity=parity, stopbits=stopbits, timeout=timeout,
+            do_not_open=do_not_open)
+        self.intern_write_buffer: list[bytes] = []
+        self.poll_task: asyncio.Task[Any] | None = None
+        self._poll_wait_time = 0.0005
+        self.sync_serial.timeout = 0
+        self.sync_serial.write_timeout = 0
+
+
+async def create_serial_connection(
+    loop:asyncio.AbstractEventLoop,
+    protocol_factory:Callable[[], asyncio.Protocol],
+    url:str,
+    baudrate:int,
+    bytesize:int,
+    parity:str,
+    stopbits:float,
+    timeout:float,
+    clear_HUPCL:bool = False # if True, try to prevent toggling the RTS/DTR lines on opening the port to prevent to trigger a reboot on the connected device (ESP32/Orbiter)
+) -> tuple[asyncio.Transport, asyncio.BaseProtocol]:
+    """Create a connection to a new serial port instance."""
+    protocol = protocol_factory()
+    transport = ArtisanSerialTransport(loop, protocol, url,
+                    baudrate,
+                    bytesize,
+                    parity,
+                    stopbits,
+                    timeout,
+                    clear_HUPCL) # prevent opening the serial port on creation if clear_HUPCL is set
+    ####
+
+    # first we need to clear HUPCL, Hang Up on Close, (UNIX) or clear RTS/DTR (Windows) so the device will not reboot based on RTS and/or DTR
+    # stty -F /dev/ttyACM0 -hupcl to clear the HUPCL (Hang Up on Close) flag, preventing the reset when the port closes or reopens.
+    # see https://github.com/pyserial/pyserial/issues/124
+    # and https://github.com/npat-efault/picocom/blob/master/lowerrts.md
+    if clear_HUPCL:
+        # the transport serial port is not open yet in this case
+        try:
+            if platform.system() != 'Windows':
+                import termios # pylint: disable=C0415,E0401
+                port:str = url.replace('/dev/tty.','/dev/cu.')
+                # the following might hang on macOS for non-callup devices
+                with open(port, encoding='utf8') as f:
+                    attrs = termios.tcgetattr(f)
+                    attrs[2] = attrs[2] & ~termios.HUPCL
+                    termios.tcsetattr(f, termios.TCSAFLUSH, attrs)
+                    f.close()
+                time.sleep(0.1)
+        except Exception as e: # pylint: disable=broad-except
+            _log.error(e)
+        try:
+            # for Windows the following should be enough
+            transport.sync_serial.dtr = False
+            transport.sync_serial.rts = False
+        except Exception as e: # pylint: disable=broad-except
+            _log.error(e)
+
+    # in any case we open the serial port
+    if not transport.sync_serial.is_open:
+        transport.sync_serial.open() # ty:ignore
+
+    # and if clear_HUPCL, we immediately set the dtr/rts again
+    if clear_HUPCL:
+        try:
+            transport.sync_serial.dtr = False
+            transport.sync_serial.rts = False
+        except Exception as e: # pylint: disable=broad-except
+            _log.error(e)
+
+    loop.call_soon(transport.setup)
+    return transport, protocol
+
 class AsyncComm:
 
     __slots__ = [ '_asyncLoopThread', '_write_queue', '_running', '_host', '_port', '_serial', '_connected_handler', '_disconnected_handler',
@@ -210,7 +315,7 @@ async def open_serial_connection(url:str, *, loop:asyncio.AbstractEventLoop|None
         reader = asyncio.StreamReader(limit=limit, loop=loop)
         protocol = asyncio.StreamReaderProtocol(reader, loop=loop)
         transport, _ = await create_serial_connection(
-            loop, lambda: protocol, url, **kwargs
+            loop, lambda: protocol, url, **kwargs # type: ignore[arg-type] # ty:ignore[unused-ignore-comment]
         )
         writer = asyncio.StreamWriter(transport, protocol, reader, loop)
         return reader, writer
@@ -277,7 +382,8 @@ async def connect(self, connect_timeout:float=5) -> None:
                         bytesize = self._serial['bytesize'],
                         stopbits = self._serial['stopbits'],
                         parity = self._serial['parity'],
-                        timeout = self._serial['timeout'])
+                        timeout = self._serial['timeout'],
+                        clear_HUPCL = self._serial['clear_HUPCL'])
                 else:
                     _log.debug('connecting to %s:%s ...', self._host, self._port)
                     connect = asyncio.open_connection(self._host, self._port)

src/artisanlib/atypes.py

@@ -540,6 +540,7 @@ class SerialSettings(TypedDict):
     stopbits: int
     parity: str
     timeout: float
+    clear_HUPCL: bool # if True, try to prevent toggling the RTS/DTR lines on opening the port to prevent to trigger a reboot on the connected device (ESP32/Orbiter
 
 class BTBreakParams(TypedDict):
     delay: list[list[float]]

src/artisanlib/ble_port.py

@@ -18,7 +18,7 @@
 import asyncio
 import logging
 from bleak import BleakScanner, BleakClient
-from bleak.exc import BleakCharacteristicNotFoundError, BleakBluetoothNotAvailableError
+from bleak.exc import BleakError, BleakCharacteristicNotFoundError, BleakBluetoothNotAvailableError
 
 
 from PyQt6.QtCore import QObject
@@ -200,6 +200,9 @@ def scan_and_connect(self,
         except BleakBluetoothNotAvailableError:
             _log.error('Bluetooth is not supported, turned off or permission is denied')
             return None, None, None
+        except BleakError as e:
+            _log.error('BLE exception: %s', e)
+            return None, None, None
         except Exception: # pylint: disable=broad-except
             _log.error('exception in scan_and_connect: %s', fut.exception())
             return None, None, None
@@ -353,8 +356,11 @@ async def _connect(self, case_sensitive:bool=True, scan_timeout:float=6, connect
                 self._disconnected_event.clear()
                 await self._disconnected_event.wait()
                 _log.debug('BLE reconnect')
-            await asyncio.sleep(self._sleep_between_scans)
-            self._sleep_between_scans = max(self._sleep_between_scans + self.SCAN_BETWEEN_SCANS_INC, self.SCAN_BETWEEN_SCANS_MAX)
+            try:
+                await asyncio.sleep(self._sleep_between_scans)
+                self._sleep_between_scans = max(self._sleep_between_scans + self.SCAN_BETWEEN_SCANS_INC, self.SCAN_BETWEEN_SCANS_MAX)
+            except Exception as e: # pylint: disable=broad-except
+                _log.warning(e)
 
     # release the async lock _disconnected_event after disconnect triggered to enable the automatic reconnect
     async def set_event(self) -> None:
@@ -370,7 +376,7 @@ def disconnected_callback(self, _client:BleakClient) -> None:
         if hasattr(self, '_async_loop_thread') and self._async_loop_thread is not None:
             asyncio.run_coroutine_threadsafe(self.set_event(), self._async_loop_thread.loop)
 
-    def send(self, message:bytes, response:bool = False, write_characteristic:str|None = None) -> None:
+    def send(self, message:bytes, response:bool = False, write_characteristic:str|None = None, chunk:int = 20) -> None:
         if self._ble_client is not None and self._connected_service_uuid is not None and self._connected_service_uuid in self._writers:
             if self._logging:
                 _log.debug('send to %s: %s', self._writers[self._connected_service_uuid], message)
@@ -388,7 +394,7 @@ def send(self, message:bytes, response:bool = False, write_characteristic:str|No
                 else:
                     _log.debug('send failed. Characteristic %s not registered for write for service %s', write_characteristic, self._connected_service_uuid)
             else:
-                ble.write(self._ble_client, wc, message, response)
+                ble.write(self._ble_client, wc, message, response, chunk)
 
     def read(self, read_characteristic:str|None = None) -> bytes|None:
         if self._ble_client is not None and self._connected_service_uuid is not None and self._connected_service_uuid in self._readers:
@@ -439,6 +445,8 @@ def scan(self, scan_timeout:float = 5.0) -> 'list[tuple[BLEDevice, Advertisement
                     return list(res.values())
         except BleakBluetoothNotAvailableError:
             _log.error('Bluetooth is not supported, turned off or permission is denied')
+        except BleakError as e:
+            _log.error('BLE exception: %s', e)
         except Exception as e:  # pylint: disable=broad-except
             _log.exception(e)
         return []
@@ -471,7 +479,9 @@ def stop(self) -> None:
             if self._ble_client is None:
                 ble.terminate_scan() # we stop ongoing scanning
             self._disconnect()
-            self._async_loop_thread = None
+            if self._async_loop_thread is not None:
+                del self._async_loop_thread
+                self._async_loop_thread = None
             self._ble_client = None
             self._connected_service_uuid = None
             self._connected_device_name = None

src/artisanlib/canvas.py

@@ -1348,6 +1348,11 @@ def __init__(self, parent:QWidget, dpi:int, locale:str, aw:'ApplicationWindow')
         self.roastpropertiesflag:int = 1  #resets roast properties if not zero
         self.roastpropertiesAutoOpenFlag:int = 0  #open roast properties dialog on CHARGE if not zero
         self.roastpropertiesAutoOpenDropFlag:int = 0  #open roast properties dialog on DROP if not zero
+
+        # if True and plus is connected reminds user to set beans and open Roast Properties dialog if not yet set (once)
+        # this flag is reset after the warning dialog popped up once and is set to True again on OFF and
+        self.plus_beans_reminder_on_start:bool = True
+
         self.title:str = QApplication.translate('Scope Title', 'Roaster Scope')
         self.title_show_always:bool = False
         self.ambientTemp:float = 0.
@@ -13309,7 +13314,8 @@ def OnMonitor(self) -> None:
                                 bytesize = self.aw.ser.bytesize,
                                 stopbits = self.aw.ser.stopbits,
                                 parity = self.aw.ser.parity,
-                                timeout = self.aw.ser.timeout)
+                                timeout = self.aw.ser.timeout,
+                                clear_HUPCL = False)
                     self.aw.hottop = Hottop(
                         serial=hottop_serial,
                         connected_handler=lambda : self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} connected').format('Hottop'),True,None),
@@ -13327,7 +13333,8 @@ def OnMonitor(self) -> None:
                                 bytesize = self.aw.ser.bytesize,
                                 stopbits = self.aw.ser.stopbits,
                                 parity = self.aw.ser.parity,
-                                timeout = self.aw.ser.timeout)
+                                timeout = self.aw.ser.timeout,
+                                clear_HUPCL = False)
                     self.aw.santoker = Santoker(self.aw.santokerHost, self.aw.santokerPort,
                         santoker_serial, self.aw.santokerBLE,
                         connected_handler=lambda : self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} connected').format('Santoker'),True,None),
@@ -13370,7 +13377,8 @@ def OnMonitor(self) -> None:
                                 bytesize = self.aw.ser.bytesize,
                                 stopbits = self.aw.ser.stopbits,
                                 parity = self.aw.ser.parity,
-                                timeout = self.aw.ser.timeout)
+                                timeout = self.aw.ser.timeout,
+                                clear_HUPCL = False)
                     self.aw.kaleido.start(self.mode, self.aw.kaleidoHost, self.aw.kaleidoPort,
                         serial=kaleido_serial,
                         connected_handler=lambda : self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} connected').format('Kaleido'),True,None),
@@ -13406,7 +13414,8 @@ def OnMonitor(self) -> None:
                                 bytesize = self.aw.ser.bytesize,
                                 stopbits = self.aw.ser.stopbits,
                                 parity = self.aw.ser.parity,
-                                timeout = self.aw.ser.timeout)
+                                timeout = self.aw.ser.timeout,
+                                clear_HUPCL = True)
                     self.aw.orbiter = Orbiter(orbiter_serial,
                         connected_handler=lambda : self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} connected').format('Orbiter'),True,None),
                         disconnected_handler=lambda : self.aw.sendmessageSignal.emit(QApplication.translate('Message', '{} disconnected').format('Orbiter'),True,None))
@@ -13675,7 +13684,10 @@ def OffMonitor(self, respectAlwaysON:bool = True) -> None:
         _log.info('MODE: OFF MONITOR')
         if self.flagon:
             try:
-                # first activate "Stopping Mode" to ensure that sample() is not resetting the timer now (independent of the flagstart state)
+                # reset
+                self.plus_beans_reminder_on_start = True # ensure that for the next recording the corresponding warning is shown if beans are not specified for plus
+
+                # activate "Stopping Mode" to ensure that sample() is not resetting the timer now (independent of the flagstart state)
 
                 self.aw.buttonONOFF.setEnabled(False)
                 ge:QGraphicsEffect|None = self.aw.buttonONOFF.graphicsEffect()
@@ -14363,6 +14375,7 @@ def ToggleRecorder(self, _:bool = False) -> None:
             if (self.aw.plus_account is not None and              # plus connected
                     not self.roastpropertiesAutoOpenFlag and      # no "Open on CHARGE"
                     not self.roastpropertiesAutoOpenDropFlag and  # no "Open on DROP"
+                    self.plus_beans_reminder_on_start and         # warning was not yet shown for this recording
                     (self.plus_coffee is None and self.plus_blend_spec is None and self.beans == '') and # beans are not set
                     (self.aw.schedule_window is None or self.aw.schedule_window.selected_remaining_item is None) # scheduler is off or no schedule item selected
                     ):

src/artisanlib/colortrack.py

@@ -205,7 +205,8 @@ def main() -> None:
         bytesize = 8,
         stopbits = 1,
         parity = 'N',
-        timeout = 0.3)
+        timeout = 0.3,
+        clear_HUPCL = False)
     colorTrack = ColorTrack(serial=colortrack_serial)
     colorTrack.start()
     for _ in range(4):

src/artisanlib/comm.py

@@ -1797,7 +1797,8 @@ def ColorTrackSerial(self) -> tuple[float,float,float]:
                     bytesize = self.bytesize,
                     stopbits = self.stopbits,
                     parity = self.parity,
-                    timeout = self.timeout)
+                    timeout = self.timeout,
+                    clear_HUPCL = False)
                 self.colorTrackSerial = ColorTrack(serial=colortrack_serial)
                 self.colorTrackSerial.setLogging(self.aw.qmc.device_logging)
                 self.colorTrackSerial.start()

src/artisanlib/hottop.py

@@ -210,7 +210,8 @@ def main() -> None:
         bytesize = 8,
         stopbits = 1,
         parity = 'N',
-        timeout = 0.3)
+        timeout = 0.3,
+        clear_HUPCL = False)
     hottop = Hottop(serial=hottop_serial)
     hottop.start()
     for _ in range(4):

src/artisanlib/orbiter.py

@@ -295,7 +295,8 @@ def main() -> None:
         bytesize = 8,
         stopbits = 1,
         parity = 'N',
-        timeout = 0.5)
+        timeout = 0.5,
+        clear_HUPCL = True)
     orbiter = Orbiter(serial)
     orbiter.start()
     for _ in range(4):

src/artisanlib/roast_properties.py

@@ -1686,6 +1686,7 @@ def __init__(self, parent:QWidget, aw:'ApplicationWindow', activeTab:int = 0, st
             plus.util.setPlusIcon(mbox)
             mbox.setStandardButtons(QMessageBox.StandardButton.Ok)
             mbox.exec()
+            self.aw.qmc.plus_beans_reminder_on_start = False # prevent this warning to be shown again for this recording
 
         self.setLayout(totallayout)
 

src/artisanlib/transposer.py

@@ -836,7 +836,7 @@ def calcTempPolyfit(self) -> 'npt.NDArray[numpy.float64]|None':
     @staticmethod
     def calcDiscretefits(sources:list[float|None], targets:list[float|None]) -> 'list[npt.NDArray[numpy.float64]|None]':
         if len(sources) != len(targets):
-            return [None]*len(sources) # ty:ignore # Return type does not match returned value
+            return [None]*len(sources)
         fits:list[npt.NDArray[numpy.float64]|None] = [None]*len(sources)
         last_fit:npt.NDArray[numpy.float64]|None = None
         for i, _ in enumerate(sources):