qlsdk2 0.3.0a2__py3-none-any.whl → 0.4.0a1__py3-none-any.whl

qlsdk/rsc/paradigm.py

@@ -0,0 +1,310 @@
+from enum import Enum
+from abc import ABC, abstractmethod
+from loguru import logger
+import struct
+
+from qlsdk.core import to_bytes, to_channels
+
+class C64Channel(Enum):
+    CH0 = 0
+    CH1 = 1
+    CH2 = 2
+    CH3 = 3
+    CH4 = 4
+    CH5 = 5
+    CH6 = 6
+    CH7 = 7
+    CH8 = 8
+    CH9 = 9
+    CH10 = 10
+    CH11 = 11
+    CH12 = 12
+    CH13 = 13
+    CH14 = 14
+    CH15 = 15
+
+class WaveForm(Enum):
+    DC = 0
+    PULSE = 1
+    AC = 2
+    SQUARE = 3
+    
+class StimulationChannel(ABC):
+    def __init__(self, channel_id: int, wave_form: int, current: float, duration: float, ramp_up: float = None, ramp_down: float = None,):
+        self.channel_id = channel_id
+        self.wave_form = wave_form
+        self.current_max = current
+        self.current_min = 0
+        self.duration = duration
+        self.ramp_up = ramp_up
+        self.ramp_down = ramp_down
+        self.delay_time = 0
+        self.frequency = 0
+        self.phase_position = 0
+        # 预留值，用作占位
+        self.reserved = 0
+    
+    def to_bytes(self):        
+        result = self.channel_id.to_bytes(1, 'little')
+        result += self.wave_form.to_bytes(1, 'little')
+        result += int(self.current_max * 1000 ).to_bytes(2, 'little', signed = True)
+        result += int(self.current_min * 1000 ).to_bytes(2, 'little', signed = True)
+        result += struct.pack('<f', self.frequency)
+        result += struct.pack('<f', self.phase_position)
+        
+        result += self._ext_bytes()
+        
+        result += int(self.delay_time).to_bytes(4, 'little')
+        result += int(self.ramp_up * 1000).to_bytes(4, 'little')
+        result += int((self.duration + self.ramp_up)  * 1000).to_bytes(4, 'little')
+        result += int(self.ramp_down * 1000).to_bytes(4, 'little')
+        
+        return result
+    
+    def _ext_bytes(self):
+        return bytes.fromhex("00000000000000000000000000000000")
+    
+    def to_json(self):
+        pass
+        
+    def from_json(self, param):
+        pass
+    
+    def __str__(self):
+        return f"ACStimulation(channel_id={self.channel_id}, waveform={self.waveform}, current={self.current_max}, duration={self.duration}, ramp_up={self.ramp_up}, ramp_down={self.ramp_down}, frequency={self.frequency}, phase_position={self.phase_position}, duration_delay={self.duration_delay})"
+        
+        
+        
+# 刺激模式-直流
+class DCStimulation(StimulationChannel):
+    '''
+        channel_id: int,  通道编号，从0开始
+        current: float,  电流值，单位为mA
+        duration: float,  刺激时间，单位为秒
+        ramp_up: float,  上升时间，单位为秒
+        ramp_down: float,  下降时间，单位为秒
+    '''
+    def __init__(self, channel_id: int, current: float, duration: float, ramp_up: float = 0, ramp_down: float = 0):
+        super().__init__(channel_id, WaveForm.DC.value, current, duration, ramp_up, ramp_down)
+    def to_json(self):
+        return {
+            "channel_id": self.channel_id,
+            "waveform": self.wave_form,
+            "current_max": self.current_max,
+            "duration": self.duration,
+            "ramp_up": self.ramp_up,
+            "ramp_down": self.ramp_down,
+            "frequency": self.frequency,
+            "phase_position": self.phase_position,
+            "delay_time": self.delay_time
+        }
+        
+    def from_json(self, param):
+        pass
+    def __str__(self):
+        return f"ACStimulation(channel_id={self.channel_id}, waveform={self.waveform}, current={self.current_max}, duration={self.duration}, ramp_up={self.ramp_up}, ramp_down={self.ramp_down}, frequency={self.frequency}, phase_position={self.phase_position}, duration_delay={self.duration_delay})"
+        
+
+# 刺激模式-方波
+class SquareWaveStimulation(StimulationChannel):
+    '''
+        channel_id: int,  通道编号，从0开始
+        current: float,  电流值，单位为mA
+        duration: float,  刺激时间，单位为秒
+        ramp_up: float,  上升时间，单位为秒
+        ramp_down: float,  下降时间，单位为秒
+        frequency: float,  频率，单位为Hz
+        duty_cycle: float,  占空比，高电平时间/周期，范围(0, 100)
+    '''
+    def __init__(self, channel_id: int, current: float, duration: float, ramp_up: float = 0, ramp_down: float = 0,
+                 frequency: float = None, duty_cycle: float = 0.5):
+        super().__init__(channel_id, WaveForm.SQUARE.value, current, duration, ramp_up, ramp_down)
+        self.frequency = frequency
+        self.duty_cycle = duty_cycle
+        
+        
+    def to_bytes(self):
+        # Convert the object to bytes for transmission
+        result = self.channel_id.to_bytes(1, 'little')
+        result += self.wave_form.to_bytes(1, 'little')
+        result += int(self.current_max * 1000 * 1000).to_bytes(4, 'little', signed = True)
+        # result += int(self.current_min * 1000).to_bytes(2, 'little')
+        result += int(self.frequency).to_bytes(2, 'little')
+        result += int(self.reserved).to_bytes(2, 'little')
+        result += struct.pack('<f', self.duty_cycle)
+        
+        result += self._ext_bytes()
+        
+        result += int(self.delay_time).to_bytes(4, 'little')
+        result += int(self.ramp_up * 1000).to_bytes(4, 'little')
+        result += int((self.duration + self.ramp_up)  * 1000).to_bytes(4, 'little')
+        result += int(self.ramp_down * 1000).to_bytes(4, 'little')
+        
+        return result
+        
+# 刺激模式-交流
+class ACStimulation(StimulationChannel):
+    '''
+        channel_id: int,  通道编号，从0开始
+        current: float,  电流值，单位为mA
+        duration: float,  刺激时间，单位为秒
+        ramp_up: float,  上升时间，单位为秒
+        ramp_down: float,  下降时间，单位为秒
+        frequency: float,  频率，单位为Hz
+        phase_position: int,  相位位置，单位为度
+    '''
+    
+    def __init__(self, channel_id: int, current: float, duration: float, ramp_up: float = 0, ramp_down: float = 0,
+                 frequency: float = None, phase_position: int = 0):
+        super().__init__(channel_id, WaveForm.AC.value, current, duration, ramp_up, ramp_down)
+        self.current_max = abs(current)
+        self.current_min = -abs(current)
+        self.frequency = frequency
+        # self.frequency = frequency
+        self.phase_position = phase_position
+    
+    def to_json(self):
+        return {
+            "channel_id": self.channel_id,
+            "waveform": self.wave_form,
+            "current_max": self.current_max,
+            "duration": self.duration,
+            "ramp_up": self.ramp_up,
+            "ramp_down": self.ramp_down,
+            "frequency": self.frequency,
+            "phase_position": self.phase_position
+        }
+        
+    def from_json(self, param):
+        pass
+    def __str__(self):
+        return f"ACStimulation(channel_id={self.channel_id}, waveform={self.waveform}, current={self.current_max}, duration={self.duration}, ramp_up={self.ramp_up}, ramp_down={self.ramp_down}, frequency={self.frequency}, phase_position={self.phase_position}, duration_delay={self.duration_delay})"
+        
+# 刺激模式-脉冲
+class PulseStimulation(StimulationChannel):
+    '''
+        channel_id: int,  通道编号，从0开始
+        current: float,  电流值，单位为mA
+        duration: float,  刺激时间，单位为秒
+        ramp_up: float,  上升时间，单位为秒
+        ramp_down: float,  下降时间，单位为秒
+        frequency: float,  频率，单位为Hz
+        phase_position: int,  相位位置，单位为度
+    '''
+    def __init__(self, channel_id: int, current: float, duration: float, frequency: float,  pulse_width: int, 
+                 pulse_width_ratio: float = 1, ramp_up: float = 0, ramp_down: float = 0, delay_time = 0):
+        super().__init__(channel_id, WaveForm.PULSE.value, current, duration, ramp_up, ramp_down)
+        self.frequency = frequency
+        self.duration_delay = delay_time
+        self.pulse_width = pulse_width 
+        self.pulse_width_ratio = pulse_width_ratio
+        self.pulse_interval = 0
+        self.with_group_repeats = 1
+        self.pulse_time_f = 0
+        self.pulse_time_out = 0
+        self.pulse_time_idle = 0
+        
+    def to_bytes(self):
+        # Convert the object to bytes for transmission
+        result = self.channel_id.to_bytes(1, 'little')
+        result += self.wave_form.to_bytes(1, 'little')
+        result += int(self.current_max * 1000 * 1000).to_bytes(4, 'little', signed = True)
+        # result += int(self.current_min * 1000).to_bytes(2, 'little')
+        result += int(self.frequency).to_bytes(2, 'little')
+        result += int(self.pulse_width).to_bytes(2, 'little')
+        result += struct.pack('<f', self.pulse_width_ratio)
+        
+        result += int(self.pulse_interval).to_bytes(2, 'little')
+        result += int(self.with_group_repeats).to_bytes(2, 'little')
+        result += int(self.pulse_time_f).to_bytes(4, 'little')
+        result += int(self.pulse_time_out).to_bytes(4, 'little')
+        result += int(self.pulse_time_idle).to_bytes(4, 'little')
+        
+        result += int(self.delay_time).to_bytes(4, 'little')
+        result += int(self.ramp_up * 1000).to_bytes(4, 'little')
+        result += int((self.duration + self.ramp_up)  * 1000).to_bytes(4, 'little')
+        result += int(self.ramp_down * 1000).to_bytes(4, 'little')
+        
+        return result
+    
+    def to_json(self):
+        return {
+            "channel_id": self.channel_id,
+            "wave_form": self.wave_form,
+            "current_max": self.current_max,
+            "current_min": self.current_min,
+            "duration": self.duration,
+            "ramp_up": self.ramp_up,
+            "ramp_down": self.ramp_down,
+            "frequency": self.frequency,
+            "phase_position": self.phase_position,
+            "duration_delay": self.duration_delay,
+            "pulse_width": self.pulse_width,
+            "delay_time": self.delay_time,
+            "pulse_interval": self.pulse_interval,
+            "with_group_repeats": self.with_group_repeats
+        }
+    
+        
+# 刺激范式
+class StimulationParadigm(object):
+    def __init__(self):
+        self.channels = None
+        self.duration = None
+        self.interval_time = 0
+        self.characteristic = 1
+        self.mode = 0
+        self.repeats = 0
+        
+    def add_channel(self, channel: StimulationChannel, update=False):
+        if self.channels is None:
+            self.channels = {}
+        channel_id = channel.channel_id + 1
+        if channel_id in self.channels.keys():
+            logger.warning(f"Channel {channel_id} already exists")
+            if update:
+                self.channels[channel_id] = channel
+        else:
+            self.channels[channel_id] = channel  
+            
+        # 计算刺激时间
+        duration = channel.duration + channel.ramp_up + channel.ramp_down     
+        if self.duration is None or duration > self.duration:
+            self.duration = duration 
+        
+        
+    def to_bytes(self):
+        result = to_bytes(list(self.channels.keys()), 64)
+        result += int(self.duration * 1000).to_bytes(4, 'little')
+        result += int(self.interval_time).to_bytes(4, 'little')
+        result += int(self.characteristic).to_bytes(4, 'little')
+        result += int(self.mode).to_bytes(1, 'little')
+        result += int(self.repeats).to_bytes(4, 'little')
+        for channel in self.channels.values():
+            result += channel.to_bytes()
+        return result
+    
+    def to_json(self):
+        # Convert the object to JSON for transmission
+        return {
+            "channels": list(self.channels.keys()),
+            "duration": self.duration,
+            "interval_time": self.interval_time,
+            "characteristic": self.characteristic,
+            "mode": self.mode,
+            "repeats": self.repeats, 
+            "stim": [channel.to_json() for channel in self.channels.values()]
+        }
+        
+    # @staticmethod
+    # def from_json(param: Dict[str, Any]):
+    #     pass
+    
+    def clear(self):
+        self.channels = None
+        self.duration = None
+        self.interval_time = 0
+        self.characteristic = 1
+        self.mode = 0
+        self.repeats = 0
+

qlsdk/rsc/proxy.py

@@ -0,0 +1,76 @@
+from loguru import logger
+from threading import Thread, Lock
+import socket
+
+class DeviceProxy(object):
+    def __init__(self, client_socket):
+        self.client_socket = client_socket
+        self.server_socket = None   
+        # 客户端设备
+        # self.device = QLDevice(client_socket)
+        # self.parser = DeviceParser(self.device)
+        
+        self._init_server()
+        
+    def _init_server(self):
+        # 连接目标服务（桌面端运行在本地的18125端口）
+        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.server_socket.connect(('localhost', 18125))
+    
+    def start(self):
+        logger.info("DeviceProxy连接已建立")
+        
+        try:            
+            # 创建双向转发线程
+            client_thread = Thread(
+                target=self.data_forward,
+                args=(self.client_socket, self.server_socket, "设备->软件")
+            )
+            server_thread = Thread(
+                target=self.data_forward,
+                args=(self.server_socket, self.client_socket, "软件->设备")
+            )
+
+            # 启动线程
+            client_thread.start()
+            server_thread.start()
+
+            # 等待线程结束
+            client_thread.join()
+            server_thread.join()
+            
+        except Exception as e:
+            logger.error(f"连接异常: {str(e)}")
+            self.client_socket.close()      
+        finally:
+            logger.error(f"连接已结束")
+            self.client_socket.close()
+            
+    def data_forward(self, src, dest, direction, callback=None):
+        """
+        数据转发函数
+        :param src: 源socket连接
+        :param dest: 目标socket连接
+        :param direction: 转发方向描述
+        """
+        try:
+            logger.debug(f"[{direction}] 转发开始")
+            while True:
+                data = src.recv(4096*1024)  # 接收数据缓冲区设为4KB
+                if not data:
+                    break
+                logger.info(f"[{direction}] 转发指令: {hex(int.from_bytes(data[12:14], 'little'))} ")
+                logger.debug(f"[{direction}] 转发 {data.hex()} ")
+                if callback:
+                    callback(data)
+                dest.sendall(data)
+                logger.debug(f"[{direction}] 转发 {len(data)} 字节")
+        except ConnectionResetError:
+            logger.error(f"[{direction}] 连接已关闭")
+        finally:
+            src.close()
+            dest.close()
+            
+    # def device_message(self, data):     
+    #     # 解析数据包
+    #     self.parser.append(data)

{qlsdk2-0.3.0a2.dist-info → qlsdk2-0.4.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: qlsdk2
-Version: 0.3.0a2
+Version: 0.4.0a1
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun

qlsdk2-0.4.0a1.dist-info/RECORD

@@ -0,0 +1,40 @@
+qlsdk/__init__.py,sha256=mjjFQ8LEHgwMmud5ie2Tgl2aOafnz53gkcAju0q7T0c,446
+qlsdk/ar4/__init__.py,sha256=iR0bFanDwqSxSEM1nCcge1l-GSIWjwnMeRQa47wGrds,4752
+qlsdk/ar4m/__init__.py,sha256=Z13X53WKmKp6MW_fA1FUPdQgJxhxxuyzemJWPS_CEHA,639
+qlsdk/core/__init__.py,sha256=nFXRJIMxV8nnHIn0doWey0pDZvfmhMu8J4ECMfzAZgc,126
+qlsdk/core/device.py,sha256=dPoQUwd78-Ieef6ZcBI7isVm0W8aYarqBy6UHP7Yjoc,587
+qlsdk/core/exception.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qlsdk/core/local.py,sha256=vbison4XZtS4SNYLJ9CqBhetEcukdviTWmvtdA1efkQ,811
+qlsdk/core/utils.py,sha256=eAg6oa8lGoVdaPcUAR128J1-Nwf_ghDPehUVtbw_WCc,4036
+qlsdk/core/crc/__init__.py,sha256=kaYSr6KN5g4U49xlxAvT2lnEeGtwX4Dz1ArwKDvUIIY,143
+qlsdk/core/crc/crctools.py,sha256=sDeE6CMccQX2cRAyMQK0SZUk1fa50XMuwqXau5UX5C8,4242
+qlsdk/core/entity/__init__.py,sha256=xEROyxn-KX1aa1XomOmYgwfeYOx52ZXDAs0SftAEOD8,3289
+qlsdk/core/filter/__init__.py,sha256=YIWIzDUKN30mq2JTr53ZGblggZfC_rLUp2FSRrsQFgU,36
+qlsdk/core/filter/norch.py,sha256=5RdIBX5eqs5w5nmVAnCB3ESSuAT_vVBZ2g-dg6HMZdY,1858
+qlsdk/core/message/__init__.py,sha256=sHuavOyHf4bhH6VdDpTA1EsCh7Q-XsPHcFiItpVz3Rs,51
+qlsdk/core/message/command.py,sha256=wk5DAsvlAtUikGZ4a8honRZf-iQQaIypjzud8GpnHtU,11311
+qlsdk/core/message/tcp.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qlsdk/core/message/udp.py,sha256=KS_pKZcCEFhNGABCOZTOHiVFkfPNZl_0K5RXppwMIvA,3085
+qlsdk/persist/__init__.py,sha256=OR8mnPTsktxw67G-z0VsPWJXInkKircMTHQdibmmz3M,63
+qlsdk/persist/edf.py,sha256=usgFjZJVcfAUwSy6cJtRdgjdqMgOS4viLCDGcwAGMZE,7106
+qlsdk/persist/rsc_edf.py,sha256=DM871w2-2vXNSEIzNnMLzW_ftCZSM8NhPSmu56h5jz4,8692
+qlsdk/rsc/__init__.py,sha256=bR678DilIIK7tFP65tscPUI7Bp4VN0ndVQWt6bnQKGg,197
+qlsdk/rsc/device_manager.py,sha256=ZUuhwamKky_Z9jI9_ww5S8ZcGZpSTkjWwP1kRZEOK2U,3597
+qlsdk/rsc/discover.py,sha256=cFDOADWD6Y0oE4x37f8j14a18Udwi6F0uSTbiC_1N1E,3039
+qlsdk/rsc/eegion.py,sha256=lxrktO-3Z_MYdFIwc4NxvgLM5AL5kU3UItjH6tsKmHY,11670
+qlsdk/rsc/entity.py,sha256=qmLvJ6gCR9r7y60m91L20FJYOaAHwH6k6aXecqHurjU,21062
+qlsdk/rsc/paradigm.py,sha256=Iy_eU_yZLHiUZlLNPvqke5GDVJFnMEQ_PQ6cRxTm2BM,12606
+qlsdk/rsc/proxy.py,sha256=9CPdGNGWremwBUh4GvlXAykYB-x_BEPPLqsNvwuwIDE,2736
+qlsdk/rsc/command/__init__.py,sha256=D5pBE2leqFG-IPU2pDAGuLsqHmc0wRPrBOXR0-K8d6k,8117
+qlsdk/rsc/command/message.py,sha256=bcuUDJj0CMekcZMNhKrzIpkHtDC-QBCs3dJG6Bx_PHc,8723
+qlsdk/sdk/__init__.py,sha256=v9LKP-5qXCqnAsCkiRE9LDb5Tagvl_Qd_fqrw7y9yd4,68
+qlsdk/sdk/ar4sdk.py,sha256=ZILuUVgUZN7-LNQm4xdItxmZWGwvFt4oWUKGez1BCLI,27101
+qlsdk/sdk/hub.py,sha256=uEOGZBZtMDCWlV8G2TZe6FAo6eTPcwHAW8zdqr1eq_0,1571
+qlsdk/sdk/libs/libAr4SDK.dll,sha256=kZp9_DRwPdAJ5OgTFQSqS8tEETxUs7YmmETuBP2g60U,15402132
+qlsdk/sdk/libs/libwinpthread-1.dll,sha256=W77ySaDQDi0yxpnQu-ifcU6-uHKzmQpcvsyx2J9j5eg,52224
+qlsdk/x8/__init__.py,sha256=XlQn3Af_HA7bGrxhv3RZKWMob_SnmissXiso7OH1UgI,4750
+qlsdk/x8m/__init__.py,sha256=cLeUqEEj65qXw4Qa4REyxoLh6T24anSqPaKe9_lR340,634
+qlsdk2-0.4.0a1.dist-info/METADATA,sha256=-yHCdrfe8EJRciRLY0Pl2bjjrFYtPkHuOyiYLPb6ey8,7066
+qlsdk2-0.4.0a1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+qlsdk2-0.4.0a1.dist-info/top_level.txt,sha256=2CHzn0SY-NIBVyBl07Suh-Eo8oBAQfyNPtqQ_aDatBg,6
+qlsdk2-0.4.0a1.dist-info/RECORD,,