qlsdk2 0.4.0a2__py3-none-any.whl → 0.4.1__py3-none-any.whl

qlsdk/rsc/entity.py

@@ -1,11 +1,12 @@
 from multiprocessing import Queue, Process
 from typing import Any, Dict, Literal
-# from rsc.command import *
-from qlsdk.core import *
-from qlsdk.core.device import BaseDevice
 from threading import Thread
 from loguru import logger
-from time import time_ns
+from time import time_ns, sleep
+
+from qlsdk.core import *
+from qlsdk.core.device import BaseDevice
+from qlsdk.persist import RscEDFHandler
 
 class QLDevice(BaseDevice):
     def __init__(self, socket):
@@ -25,6 +26,10 @@ class QLDevice(BaseDevice):
         self.battery_remain = None
         # %
         self.battery_total = None
+        # persist
+        self._recording = False
+        self._storage_path = None
+        self._file_prefix = None
         
         # 可设置参数
         # 采集：采样量程、采样率、采样通道
@@ -33,6 +38,12 @@ class QLDevice(BaseDevice):
         self._sample_range:Literal[188, 375, 563, 750, 1125, 2250, 4500] = 188        
         # 采样率（Hz）：250、500、1000、2000、4000、8000、16000、32000
         self._sample_rate:Literal[250, 500, 1000, 2000, 4000, 8000, 16000, 32000] = 500
+        self._physical_max = 188000
+        self._physical_min = -188000
+        self._digital_max = 8388607
+        self._digital_min = -8388608
+        self._physical_range = 376000
+        self._digital_range = 16777215
         self._acq_channels = None
         self._acq_param = {
             "sample_range": 188,
@@ -101,6 +112,9 @@ class QLDevice(BaseDevice):
         self.__signal_consumer: Dict[str, Queue[Any]]={}
         self.__impedance_consumer: Dict[str, Queue[Any]]={}
         
+        # EDF文件处理器
+        self._edf_handler = None       
+        self.storage_enable = True 
         
         self._parser = DeviceParser(self)
         self._parser.start()
@@ -109,18 +123,45 @@ class QLDevice(BaseDevice):
         self._accept = Thread(target=self.accept)
         self._accept.daemon = True
         self._accept.start()
+        
+    def init_edf_handler(self):
+        self._edf_handler = RscEDFHandler(self.sample_rate,  self._physical_max , self._physical_min, self.resolution)  
+        self._edf_handler.set_device_type(self.device_type)
+        self._edf_handler.set_device_no(self.device_name)
+        self._edf_handler.set_storage_path(self._storage_path)
+        self._edf_handler.set_file_prefix(self._file_prefix)
+        
+    # eeg数字值转物理值
+    def eeg2phy(self, digital:int):
+        # 向量化计算（自动支持广播）
+        return ((digital - self._digital_min) / self._digital_range) * self._physical_range + self._physical_min
     
+    @property
+    def edf_handler(self):
+        if not self.storage_enable:
+            return None
+        
+        if self._edf_handler is None:
+            self.init_edf_handler() 
+            
+        return self._edf_handler  
+    
+    # 采集通道列表， 从1开始
     @property
     def acq_channels(self):
         if self._acq_channels is None:
             self._acq_channels = [i for i in range(1, 63)]
         return self._acq_channels
+    
+    # 量程范围
     @property
     def sample_range(self):
+        
         return self._sample_range if self._sample_range else 188
     @property
     def sample_rate(self):
         return self._sample_rate if self._sample_rate else 500
+    
     @property
     def resolution(self):
         return 24
@@ -132,11 +173,18 @@ class QLDevice(BaseDevice):
     @property
     def impedance_consumers(self):
         return self.__impedance_consumer
+    
+    # 设置记录文件路径
+    def set_storage_path(self, path):
+        self._storage_path = path
+       
+    # 设置记录文件名称前缀 
+    def set_file_prefix(self, prefix):
+        self._file_prefix = prefix
         
     def accept(self):
         while True:
             data = self.socket.recv(4096*1024)
-            # logger.debug(f"QLDevice接收到数据: {data.hex()}")
             if not data:
                 logger.warning(f"设备{self.device_name}连接结束")
                 break
@@ -155,35 +203,31 @@ class QLDevice(BaseDevice):
         self.stim_paradigm = param
     
     # 设置采集参数
-    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
+    def set_acq_param(self, channels, sample_rate:Literal[250, 500, 1000, 2000, 4000, 8000, 16000, 32000] = 500, sample_range:Literal[188, 375, 563, 750, 1125, 2250, 4500] = 188):
         self._acq_param["channels"] = channels 
         self._acq_param["sample_rate"] = sample_rate
         self._acq_param["sample_range"] = sample_range
         self._acq_channels = channels
         self._sample_rate = sample_rate
         self._sample_range = sample_range
+        # 根据量程更新信号物理值范围
+        self._physical_max = self._sample_range * 1000
+        self._physical_min = -self._sample_range * 1000
+        self._physical_range = self._physical_max - self._physical_min
     
-    # 通用配置
+    # 通用配置-TODO
     def set_config(self, key:str, val: str):
         pass      
         
-    def set_impedance_param(self):
-        channels = bytes.fromhex("FFFFFFFFFFFFFFFF0000000000000000000000000000000000000000000000000000")
-        sample_rate = 1000
-        sample_len = 300
-        resolution = self.resolution
-        
     def start_impedance(self):
         logger.info("启动阻抗测量")  
         msg = StartImpedanceCommand.build(self).pack()
-        # msg = bytes.fromhex("5aa50239320013243f0000001104ffffffffffffffff000000000000000000000000000000000000000000000000e8030000fa00000010000164000000a11e5aa50239320013243a00000012040000000000000000000000000000000000000000000000000000000000000000000001000000000000000325")
         logger.debug(f"start_impedance message is {msg.hex()}")
         self.socket.sendall(msg)
     
     def stop_impedance(self):
         logger.info("停止阻抗测量")  
         msg = StopImpedanceCommand.build(self).pack()
-        # msg = bytes.fromhex("5aa5023932001324100000001304e9df")
         logger.debug(f"stop_impedance message is {msg.hex()}")
         self.socket.sendall(msg)
     
@@ -192,20 +236,33 @@ class QLDevice(BaseDevice):
             logger.warning("刺激参数未设置，请先设置刺激参数")
             return
         logger.info("启动电刺激")  
-        # conf = SetStimulationParamCommand.build(self).pack()
         msg = StartStimulationCommand.build(self).pack()
         logger.debug(f"start_stimulation message is {msg.hex()}")
         self.socket.sendall(msg)
+        t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,))
+        t.start()
+        
+    def _stop_stimulation_trigger(self, duration):
+        delay = duration
+        while delay > 0:
+            sleep(1)
+            delay -= 1
+        logger.info(f"_stop_stimulation_trigger duration: {duration}")
+        if self._edf_handler:
+            self._edf_handler.trigger("stimulation should be stopped")
+        else:
+            logger.warning("trigger fail for 'stop stim'. no recording file to write")
         
     def stop_stimulation(self):
         logger.info("停止电刺激")  
-        msg = StopStimulationCommand.pack()
+        msg = StopStimulationCommand.build().pack()
         logger.debug(f"stop_stimulation message is {msg.hex()}")
         self.socket.sendall(msg)
         
     # 启动采集
-    def start_acquisition(self):
+    def start_acquisition(self, recording = True):
         logger.info("启动信号采集")  
+        self._recording = recording
         # 设置数据采集参数
         param_bytes = SetAcquisitionParamCommand.build(self).pack()
         # 启动数据采集
@@ -218,15 +275,18 @@ class QLDevice(BaseDevice):
     def stop_acquisition(self):
         logger.info("停止信号采集")  
         msg = StopAcquisitionCommand.build(self).pack()
-        logger.debug(f"stop_acquisition message is {msg}")
+        logger.debug(f"stop_acquisition message is {msg.hex()}")
         self.socket.sendall(msg)
+        if self._edf_handler:
+            # 发送结束标识
+            self.edf_handler.write(None)
         
     # 订阅实时数据
     def subscribe(self, topic:str=None, q : Queue=None, type : Literal["signal","impedance"]="signal"):  
             
         # 数据队列
         if q is None:
-            q = Queue()
+            q = Queue(maxsize=1000)
             
         # 队列名称     
         if topic is None:
@@ -248,6 +308,12 @@ class QLDevice(BaseDevice):
                 self.__impedance_consumer[topic] = q
             
         return topic, q
+    
+    def trigger(self, desc):
+        if self._edf_handler:
+            self.edf_handler.trigger(desc)
+        else:
+            logger.warning("no edf handler, no place to recording trigger")
         
     def __str__(self):
         return f''' 
@@ -303,10 +369,6 @@ class RSC64R(QLDevice):
 class ARSKindling(QLDevice):
     def __init__(self, socket):
         super().__init__(socket)
-        
-        
-        
-
 
 class DeviceParser(object):
     def __init__(self, device : QLDevice):
@@ -318,7 +380,7 @@ class DeviceParser(object):
         
     def append(self, buffer):
         self.cache += buffer
-        logger.debug(f"append cache len: {len(self.cache)}")
+        logger.debug(f"已缓存的数据长度: {len(self.cache)}")
         
         # if not self.running:
         #     self.start()
@@ -326,14 +388,13 @@ class DeviceParser(object):
     def __parser__(self):
         logger.info("数据解析开始")
         while self.running:
-            # logger.debug(f" cache len: {len(self.cache)}")
             if len(self.cache) < 14:
                 continue
             if self.cache[0] != 0x5A or self.cache[1] != 0xA5:
                 self.cache = self.cache[1:]
                 continue
             pkg_len = int.from_bytes(self.cache[8:12], 'little')
-            logger.debug(f" cache len: {len(self.cache)}, pkg_len len: {len(self.cache)}")
+            logger.trace(f" cache len: {len(self.cache)}, pkg_len len: {len(self.cache)}")
             # 一次取整包数据
             if len(self.cache) < pkg_len:
                 continue
@@ -368,11 +429,13 @@ class TCPMessage(object):
         TCPMessage._validate_packet(data)
         # 提取指令码
         cmd_code = int.from_bytes(data[TCPMessage.CMD_POS:TCPMessage.CMD_POS+2], 'little')
-        logger.debug(f"收到指令：{hex(cmd_code)}")
         cmd_class = CommandFactory.create_command(cmd_code)
-        logger.debug(f"Command class: {cmd_class}")
+        logger.debug(f"收到指令：{cmd_class.cmd_desc}[{hex(cmd_code)}]")
         instance = cmd_class(device)
+        start = time_ns()
+        logger.debug(f"开始解析: {start}")
         instance.parse_body(data[TCPMessage.HEADER_LEN:-2])
+        logger.debug(f"解析完成:{time_ns()}, 解析耗时：{time_ns() - start}ns")
         return instance
 
     @staticmethod
@@ -388,9 +451,9 @@ class TCPMessage(object):
         if len(data) != expected_len:
             raise ValueError(f"Length mismatch: {len(data)} vs {expected_len}")
         
-        logger.debug(f"checksum: {int.from_bytes(data[-2:], 'little')}")
-        checksum = crc16(data[:-2])
-        logger.debug(f"checksum recv: {checksum}")
+        # logger.trace(f"checksum: {int.from_bytes(data[-2:], 'little')}")
+        # checksum = crc16(data[:-2])
+        # logger.trace(f"checksum recv: {checksum}")
         
         
         
@@ -402,150 +465,3 @@ class DataPacket(object):
         
     def parse_body(self, body: bytes):
         raise NotImplementedError("Subclasses should implement this method")
-  
-    
-
-class C64Channel(Enum):
-    CH0 = 0
-    CH1 = 1
-    CH2 = 2
-    CH3 = 3
-    CH4 = 4
-    CH5 = 5
-    CH6 = 6
-    CH7 = 7
-    CH8 = 8
-    CH9 = 9
-    CH10 = 10
-    CH11 = 11
-    CH12 = 12
-    CH13 = 13
-    CH14 = 14
-    CH15 = 15
-
-class WaveForm(Enum):
-    DC = 0
-    SQUARE = 1
-    AC = 2
-    CUSTOM = 3
-    PULSE = 4
-
-#  # 刺激通道 
-# class StimulationChannel(object):
-#     def __init__(self, channel_id: int, waveform: int, current: float, duration: float, ramp_up: float = None, ramp_down: float = None,
-#                  frequency: float = None, phase_position: int = None, duration_delay: float = None, pulse_width: int = None, pulse_width_rate: int = 1):
-#         self.channel_id = channel_id
-#         self.waveform = waveform
-#         self.current_max = current
-#         self.current_min = current
-#         self.duration = duration
-#         self.ramp_up = ramp_up
-#         self.ramp_down = ramp_down
-#         self.frequency = frequency
-#         self.phase_position = phase_position
-#         self.duration_delay = duration_delay
-#         self.pulse_width = pulse_width 
-#         self.delay_time = 0
-#         self.pulse_interval = 0
-#         self.with_group_repeats = 1
-#         self.pulse_width_rate = 1065353216
-#         self.pulse_time_f = 0
-#         self.pulse_time_out = 0
-#         self.pulse_time_idle = 0
-    
-#     def to_bytes(self):
-#         # Convert the object to bytes for transmission
-#         result = self.channel_id.to_bytes(1, 'little')
-#         wave_form = WaveForm.SQUARE.value if self.waveform == WaveForm.PULSE.value else self.waveform
-#         result += wave_form.to_bytes(1, 'little')
-#         result += int(self.current_max * 1000 * 1000).to_bytes(4, 'little')
-#         # result += int(self.current_min * 1000).to_bytes(2, 'little')
-#         result += int(self.frequency).to_bytes(2, 'little')
-#         result += int(self.pulse_width).to_bytes(2, 'little')
-#         result += int(self.pulse_width_rate).to_bytes(4, 'little')
-        
-#         result += int(self.pulse_interval).to_bytes(2, 'little')
-#         result += int(self.with_group_repeats).to_bytes(2, 'little')
-#         result += int(self.pulse_time_f).to_bytes(4, 'little')
-#         result += int(self.pulse_time_out).to_bytes(4, 'little')
-#         result += int(self.pulse_time_idle).to_bytes(4, 'little')
-        
-#         result += int(self.delay_time).to_bytes(4, 'little')
-#         result += int(self.ramp_up * 1000).to_bytes(4, 'little')
-#         result += int((self.duration + self.ramp_up)  * 1000).to_bytes(4, 'little')
-#         result += int(self.ramp_down * 1000).to_bytes(4, 'little')
-        
-#         return result
-    
-#     def to_json(self):
-#         return {
-#             "channel_id": self.channel_id,
-#             "waveform": self.waveform,
-#             "current_max": self.current_max,
-#             "current_min": self.current_min,
-#             "duration": self.duration,
-#             "ramp_up": self.ramp_up,
-#             "ramp_down": self.ramp_down,
-#             "frequency": self.frequency,
-#             "phase_position": self.phase_position,
-#             "duration_delay": self.duration_delay,
-#             "pulse_width": self.pulse_width,
-#             "delay_time": self.delay_time,
-#             "pulse_interval": self.pulse_interval,
-#             "with_group_repeats": self.with_group_repeats
-#         }
-        
-# # 刺激范式
-# class StimulationParadigm(object):
-#     def __init__(self):
-#         self.channels = None
-#         self.duration = None
-#         self.interval_time = 0
-#         self.characteristic = 0
-#         self.mode = 0
-#         self.repeats = 0
-        
-#     def add_channel(self, channel: StimulationChannel, update=False):
-#         if self.channels is None:
-#             self.channels = {}
-#         channel_id = channel.channel_id + 1
-#         if channel_id in self.channels.keys():
-#             logger.warning(f"Channel {channel_id} already exists")
-#             if update:
-#                 self.channels[channel_id] = channel
-#         else:
-#             self.channels[channel_id] = channel  
-            
-#         # 计算刺激时间
-#         duration = channel.duration + channel.ramp_up + channel.ramp_down     
-#         if self.duration is None or duration > self.duration:
-#             self.duration = duration 
-        
-        
-#     def to_bytes(self):
-#         result = to_bytes(list(self.channels.keys()), 64)
-#         result += int(self.duration * 1000).to_bytes(4, 'little')
-#         result += int(self.interval_time).to_bytes(4, 'little')
-#         result += int(self.characteristic).to_bytes(4, 'little')
-#         result += int(self.mode).to_bytes(1, 'little')
-#         result += int(self.repeats).to_bytes(4, 'little')
-#         for channel in self.channels.values():
-#             result += channel.to_bytes()
-#         return result
-    
-#     def to_json(self):
-#         # Convert the object to JSON for transmission
-#         return {
-#             "channels": list(self.channels.keys()),
-#             "duration": self.duration,
-#             "interval_time": self.interval_time,
-#             "characteristic": self.characteristic,
-#             "mode": self.mode,
-#             "repeats": self.repeats, 
-#             "stim": [channel.to_json() for channel in self.channels.values()]
-#         }
-        
-    # @staticmethod
-    # def from_json(param: Dict[str, Any]):
-    #     pass
-

qlsdk/rsc/interface/__init__.py

@@ -0,0 +1,3 @@
+from .device import *
+from .parser import *
+from .handler import *

qlsdk/rsc/interface/command.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+class ICommand(ABC):
+    def __init__(self):
+        super().__init__()
+        
+        
+    @abstractmethod
+    def append(self, buffer):
+        pass 

qlsdk/rsc/interface/device.py

@@ -0,0 +1,107 @@
+from abc import ABC, abstractmethod
+import abc
+
+class  IDevice(ABC):     
+    
+    @property
+    @abc.abstractmethod   
+    def device_type(self) -> int:
+        pass
+    
+    def set_device_type(self, value: int):
+        pass
+    
+    @property
+    def device_no(self) -> str:
+        pass
+    
+    def set_device_no(self, value: str):
+        pass
+    
+    def from_parent(cls, parent) :
+        pass
+        
+    def start_implementation(self) -> None:
+        pass
+    
+    def stop_implementation(self) -> None:
+        pass
+    
+    def start_acquisition(self) -> None:
+        pass
+    
+    def stop_acquisition(self) -> None:
+        pass
+    
+    def subscribe(self, type="signal") -> None:
+        pass
+    
+    def unsubscribe(self, topic) -> None:
+        pass
+    
+    def start_stimulation(self, type="signal", duration=0) -> None:
+        pass
+    
+    def stop_stimulation(self) -> None:
+        pass
+        
+    def __eq__(self, other):
+        return self.device_id == other.device_id
+    
+    
+class RscDevice(IDevice):
+    def __init__(self, socket):
+        super().__init__(socket)
+        
+    def start_implementation(self):
+        """
+        Start the device implementation
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+    
+    def stop_implementation(self):
+        """
+        Stop the device implementation
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+    
+    def start_acquisition(self):
+        """
+        Start data acquisition
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+    
+    def stop_acquisition(self):
+        """
+        Stop data acquisition
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+    
+    def subscribe(self, type="signal"):
+        """
+        Subscribe to data of a specific type (default is "signal")
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+    
+    def unsubscribe(self, topic):
+        """
+        Unsubscribe from a specific topic
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+    
+    def start_stimulation(self, type="signal", duration=0):
+        """
+        Start stimulation of a specific type (default is "signal") for a given duration
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+    
+    def stop_stimulation(self):
+        """
+        Stop stimulation
+        """
+        raise NotImplementedError("This method should be overridden by subclasses")
+        
+class ProxyDevice(IDevice):
+    def __init__(self, socket, proxy_socket):
+        super().__init__(socket)
+        self.proxy_socket = proxy_socket

qlsdk/rsc/interface/handler.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+class IHandler(ABC):
+    def __init__(self):
+        super().__init__()        
+        
+    @abstractmethod
+    def handler(self, buffer):
+        pass 

qlsdk/rsc/interface/parser.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+class IParser(ABC):
+    def __init__(self):
+        super().__init__()        
+        
+    @abstractmethod
+    def append(self, buffer):
+        pass 

qlsdk/rsc/manager/__init__.py

@@ -0,0 +1,2 @@
+
+from .container import DeviceContainer