Initial commit

unilabos/device_comms/universal_driver.py

@@ -0,0 +1,228 @@
+
+from abc import abstractmethod
+from functools import wraps
+import inspect
+import json
+import logging
+import queue
+from socket import socket
+import threading
+import time
+import traceback
+from typing import Optional
+
+import serial
+
+class SingleRunningExecutor(object):
+    """
+    异步执行单个任务，不允许重复执行，通过class的函数获得唯一任务名的实例
+    需要对
+    """
+    __instance = {}
+
+    @classmethod
+    def get_instance(cls, func, post_func=None, name=None, *var, **kwargs):
+        print(f"!!!get_instance: {name} {kwargs}")
+        if name is None:
+            name = func.__name__
+        if name not in cls.__instance:
+            cls.__instance[name] = cls(func, post_func, *var, **kwargs)
+        return cls.__instance[name]
+
+    start_time: float = None
+    end_time: float = None
+    is_running: bool = None
+    is_error: bool = None
+    is_success: bool = None
+
+    @property
+    def is_ended(self):
+        return not self.is_running and (self.is_error or self.is_success)
+    
+    @property
+    def is_started(self):
+        return self.is_running or self.is_error or self.is_success
+    
+    def reset(self):
+        self.start_time = None
+        self.end_time = None
+        self.is_running = False
+        self.is_error = False
+        self.is_success = False
+        self._final_var = {}
+        self._thread = threading.Thread(target=self._execute)
+
+    def __init__(self, func, post_func=None, *var, **kwargs):
+        self._func = func
+        self._post_func = post_func
+        self._sig = inspect.signature(self._func)
+        self._var = var
+        self._kwargs = kwargs
+        self.reset()
+
+    def _execute(self):
+        res = None
+        try:
+            for ind, i in enumerate(self._var):
+                self._final_var[list(self._sig.parameters.keys())[ind]] = i  
+            for k, v in self._kwargs.items():
+                if k in self._sig.parameters.keys():
+                    self._final_var[k] = v
+            self.is_running = True
+            print(f"!!!_final_var: {self._final_var}")
+            res = self._func(**self._final_var)
+        except Exception as e:
+            self.is_running = False
+            self.is_error = True
+            traceback.print_exc()
+        if callable(self._post_func):
+            self._post_func(res, self._final_var)
+
+    def start(self, **kwargs):
+        if len(kwargs) > 0:
+            self._kwargs = kwargs
+        self.start_time = time.time()
+        self._thread.start()
+
+    def join(self):
+        if self.is_running: 
+            self._thread.join()
+            self.end_time = time.time()
+
+
+def command(func):
+    """
+    Decorator for command_set execution. Checks if the method is called in the same thread as the class instance,
+    if so enqueues the command_set and waits for a reply in the reply queue. Else it concludes it must be the command
+    handler thread and actually executes the method. This way methods in the child classes need to be written
+    just once and decorated accordingly.
+    :return: decorated method
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        device_instance = args[0]
+        if threading.get_ident() == device_instance.current_thread:
+            command_set = [func, args, kwargs]
+            device_instance.command_queue.put(command_set)
+            while True:
+                if not device_instance.reply_queue.empty():
+                    return device_instance.reply_queue.get()
+        else:
+            return func(*args, **kwargs)
+
+    return wrapper
+
+
+
+class UniversalDriver(object):
+    def _init_logger(self):
+        self.logger = logging.getLogger(f"{self.__class__.__name__}_logger")
+
+    def __init__(self):
+        self._init_logger()
+    
+    def execute_command_from_outer(self, command: str):
+        try:
+            command = json.loads(command.replace("'", '"').replace("False", "false").replace("True", "true"))  # 要求不能出现'作为字符串
+        except Exception as e:
+            print(f"Json解析失败: {e}")
+            return False
+        for k, v in command.items():
+            print(f"执行{k}方法，参数为{v}")
+            try:
+                getattr(self, k)(**v)
+            except Exception as e:
+                print(f"执行{k}方法失败: {e}")
+                traceback.print_exc()
+                return False
+        return True
+    
+
+class TransportDriver(UniversalDriver):
+    COMMAND_QUEUE_ENABLE = True
+    command_handler_thread: Optional[threading.Thread] = None
+    __connection: Optional[serial.Serial | socket] = None
+
+
+    def _init_command_queue(self):
+        self.command_queue = queue.Queue()
+        self.reply_queue = queue.Queue()
+
+    def __command_handler_daemon(self):
+        while True:
+            try:
+                if not self.command_queue.empty():
+                    command_item = self.command_queue.get()
+                    method = command_item[0]
+                    arguments = command_item[1]
+                    keywordarguments = command_item[2]
+                    reply = method(*arguments, **keywordarguments)
+                    self.reply_queue.put(reply)
+                else:
+                    self.keepalive()
+            except ValueError as e:
+                # workaround if something goes wrong with the serial connection
+                # future me will certainly not hate past me for this...
+                self.logger.critical(e)
+                self.__connection.flush()
+                # thread-safe purging of both queues
+                while not self.command_queue.empty():
+                    self.command_queue.get()
+                while not self.reply_queue.empty():
+                    self.reply_queue.get()
+
+    def launch_command_handler(self):
+        if self.COMMAND_QUEUE_ENABLE:
+            self.command_handler_thread = threading.Thread(target=self.__command_handler_daemon, name="{0}_command_handler".format(self.device_name), daemon=True)
+            self.command_handler_thread.start()
+
+    @abstractmethod
+    def open_connection(self):
+        pass
+
+    @abstractmethod
+    def close_connection(self):
+        pass
+
+    @abstractmethod
+    def keepalive(self):
+        pass
+
+    def __init__(self):
+        super().__init__()
+        if self.COMMAND_QUEUE_ENABLE:
+            self.launch_command_handler()
+
+
+class DriverChecker(object):
+    def __init__(self, driver, interval: int | float):
+        self.driver = driver
+        self.interval = interval
+        self._thread = threading.Thread(target=self._monitor)
+        self._thread.daemon = True
+        self._stop_event = threading.Event()
+
+    def _monitor(self):
+        while not self._stop_event.is_set():
+            try:
+                # print(self.__class__.__name__, "Started!")
+                self.check()
+            except Exception as e:
+                print(f"Error in {self.__class__.__name__}: {str(e)}")
+                traceback.print_exc()
+            finally:
+                time.sleep(self.interval)
+
+    @abstractmethod
+    def check(self):
+        """子类必须实现此方法"""
+        raise NotImplementedError
+
+    def start_monitoring(self):
+        self._thread.start()
+
+    def stop_monitoring(self):
+        self._stop_event.set()
+        self._thread.join()
+