qlsdk2 0.6.0__py3-none-any.whl → 0.6.0a1__py3-none-any.whl

qlsdk/rsc/device/c64s1.py

@@ -1,15 +1,145 @@
+
+from multiprocessing import Queue
+from threading import Thread
+from time import sleep, time_ns
+from typing import Any, Dict, Literal
+
 from loguru import logger
 from qlsdk.persist import RscEDFHandler
-from qlsdk.rsc.interface import IDevice
+from qlsdk.rsc.interface import IDevice, IParser
 from qlsdk.rsc.command import *
+from qlsdk.rsc.parser.base import TcpMessageParser
 from qlsdk.rsc.device.base import QLBaseDevice
 
 class C64S1(QLBaseDevice):
     
-    device_type = 0x40  # C64RS-S1设备类型标识符
+    device_type = 0x40  # C64RS设备类型标识符
     
     def __init__(self, socket):
         super().__init__(socket)
+        self.socket = socket
+        
+        self._id = None
+        
+        # 设备信息
+        self.device_id = None
+        self.device_name = None
+        self._device_no = None
+        self.software_version = None
+        self.hardware_version = None
+        self.connect_time = None
+        self.current_time = None
+        # mV
+        self.voltage = None
+        # %
+        self.battery_remain = None
+        # %
+        self.battery_total = None
+        # persist
+        self._recording = False
+        self._storage_path = None
+        self._file_prefix = None
+        
+        # 可设置参数
+        # 采集：采样量程、采样率、采样通道
+        # 刺激：刺激电流、刺激频率、刺激时间、刺激通道
+        # 采样量程（mV）：188、375、563、750、1125、2250、4500
+        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 = self._sample_range * 1000  # 物理最大值（uV）
+        self._physical_min = -self._sample_range * 1000  # 物理最小值（uV）
+        self._digital_max = 8388607
+        self._digital_min = -8388608
+        self._physical_range = self._physical_max - self._physical_min
+        self._digital_range = 16777215
+        self._acq_channels = None
+        self._acq_param = {
+            "sample_range": 188,
+            "sample_rate": 500,
+            "channels": [],
+        }
+        
+        self._stim_param = {
+            "stim_type": 0,                 # 刺激类型：0-所有通道参数相同, 1: 通道参数不同
+            "channels": [],
+            "param": [{
+                    "channel_id": 0,        #通道号 从0开始                          -- 必填
+                    "waveform": 3,          #波形类型：0-直流，1-交流 2-方波 3-脉冲   -- 必填
+                    "current": 1,           #电流强度(mA)                            -- 必填
+                    "duration": 30,         #平稳阶段持续时间(s)                      -- 必填
+                    "ramp_up": 5,           #上升时间(s) 默认0
+                    "ramp_down": 5,         #下降时间(s) 默认0
+                    "frequency": 500,       #频率(Hz) -- 非直流必填
+                    "phase_position": 0,    #相位 -- 默认0
+                    "duration_delay": "0",  #延迟启动时间(s) -- 默认0
+                    "pulse_width": 0,       #脉冲宽度(us) -- 仅脉冲类型电流有效， 默认100us
+                },
+                {
+                    "channel_id": 1,        #通道号 从0开始                          -- 必填
+                    "waveform": 3,          #波形类型：0-直流，1-交流 2-方波 3-脉冲   -- 必填
+                    "current": 1,           #电流强度(mA)                            -- 必填
+                    "duration": 30,         #平稳阶段持续时间(s)                      -- 必填
+                    "ramp_up": 5,           #上升时间(s) 默认0
+                    "ramp_down": 5,         #下降时间(s) 默认0
+                    "frequency": 500,       #频率(Hz) -- 非直流必填
+                    "phase_position": 0,    #相位 -- 默认0
+                    "duration_delay": "0",  #延迟启动时间(s) -- 默认0
+                    "pulse_width": 0,       #脉冲宽度(us) -- 仅脉冲类型电流有效， 默认100us
+                }
+            ]
+        }
+        
+        self.stim_paradigm = None
+                      
+        signal_info = {
+            "param" : None,
+            "start_time" : None,
+            "finished_time" : None,
+            "packet_total" : None,
+            "last_packet_time" : None,
+            "state" : 0
+        }
+        stim_info = {
+            
+        }
+        Impedance_info = {
+            
+        }
+        # 信号采集状态
+        # 信号数据包总数（一个信号采集周期内）
+        # 信号采集参数
+        # 电刺激状态
+        # 电刺激开始时间（最近一次）
+        # 电刺激结束时间（最近一次）
+        # 电刺激参数
+        # 启动数据解析线程
+        # 数据存储状态
+        # 存储目录
+        
+        # 
+        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: IParser = TcpMessageParser(self)
+        self._parser.start()
+        
+        # 启动数据接收线程
+        self._accept = Thread(target=self.accept)
+        self._accept.daemon = True
+        self._accept.start()
+        
+    @property
+    def device_no(self):
+        return self._device_no
+    
+    @device_no.setter
+    def device_no(self, value: str):
+        self._device_no = value
     
     @classmethod
     def from_parent(cls, parent:IDevice) -> IDevice:
@@ -25,5 +155,211 @@ class C64S1(QLBaseDevice):
         self._edf_handler.set_device_no(self.device_no)
         self._edf_handler.set_storage_path(self._storage_path)
         self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'C64S1')
-        logger.debug(f"EDF Handler initialized")
-        
+        
+    @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  
+    
+    @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
+    
+    @property
+    def signal_consumers(self):
+        return self.__signal_consumer
+    
+    @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
+        
+    # 接收socket消息
+    def accept(self):
+        while True:
+            # 缓冲去4M
+            data = self.socket.recv(4096*1024)
+            if not data:
+                logger.warning(f"设备{self.device_name}连接结束")
+                break
+            
+            self._parser.append(data)
+            
+       
+    # socket发送数据    
+    def send(self, data):
+        self.socket.sendall(data)
+    
+    # 设置刺激参数
+    def set_stim_param(self, param):
+        self.stim_paradigm = param
+    
+    # 设置采集参数
+    def set_acq_param(self, channels, sample_rate = 500, sample_range = 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
+    
+    # 通用配置-TODO
+    def set_config(self, key:str, val: str):
+        pass      
+        
+    def start_impedance(self):
+        logger.info("启动阻抗测量")  
+        msg = StartImpedanceCommand.build(self).pack()
+        logger.debug(f"start_impedance message is {msg.hex()}")
+        self.socket.sendall(msg)
+    
+    def stop_impedance(self):
+        logger.info("停止阻抗测量")  
+        msg = StopImpedanceCommand.build(self).pack()
+        logger.debug(f"stop_impedance message is {msg.hex()}")
+        self.socket.sendall(msg)
+    
+    def start_stimulation(self):
+        if self.stim_paradigm is None:
+            logger.warning("刺激参数未设置，请先设置刺激参数")
+            return
+        logger.info("启动电刺激")  
+        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("stop stim trigger fail. no edf writer alive")
+        
+    def stop_stimulation(self):
+        logger.info("停止电刺激")  
+        msg = StopStimulationCommand.pack()
+        logger.debug(f"stop_stimulation message is {msg.hex()}")
+        self.socket.sendall(msg)
+        
+    # 启动采集
+    def start_acquisition(self, recording = True):
+        logger.info("启动信号采集")  
+        self._recording = recording
+        # 设置数据采集参数
+        param_bytes = SetAcquisitionParamCommand.build(self).pack()
+        # 启动数据采集
+        start_bytes = StartAcquisitionCommand.build(self).pack()
+        msg = param_bytes + start_bytes
+        logger.debug(f"start_acquisition message is {msg.hex()}")
+        self.socket.sendall(msg)
+        
+    # 停止采集
+    def stop_acquisition(self):
+        logger.info("停止信号采集")  
+        msg = StopAcquisitionCommand.build(self).pack()
+        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(maxsize=1000)
+            
+        # 队列名称     
+        if topic is None:
+            topic = f"{type}_{time_ns()}"
+        
+        # 订阅生理电信号数据
+        if type == "signal":
+            # topic唯一，用来区分不同的订阅队列（下同）
+            if topic in list(self.__signal_consumer.keys()):
+                logger.warning(f"exists {type} subscribe of {topic}")
+            else:
+                self.__signal_consumer[topic] = q
+            
+        # 订阅阻抗数据
+        if type == "impedance":
+            if topic in list(self.__signal_consumer.keys()):
+                logger.warning(f"exists {type} subscribe of {topic}")
+            else:
+                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''' 
+            Device: 
+                Name: {self.device_name}, 
+                Type: {hex(self.device_type) if self.device_type else None}, 
+                ID: {self.device_id if self.device_id else None}, 
+                Software: {self.software_version}, 
+                Hardware: {self.hardware_version}, 
+                Connect Time: {self.connect_time},
+                Current Time: {self.current_time},
+                Voltage: {str(self.voltage) + "mV" if self.voltage else None},
+                Battery Remain: {str(self.battery_remain)+ "%" if self.battery_remain else None},
+                Battery Total: {str(self.battery_total) + "%" if self.battery_total else None}
+            '''
+
+    def __repr__(self):
+        return f''' 
+            Device: 
+                Name: {self.device_name}, 
+                Type: {hex(self.device_type)}, 
+                ID: {self.device_id}, 
+                Software: {self.software_version}, 
+                Hardware: {self.hardware_version}, 
+                Connect Time: {self.connect_time},
+                Current Time: {self.current_time},
+                Voltage: {self.voltage}mV,
+                Battery Remain: {self.battery_remain}%,
+                Battery Total: {self.battery_total}%
+            '''
+
+    def __eq__(self, other):
+        return self.device_name == other.device_name and self.device_type == other.device_type and self.device_id == other.device_id
+
+    def __hash__(self):
+        return hash((self.device_name, self.device_type, self.device_id))    
+    
+    

qlsdk/rsc/interface/device.py

@@ -24,10 +24,6 @@ class  IDevice(ABC):
     @property
     def device_no(self) -> str:
         pass
-       
-    def set_impedance_channels(self):
-        raise NotImplementedError("Not Supported")
-        
     
     def read_msg(self, size: int) -> bytes:
         raise NotImplementedError("Not Supported")
@@ -65,21 +61,4 @@ class  IDevice(ABC):
         raise NotImplementedError("Not Supported")
     def disconnect(self) -> None:
         raise NotImplementedError("Not Supported")
-    
-    def set_stim_param(self, param):
-        pass
-        
-    def trigger(self, desc):
-        pass
-    
-    def enable_storage(self, enable: bool = True):
-        pass
-    
-    def set_impedance_channel(self):
-        raise NotImplementedError("Not Supported")
-    
-    def start_impedance(self):
-        raise NotImplementedError("Not Supported")
-    
-    def stop_impedance(self):
-        raise NotImplementedError("Not Supported")
+        

qlsdk/rsc/paradigm.py

@@ -61,22 +61,6 @@ class StimulationChannel(ABC):
         
         return result
     
-    def to_bytes_c256(self):        
-        result = self.channel_id.to_bytes(1, 'little')
-        result += self.wave_form.to_bytes(1, 'little')
-        
-        result += self._to_bytes_c256()
-        
-        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_bytes_c256(self):
-        return bytes.fromhex("00000000000000000000000000000000000000000000000000000000")
-    
     def _ext_bytes(self):
         return bytes.fromhex("00000000000000000000000000000000")
     
@@ -115,9 +99,6 @@ class DCStimulation(StimulationChannel):
             "delay_time": self.delay_time
         }
         
-    def _to_bytes_c256(self):
-        return int(self.current_max * 1000 ).to_bytes(2, 'little') + bytes.fromhex("0000000000000000000000000000000000000000000000000000")
-        
     def from_json(self, param):
         pass
     def __str__(self):
@@ -159,19 +140,9 @@ class SquareWaveStimulation(StimulationChannel):
         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_bytes_c256(self):
-        result = int(self.current_max * 1000000 ).to_bytes(4, 'little')
-        result += int(self.frequency).to_bytes(2, 'little')
-        result += bytes.fromhex("0000")
-        result += struct.pack('<f', self.duty_cycle)
-        result = int(self.current_min * 1000000 ).to_bytes(4, 'little')
-        result += self._ext_bytes()
-        return  result
-    
-      
-# 刺激模式-正弦
+        return result
+        
+# 刺激模式-交流
 class ACStimulation(StimulationChannel):
     '''
         channel_id: int,  通道编号，从0开始
@@ -191,8 +162,7 @@ class ACStimulation(StimulationChannel):
         self.frequency = frequency
         # self.frequency = frequency
         self.phase_position = phase_position
-        if current < 0:
-            self.phase_position = (phase_position + 180) % 360
+    
     def to_json(self):
         return {
             "channel_id": self.channel_id,
@@ -207,15 +177,6 @@ class ACStimulation(StimulationChannel):
         
     def from_json(self, param):
         pass
-    
-    def _to_bytes_c256(self):
-        result = int(self.current_max * 1000 ).to_bytes(2, 'little')
-        result += bytes.fromhex("0000")
-        result += struct.pack('<f', self.frequency)
-        result += struct.pack('<f', self.phase_position)
-        result += self._ext_bytes()
-        return  result
-    
     def __str__(self):
         return f"ACStimulation(channel_id={self.channel_id}, waveform={self.waveform}, current={self.current_max}, 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})"
         
@@ -269,15 +230,6 @@ class PulseStimulation(StimulationChannel):
         
         return result
     
-    def _to_bytes_c256(self):
-        result = int(self.current_max * 1000000 ).to_bytes(4, 'little')
-        result += int(self.frequency).to_bytes(2, 'little')
-        result += bytes.fromhex("0000")
-        result += struct.pack('<f', self.duty_cycle)
-        result = int(self.current_min * 1000000 ).to_bytes(4, 'little')
-        result += self._ext_bytes()
-        return  result
-    
     def to_json(self):
         return {
             "channel_id": self.channel_id,
@@ -299,80 +251,6 @@ class PulseStimulation(StimulationChannel):
         
 # 刺激范式
 class StimulationParadigm(object):
-    def __init__(self):
-        self.channels = None
-        self.duration = None
-        self.interval_time = 25000
-        self.characteristic = 1
-        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_bytes_c256(self):
-        result = to_bytes(list(self.channels.keys()), 256)
-        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
-    
-    def clear(self):
-        self.channels = None
-        self.duration = None
-        self.interval_time = 25000
-        self.characteristic = 1
-        self.mode = 0
-        self.repeats = 0
-
-
-# 刺激范式
-class C256StimulationParadigm(object):
     def __init__(self):
         self.channels = None
         self.duration = None
@@ -431,4 +309,5 @@ class C256StimulationParadigm(object):
         self.interval_time = 0
         self.characteristic = 1
         self.mode = 0
-        self.repeats = 0
+        self.repeats = 0
+

qlsdk/rsc/parser/base.py

@@ -53,7 +53,7 @@ class TcpMessageParser(IParser):
                 buf_len = get_len(self.buffer)
                 
                 if buf_len < self.header_len:
-                    # logger.trace(f"等待数据中...: expect: {self.header_len}, actual: {buf_len}")
+                    logger.trace(f"等待数据中...: expect: {self.header_len}, actual: {buf_len}")
                     if not self.__fill_from_cache():
                         time.sleep(0.1)
                         continue
@@ -64,7 +64,7 @@ class TcpMessageParser(IParser):
                 start_pos = self.buffer.tell()
                 head = self.buffer.read(2)
                 if head != self.header:
-                    # logger.trace(f"数据包头部不匹配: {head.hex()}, 期望: {self.header.hex()},继续查找...")
+                    logger.debug(f"数据包头部不匹配: {head.hex()}, 期望: {self.header.hex()},继续查找...")
                     self.buffer.seek(start_pos + 1)  # 移动到下一个字节
                     continue
                 
@@ -131,15 +131,10 @@ class TcpMessageParser(IParser):
     
     def unpack(self, packet):        
         # 提取指令码
-        cmd_code = None
-        try:
-            cmd_code = int.from_bytes(packet[self.cmd_pos : self.cmd_pos + 2], 'little')
-            cmd_class = CommandFactory.create_command(cmd_code)
-            instance = cmd_class(self.device)
-            instance.parse_body(packet[self.header_len:-2])
-        except Exception as e:
-            logger.error(f"指令[{cmd_code}]数据包[len={len(packet)}]解析异常: {e}")
-            
+        cmd_code = int.from_bytes(packet[self.cmd_pos : self.cmd_pos + 2], 'little')
+        cmd_class = CommandFactory.create_command(cmd_code)
+        instance = cmd_class(self.device)
+        instance.parse_body(packet[self.header_len:-2])
         return instance
             
     def start(self):

{qlsdk2-0.6.0.dist-info → qlsdk2-0.6.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: qlsdk2
-Version: 0.6.0
+Version: 0.6.0a1
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun
@@ -10,17 +10,21 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Microsoft :: Windows :: Windows 10
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: loguru >=0.6.0
-Requires-Dist: numpy >=1.23.5
-Requires-Dist: bitarray >=1.5.3
+Requires-Dist: loguru>=0.6.0
+Requires-Dist: numpy>=1.23.5
+Requires-Dist: bitarray>=1.5.3
 Provides-Extra: dev
-Requires-Dist: pytest >=6.0 ; extra == 'dev'
-Requires-Dist: twine >=3.0 ; extra == 'dev'
-
-## **v0.6.0 (2025-xx-xx)
-#### 新设备
-- C256RS设备
-
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: twine>=3.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ## **v0.5.1.1** (2025-08-24)
 #### 🐛 Bug Fixed