- adds support for Orbiter smart roaster

- adds popup on missing bean information on START if plus is connected

Author: MAKOMO

doc/help_dialogs/Input_files/eventbuttons.xlsx

@@ -497,6 +497,11 @@
             <td>kaleido(&lt;target&gt;,&lt;value&gt;)</td>
             <td>sends &lt;value&gt; to &lt;target&gt; via the Kaleido Serial or Network protocol</td>
         </tr>
+        <tr>
+            <td>&#160;</td>
+            <td>orbiter(&lt;cmd&gt;[,&lt;value&gt;[,&lt;param&gt;]])</td>
+            <td>sends &lt;cmd&gt; (1byte in HEX) and optional &lt;value&gt; (0-65535) and &lt;param&gt; (0-255) to Orbiter</td>
+        </tr>
         <tr>
             <td>&#160;</td>
             <td>shellyrelay(n,b)</td>

doc/help_dialogs/Input_files/eventsliders.xlsx

@@ -441,6 +441,12 @@
             <td>sends &lt;value&gt; to &lt;target&gt; via the Kaleido Serial or Network protocol</td>
             <td>&#160;</td>
         </tr>
+        <tr>
+            <td>&#160;</td>
+            <td>orbiter(&lt;cmd&gt;[,&lt;value&gt;[,&lt;param&gt;]])</td>
+            <td>sends &lt;cmd&gt; (1byte in HEX) and optional &lt;value&gt; (0-65535) and &lt;param&gt; (0-255) to Orbiter</td>
+            <td>&#160;</td>
+        </tr>
         <tr>
             <td>&#160;</td>
             <td>shellyrelay(n,b)</td>

doc/help_dialogs/Output_html/eventbuttons_help.html

@@ -147,7 +147,7 @@ async def readuntil(self, separator:bytes = b'\n') -> bytes:
 class AsyncComm:
 
     __slots__ = [ '_asyncLoopThread', '_write_queue', '_running', '_host', '_port', '_serial', '_connected_handler', '_disconnected_handler',
-                    '_verify_crc', '_logging' ]
+                    '_verify_crc', '_logging', '_send_timeout' ]
 
     def __init__(self, host:str = '127.0.0.1', port:int = 8080, serial:'SerialSettings|None' = None,
                 connected_handler:Callable[[], None]|None = None,
@@ -169,6 +169,7 @@ def __init__(self, host:str = '127.0.0.1', port:int = 8080, serial:'SerialSettin
         # configuration
         self._verify_crc:bool = True  # if True the CRC of incoming messages is verified
         self._logging = False         # if True device communication is logged
+        self._send_timeout:Final[float] = 0.6    # in seconds
 
 
     # external API
@@ -328,6 +329,38 @@ def send(self, message:bytes) -> None:
             asyncio.run_coroutine_threadsafe(self._write_queue.put(message), self.async_loop_thread.loop)
 
 
+    # adds message to write queue and awaits new data
+    async def write_await(self, message:bytes, event:asyncio.Event, send_timeout:float) -> None:
+        if self._write_queue is None:
+            return
+        await self._write_queue.put(message)
+        # await a response containing a new value for var with timeout
+        try:
+            await asyncio.wait_for(event.wait(), send_timeout)
+        except TimeoutError:
+            if self._logging:
+                _log.info('write_await (msg=%s, send_timeout:%s)', message.strip(), send_timeout)
+
+    def send_await(self, message:bytes, event:asyncio.Event, timeout:float|None = None) -> None:
+        if self.async_loop_thread is not None and self._write_queue is not None:
+            send_timeout:float = self._send_timeout
+            if timeout is not None:
+                send_timeout = timeout
+            task = self.write_await(message, event, send_timeout)
+            if self._asyncLoopThread is not None:
+                future = asyncio.run_coroutine_threadsafe(task, self._asyncLoopThread.loop)
+                try:
+                    future.result()
+                except TimeoutError:
+                    # the coroutine took too long, cancelling the task...
+                    if self._logging:
+                        _log.info('send_request timeout (msg=%s, timeout:%s, send_timeout:%s)',message,timeout,send_timeout)
+                    future.cancel()
+                except Exception as ex: # pylint: disable=broad-except
+                    _log.error(ex)
+
+
+
     # start/stop sample thread
 
     def start(self, connect_timeout:float=5) -> None:

doc/help_dialogs/Output_html/eventsliders_help.html

@@ -992,7 +992,12 @@ def __init__(self, parent:QWidget, dpi:int, locale:str, aw:'ApplicationWindow')
                        '+Phidget HUM1000 Hum/Temp',  #192
                        '+Phidget PRE1000',           #193
                        '+Yocto Meteo Hum/Temp',      #194
-                       '+Yocto Meteo Pressure'       #195
+                       '+Yocto Meteo Pressure',      #195
+                       'Orbiter BT/ET',              #196
+                       '+Orbiter IT/DT',             #197
+                       '+Orbiter Sound/Drum',        #198
+                       '+Orbiter Damper/Heater',     #199
+                       '+Orbiter Air/RoR'            #200
                        ]
 
         # ADD DEVICE:
@@ -1156,7 +1161,10 @@ def __init__(self, parent:QWidget, dpi:int, locale:str, aw:'ApplicationWindow')
             192, # +Phidget HUM1000 Hum/Temp
             193, # +Phidget PRE1000
             194, # +Yocto Meteo Hum/Temp
-            195  # +Yocto Meteo Pressure
+            195, # +Yocto Meteo Pressure
+            198, # +Orbiter Sound/Drum
+            199, # +Orbiter Damper/Heater
+            200  # +Orbiter Air/RoR
         ]
 
         # ADD DEVICE:
@@ -4455,7 +4463,9 @@ def intChannel(self, n:int, c:int) -> bool:
                             (self.aw.s7.div[idx*2 + c] == 0 or self.aw.s7.type[idx*2 + c] == 2) and
                             no_math_formula_defined)
             # others
-            if self.extradevices[n] in {54, 90, 91, 135, 136, 140, 141, 165}: # Hottop Heater/Fan, Slider 12, Slider 34, Santoker Power / Fan, Kaleido Fan/Drum, Kaleido Heater/AH, Mugma Heater/Fan
+            if self.extradevices[n] in {54, 90, 91, 135, 136, 140, 141, 165,
+                198, 199
+                }: # Hottop Heater/Fan, Slider 12, Slider 34, Santoker Power / Fan, Kaleido Fan/Drum, Kaleido Heater/AH, Mugma Heater/Fan, Orbiter Sound/Drum, Orbiter Damper/Heater
                 return True
             if self.extradevices[n] == 136 and c == 0: # Santoker Drum
                 return True
@@ -13376,6 +13386,21 @@ def OnMonitor(self) -> None:
                     self.aw.mugma.setLogging(self.device_logging)
                     self.aw.mugma.start()
 
+                elif self.device == 196:
+                    # connect Orbiter
+                    from artisanlib.orbiter import Orbiter
+                    orbiter_serial = SerialSettings(
+                                port = self.aw.ser.comport,
+                                baudrate = self.aw.ser.baudrate,
+                                bytesize = self.aw.ser.bytesize,
+                                stopbits = self.aw.ser.stopbits,
+                                parity = self.aw.ser.parity,
+                                timeout = self.aw.ser.timeout)
+                    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))
+                    self.aw.orbiter.setLogging(self.device_logging)
+                    self.aw.orbiter.start()
 
             self.aw.initializedMonitoringExtraDeviceStructures()
 
@@ -13526,6 +13551,11 @@ def OffMonitorCloseDown(self, respectAlwaysON:bool) -> None:
                     self.aw.mugma.stop()
                     self.aw.mugma = None
 
+                # disconnect Orbiter
+                if not bool(self.aw.simulator) and self.device == 196 and self.aw.orbiter is not None:
+                    self.aw.orbiter.stop()
+                    self.aw.orbiter = None
+
                 # at OFF we stop the follow-background on FujiPIDs and set the SV to 0
                 if self.device == 0 and self.aw.fujipid.followBackground and self.aw.fujipid.sv and self.aw.fujipid.sv > 0:
                     try:

src/artisanlib/async_comm.py

@@ -570,7 +570,12 @@ def __init__(self, aw:'ApplicationWindow') -> None:
                                    self.Phidget_HUM1000_HumTemp,     #192
                                    self.Phidget_PRE1000,             #193
                                    self.Yocto_Meteo_HumTemp,         #194
-                                   self.Yocto_Meteo_Pressure         #195
+                                   self.Yocto_Meteo_Pressure,        #195
+                                   self.Orbiter_BTET,                #196
+                                   self.Orbiter_ITDT,                #197
+                                   self.Orbiter_Sound_Drum,          #198
+                                   self.Orbiter_Damper_Heater,       #199
+                                   self.Orbiter_Air_RoR              #200
                                    ]
         #string with the name of the program for device #27
         self.externalprogram:str = 'test.py'
@@ -2211,7 +2216,56 @@ def Kaleido_HeaterFan(self) -> tuple[float,float,float]:
             t1,t2 = self.aw.kaleido.getHeaterFan()
         else:
             t1 = t2 = -1
-        return tx,t2,t1 # time Fan (chan2), Heater (chan1)
+        return tx,t2,t1 # time, Fan (chan2), Heater (chan1)
+
+# Orbiter
+
+    def Orbiter_BTET(self) -> tuple[float,float,float]:
+        tx = self.aw.qmc.timeclock.elapsedMilli()
+        t1:float = -1
+        t2:float = -1
+        if self.aw.orbiter is not None:
+            t1 = self.aw.orbiter.getBT()
+            t2 = self.aw.orbiter.getET()
+        return tx,t2,t1
+
+    def Orbiter_ITDT(self) -> tuple[float,float,float]:
+        tx = self.aw.qmc.timeclock.elapsedMilli()
+        t1:float = -1
+        t2:float = -1
+        if self.aw.orbiter is not None:
+            t1 = self.aw.orbiter.getIT()
+            t2 = self.aw.orbiter.getDT()
+        return tx,t2,t1 # time, DT (chan2), IT (chan1)
+
+    def Orbiter_Sound_Drum(self) -> tuple[float,float,float]:
+        tx = self.aw.qmc.timeclock.elapsedMilli()
+        t1:float = -1
+        t2:float = -1
+        if self.aw.orbiter is not None:
+            t1 = self.aw.orbiter.getSound()
+            t2 = self.aw.orbiter.getDrum()
+        return tx,t2,t1 # time, Drum (chan2), Sound (chan1)
+
+    def Orbiter_Damper_Heater(self) -> tuple[float,float,float]:
+        tx = self.aw.qmc.timeclock.elapsedMilli()
+        t1:float = -1
+        t2:float = -1
+        if self.aw.orbiter is not None:
+            t1 = self.aw.orbiter.getDamper()
+            t2 = self.aw.orbiter.getHeater()
+        return tx,t2,t1 # time, Heater (chan2), Damper (chan1)
+
+    def Orbiter_Air_RoR(self) -> tuple[float,float,float]:
+        tx = self.aw.qmc.timeclock.elapsedMilli()
+        t1:float = -1
+        t2:float = -1
+        if self.aw.orbiter is not None:
+            t1 = self.aw.orbiter.getAir()
+            t2 = self.aw.orbiter.getRoR()
+        return tx,t2,t1 # time, RoR (chan2), Air (chan1)
+
+# IKAWA
 
     def Ikawa(self) -> tuple[float,float,float]:
         tx = self.aw.qmc.timeclock.elapsedMilli()

src/artisanlib/canvas.py

@@ -4472,6 +4472,30 @@ def okEvent(self) -> None: # pyright: ignore [reportGeneralTypeIssues] # Code is
                 ##########################
                 ####  DEVICE 195 is +Yocto Meteo Pressure
                 ##########################
+                ##########################
+                ####  DEVICE 196 is Kaleido BT/ET
+                elif meter == 'Orbiter BT/ET':
+                    self.aw.qmc.device = 196
+                    #self.aw.ser.comport = "COM4"
+                    self.aw.ser.baudrate = 115200
+                    self.aw.ser.bytesize = 8
+                    self.aw.ser.parity= 'N'
+                    self.aw.ser.stopbits = 1
+                    self.aw.ser.timeout = 1.0
+                    message = QApplication.translate('Message','Device set to {0}').format(meter)
+                ##########################
+                ##########################
+                ####  DEVICE 197 is +Orbiter IT/DT but +DEVICE cannot be set as main device
+                ##########################
+                ##########################
+                ####  DEVICE 198 is +Orbiter Sound/Drum but +DEVICE cannot be set as main device
+                ##########################
+                ##########################
+                ####  DEVICE 199 is +Orbiter Damper/Heater but +DEVICE cannot be set as main device
+                ##########################
+                ##########################
+                ####  DEVICE 200 is +Orbiter Air/RoR but +DEVICE cannot be set as main device
+                ##########################
 
 
                 # ADD DEVICE:
@@ -4687,7 +4711,12 @@ def okEvent(self) -> None: # pyright: ignore [reportGeneralTypeIssues] # Code is
                 3, # 192
                 3, # 193
                 3, # 194
-                3  # 195
+                3, # 195
+                8, # 196
+                8, # 197
+                8, # 198
+                8, # 199
+                8  # 200
                 ]
             #init serial settings of extra devices
             for i, _ in enumerate(self.aw.qmc.extradevices):

src/artisanlib/comm.py

@@ -177,6 +177,7 @@
     from artisanlib.bluedot import BlueDOT # pylint: disable=unused-import
     from artisanlib.mugma import Mugma # pylint: disable=unused-import
     from artisanlib.kaleido import KaleidoPort # pylint: disable=unused-import
+    from artisanlib.orbiter import Orbiter # pylint: disable=unused-import
     from artisanlib.phases_canvas import tphasescanvas # pylint: disable=unused-import
     try:
         from artisanlib.ikawa import IKAWA_BLE # pylint: disable=unused-import
@@ -1428,6 +1429,7 @@ class ApplicationWindow(QMainWindow):
     santokerSendMessageSignal = pyqtSignal(bytes,int)
     kaleidoSendMessageSignal = pyqtSignal(str,str)
     kaleidoSendMessageAwaitSignal = pyqtSignal(str,str,int,int)
+    orbiterSendMessageSignal = pyqtSignal(bytes,bytes,bytes)
     addEventSignal = pyqtSignal(int,int,bool,bool,bool)
     addRawEventSignal = pyqtSignal(int,float,int,bool,bool,bool)
     updateMessageLogSignal = pyqtSignal()
@@ -1840,6 +1842,9 @@ def __init__(self, parent:QWidget|None = None, *, locale:str, WebEngineSupport:b
         self.kaleido:KaleidoPort|None = None # holds the Kaleido instance created on connect; reset to None on disconnect
         self.kaleidoEventFlags:list[bool] = [False, False, False, False, False, False, False ] # CHARGE, DRY, FCs, FCe, SCs, SCe, DROP
 
+        # Orbiter
+        self.orbiter:Orbiter|None = None # holds the Orbiter instance created on connect; reset to None on disconnect
+
         # Ikawa BLE
         self.ikawa:'IKAWA_BLE|None' = None # noqa: UP037
 
@@ -4277,6 +4282,7 @@ def __init__(self, parent:QWidget|None = None, *, locale:str, WebEngineSupport:b
         self.santokerSendMessageSignal.connect(self.santokerSendMessage)
         self.kaleidoSendMessageSignal.connect(self.kaleidoSendMessage)
         self.kaleidoSendMessageAwaitSignal.connect(self.kaleidoSendMessageAwait)
+        self.orbiterSendMessageSignal.connect(self.orbiterSendMessage)
         self.addEventSignal.connect(self.addEventSlot, type=Qt.ConnectionType.QueuedConnection) # type: ignore[call-arg]
         self.addRawEventSignal.connect(self.addRawEventSlot, type=Qt.ConnectionType.QueuedConnection) # type: ignore[call-arg]
            # by default the connection type is AutoConnection (If the emitter & receiver are in the same thread, a DirectConnection is used. Otherwise, a QueuedConnection is used.)
@@ -5945,7 +5951,7 @@ def openMachineSettings(self, _checked:bool = False) -> None:
                             self.mugmaHost = host
                         else:
                             res = False
-                    elif (self.qmc.device in {0, 9, 19, 53, 101, 115, 126} or ((self.qmc.device == 29 or 29 in self.qmc.extradevices) and self.modbus.type in {0, 1, 2}) or
+                    elif (self.qmc.device in {0, 9, 19, 53, 101, 115, 126, 196} or ((self.qmc.device == 29 or 29 in self.qmc.extradevices) and self.modbus.type in {0, 1, 2}) or
                             (self.qmc.device == 134 and self.santokerSerial and not self.santokerBLE) or
                             (self.qmc.device == 138 and self.kaleidoSerial)): # Fuji, Center301, TC4, Hottop, Behmor or MODBUS serial, HB/ARC
                         select_device_name = None
@@ -9551,6 +9557,30 @@ def eventaction_internal(self, action:int, cmd:str, eventtype:int|None) -> None:
                                                 # send message, await new value and create an event with the new value
                                                 self.kaleidoSendMessageAwaitSignal.emit(target, vs, eventtype, lastbuttonpressed)
 
+
+                                ##  orbiter(<cmd>[,<value>[,<param>]]) : <cmd>: command (1 byte in hex syntax), optional: <value> a 16bit positive number, <param> a number 0-255
+                                #     ex: orbiter(0D,7) => set heater power to 7
+                                elif c.startswith('orbiter'):
+                                    if self.orbiter is not None:
+                                        args = c[len('orbiter'):]
+                                        if args.startswith('(') and args.endswith(')'):
+                                            parts = args[1:-1].split(',')
+                                            try:
+                                                if len(parts) > 0:
+                                                    orbiter_cmd:bytes = bytes.fromhex(parts[0])
+                                                    orbiter_data:bytes
+                                                    if len(parts) > 2:
+                                                        orbiter_param = min(255, max(0, int(round(float(parts[2]))))).to_bytes(1, 'little')
+                                                    else:
+                                                        orbiter_param = b'\x00'
+                                                    if len(parts) > 1:
+                                                        orbiter_data = min(65535, max(0, int(round(float(parts[1]))))).to_bytes(2, 'little')
+                                                    else:
+                                                        orbiter_data = b'\x00\x00'
+                                                    self.orbiterSendMessageSignal.emit(orbiter_cmd, orbiter_data, orbiter_param)
+                                            except Exception as e: # pylint: disable=broad-except
+                                                _log.error(e)
+
                                 ##  shellyrelay(n,b) : switches Shelly plug number <n> ON if b is true or 1, and OFF otherwise
                                 elif c.startswith('shellyrelay'):
                                     cs_a = re.findall(r'[0-9a-zA-Z-.:]+', c)
@@ -17798,6 +17828,12 @@ def kaleidoSendMessage(self, target:str, value:str) -> None:
         if self.kaleido is not None:
             self.kaleido.send_msg(target, value)
 
+    # orbiterSendMessage() just sends out the message to the machine without waiting for a response
+    @pyqtSlot(bytes,bytes,bytes)
+    def orbiterSendMessage(self, cmd:bytes, data:bytes, param:bytes) -> None:
+        if self.orbiter is not None:
+            self.orbiter.send_msg(cmd, data, param)
+
     # if record is True, an event is added during recording, otherwise only the slider is moved
     # if fire_slider_action is True, the slider action is fired
     # if force is True, process even if value is equal to the events lastvalue resp. the current slider value