qlsdk2 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

qlsdk/rsc/command/__init__.py

@@ -51,15 +51,29 @@ class DeviceCommand(abc.ABC):
         device_id = int(self.device.device_id) if self.device and self.device.device_id else 0
         device_type = int(self.device.device_type) if self.device and self.device.device_type else 0
         
-        """构建消息头"""
-        return (
-            DeviceCommand.HEADER_PREFIX
-            + int(2).to_bytes(1, 'little')     # pkgType  
-            + device_type.to_bytes(1, 'little')
-            + device_id.to_bytes(4, 'little')
-            + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
-            + self.cmd_code.to_bytes(2, 'little')
-        )
+        #兼容设计
+        b_device_type = None
+        if device_type > 0xFF:
+            b_device_type = int.to_bytes(device_type, 2, 'little')
+        
+        if b_device_type is None:
+            return (
+                DeviceCommand.HEADER_PREFIX
+                + int(2).to_bytes(1, 'little')     # pkgType  
+                + device_type.to_bytes(1, 'little')
+                + device_id.to_bytes(4, 'little')
+                + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
+                + self.cmd_code.to_bytes(2, 'little')
+            )
+        else:
+            return (
+                DeviceCommand.HEADER_PREFIX
+                + b_device_type[0].to_bytes(1, 'little')     # pkgType  
+                + b_device_type[1].to_bytes(1, 'little')
+                + device_id.to_bytes(4, 'little')
+                + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
+                + self.cmd_code.to_bytes(2, 'little')
+            )
     
     def unpack(self, payload: bytes) -> bytes:
         """解析消息体"""
@@ -70,7 +84,7 @@ class DeviceCommand(abc.ABC):
         time = int.from_bytes(body[0:8], 'little')
         # result - 1B
         result = body[8]
-        logger.info(f"[{time}]{self.cmd_desc}{'成功' if result == 0 else '失败'}")
+        logger.debug(f"[{time}]{self.cmd_desc}{'成功' if result == 0 else '失败'}")
         
     
 
@@ -165,15 +179,9 @@ class SetAcquisitionParamCommand(DeviceCommand):
     cmd_code = 0x451
     cmd_desc = "设置信号采集参数"
     
-    def pack_body(self):
-        body = to_bytes(self.device.acq_channels) 
-        body += self.device.sample_range.to_bytes(4, byteorder='little')
-        body += self.device.sample_rate.to_bytes(4, byteorder='little')
-        body += self.device.sample_num.to_bytes(4, byteorder='little')
-        body += self.device.resolution.to_bytes(1, byteorder='little')
-        body += bytes.fromhex('00')        
+    def pack_body(self): 
 
-        return body
+        return self.device.gen_set_acquirement_param()
         
 # 启动采集
 class StartAcquisitionCommand(DeviceCommand):
@@ -300,18 +308,8 @@ class SignalDataCommand(DeviceCommand):
         # 解析数据包
         packet = RscPacket()
         packet.transfer(body)  
-        
-        # 文件写入到edf
-        if self.device.edf_handler:
-            self.device.edf_handler.write(packet)
-                        
-        if len(self.device.signal_consumers) > 0 :
-            # 信号数字值转物理值
-            packet.eeg = self.device.eeg2phy(np.array(packet.eeg))
-            
-            # 发送数据包到订阅者
-            for q in list(self.device.signal_consumers.values()):
-                q.put(packet)
+        # 将数据包传递给设备
+        self.device.produce(packet)
                 
             
 

qlsdk/rsc/device/__init__.py

@@ -1,2 +1,7 @@
 from .base import QLBaseDevice
-from .device_factory import DeviceFactory
+from .device_factory import DeviceFactory
+
+# import devices
+from .c64_rs import C64RS
+from .c16_rs import C16RS
+from .arskindling import ARSKindling

qlsdk/rsc/device/arskindling.py

@@ -0,0 +1,386 @@
+
+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 ARSKindlingEDFHandler
+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 ARSKindling(QLBaseDevice):
+    
+    device_type = 0x60 # 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.start_message_listening()
+        # self.start()
+        # self.parser.set_device(self)
+        
+        self.channel_mapping = {
+            "A1": 55, "A2": 56, "A3": 53, "A4": 54, "A5": 51, "A6": 52, "A7": 49, "A8": 50,
+            "A9": 57, "A10": 58, "A11": 59, "A12": 60, "A13": 61, "A14": 62, 
+            
+            "B1": 39, "B2": 40,  "B3": 37, "B4": 38, "B5": 35, "B6": 36, "B7": 33, "B8": 34,
+            "B9": 41, "B10": 42, "B11": 43, "B12": 44, "B13": 45, "B14": 46, 
+            
+            "C1": 23, "C2": 24, "C3": 21, "C4": 22, "C5": 19, "C6": 20, "C7": 17, "C8": 18,
+            "C9": 25, "C10": 26, "C11": 27, "C12": 28, "C13": 29, "C14": 30, 
+            
+            "D1": 7, "D2": 8, "D3": 5, "D4": 6, "D5": 3, "D6": 4, "D7": 1, "D8": 2,
+            "D9": 9, "D10": 10, "D11": 11, "D12": 12, "D13": 13, "D14": 14, 
+        }
+        
+    @property
+    def device_no(self):
+        return self._device_no
+    
+    @device_no.setter
+    def device_no(self, value: str):
+        self._device_no = value
+    
+    @property
+    def parser(self) -> IParser:
+        return self._parser
+    
+    @classmethod
+    def from_parent(cls, parent:IDevice) -> IDevice:
+        rlt = cls(parent.socket)
+        rlt.device_id = parent.device_id
+        rlt._device_no = parent.device_no
+        return rlt
+        
+    def init_edf_handler(self):
+        self._edf_handler = ARSKindlingEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
+        self._edf_handler.set_device_type(self.device_type)
+        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 'ARS')
+        
+    @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_no}连接结束")
+                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["original_channels"] = channels
+        
+        # 根据映射关系做通道转换
+        for k in channels.keys():
+            if isinstance(channels[k], list):
+                temp = [k + str(i) for i in channels[k]]
+                channels[k] = [self.channel_mapping.get(c, 1) for c in temp]
+            else:
+                channels[k] = [k + str(channels[k])]
+                
+                
+        # 更新采集参数        
+        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"):  
+        logger.info(f"订阅{self.device_no}的数据流")    
+        # 数据队列
+        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 gen_set_acquirement_param(self) -> bytes:
+        
+        arr = []
+        for k in self.acq_channels.keys():
+            arr = list(arr + self.acq_channels[k])
+            
+        arr = list(set(arr))
+        body = to_bytes(arr) 
+        body += self.sample_range.to_bytes(4, byteorder='little')
+        body += self.sample_rate.to_bytes(4, byteorder='little')
+        body += self.sample_num.to_bytes(4, byteorder='little')
+        body += self.resolution.to_bytes(1, byteorder='little')
+        body += bytes.fromhex('00')     
+        
+        return body
+    
+    def __str__(self):
+        return f''' 
+            Device: 
+                Name: {self.device_no}, 
+                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}
+            '''
+    
+