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

qlsdk/core/entity/__init__.py

@@ -19,65 +19,197 @@ class RscPacket(Packet):
         self.filter = None
         self.data_len = None
         self.trigger = None
-        self.eeg = None
+        self.eeg = None # 数字信号
+        self.eeg_p = None # 物理值
     
-    def transfer(self, body: bytes) -> 'RscPacket':
-        self.time_stamp = int.from_bytes(body[0:8], 'little')
-        self.result = body[8]
-        self.pkg_id = int.from_bytes(body[9: 13], 'little')
-        logger.trace(f"pkg_id: {self.pkg_id}")
-        self.channels = to_channels(body[13: 45])
-        self.origin_sample_rate = int.from_bytes(body[45: 49], 'little')
-        self.sample_rate = int.from_bytes(body[49: 53], 'little')
-        self.sample_num = int.from_bytes(body[53: 57], 'little')
-        self.resolution = int(int(body[57]) / 8)
-        self.filter = body[58]
-        self.data_len = int.from_bytes(body[59: 63], 'little')
+    @staticmethod
+    def transfer(body: bytes) -> 'RscPacket':
+        packet = RscPacket()
+        packet.time_stamp = int.from_bytes(body[0:8], 'little')
+        packet.result = body[8]
+        packet.pkg_id = int.from_bytes(body[9: 13], 'little')
+        logger.trace(f"pkg_id: {packet.pkg_id}")
+        packet.channels = to_channels(body[13: 45])
+        packet.origin_sample_rate = int.from_bytes(body[45: 49], 'little')
+        packet.sample_rate = int.from_bytes(body[49: 53], 'little')
+        packet.sample_num = int.from_bytes(body[53: 57], 'little')
+        packet.resolution = int(int(body[57]) / 8)
+        packet.filter = body[58]
+        packet.data_len = int.from_bytes(body[59: 63], 'little')
         # 步径 相同通道的点间隔
-        step = int(len(self.channels) * self.resolution + 4)
-        self.trigger = [int.from_bytes(body[i:i+4], 'little') for i in range(63, len(body) - 3, step)]
+        step = int(len(packet.channels) * packet.resolution + 4)
         b_eeg = body[63:]
-        ch_num = len(self.channels) 
-        self.eeg = [
+        ch_num = len(packet.channels) 
+        # 字节序列(4Cn{channel_size}){sample_num})
+        packet.trigger = [int.from_bytes(b_eeg[j * step : j * step + 4], 'little', signed=False) for j in range(packet.sample_num)]
+        
+        packet.eeg = [
             [
-                int.from_bytes(b_eeg[i * self.resolution + 4 + j * step:i * self.resolution + 4 + j * step + 3], 'big', signed=True)
-                for j in range(self.sample_num)
+                int.from_bytes(b_eeg[i * packet.resolution + 4 + j * step:i * packet.resolution + 4 + j * step + 3], 'big', signed=True)
+                for j in range(packet.sample_num)
             ]
             for i in range(ch_num)
         ]
                 
-        # logger.trace(self)
-        return self
+        logger.trace(packet)
+        
+        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}
-            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}
-        """
+        return f"""[
+            "time_stamp": {self.time_stamp}
+            "pkg_id": {self.pkg_id}
+            "channels": {self.channels}
+            "trigger": {self.trigger}
+            "eeg": {self.eeg}
+        ]"""
         
 class ImpedancePacket(Packet):
     def __init__(self):
         super().__init__()
-        self.data_len = None
         self.impedance = None
         
-    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])
+    @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}")
         
-        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}
+        ]"""
         
+    
+class C256RSPacket(Packet):
+    def __init__(self):
+        super().__init__()
+        self.origin_sample_rate = None
+        self.sample_rate = None
+        self.sample_num = None
+        self.resolution = None
+        self.filter = None
+        self.data_len = None
+        self.trigger = None
+        self.eeg = None
+    
+    @staticmethod
+    def transfer(body: bytes) -> 'RscPacket':
+        packet = RscPacket()
+        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])
+        logger.trace(f"pkg_id: {packet.pkg_id}, channels: {packet.channels}")
+            
+        packet.origin_sample_rate = int.from_bytes(body[45: 49], 'little')
+        packet.sample_rate = int.from_bytes(body[49: 53], 'little')
+        packet.sample_num = int.from_bytes(body[53: 57], 'little')
+        packet.resolution = int(int(body[57]) / 8)
+        packet.filter = body[58]
+        packet.data_len = int.from_bytes(body[59: 63], 'little')
+                
+        # 数据块
+        b_eeg = body[63:]
+        # 根据值域分割数组-代表设备的4个模块
+        ranges = [(1, 64), (65, 128), (129, 192), (193, 256)]
+        sub_channels = [[x for x in packet.channels if low <= x <= high] for low, high in ranges]
+        # 只处理选中的模块
+        sub_channels = [_ for _ in sub_channels if len(_) > 0]
+        # 步径 相同通道的点间隔
+        step = int(len(packet.channels) * packet.resolution + 4 * len(sub_channels))
+        offset = 0
+        
+        # 分按子模块处理
+        for channels in sub_channels:
+            logger.trace(f"子数组: {channels} 长度: {len(channels)}")
+            channel_size = len(channels) 
+            
+            # 模块没有选中通道的，跳过
+            if channel_size == 0:
+                continue
+            
+            # 只保留第一个有效模块的trigger，其他的模块是冗余信息，无实际含义
+            if packet.trigger is None:
+                packet.trigger = [int.from_bytes(b_eeg[j * step : j * step + 4], 'little', signed=False) for j in range(packet.sample_num)]
+                logger.trace(f"trigger: {packet.trigger}")
+                trigger_positions = [index for index, value in enumerate(packet.trigger) if value != 0]
+                if len(trigger_positions) > 0:
+                    logger.debug(f"Trigger触发点位置: {trigger_positions}, 触发点时间戳: {[packet.time_stamp + int(pos * 1000 / packet.sample_rate) for pos in trigger_positions]}")
+                
+            eeg = [
+                [
+                    int.from_bytes(b_eeg[offset + step * j + 4 +  k * packet.resolution : offset + step * j + 7 +  k * packet.resolution], 'big', signed=True)
+                    for j in range(packet.sample_num)
+                ]
+                for k in range(channel_size)
+            ]
+            packet.eeg = packet.eeg + eeg if packet.eeg else eeg
+            
+            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}
@@ -86,4 +218,5 @@ class ImpedancePacket(Packet):
             channels: {self.channels}
             data len: {self.data_len}
             impedance: {self.impedance}
-        """
+        """
+            

qlsdk/core/message/udp.py

@@ -2,7 +2,7 @@
 from enum import Enum
 from time import timezone
 from qlsdk.core.crc import check_crc, crc16
-from qlsdk.core.local import get_ip
+from qlsdk.core.local import get_ip, get_ips
 
 from loguru import logger
 
@@ -72,6 +72,14 @@ class UDPMessage(object):
         if server_ip is None:
             server_ip = get_ip()
             
+        return UDPMessage._search_(device_id, server_ip, server_port)
+    
+    @staticmethod
+    def _search_(device_id : str, server_ip : str, server_port : int=19216):
+        # 服务端Ip
+        if server_ip is None:
+            raise ValueError("server_ip is None")
+            
         logger.debug(f"search device {device_id} on {server_ip}:{server_port}")
             
         message = bytearray(28)

qlsdk/interface/__init__.py

@@ -0,0 +1,10 @@
+from parser import *
+
+from device import *
+
+
+'''
+    设备消息解析器
+'''
+class DeviceMessageParser:
+    pass

qlsdk/interface/analyzer.py

@@ -0,0 +1,2 @@
+class IAnalyzer:
+    pass

qlsdk/interface/collector.py

@@ -0,0 +1,10 @@
+class ICollector:
+    def __init__(self):
+        pass
+
+    def collect_data(self):
+        pass
+    
+class Collector(ICollector):
+    def __init__(self):
+        super().__init__()

qlsdk/interface/device.py

@@ -0,0 +1,2 @@
+class IDevice:
+    pass

qlsdk/interface/parser.py

@@ -0,0 +1,13 @@
+class IParser:
+    pass
+
+class Parser(IParser):
+    def __init__(self):
+        super().__init__()
+        
+class MessageParser(Parser):
+    def __init__(self):
+        super().__init__()
+        
+    def parse(self, data):
+        pass

qlsdk/interface/stimulator.py

@@ -0,0 +1,2 @@
+class IStimulator:
+    pass

qlsdk/interface/store.py

@@ -0,0 +1,2 @@
+class IStore:
+    pass

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,6 +172,8 @@ 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)
         
@@ -195,55 +197,32 @@ class ARSKindlingEDFHandler(object):
         if packet is None:
             # self._edf_writer_thread.stop_recording()
             for k in self._edf_handler.keys():
-                self._edf_handler[k].append(None)
+                self._edf_handler[k].write(None)
             return
          
-        #按分区写入数据
-        
+        #按分区写入数据        
         for k in self._channel_spilt.keys():      
-            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)
+            logger.trace(f'分区{k}写入数据到文件')  
+            if k in packet.channels.keys():    
+                p = packet
+                self.writeA(p, k)
      
-    def writeA(self, packet: RscPacket, channel_filter, name='A'):
+    def writeA(self, packet: RscPacket, name='A'):
         # 参数检查
-        if packet is None or channel_filter is None:
+        if packet is None:
             logger.warning("空数据，忽略")
             return
+            
+        channels = packet.channels.get(name, None)
+        eeg = packet.eeg.get(name, None)
         
-        channel_pos = intersection_positions(packet.channels, channel_filter)
-        
-        if channel_pos is None or len(channel_pos) == 0 :
-            logger.debug(f"没有指定分区{name}的通道，跳过")
-            pass
+        if eeg is None :
+            logger.trace(f"分区{name}没有可用的数据，跳过文件写入")
+            return
         
         # 分区数据包写入
         if name not in self._edf_handler.keys():
-            edf_handler = RscEDFHandler(self.sample_rate,  self.digital_max , self.digital_min, self.resolution)  
+            edf_handler = RscEDFHandler(self.sample_rate,  self.physical_max , self.physical_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)
@@ -251,15 +230,12 @@ 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 = channels
+        data.channels = self.channel_display(channels, name)
         data.origin_sample_rate = packet.origin_sample_rate
         data.sample_rate = packet.sample_rate
         data.sample_num = packet.sample_num
@@ -276,3 +252,6 @@ 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]