qlsdk2 0.4.1__tar.gz → 0.5.0__tar.gz

qlsdk2-0.5.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.2
+Name: qlsdk2
+Version: 0.5.0
+Summary: SDK for quanlan device
+Home-page: https://github.com/hehuajun/qlsdk
+Author: hehuajun
+Author-email: hehuajun@eegion.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Provides-Extra: dev
+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.0 
+时间：2025-07-29
+[新特性]
+1. C16R设备搜索
+2、C16R设备连接
+3、C16R信号采集/停止
+4、C16R数据自动记录到文件
+5、C16R采集通道设置支持数字和名称两种模式（可混用）
+
+[优化]
+1、提升信号接收及指令解析性能
+2、日志级别及文案优化

qlsdk2-0.5.0/README.md

@@ -0,0 +1,12 @@
+版本：v0.5.0 
+时间：2025-07-29
+[新特性]
+1. C16R设备搜索
+2、C16R设备连接
+3、C16R信号采集/停止
+4、C16R数据自动记录到文件
+5、C16R采集通道设置支持数字和名称两种模式（可混用）
+
+[优化]
+1、提升信号接收及指令解析性能
+2、日志级别及文案优化

{qlsdk2-0.4.1 → qlsdk2-0.5.0}/setup.py

@@ -1,12 +1,12 @@
 # setup.py
 import setuptools
 
-with open("README.md", "r") as fh:
+with open("README.md", "r", encoding='utf-8' ) as fh:
     long_description = fh.read()
 
 setuptools.setup(
     name="qlsdk2",
-    version="0.4.1",
+    version="0.5.0",
     author="hehuajun",
     author_email="hehuajun@eegion.com",
     description="SDK for quanlan device",

{qlsdk2-0.4.1 → qlsdk2-0.5.0}/src/qlsdk/core/entity/__init__.py

@@ -26,6 +26,7 @@ class RscPacket(object):
         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')

qlsdk2-0.5.0/src/qlsdk/core/utils.py

@@ -0,0 +1,75 @@
+from bitarray import bitarray
+from loguru import logger
+# 通道数组[1,2,3,...]转换为bytes
+def to_bytes(channels: list[int], upper=256) -> bytes:
+    byte_len = int(upper / 8)
+    channel = [0] * byte_len
+    result = bitarray(upper)
+    result.setall(0)
+    for i in range(len(channels)):
+        if channels[i] > 0 and channels[i] <= upper: 
+            # 每个字节从低位开始计数
+            m = (channels[i] - 1) % 8
+            result[channels[i] + 6 - 2 * m] = 1
+    return result.tobytes()
+
+# 通道bytes转换为数组[1,2,3,...]
+def to_channels(data: bytes) -> list[int]:
+    ba = bitarray()
+    ba.frombytes(data)
+    channels = []
+    for i in range(len(ba)):
+        if ba[i] == 1:
+            m = i % 8
+            channels.append(i + 8 - 2 * m)
+            
+    channels.sort()
+    return channels
+
+def bytes_to_ints(b):
+    """将小端字节序的3字节bytes数组转换为int数组"""
+    if len(b) % 3 != 0:
+        raise ValueError("输入的bytes长度必须是3的倍数")
+    return [
+        b[i] | (b[i + 1] << 8) | (b[i + 2] << 16)
+        for i in range(0, len(b), 3)
+    ]
+    
+def bytes_to_int(b: bytes) -> int:
+    """将小端字节序的3字节bytes数组转换为int数组"""
+    if len(b)  != 3:
+        raise ValueError("输入的bytes长度必须是3的倍数")
+    return b[0] | (b[1] << 8) | (b[2] << 16)
+def bytes_to_ints2(b):
+    """将小端字节序的3字节bytes数组转换为int数组"""
+    if len(b) % 3 != 0:
+        raise ValueError("输入的bytes长度必须是3的倍数")
+    return [
+        b[i] | (b[i + 1] << 8) | (b[i + 2] << 16)
+        for i in range(0, len(b), 3)
+    ]
+   
+import numpy as np 
+if __name__ == "__main__":
+    
+    # channels = [1]
+    # channels1 = [1, 2, 3, 4]
+    # channels2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64]
+    # channels3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145,146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176,177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238,239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256]
+    # channels4 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63]
+    # logger.info(to_bytes(channels).hex())
+    # logger.info(to_bytes(channels1).hex())
+    # logger.info(to_bytes(channels2).hex())
+    # logger.info(to_bytes(channels3).hex())
+    # logger.info(to_bytes(channels4).hex())
+    
+    # bs = 'ffffffffffffff7f000000000000000000000000000000000000000000000000'
+    # bs1 = '8000000000000000000000000000000000000000000000000000000000000000'
+    # bs2 = '0100000000000000000000000000000000000000000000000000000000000000'
+
+    # logger.info(to_channels(bytes.fromhex(bs1)))
+    # logger.info(to_channels(bytes.fromhex(bs2)))
+    
+    aa = 'ff3fff3fff3fff3f000000000000000000000000000000000000000000000000'
+    
+    logger.info(to_channels(bytes.fromhex(aa)))

qlsdk2-0.5.0/src/qlsdk/persist/__init__.py

@@ -0,0 +1,3 @@
+from .edf import EdfHandler
+from .rsc_edf import RscEDFHandler
+from .ars_edf import ARSKindlingEDFHandler

qlsdk2-0.5.0/src/qlsdk/persist/ars_edf.py

@@ -0,0 +1,278 @@
+from datetime import datetime
+import os
+from threading import Lock
+from loguru import logger
+import numpy as np
+
+from qlsdk.core.entity import RscPacket
+from qlsdk.persist.rsc_edf import RscEDFHandler
+from qlsdk.persist.stream import EDF_FILE_TYPE, EDFStreamWriter
+
+
+def intersection_positions(A, B):
+    setB = set(B)
+    seen = set()
+    return [idx for idx, elem in enumerate(A) 
+            if elem in setB and elem not in seen and not seen.add(elem)]
+
+# 用作数据结构一致化处理，通过调用公共类写入edf文件
+# 入参包含写入edf的全部前置参数
+# 实时数据包为个性化数据包，含有eeg数据部分
+class ARSKindlingEDFHandler(object):
+    '''
+        Rsc EDF Handler
+        处理EDF文件的读写
+        RSC设备通道数根据选择变化，不同通道采样频率相同
+        eeg_sample_rate: 采样频率
+        physical_max: 物理最大值 (uV)   
+        physical_min: 物理最小值 (uV)
+        resolution: 分辨率
+        storage_path: 存储路径        
+        
+        @author: qlsdk
+        @since: 0.4.0
+    '''
+    def __init__(self, eeg_sample_rate, physical_max, physical_min, resolution=24, storage_path = None):
+        # edf文件参数
+        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.file_type = EDF_FILE_TYPE["bdf"] if resolution == 24 else EDF_FILE_TYPE["edf"]
+        # 点分辨率
+        self.resolution = resolution
+        # eeg通道数
+        self.channels = None
+        # eeg采样率
+        self.sample_rate = eeg_sample_rate
+        # bytes per second
+        self.bytes_per_second = 0
+        self._edf_writer = None
+        self._cache2 = tuple()
+        self._recording = False
+        self._edf_writer = None
+        self.annotations = None
+        # 每个数据块大小
+        self._chunk = np.array([])
+        self._duration = 0
+        self._points = 0
+        self._first_pkg_id = None
+        self._last_pkg_id = None
+        self._first_timestamp = None
+        self._start_time = None
+        self._end_time = None
+        self._patient_code = "patient_code"
+        self._patient_name = "patient_name"
+        self._device_type = "24130032"
+        self._device_no = "24130032"
+        self._total_packets = 0
+        self._lost_packets = 0
+        self._storage_path = storage_path
+        self._edf_writer_thread = None
+        self._file_prefix = None
+        
+        # 癫痫造模仪1对4， 这个是固定模式，写死，规则随设备
+        self._edf_handler = {}
+        self._edf_Handler_A = None
+        self._edf_Handler_B = None  
+        self._edf_Handler_C = None
+        self._edf_Handler_D = None
+        
+        self._channel_spilt = {
+            "A" : [49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62],
+            "B" : [33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46],
+            "C" : [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30],
+            "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",
+            
+            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",
+            
+            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()
+        
+    @property
+    def file_name(self): 
+        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}"
+        
+        if self._storage_path:
+            try:
+                # 自动创建目录，存在则忽略
+                os.makedirs(self._storage_path, exist_ok=True)  
+                
+                return f"{self._storage_path}/{file_name}"
+            except Exception as e:
+                logger.error(f"创建目录[{self._storage_path}]失败: {e}")            
+        
+        return file_name
+    
+    def set_device_type(self, device_type):
+        if device_type == 0x39:
+            self._device_type = "C64RS"
+        elif device_type == 0x40:
+            self._device_type = "LJ64S1"
+        else:
+            self._device_type = hex(device_type)
+        
+    def set_device_no(self, device_no):
+        self._device_no = device_no
+        
+    def set_storage_path(self, storage_path):
+        self._storage_path = storage_path
+        
+    def set_file_prefix(self, file_prefix):
+        self._file_prefix = file_prefix
+        
+    def set_patient_code(self, patient_code):
+        self._patient_code = patient_code
+        
+    def set_patient_name(self, patient_name):
+        self._patient_name = patient_name
+    
+    def write(self, packet: RscPacket):
+        # logger.trace(f"packet: {packet}")    
+        if packet is None:
+            # self._edf_writer_thread.stop_recording()
+            for k in self._edf_handler.keys():
+                self._edf_handler[k].append(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)
+     
+    def writeA(self, packet: RscPacket, channel_filter, name='A'):
+        # 参数检查
+        if packet is None or channel_filter is None:
+            logger.warning("空数据，忽略")
+            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.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)
+            edf_handler.set_file_prefix(f'{self._file_prefix}_{name}' if self._file_prefix else name)
+            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.origin_sample_rate = packet.origin_sample_rate
+        data.sample_rate = packet.sample_rate
+        data.sample_num = packet.sample_num
+        data.resolution = packet.resolution
+        data.trigger = packet.trigger
+        data.eeg = eeg
+        
+        self._edf_handler[name].write(data)
+    
+    # trigger标记
+    # desc: 标记内容
+    # cur_time: 设备时间时间戳，非设备发出的trigger不要设置
+    def trigger(self, desc, cur_time=None):
+        # trigger现在（20250702）多个分区共享， 分发到所有分区文件中标记
+        for k in self._edf_handler.keys():
+            self._edf_handler[k].trigger(desc, cur_time) 

{qlsdk2-0.4.1 → qlsdk2-0.5.0}/src/qlsdk/persist/rsc_edf.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+import time
 from multiprocessing import Lock, Queue
 from time import time_ns
 from pyedflib import FILETYPE_BDFPLUS, FILETYPE_EDFPLUS, EdfWriter
@@ -77,8 +78,9 @@ class EDFStreamWriter(Thread):
         if self._writer is None:
             self._init_writer()
             
-        while True:
-            if self._recording or (not self.data_queue.empty()):
+        waits = 300
+        while waits > 0:
+            if not self.data_queue.empty():
                 try:
                     data = self.data_queue.get(timeout=30)
                     if data is None:
@@ -88,13 +90,20 @@ class EDFStreamWriter(Thread):
                     self._points += len(data[1])
                     logger.trace(f"已处理数据点数：{self._points}")
                     self._write_file(data)
+                    # 有数据重置计数器
+                    waits = 100  # 重置等待计数器
                 except Exception as e:
                     logger.error(f"异常或超时(30s)结束: {str(e)}")
                     break
             else:
-                logger.debug("数据记录完成")
-                break
+                time.sleep(0.1)
+                # 记录状态等待30s、非记录状态等待3s
+                if self._recording:
+                    waits -= 1
+                else:
+                    waits -= 10
             
+        logger.info(f"数据记录完成：{self.file_path}")
         self.close()
         
     def _init_writer(self):
@@ -159,6 +168,9 @@ class EDFStreamWriter(Thread):
         # 写入时转置为(样本数, 通道数)格式
         self._writer.writeSamples(data_float64)
         self._duration += 1
+        
+        if self._duration % 10 == 0:  # 每10秒打印一次进度
+            logger.info(f"数据记录中... 文件名：{self.file_path}, 已记录时长: {self._duration}秒")
 
 # 用作数据结构一致化处理，通过调用公共类写入edf文件
 # 入参包含写入edf的全部前置参数
@@ -199,7 +211,6 @@ class RscEDFHandler(object):
         self.annotations = None
         # 每个数据块大小
         self._chunk = np.array([])
-        self._Lock = Lock()
         self._duration = 0
         self._points = 0
         self._first_pkg_id = None
@@ -217,6 +228,8 @@ class RscEDFHandler(object):
         self._edf_writer_thread = None
         self._file_prefix = None
         
+        self._lock = Lock()
+        
     @property
     def file_name(self): 
         suffix = "bdf" if self.resolution == 24 else "edf"
@@ -240,8 +253,12 @@ class RscEDFHandler(object):
             self._device_type = "C64RS"
         elif device_type == 0x40:
             self._device_type = "LJ64S1"
+        elif device_type == 0x60:
+            self._device_type = "ARSKindling"
+        elif device_type == 0x339:
+            self._device_type = "C16R"
         else:
-            self._device_type = hex(device_type)
+            self._device_type = device_type
         
     def set_device_no(self, device_no):
         self._device_no = device_no
@@ -259,33 +276,35 @@ class RscEDFHandler(object):
         self._patient_name = patient_name
     
     def write(self, packet: RscPacket):
-        logger.debug(f"packet: {packet}")    
+        # logger.trace(f"packet: {packet}")    
         if packet is None:
+            logger.info(f"收到结束信号，即将停止写入数据:{self.file_name}")
             self._edf_writer_thread.stop_recording()
             return
     
-        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}")
+        with self._lock:
+            if self.channels is None:
+                logger.debug(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.debug(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
             
-        self._edf_writer_thread.append(packet.eeg)
+            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)
             
     
     # trigger标记