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

qlsdk/core/entity/__init__.py

@@ -19,8 +19,7 @@ class RscPacket(Packet):
         self.filter = None
         self.data_len = None
         self.trigger = None
-        self.eeg = None # 数字信号
-        self.eeg_p = None # 物理值
+        self.eeg = None
     
     @staticmethod
     def transfer(body: bytes) -> 'RscPacket':
@@ -51,68 +50,47 @@ class RscPacket(Packet):
             for i in range(ch_num)
         ]
                 
-        logger.trace(packet)
-        
+        # logger.trace(self)
         return packet
-
-    def copy(self) -> 'RscPacket':
-        packet = RscPacket()
-        packet.time_stamp = self.time_stamp
-        packet.pkg_id = self.pkg_id
-        packet.result = self.result
-        packet.channels = self.channels
-        packet.origin_sample_rate = self.origin_sample_rate
-        packet.sample_rate = self.sample_rate
-        packet.sample_num = self.sample_num
-        packet.resolution = self.resolution
-        packet.filter = self.filter
-        packet.data_len = self.data_len
-        packet.trigger = self.trigger
-        packet.eeg = self.eeg
-        return packet  
         
     def __str__(self):
-        return f"""[
-            "time_stamp": {self.time_stamp}
-            "pkg_id": {self.pkg_id}
-            "channels": {self.channels}
-            "trigger": {self.trigger}
-            "eeg": {self.eeg}
-        ]"""
+        return f"""
+            time_stamp: {self.time_stamp}
+            pkg_id: {self.pkg_id}
+            origin_sample_rate: {self.origin_sample_rate}
+            sample_rate: {self.sample_rate}
+            sample_num: {self.sample_num}
+            resolution: {self.resolution}
+            filter: {self.filter}
+            channels: {self.channels}
+            data len: {self.data_len}
+            trigger: {self.trigger}
+            eeg: {self.eeg}
+        """
         
 class ImpedancePacket(Packet):
     def __init__(self):
         super().__init__()
+        self.data_len = None
         self.impedance = None
         
-    @staticmethod
-    def transfer(body:bytes) -> 'ImpedancePacket':
-        packet = ImpedancePacket()
-        packet.time_stamp = int.from_bytes(body[0:8], 'little')
-        # packet.result = body[8]
-        packet.pkg_id = int.from_bytes(body[9: 13], 'little')
-        packet.channels = to_channels(body[13: 45])
-        # packet.sample_rate = int.from_bytes(body[45: 49], 'little')
-        # packet.sample_len = int.from_bytes(body[49: 53], 'little')
-        # packet.resolution = int(int(body[53]) / 8)
-        # packet.filter = int(int(body[54]) / 8)
-        # packet.wave_type = int(int(body[55]) / 8)
-        # packet.wave_freq = int.from_bytes(body[56: 60], 'little')
-        # packet.data_len = int.from_bytes(body[60: 64], 'little')
-        b_impedance = body[64:]
-        packet.impedance = [int.from_bytes(b_impedance[j * 4 : j * 4 + 4], 'little', signed=False) for j in range(len(packet.channels))]
-
-        logger.trace(f"impedance: {packet}")
+    def transfer(self, body:bytes) -> 'ImpedancePacket':
+        self.time_stamp = int.from_bytes(body[0:8], 'little')
+        self.result = body[8]
+        self.pkg_id = int.from_bytes(body[9: 13], 'little')
+        self.channels = to_channels(body[13: 45])
+        
+        logger.debug(f"impedance: {self}")
         
-        return packet
-
     def __str__(self):
-        return f"""[
-            "time_stamp": {self.time_stamp}
-            "pkg_id": {self.pkg_id}
-            "channels": {self.channels}
-            "impedance": {self.impedance}
-        ]"""
+        return f"""
+            time_stamp: {self.time_stamp}
+            pkg_id: {self.pkg_id}
+            result: {self.result}
+            channels: {self.channels}
+            data len: {self.data_len}
+            impedance: {self.impedance}
+        """
         
     
 class C256RSPacket(Packet):
@@ -183,40 +161,4 @@ class C256RSPacket(Packet):
             offset += 4 + channel_size * packet.resolution 
             
         logger.trace(packet)
-        return packet
-    
-  
-class C256ImpedancePacket(Packet):
-    def __init__(self):
-        super().__init__()
-        self.impedance = None
-        
-    @staticmethod
-    def transfer(body:bytes) -> 'ImpedancePacket':
-        packet = ImpedancePacket()
-        packet.time_stamp = int.from_bytes(body[0:8], 'little')
-        # packet.result = body[8]
-        packet.pkg_id = int.from_bytes(body[9: 13], 'little')
-        packet.channels = to_channels(body[13: 45])
-        # packet.sample_rate = int.from_bytes(body[45: 49], 'little')
-        # packet.sample_len = int.from_bytes(body[49: 53], 'little')
-        # packet.resolution = int(int(body[53]) / 8)
-        # packet.filter = int(int(body[54]) / 8)
-        # packet.wave_type = int(int(body[55]) / 8)
-        # packet.wave_freq = int.from_bytes(body[56: 60], 'little')
-        # packet.data_len = int.from_bytes(body[60: 64], 'little')
-        b_impedance = body[64:]
-        packet.impedance = [int.from_bytes(b_impedance[j : j + 4], 'little', signed=False) for j in range(len(packet.channels))]
-
-        logger.trace(f"impedance: {packet}")
-
-    def __str__(self):
-        return f"""
-            time_stamp: {self.time_stamp}
-            pkg_id: {self.pkg_id}
-            result: {self.result}
-            channels: {self.channels}
-            data len: {self.data_len}
-            impedance: {self.impedance}
-        """
-            
+        return packet

qlsdk/persist/ars_edf.py

@@ -85,67 +85,67 @@ class ARSKindlingEDFHandler(object):
             "D" : [7, 8, 5, 6, 3, 4, 1, 2, 9, 10, 11, 12, 13, 14],
         }
         
-        # self._channel_mapping = {
-        #     1: "D7", 
-        #     2: "D8",
-        #     3: "D5", 
-        #     4: "D6",
-        #     5: "D3", 
-        #     6: "D4",
-        #     7: "D1", 
-        #     8: "D2",
-        #     9: "D9", 
-        #     10: "D10",
-        #     11: "D11", 
-        #     12: "D12",
-        #     13: "D13", 
-        #     14: "D14",
+        self._channel_mapping = {
+            1: "D7", 
+            2: "D8",
+            3: "D5", 
+            4: "D6",
+            5: "D3", 
+            6: "D4",
+            7: "D1", 
+            8: "D2",
+            9: "D9", 
+            10: "D10",
+            11: "D11", 
+            12: "D12",
+            13: "D13", 
+            14: "D14",
             
-        #     17: "C7", 
-        #     18: "C8",
-        #     19: "C5", 
-        #     20: "C6",
-        #     21: "C3", 
-        #     22: "C4",
-        #     23: "C1", 
-        #     24: "C2",
-        #     25: "C9", 
-        #     26: "C10",
-        #     27: "C11", 
-        #     28: "C12",
-        #     29: "C13", 
-        #     30: "C14",
+            17: "C7", 
+            18: "C8",
+            19: "C5", 
+            20: "C6",
+            21: "C3", 
+            22: "C4",
+            23: "C1", 
+            24: "C2",
+            25: "C9", 
+            26: "C10",
+            27: "C11", 
+            28: "C12",
+            29: "C13", 
+            30: "C14",
             
-        #     33: "B7", 
-        #     34: "B8",
-        #     35: "B5", 
-        #     36: "B6",
-        #     37: "B3", 
-        #     38: "B4",
-        #     39: "B1", 
-        #     40: "B2",
-        #     41: "B9", 
-        #     42: "B10",
-        #     43: "B11", 
-        #     44: "B12",
-        #     45: "B13", 
-        #     46: "B14",
+            33: "B7", 
+            34: "B8",
+            35: "B5", 
+            36: "B6",
+            37: "B3", 
+            38: "B4",
+            39: "B1", 
+            40: "B2",
+            41: "B9", 
+            42: "B10",
+            43: "B11", 
+            44: "B12",
+            45: "B13", 
+            46: "B14",
             
-        #     49: "A7", 
-        #     50: "A8",
-        #     51: "A5", 
-        #     52: "A6",
-        #     53: "A3", 
-        #     54: "A4",
-        #     55: "A1", 
-        #     56: "A2",
-        #     57: "A9", 
-        #     58: "A10",
-        #     59: "A11", 
-        #     60: "A12",
-        #     61: "A13", 
-        #     62: "A14"
-        # }
+            49: "A7", 
+            50: "A8",
+            51: "A5", 
+            52: "A6",
+            53: "A3", 
+            54: "A4",
+            55: "A1", 
+            56: "A2",
+            57: "A9", 
+            58: "A10",
+            59: "A11", 
+            60: "A12",
+            61: "A13", 
+            62: "A14"
+        }
         
         self._lock = Lock()
         
@@ -172,8 +172,6 @@ class ARSKindlingEDFHandler(object):
             self._device_type = "C64RS"
         elif device_type == 0x40:
             self._device_type = "LJ64S1"
-        elif device_type == 0x60:
-            self._device_type = "ArsKindling"
         else:
             self._device_type = hex(device_type)
         
@@ -197,32 +195,55 @@ class ARSKindlingEDFHandler(object):
         if packet is None:
             # self._edf_writer_thread.stop_recording()
             for k in self._edf_handler.keys():
-                self._edf_handler[k].write(None)
+                self._edf_handler[k].append(None)
             return
          
-        #按分区写入数据        
+        #按分区写入数据
+        
         for k in self._channel_spilt.keys():      
-            logger.trace(f'分区{k}写入数据到文件')  
-            if k in packet.channels.keys():    
-                p = packet
-                self.writeA(p, k)
+            logger.info(f'分区{k}, {self._channel_spilt[k]}')      
+            p = packet
+            self.writeA(p, self._channel_spilt[k], k)
+    
+        # with self._lock:
+        #     if self.channels is None:
+        #         logger.info(f"开始记录数据到文件...")
+        #         self.channels = packet.channels
+        #         self._first_pkg_id = packet.pkg_id if self._first_pkg_id is None else self._first_pkg_id
+        #         self._first_timestamp = packet.time_stamp if self._first_timestamp is None else self._first_timestamp
+        #         self._start_time = datetime.now()
+        #         logger.info(f"第一个包id: {self._first_pkg_id }, 时间戳:{self._first_timestamp}， 当前时间:{datetime.now().timestamp()}  offset: {datetime.now().timestamp() - self._first_timestamp}")
+                
+        #     if self._last_pkg_id and self._last_pkg_id != packet.pkg_id - 1:  
+        #         self._lost_packets += packet.pkg_id - self._last_pkg_id - 1
+        #         logger.warning(f"数据包丢失: {self._last_pkg_id} -> {packet.pkg_id}, 丢包数: {packet.pkg_id - self._last_pkg_id - 1}")
+                
+        #     self._last_pkg_id = packet.pkg_id
+        #     self._total_packets += 1
+            
+        #     if self._edf_writer_thread is None:
+        #         self._edf_writer_thread = EDFStreamWriter(self.channels, self.sample_rate, self.physical_max, self.physical_min, self.file_type, self.file_name)
+        #         self._edf_writer_thread.set_start_time(self._start_time)
+        #         self._edf_writer_thread.start()
+        #         logger.info(f"开始写入数据: {self.file_name}")
+                
+        #     self._edf_writer_thread.append(packet.eeg)
      
-    def writeA(self, packet: RscPacket, name='A'):
+    def writeA(self, packet: RscPacket, channel_filter, name='A'):
         # 参数检查
-        if packet is None:
+        if packet is None or channel_filter is None:
             logger.warning("空数据，忽略")
             return
-            
-        channels = packet.channels.get(name, None)
-        eeg = packet.eeg.get(name, None)
         
-        if eeg is None :
-            logger.trace(f"分区{name}没有可用的数据，跳过文件写入")
-            return
+        channel_pos = intersection_positions(packet.channels, channel_filter)
+        
+        if channel_pos is None or len(channel_pos) == 0 :
+            logger.debug(f"没有指定分区{name}的通道，跳过")
+            pass
         
         # 分区数据包写入
         if name not in self._edf_handler.keys():
-            edf_handler = RscEDFHandler(self.sample_rate,  self.physical_max , self.physical_min, self.resolution)  
+            edf_handler = RscEDFHandler(self.sample_rate,  self.digital_max , self.digital_min, self.resolution)  
             edf_handler.set_device_type(self._device_type)
             edf_handler.set_device_no(self._device_no)
             edf_handler.set_storage_path(self._storage_path)
@@ -230,12 +251,15 @@ class ARSKindlingEDFHandler(object):
             logger.info(f"开始写入分区{name}的数据到文件")
             self._edf_handler[name] = edf_handler
         
+        # 保留本分区的通道和数据
+        channels = [packet.channels[p] for p in channel_pos]
+        eeg = [packet.eeg[p] for p in channel_pos]
+        
         # 新建数据包实例
         data = RscPacket()
         data.time_stamp = packet.time_stamp
         data.pkg_id = packet.pkg_id
-        # data.channels = channels
-        data.channels = self.channel_display(channels, name)
+        data.channels = channels
         data.origin_sample_rate = packet.origin_sample_rate
         data.sample_rate = packet.sample_rate
         data.sample_num = packet.sample_num
@@ -252,6 +276,3 @@ class ARSKindlingEDFHandler(object):
         # trigger现在（20250702）多个分区共享， 分发到所有分区文件中标记
         for k in self._edf_handler.keys():
             self._edf_handler[k].trigger(desc, cur_time) 
-            
-    def channel_display(self, channel, name: str):
-        return [f'{name}-{channel_id}' for channel_id in channel]

qlsdk/persist/rsc_edf.py

@@ -15,7 +15,7 @@ EDF_FILE_TYPE = {
 }
 
 class EDFStreamWriter(Thread):
-    def __init__(self, channels, sample_frequency, physical_max, physical_min, file_type, file_path, record_duration=None):
+    def __init__(self, channels, sample_frequency, physical_max, digital_min, file_type, file_path, record_duration=None):
         
         super().__init__()
         self._writer : EdfWriter = None
@@ -32,7 +32,7 @@ class EDFStreamWriter(Thread):
         self._n_channels = len(channels)
         self.sample_frequency = sample_frequency
         self.physical_max = physical_max
-        self.physical_min = physical_min
+        self.physical_min = digital_min
         # 和位数相关，edf 16 bits/bdf  24 bits
         self.digital_max = 8388607 if file_type == EDF_FILE_TYPE['bdf'] else 32767
         self.digital_min = -8388608 if file_type == EDF_FILE_TYPE['bdf'] else -32768
@@ -46,7 +46,6 @@ class EDFStreamWriter(Thread):
         self.equipment = "equipment"
         self.patient_code = "patient_code"
         self.patient_name = "patient_name"
-        logger.info(f'digital_max:{self.digital_max}, digital_min:{self.digital_min}, physical_max:{self.physical_max}, physical_min:{self.physical_min}')
         
     def set_channels(self, channels):
         self._channels = channels
@@ -62,7 +61,7 @@ class EDFStreamWriter(Thread):
         self._recording = False
         
     def append(self, data):
-        if data is not None:
+        if data:
             # 数据
             self.data_queue.put(data)
             
@@ -128,7 +127,6 @@ class EDFStreamWriter(Thread):
         
         # 配置通道参数
         signal_headers = []
-        logger.trace(f"sf: {self.sample_frequency}, pm: {self.physical_max}, pn: {self.physical_min}, dm: {self.digital_max}, dn: {self.digital_min}")
         for ch in range(self._n_channels):
             signal_headers.append({
                 "label": f'channels {self._channels[ch]}',
@@ -171,16 +169,14 @@ class EDFStreamWriter(Thread):
     # 写入1秒的数据
     def _write_block(self, block):
         logger.trace(f"写入数据: {block}")
-        # 转换数据类型为float64-物理信号uV int32-数字信号
-        data_input = block.astype(np.int32)
-        logger.trace(f"写入数据-real: {data_input}")
+        # 转换数据类型为float64
+        data_float64 = block.astype(np.float64)
         # 写入时转置为(样本数, 通道数)格式
-        self._writer.writeSamples(data_input, digital=True)
+        self._writer.writeSamples(data_float64)
         self._duration += 1
         
         if self._duration % 10 == 0:  # 每10秒打印一次进度
             logger.info(f"数据记录中... 文件名：{self.file_path}, 已记录时长: {self._duration}秒")
-            
 
 # 用作数据结构一致化处理，通过调用公共类写入edf文件
 # 入参包含写入edf的全部前置参数
@@ -204,7 +200,7 @@ class RscEDFHandler(object):
         self.physical_max = physical_max
         self.physical_min = physical_min
         self.digital_max = 8388607 if resolution == 24 else 32767
-        self.digital_min = -8388608 if resolution == 24 else - 32768
+        self.digital_min = -8388607 if resolution == 24 else - 32768
         self.file_type = EDF_FILE_TYPE["bdf"] if resolution == 24 else EDF_FILE_TYPE["edf"]
         # 点分辨率
         self.resolution = resolution
@@ -230,8 +226,8 @@ class RscEDFHandler(object):
         self._end_time = None
         self._patient_code = "patient_code"
         self._patient_name = "patient_name"
-        self._device_type = "0000"
-        self._device_no = "00000000"
+        self._device_type = "24130032"
+        self._device_no = "24130032"
         self._total_packets = 0
         self._lost_packets = 0
         self._storage_path = storage_path
@@ -246,7 +242,7 @@ class RscEDFHandler(object):
         suffix = "bdf" if self.resolution == 24 else "edf"
         
         # 文件名称
-        file_name = f"{self._file_prefix}_{self._device_no}_{self._start_time.strftime('%y%m%d%H%M%S')}.{suffix}" if self._file_prefix else f"{self._device_no}_{self._start_time.strftime('%y%m%d%H%I%M')}.{suffix}"
+        file_name = f"{self._file_prefix}_{self._device_no}_{self._start_time.strftime('%y%m%d%H%I%M')}.{suffix}" if self._file_prefix else f"{self._device_no}_{self._start_time.strftime('%y%m%d%H%I%M')}.{suffix}"
         
         if self._storage_path:
             try:
@@ -264,8 +260,6 @@ class RscEDFHandler(object):
             self._device_type = "C64RS"
         elif device_type == 0x40:
             self._device_type = "LJ64S1"
-        elif device_type == 0x45:
-            self._device_type = "C256RS"
         elif device_type == 0x51:
             self._device_type = "C256RS"
         elif device_type == 0x60:
@@ -296,8 +290,6 @@ class RscEDFHandler(object):
             logger.info(f"收到结束信号，即将停止写入数据:{self.file_name}")
             self._edf_writer_thread.stop_recording()
             return
-        
-        logger.debug(f"packet: {packet}")
     
         with self._lock:
             if self.channels is None:
@@ -320,7 +312,6 @@ class RscEDFHandler(object):
                 self._edf_writer_thread.set_start_time(self._start_time)
                 self._edf_writer_thread.start()
                 logger.info(f"开始写入数据: {self.file_name}")
-                self._edf_writer_thread.equipment = f'{self._device_type}_{self._device_no}'
                 
             self._edf_writer_thread.append(packet.eeg)
             
@@ -340,4 +331,5 @@ class RscEDFHandler(object):
             else: onset = 0
         else:
             onset = cur_time - self._first_timestamp
-        self._edf_writer_thread.trigger(onset, desc)     
+        self._edf_writer_thread.trigger(onset, desc)     
+    

qlsdk/rsc/command/__init__.py

@@ -48,9 +48,8 @@ class DeviceCommand(abc.ABC):
         """构建消息体"""
         return b''
     def pack_header(self, body_len: int) -> bytes:
-        # device_id = int(self.device.device_id) if self.device and self.device.device_id else 0
+        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
-        device_id = bytes.fromhex(self.device.device_id)[::-1] if self.device.device_id else bytes.fromhex('00000000')
         
         #兼容设计
         b_device_type = None
@@ -62,7 +61,7 @@ class DeviceCommand(abc.ABC):
                 DeviceCommand.HEADER_PREFIX
                 + int(2).to_bytes(1, 'little')     # pkgType  
                 + device_type.to_bytes(1, 'little')
-                + device_id
+                + 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')
             )
@@ -205,15 +204,6 @@ class StopAcquisitionCommand(DeviceCommand):
 class SetImpedanceParamCommand(DeviceCommand):
     cmd_code = 0x411
     cmd_desc = "设置阻抗测量参数"
-    def pack_body(self): 
-
-        return self.device.gen_set_impedance_param()
-    def parse_body(self, body):
-        result = body[8]
-        if result == 0x00:
-            logger.info("阻抗测量参数设置成功")
-        else:
-            logger.warning(f"阻抗测量参数设置失败: {int(result)}")
         
 # 启动阻抗测量
 class StartImpedanceCommand(DeviceCommand):
@@ -221,16 +211,13 @@ class StartImpedanceCommand(DeviceCommand):
     cmd_desc = "启动阻抗测量"
     def pack_body(self):
         body = bytes.fromhex('0000')
-        body += to_bytes(self.device.get_impedance_channels())
+        body += to_bytes(self.device.acq_channels)
         body += bytes.fromhex('0000000000000000') # 8字节占位符
         return body
     
     def parse_body(self, body):
-        result = body[8]
-        if result == 0x00:
-            logger.info("阻抗测量启动成功")
-        else:
-            logger.warning(f"阻抗测量启动失败: {int(result)}")
+        logger.info(f"Received StartImpedance response: {body.hex()}")
+        return super().parse_body(body) 
         
 
 # 停止阻抗测量
@@ -246,7 +233,7 @@ class StartStimulationCommand(DeviceCommand):
     cmd_code = 0x48C
     cmd_desc = "启动刺激"
     def pack_body(self):
-        return self.device.get_stim_param()
+        return self.device.stim_paradigm.to_bytes()
         # return bytes.fromhex('01000000000000008813000000000000010000000000000000000140420f00640064000000803f0000010000000000000000000000000000000000000000008813000000000000')
     def parse_body(self, body: bytes):
         # time - 8B
@@ -256,9 +243,8 @@ class StartStimulationCommand(DeviceCommand):
         # error_channel - 8B
         # error_channel= int.from_bytes(body[9:17], 'big')
         channels = to_channels(body[9:17])
-        logger.info(f"通道 {channels} 刺激开始")
-        if self.device:
-            self.device.trigger(f"通道 {channels} 刺激开始")
+        logger.success(f"通道 {channels} 刺激开始")
+        self.device.trigger(f"通道 {channels} 刺激开始")
         # error_type - 1B
         error_type = body[17]
 
@@ -282,9 +268,8 @@ class StopStimulationNotifyCommand(DeviceCommand):
         # error_channel - 8B
         # error_channel= int.from_bytes(body[9:17], 'big')
         channels = to_channels(body[9:17])
-        logger.info(f"通道 {channels} 刺激结束")
-        if self.device:
-            self.device.trigger(f"通道 {channels} 刺激结束", time)
+        logger.success(f"通道 {channels} 刺激结束")
+        self.device.trigger(f"通道 {channels} 刺激结束", time)
         # error_type - 1B
         error_type = body[17]   
 # 刺激信息
@@ -312,7 +297,8 @@ class ImpedanceDataCommand(DeviceCommand):
     cmd_desc = "阻抗数据"
     
     def parse_body(self, body: bytes):
-        self.device.produce(body, type="impedance")
+        # logger.info(f"Received impedance data: {body.hex()}")
+        packet = ImpedancePacket().transfer(body)
 
 # 信号数据
 class SignalDataCommand(DeviceCommand):