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

qlsdk/persist/rsc_edf.py

@@ -15,7 +15,7 @@ EDF_FILE_TYPE = {
 }
 
 class EDFStreamWriter(Thread):
-    def __init__(self, channels, sample_frequency, physical_max, digital_min, file_type, file_path, record_duration=None):
+    def __init__(self, channels, sample_frequency, physical_max, physical_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 = digital_min
+        self.physical_min = physical_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,6 +46,7 @@ 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
@@ -61,7 +62,7 @@ class EDFStreamWriter(Thread):
         self._recording = False
         
     def append(self, data):
-        if data:
+        if data is not None:
             # 数据
             self.data_queue.put(data)
             
@@ -127,6 +128,7 @@ 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]}',
@@ -169,14 +171,16 @@ class EDFStreamWriter(Thread):
     # 写入1秒的数据
     def _write_block(self, block):
         logger.trace(f"写入数据: {block}")
-        # 转换数据类型为float64
-        data_float64 = block.astype(np.float64)
+        # 转换数据类型为float64-物理信号uV int32-数字信号
+        data_input = block.astype(np.int32)
+        logger.trace(f"写入数据-real: {data_input}")
         # 写入时转置为(样本数, 通道数)格式
-        self._writer.writeSamples(data_float64)
+        self._writer.writeSamples(data_input, digital=True)
         self._duration += 1
         
         if self._duration % 10 == 0:  # 每10秒打印一次进度
             logger.info(f"数据记录中... 文件名：{self.file_path}, 已记录时长: {self._duration}秒")
+            
 
 # 用作数据结构一致化处理，通过调用公共类写入edf文件
 # 入参包含写入edf的全部前置参数
@@ -200,7 +204,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 = -8388607 if resolution == 24 else - 32768
+        self.digital_min = -8388608 if resolution == 24 else - 32768
         self.file_type = EDF_FILE_TYPE["bdf"] if resolution == 24 else EDF_FILE_TYPE["edf"]
         # 点分辨率
         self.resolution = resolution
@@ -226,8 +230,8 @@ class RscEDFHandler(object):
         self._end_time = None
         self._patient_code = "patient_code"
         self._patient_name = "patient_name"
-        self._device_type = "24130032"
-        self._device_no = "24130032"
+        self._device_type = "0000"
+        self._device_no = "00000000"
         self._total_packets = 0
         self._lost_packets = 0
         self._storage_path = storage_path
@@ -242,7 +246,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%I%M')}.{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%M%S')}.{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:
@@ -260,6 +264,10 @@ 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:
             self._device_type = "ARSKindling"
         elif device_type == 0x339:
@@ -288,6 +296,8 @@ 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:
@@ -310,6 +320,7 @@ 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)
             
@@ -329,5 +340,4 @@ 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,8 +48,9 @@ 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
@@ -61,7 +62,7 @@ class DeviceCommand(abc.ABC):
                 DeviceCommand.HEADER_PREFIX
                 + int(2).to_bytes(1, 'little')     # pkgType  
                 + device_type.to_bytes(1, 'little')
-                + device_id.to_bytes(4, 'little')
+                + device_id
                 + (DeviceCommand.HEADER_LEN + body_len + 2).to_bytes(4, 'little')  # +1 for checksum
                 + self.cmd_code.to_bytes(2, 'little')
             )
@@ -204,6 +205,15 @@ 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):
@@ -211,13 +221,16 @@ class StartImpedanceCommand(DeviceCommand):
     cmd_desc = "启动阻抗测量"
     def pack_body(self):
         body = bytes.fromhex('0000')
-        body += to_bytes(self.device.acq_channels)
+        body += to_bytes(self.device.get_impedance_channels())
         body += bytes.fromhex('0000000000000000') # 8字节占位符
         return body
     
     def parse_body(self, body):
-        logger.info(f"Received StartImpedance response: {body.hex()}")
-        return super().parse_body(body) 
+        result = body[8]
+        if result == 0x00:
+            logger.info("阻抗测量启动成功")
+        else:
+            logger.warning(f"阻抗测量启动失败: {int(result)}")
         
 
 # 停止阻抗测量
@@ -233,7 +246,7 @@ class StartStimulationCommand(DeviceCommand):
     cmd_code = 0x48C
     cmd_desc = "启动刺激"
     def pack_body(self):
-        return self.device.stim_paradigm.to_bytes()
+        return self.device.get_stim_param()
         # return bytes.fromhex('01000000000000008813000000000000010000000000000000000140420f00640064000000803f0000010000000000000000000000000000000000000000008813000000000000')
     def parse_body(self, body: bytes):
         # time - 8B
@@ -243,8 +256,9 @@ class StartStimulationCommand(DeviceCommand):
         # error_channel - 8B
         # error_channel= int.from_bytes(body[9:17], 'big')
         channels = to_channels(body[9:17])
-        logger.success(f"通道 {channels} 刺激开始")
-        self.device.trigger(f"通道 {channels} 刺激开始")
+        logger.info(f"通道 {channels} 刺激开始")
+        if self.device:
+            self.device.trigger(f"通道 {channels} 刺激开始")
         # error_type - 1B
         error_type = body[17]
 
@@ -268,8 +282,9 @@ class StopStimulationNotifyCommand(DeviceCommand):
         # error_channel - 8B
         # error_channel= int.from_bytes(body[9:17], 'big')
         channels = to_channels(body[9:17])
-        logger.success(f"通道 {channels} 刺激结束")
-        self.device.trigger(f"通道 {channels} 刺激结束", time)
+        logger.info(f"通道 {channels} 刺激结束")
+        if self.device:
+            self.device.trigger(f"通道 {channels} 刺激结束", time)
         # error_type - 1B
         error_type = body[17]   
 # 刺激信息
@@ -297,8 +312,7 @@ class ImpedanceDataCommand(DeviceCommand):
     cmd_desc = "阻抗数据"
     
     def parse_body(self, body: bytes):
-        # logger.info(f"Received impedance data: {body.hex()}")
-        packet = ImpedancePacket().transfer(body)
+        self.device.produce(body, type="impedance")
 
 # 信号数据
 class SignalDataCommand(DeviceCommand):
@@ -309,11 +323,11 @@ class SignalDataCommand(DeviceCommand):
         return super().unpack(payload)
     
     def parse_body(self, body: bytes):     
-        # 解析数据包
-        packet = RscPacket()
-        packet.transfer(body)  
+        # # 解析数据包
+        # packet = RscPacket()
+        # packet.transfer(body)  
         # 将数据包传递给设备
-        self.device.produce(packet)
+        self.device.produce(body)
                 
             
 

qlsdk/rsc/device/__init__.py

@@ -4,4 +4,5 @@ from .device_factory import DeviceFactory
 # import devices
 from .c64_rs import C64RS
 from .c16_rs import C16RS
-from .arskindling import ARSKindling
+from .arskindling import ARSKindling
+from .c256_rs import C256RS