meerk40t 0.9.3001__py2.py3-none-any.whl → 0.9.7020__py2.py3-none-any.whl

meerk40t/ruida/serial_connection.py

@@ -0,0 +1,116 @@
+"""
+Serial Connection
+
+Registers the serial connection using pyserial to talk with the serial devices.
+"""
+
+import serial
+from serial import SerialException
+
+
+class SerialConnection:
+    def __init__(self, service):
+        self.service = service
+        self.controller = service.driver.controller
+        self.laser = None
+        self.read_buffer = bytearray()
+
+        name = self.service.safe_label
+        self.recv = service.channel(f"{name}/recv", pure=True)
+        self.send = service.channel(f"{name}/send", pure=True)
+        self.events = service.channel(f"{name}/events", pure=True)
+        self.is_shutdown = False
+
+    def shutdown(self, *args, **kwargs):
+        self.is_shutdown = True
+
+    def open(self):
+        if self.connected:
+            return
+
+        signal_load = "uninitialized"
+        try:
+            self.events("Attempting to Connect...")
+            serial_port = self.service.serial_port
+            if serial_port == "UNCONFIGURED":
+                self.events("Laser port is not set.")
+                signal_load = "error"
+                self.service.signal(
+                    "warning",
+                    "Serial Port is not set. Go to config, select the serial port for this device.",
+                    "Serial Port: UNCONFIGURED",
+                )
+                return
+
+            baud_rate = self.service.baud_rate
+            self.laser = serial.Serial(
+                serial_port,
+                baud_rate,
+                timeout=0,
+            )
+            self.events("Connected")
+
+            self.service.threaded(
+                self._run_serial_listener,
+                thread_name=f"thread-{self.service.safe_label}",
+                daemon=True,
+            )
+            self.service.signal("pipe;usb_status", "connected")
+            self.events("Connected")
+
+            signal_load = "connected"
+        except ConnectionError:
+            self.events("Connection Failed.")
+        except SerialException as e:
+            self.events("Serial connection could not be established.")
+            self.events(str(e))
+
+        self.service.signal("ruida;status", signal_load)
+
+    def close(self):
+        if not self.connected:
+            return
+        self.events("Disconnected")
+        self.laser.close()
+        del self.laser
+        self.laser = None
+        self.service.signal("pipe;usb_status", "disconnected")
+
+    @property
+    def connected(self):
+        return self.laser is not None
+
+    @property
+    def is_connecting(self):
+        return False
+
+    def abort_connect(self):
+        pass
+
+    def write(self, line, retry=0):
+        if not self.connected:
+            self.open()
+        try:
+            self.laser.write(line)
+            self.send(line)
+        except (SerialException, PermissionError, TypeError, AttributeError) as e:
+            # Type error occurs when `pipe_abort_write_r` is none, inside serialpostix.read() (out of sequence close)
+            self.events(f"Error when writing '{line}: {str(e)}'")
+            if retry > 5:
+                return
+            self.close()
+            self.open()
+            self.write(line, retry + 1)
+
+    def _run_serial_listener(self):
+        try:
+            while self.connected and not self.is_shutdown:
+                try:
+                    message = self.laser.read(self.laser.in_waiting)
+                    if message:
+                        self.recv(message)
+                except (SerialException, AttributeError, OSError, TypeError):
+                    pass
+
+        except OSError:
+            pass

meerk40t/ruida/tcp_connection.py

@@ -0,0 +1,146 @@
+"""
+TCP Connection handles Ruida TCP data sending and receiving and the Ruida Bridge Protocol.
+
+"""
+
+import socket
+import struct
+import threading
+import time
+
+
+class TCPConnection:
+    def __init__(self, service):
+        self.service = service
+        name = self.service.label.replace(" ", "-")
+        name = name.replace("/", "-")
+
+        self.recv_channel = service.channel(f"{name}/recv", pure=True)
+        self.send_channel = service.channel(f"{name}/send", pure=True)
+        self.events = service.channel(f"{name}/events", pure=True)
+
+        self.is_shutdown = False
+        self.socket = None
+        self._send_lock = threading.Condition()
+        self.buffer = bytearray()
+        self.thread = None
+
+    @property
+    def port(self):
+        return self.service.tcp_port
+
+    def address(self):
+        return self.service.tcp_address
+
+    def shutdown(self, *args, **kwargs):
+        self.is_shutdown = True
+
+    def open(self):
+        if self.connected:
+            return
+        try:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            # Make sure port is in a valid range...
+            port = min(65535, max(0, self.service.port))
+            self.socket.connect((self.service.address, port))
+            self.service.signal("tcp;status", "connected")
+            name = self.service.label.replace(" ", "-")
+            name = name.replace("/", "-")
+            self.service.threaded(
+                self._run_tcp_send, thread_name=f"tcpsend-{name}", daemon=True
+            )
+            self.service.threaded(
+                self.run_tcp_recv, thread_name=f"tcprecv-{name}", daemon=True
+            )
+            self.service.signal("pipe;usb_status", "connected")
+            self.events("Connected")
+        except TimeoutError:
+            self.close()
+            self.service.signal("tcp;status", "timeout connect")
+        except ConnectionError:
+            self.close()
+            self.service.signal("tcp;status", "connection error")
+        except (socket.gaierror, OverflowError) as e:
+            self.close()
+            self.service.signal("tcp;status", "address resolve error")
+        except socket.herror as e:
+            self.close()
+            self.service.signal("tcp;status", f"herror: {str(e)}")
+        except OSError as e:
+            self.close()
+            self.service.signal("tcp;status", f"Host down {str(e)}")
+
+    def close(self):
+        if not self.connected:
+            return
+        self.socket.close()
+        self.socket = None
+        self.service.signal("pipe;usb_status", "disconnected")
+        self.events("Disconnected")
+
+    @property
+    def is_connecting(self):
+        return False
+
+    @property
+    def connected(self):
+        return not self.is_shutdown and self.socket is not None
+
+    def abort_connect(self):
+        pass
+
+    def write(self, data):
+        """
+        Process not only the checksum for UDP but the `L<length>` preamble for the TCP.
+        @param data:
+        @return:
+        """
+        self.open()
+        data = (
+            b"L"
+            + struct.pack(">H", len(data) & 0xFFFF)
+            + struct.pack(">H", sum(data) & 0xFFFF)
+            + data
+        )
+        with self._send_lock:
+            self.buffer += data
+            self._send_lock.notify()
+
+    def _run_tcp_send(self):
+        tries = 0
+        while self.connected:
+            try:
+                if not self.buffer:
+                    if self.socket is None:
+                        self.open()
+                        if self.socket is None:
+                            return
+                    with self._send_lock:
+                        sent = self.socket.send(self.buffer)
+                        packet = self.buffer[:sent]
+                        del self.buffer[:sent]
+                        self.service.signal("tcp;buffer", len(self.buffer))
+                        self.send_channel(packet)
+                    tries = 0
+                else:
+                    tries += 1
+                    time.sleep(0.1)
+            except (ConnectionError, OSError):
+                tries += 1
+                self.close()
+                time.sleep(0.05)
+            if tries >= 20:
+                with self._send_lock:
+                    if len(self.buffer) == 0:
+                        break
+
+    def run_tcp_recv(self):
+        try:
+            while self.connected:
+                try:
+                    message, address = self.socket.recv(1024)
+                except (socket.timeout, AttributeError):
+                    continue
+                self.recv_channel(message)
+        except OSError:
+            pass

meerk40t/ruida/udp_connection.py

@@ -0,0 +1,73 @@
+"""
+UDP Connection handles Ruida UDP data sending and receiving and the Ruida protocols therein.
+"""
+
+import socket
+import struct
+
+
+class UDPConnection:
+    def __init__(self, service):
+        self.service = service
+        name = self.service.safe_label
+        self.recv = service.channel(f"{name}/recv", pure=True)
+        self.send = service.channel(f"{name}/send", pure=True)
+        self.events = service.channel(f"{name}/events", pure=True)
+        self.is_shutdown = False
+        self.recv_address = None
+        self.socket = None
+
+    def shutdown(self, *args, **kwargs):
+        self.is_shutdown = True
+
+    def open(self):
+        if self.connected:
+            return
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.socket.settimeout(4)
+        self.socket.bind(("", 40200))
+
+        name = self.service.safe_label
+        self.service.threaded(
+            self._run_udp_listener, thread_name=f"thread-{name}", daemon=True
+        )
+        self.service.signal("pipe;usb_status", "connected")
+        self.events("Connected")
+
+    def close(self):
+        if not self.connected:
+            return
+        self.socket.close()
+        self.socket = None
+        self.service.signal("pipe;usb_status", "disconnected")
+        self.events("Disconnected")
+
+    @property
+    def is_connecting(self):
+        return False
+
+    @property
+    def connected(self):
+        return not self.is_shutdown and self.socket is not None
+
+    def abort_connect(self):
+        pass
+
+    def write(self, data):
+        self.open()
+        data = struct.pack(">H", sum(data) & 0xFFFF) + data
+        self.socket.sendto(data, (self.service.address, 50200))
+        self.send(data)
+
+    def _run_udp_listener(self):
+        try:
+            while self.connected:
+                try:
+                    message, address = self.socket.recvfrom(1024)
+                except (socket.timeout, AttributeError):
+                    continue
+                if address is not None:
+                    self.recv_address = address
+                self.recv(message)
+        except OSError:
+            pass