qlsdk2 0.3.0a3__py3-none-any.whl → 0.4.0__py3-none-any.whl

qlsdk/core/message/udp.py

@@ -0,0 +1,96 @@
+
+from enum import Enum
+from time import timezone
+from qlsdk.core.crc import check_crc, crc16
+from qlsdk.core.local import get_ip
+
+from loguru import logger
+
+
+class UDPCommand(Enum):
+    CONNECT = 0x10
+    NOTIFY = 0x09
+
+
+class UDPMessage(object):
+    START = "SHQuanLan"
+    MAC = 'mac'
+    DEV_TYPE = "dev_type"
+    VERSION_CODE = "version_code"
+    VERSION_NAME = "version_name"
+
+    def __init__(self) -> None:
+        self._base = None
+        self._message = None
+
+    @staticmethod
+    def parse(packet, address = None):
+        plen = len(packet)
+        if plen < 10:
+            logger.trace("message length too short.")
+            return
+
+        start = packet[:9].decode("utf-8")
+        # quanlan udp message
+        if start != UDPMessage.START:
+            return
+
+        if not check_crc(packet):
+            logger.warn(f"数据CRC校验失败，丢弃！")
+            return
+        
+        # message command
+        cmd = int.from_bytes(packet[10:12], 'little')
+
+        return UDPMessage._parse(cmd, packet[12:])
+
+    @staticmethod
+    def _parse(cmd, data):
+        # 只解析0x09
+        if cmd == UDPCommand.NOTIFY.value:
+            return UDPMessage.parseDeviceInfo(data)
+        else:
+            logger.trace(f'不支持的消息. cmd: {hex(cmd)} dlen: {len(data)} data: {data}')
+            return None
+        
+    @staticmethod
+    def parseDeviceInfo(data):
+        device_info = {}
+        try:
+            device_info[UDPMessage.DEV_TYPE] = hex(int.from_bytes(data[:2], 'little'))
+            device_info[UDPMessage.MAC] = hex(int.from_bytes(data[2:10], 'little'))
+            device_info[UDPMessage.VERSION_CODE] = int.from_bytes(data[42:46], 'little')
+            device_info[UDPMessage.VERSION_NAME] = str(data[10:42],'utf-8').split('\x00')[0]
+        except Exception as e:
+            logger.error(f"parseDeviceInfo异常：{e}")
+
+        return device_info
+
+    @staticmethod
+    def search(device_id : str, server_ip : str=None, server_port : int=19216):
+        # 服务端Ip
+        if server_ip is None:
+            server_ip = get_ip()
+            
+        logger.debug(f"search device {device_id} on {server_ip}:{server_port}")
+            
+        message = bytearray(28)
+        # 消息头
+        message[:10] = UDPMessage.START.encode('utf-8')
+        # 消息类型
+        message[10:12] = UDPCommand.CONNECT.value.to_bytes(2, 'little')
+        # 设备序列号格式沿用现有协议
+        serial_no = f'F0{device_id[:2]}FFFFFFFF{device_id[4:]}' 
+        message[12:22] = bytes.fromhex(serial_no)
+        # 本机ip
+        ip = server_ip.split(".")    
+        message[22] = (int)(ip[0])
+        message[23] = (int)(ip[1])
+        message[24] = (int)(ip[2])
+        message[25] = (int)(ip[3])
+        # 服务端端口（按大端输出）
+        message[26:28] = server_port.to_bytes(2, 'big')
+        # 校验和（按小端输出）
+        checksum = crc16(message).to_bytes(2, 'little')
+
+        return message + checksum

qlsdk/core/network/__init__.py

@@ -0,0 +1,34 @@
+import psutil
+import socket
+
+def get_active_interfaces():
+    interfaces = {}
+    # 获取所有接口地址信息
+    all_addrs = psutil.net_if_addrs()
+    # 获取接口状态（是否处于UP状态）
+    stats = psutil.net_if_stats()
+    
+    for name, addrs in all_addrs.items():
+        # 检查接口是否启用
+        if stats[name].isup:
+            ips = []
+            for addr in addrs:
+                # 提取IPv4和IPv6地址
+                if addr.family == socket.AF_INET:
+                    ips.append(f"IPv4: {addr.address}")
+                elif addr.family == socket.AF_INET6:
+                    ips.append(f"IPv6: {addr.address}")
+            # 过滤无IP的接口（可选）
+            if ips:
+                interfaces[name] = {
+                    "status": "UP",
+                    "IPs": ips
+                }
+    return interfaces
+
+# 调用并打印结果
+active_ifs = get_active_interfaces()
+for iface, info in active_ifs.items():
+    print(f"接口: {iface}")
+    print(f"状态: {info['status']}")
+    print(f"IP地址: {info['IPs']}\n")

qlsdk/core/network/monitor.py

@@ -0,0 +1,55 @@
+from threading import Thread
+import psutil
+import time
+
+def get_active_ipv4():
+    ips = []
+    # 获取所有接口地址信息
+    all_addrs = psutil.net_if_addrs()
+    # 获取接口状态（是否处于UP状态）
+    stats = psutil.net_if_stats()
+    
+    for name, addrs in all_addrs.items():
+        # 检查接口是否启用
+        if stats[name].isup:
+            for addr in addrs:
+                # 提取IPv4地址
+                if addr.family == socket.AF_INET:
+                    ips.append(addr.address)
+    return ips
+def monitor_up_interfaces(interval=2, callback=None):
+    prev_status = {iface: psutil.net_if_stats()[iface].isup 
+                  for iface in psutil.net_if_stats()}
+    
+    while True:
+        current_stats = psutil.net_if_stats()
+        for iface, stats in current_stats.items():
+            current_up = stats.isup
+            # 检测状态变化
+            if current_up != prev_status.get(iface, None):
+                if current_up:
+                    print(f"[UP] 接口 {iface} 激活")
+                    if callback: callback(iface, "UP")
+                else:
+                    print(f"[DOWN] 接口 {iface} 断开")
+                    if callback: callback(iface, "DOWN")
+                prev_status[iface] = current_up
+        time.sleep(interval)
+
+# 自定义回调函数示例
+def notify(iface, status):
+    if status == "UP":
+        print(f"接口 {iface} 已激活")
+
+# 启动监听
+# monitor_up_interfaces(callback=notify)
+
+monitor = Thread(target=monitor_up_interfaces, name="Network Status Monitor", args=(2, notify))
+monitor.start()
+
+import socket
+def is_port_in_use(ip, port):
+    with socket.socket() as s:
+        return s.connect_ex((ip, port)) == 0
+    
+print(get_active_ipv4())

qlsdk/core/utils.py

@@ -0,0 +1,70 @@
+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)))

qlsdk/persist/__init__.py

@@ -1 +1,2 @@
-from .edf import EdfHandler
+from .edf import EdfHandler
+from .rsc_edf import RscEDFHandler

qlsdk/persist/rsc_edf.py

@@ -0,0 +1,299 @@
+from datetime import datetime
+from multiprocessing import Lock, Queue
+from time import time_ns
+from pyedflib import FILETYPE_BDFPLUS, FILETYPE_EDFPLUS, EdfWriter
+from threading import Thread
+from loguru import logger
+import numpy as np
+import os
+from qlsdk.core import RscPacket
+
+EDF_FILE_TYPE = {
+    "bdf": FILETYPE_BDFPLUS,
+    "edf": FILETYPE_EDFPLUS
+}
+
+class EDFStreamWriter(Thread):
+    def __init__(self, channels, sample_frequency, physical_max, digital_min, file_type, file_path):
+        super().__init__()
+        self._writer : EdfWriter = None
+        self.data_queue : Queue = Queue()
+        self._recording = False
+        self._points = 0
+        self._duration = 0
+        self._buffer = None
+        
+        # signal info
+        self._channels = channels
+        self._n_channels = len(channels)
+        self.sample_frequency = sample_frequency
+        self.physical_max = physical_max
+        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
+        self.file_type = file_type
+        self.file_path = file_path
+        
+        # 记录开始时间
+        self.start_time = None
+        
+        # header info
+        self.equipment = "equipment"
+        self.patient_code = "patient_code"
+        self.patient_name = "patient_name"
+        
+    def set_channels(self, channels):
+        self._channels = channels
+        self._n_channels = len(channels)
+        
+    def set_sample_rate(self, sample_rate):
+        self._sample_rate = sample_rate
+        
+    def set_start_time(self, time):
+        self.start_time = time
+
+    def stop_recording(self):
+        self._recording = False
+        
+    def append(self, data):
+        if data:
+            # 数据
+            self.data_queue.put(data)
+            
+    def trigger(self, onset, desc):
+        if self._writer:            
+            self._writer.writeAnnotation(onset, 1, desc)
+        else:
+            logger.warning("未创建文件，无法写入Trigger标记")
+        
+        
+    def run(self):
+        logger.debug(f"启动bdf文件写入线程，写入数据到文件 {self.file_path}")
+        # 记录状态
+        self._recording = True
+        
+        #  初始化
+        if self._writer is None:
+            self._init_writer()
+            
+        while True:
+            if self._recording or (not self.data_queue.empty()):
+                try:
+                    data = self.data_queue.get(timeout=30)
+                    if data is None:
+                        logger.debug("收到结束信号，停止写入数据")
+                        break
+                    # 处理数据
+                    self._points += len(data[1])
+                    logger.trace(f"已处理数据点数：{self._points}")
+                    self._write_file(data)
+                except Exception as e:
+                    logger.error(f"异常或超时(30s)结束: {str(e)}")
+                    break
+            else:
+                logger.debug("数据记录完成")
+                break
+            
+        self.close()
+        
+    def _init_writer(self):
+        
+        # 创建EDF+写入器
+        self._writer = EdfWriter(
+            self.file_path,
+            self._n_channels,
+            file_type=self.file_type
+        )
+        
+        # 设置头信息
+        self._writer.setPatientCode(self.patient_code)
+        self._writer.setPatientName(self.patient_name)
+        self._writer.setEquipment(self.equipment)
+        self._writer.setStartdatetime(self.start_time if self.start_time else datetime.now())
+        
+        # 配置通道参数
+        signal_headers = []
+        for ch in range(self._n_channels):
+            signal_headers.append({
+                "label": f'channels {self._channels[ch]}',
+                "dimension": 'uV',
+                "sample_frequency": self.sample_frequency,
+                "physical_min": self.physical_min,
+                "physical_max": self.physical_max,
+                "digital_min": self.digital_min,
+                "digital_max": self.digital_max
+            })
+        
+        self._writer.setSignalHeaders(signal_headers)
+        
+    def _write_file(self, eeg_data):
+        try:            
+            if self._buffer is None or self._buffer.size == 0:
+                self._buffer = np.asarray(eeg_data)
+            else:                
+                self._buffer = np.hstack((self._buffer, eeg_data))
+            
+            if self._buffer.shape[1] >= self.sample_frequency:      
+                block = self._buffer[:, :self.sample_frequency]          
+                self._write_block(block)
+                self._buffer = self._buffer[:, self.sample_frequency:]      
+            
+        except Exception as e:
+            logger.error(f"写入数据异常: {str(e)}")
+        
+    def close(self):
+        self._recording = False
+        if self._writer:            
+            self._writer.writeAnnotation(0, 1, "recording start")
+            self._writer.writeAnnotation(self._duration, 1, "recording end")
+            self._writer.close()
+        
+        logger.info(f"文件: {self.file_path}完成记录, 总点数: {self._points}, 总时长: {self._duration}秒")
+    
+    # 写入1秒的数据
+    def _write_block(self, block):
+        logger.trace(f"写入数据: {block}")
+        # 转换数据类型为float64
+        data_float64 = block.astype(np.float64)
+        # 写入时转置为(样本数, 通道数)格式
+        self._writer.writeSamples(data_float64)
+        self._duration += 1
+
+# 用作数据结构一致化处理，通过调用公共类写入edf文件
+# 入参包含写入edf的全部前置参数
+# 实时数据包为个性化数据包，含有eeg数据部分
+class RscEDFHandler(object):
+    '''
+        Rsc EDF Handler
+        处理EDF文件的读写
+        RSC设备通道数根据选择变化，不同通道采样频率相同
+        eeg_sample_rate: 采样频率
+        physical_max: 物理最大值    
+        physical_min: 物理最小值
+        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
+        self.digital_min = -8388607
+        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._Lock = Lock()
+        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
+        
+    @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.debug(f"packet: {packet}")    
+        if packet is None:
+            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}")
+            
+        self._edf_writer_thread.append(packet.eeg)
+            
+    
+    # trigger标记
+    # desc: 标记内容
+    # cur_time: 设备时间时间戳，非设备发出的trigger不要设置
+    def trigger(self, desc, cur_time=None):
+        if cur_time is None:
+            onset = datetime.now().timestamp() - self._start_time.timestamp()
+        else:
+            onset = cur_time - self._first_timestamp
+        self._edf_writer_thread.trigger(onset, desc)     
+    

qlsdk/rsc/__init__.py

@@ -0,0 +1,7 @@
+from .discover import *
+
+from .entity import DeviceParser, QLDevice
+from .command import *
+from .device_manager import DeviceContainer
+from .proxy import DeviceProxy
+from .paradigm import *