qlsdk2 0.6.0a3__tar.gz → 0.6.0a5__tar.gz

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qlsdk2
-Version: 0.6.0a3
+Version: 0.6.0a5
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding='utf-8' ) as fh:
 
 setuptools.setup(
     name="qlsdk2",
-    version="0.6.0a3",
+    version="0.6.0a5",
     author="hehuajun",
     author_email="hehuajun@eegion.com",
     description="SDK for quanlan device",

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/src/qlsdk/core/entity/__init__.py

@@ -72,24 +72,34 @@ class RscPacket(Packet):
 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])
-        
-        logger.trace(f"impedance: {self}")
+    @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}")
         
+        return packet
+
     def __str__(self):
         return f"""
             time_stamp: {self.time_stamp}
             pkg_id: {self.pkg_id}
-            result: {self.result}
             channels: {self.channels}
-            data len: {self.data_len}
             impedance: {self.impedance}
         """
         
@@ -162,4 +172,40 @@ class C256RSPacket(Packet):
             offset += 4 + channel_size * packet.resolution 
             
         logger.trace(packet)
-        return 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}
+            pkg_id: {self.pkg_id}
+            result: {self.result}
+            channels: {self.channels}
+            data len: {self.data_len}
+            impedance: {self.impedance}
+        """
+            

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/src/qlsdk/rsc/command/__init__.py

@@ -233,7 +233,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
@@ -297,8 +297,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):

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/src/qlsdk/rsc/device/base.py

@@ -9,6 +9,7 @@ from qlsdk.core.entity import RscPacket, ImpedancePacket
 from qlsdk.core.utils import to_bytes
 from qlsdk.rsc.interface import IDevice, IParser
 from qlsdk.rsc.command import StartImpedanceCommand, StopImpedanceCommand, StartStimulationCommand, StopStimulationCommand, SetAcquisitionParamCommand, StartAcquisitionCommand, StopAcquisitionCommand
+from qlsdk.rsc.paradigm import StimulationParadigm
 from qlsdk.rsc.parser.base import TcpMessageParser
 
 class QLBaseDevice(IDevice):
@@ -91,7 +92,7 @@ class QLBaseDevice(IDevice):
             ]
         }
         
-        self.stim_paradigm = None
+        self.stim_paradigm: StimulationParadigm = None
                       
         signal_info = {
             "param" : None,
@@ -144,7 +145,7 @@ class QLBaseDevice(IDevice):
             self._produce_impedance(body)       
         
     def _produce_impedance(self, body: bytes):
-        packet = ImpedancePacket().transfer(body)
+        packet = ImpedancePacket.transfer(body)
         # 分发阻抗数据包给订阅者
         if len(self._impedance_consumer) > 0:
             for topic, q in self._impedance_consumer.items():
@@ -354,7 +355,7 @@ class QLBaseDevice(IDevice):
         self.stim_paradigm = param
     
     # 设置采集参数
-    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
+    def set_acq_param(self, channels, sample_rate:Literal[188, 375, 563, 750, 1125, 2250, 4500] = 500, sample_range:Literal[250, 500, 1000, 2000, 4000, 8000, 16000, 32000] = 188):
         self._acq_param["channels"] = channels 
         self._acq_param["sample_rate"] = sample_rate
         self._acq_param["sample_range"] = sample_range
@@ -389,6 +390,9 @@ class QLBaseDevice(IDevice):
         t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,), daemon=True)
         t.start()
         
+    def get_stim_param(self) -> bytes:
+        return self.stim_paradigm.to_bytes()
+        
     def _stop_stimulation_trigger(self, duration):
         delay = duration
         while delay > 0:
@@ -446,7 +450,7 @@ class QLBaseDevice(IDevice):
             
         # 数据队列
         if q is None:
-            q = Queue(maxsize=1000)
+            q = Queue(maxsize=1024 * 1024)
         
         # 订阅生理电信号数据
         if type == "signal":

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/src/qlsdk/rsc/device/c256_rs.py

@@ -199,15 +199,6 @@ class C256RS(QLBaseDevice):
     def set_stim_param(self, param):
         self.stim_paradigm = param
     
-    # 设置采集参数
-    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
-        self._acq_param["channels"] = channels 
-        self._acq_param["sample_rate"] = sample_rate
-        self._acq_param["sample_range"] = sample_range
-        self._acq_channels = channels
-        self._sample_rate = sample_rate
-        self._sample_range = sample_range
-    
     def _signal_wrapper(self, body: bytes):
         return C256RSPacket().transfer(body)
         
@@ -234,6 +225,9 @@ class C256RS(QLBaseDevice):
         t = Thread(target=self._stop_stimulation_trigger, args=(self.stim_paradigm.duration,))
         t.start()
         
+    def get_stim_param(self) -> bytes:
+        return self.stim_paradigm.to_bytes_c256()
+        
     def _stop_stimulation_trigger(self, duration):
         delay = duration
         while delay > 0:

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/src/qlsdk/rsc/device/c64_rs.py

@@ -285,35 +285,7 @@ class C64RS(QLBaseDevice):
         if self._edf_handler:
             # 发送结束标识
             self.edf_handler.write(None)
-        
-    # 订阅实时数据
-    def subscribe(self, topic:str=None, q : Queue=None, type : Literal["signal","impedance"]="signal"):  
-            
-        # 数据队列
-        if q is None:
-            q = Queue(maxsize=1000)
-            
-        # 队列名称     
-        if topic is None:
-            topic = f"{type}_{time_ns()}"
-        
-        # 订阅生理电信号数据
-        if type == "signal":
-            # topic唯一，用来区分不同的订阅队列（下同）
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
-            else:
-                self.__signal_consumer[topic] = q
-            
-        # 订阅阻抗数据
-        if type == "impedance":
-            if topic in list(self.__signal_consumer.keys()):
-                logger.warning(f"exists {type} subscribe of {topic}")
-            else:
-                self.__impedance_consumer[topic] = q
-            
-        return topic, q
-    
+
     def trigger(self, desc):
         if self._edf_handler:
             self.edf_handler.trigger(desc)

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/src/qlsdk/rsc/paradigm.py

@@ -61,6 +61,22 @@ class StimulationChannel(ABC):
         
         return result
     
+    def to_bytes_c256(self):        
+        result = self.channel_id.to_bytes(1, 'little')
+        result += self.wave_form.to_bytes(1, 'little')
+        
+        result += self._to_bytes_c256()
+        
+        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_bytes_c256(self):
+        return bytes.fromhex("00000000000000000000000000000000000000000000000000000000")
+    
     def _ext_bytes(self):
         return bytes.fromhex("00000000000000000000000000000000")
     
@@ -99,6 +115,9 @@ class DCStimulation(StimulationChannel):
             "delay_time": self.delay_time
         }
         
+    def _to_bytes_c256(self):
+        return int(self.current_max * 1000 ).to_bytes(2, 'little') + bytes.fromhex("0000000000000000000000000000000000000000000000000000")
+        
     def from_json(self, param):
         pass
     def __str__(self):
@@ -140,9 +159,19 @@ class SquareWaveStimulation(StimulationChannel):
         result += int((self.duration + self.ramp_up)  * 1000).to_bytes(4, 'little')
         result += int(self.ramp_down * 1000).to_bytes(4, 'little')
         
-        return result
-        
-# 刺激模式-交流
+        return result      
+    
+    def _to_bytes_c256(self):
+        result = int(self.current_max * 1000000 ).to_bytes(4, 'little')
+        result += int(self.frequency).to_bytes(2, 'little')
+        result += bytes.fromhex("0000")
+        result += struct.pack('<f', self.duty_cycle)
+        result = int(self.current_min * 1000000 ).to_bytes(4, 'little')
+        result += self._ext_bytes()
+        return  result
+    
+      
+# 刺激模式-正弦
 class ACStimulation(StimulationChannel):
     '''
         channel_id: int,  通道编号，从0开始
@@ -177,6 +206,15 @@ class ACStimulation(StimulationChannel):
         
     def from_json(self, param):
         pass
+    
+    def _to_bytes_c256(self):
+        result = int(self.current_max * 1000 ).to_bytes(2, 'little')
+        result += bytes.fromhex("0000")
+        result += struct.pack('<f', self.frequency)
+        result += struct.pack('<f', self.phase_position)
+        result += self._ext_bytes()
+        return  result
+    
     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})"
         
@@ -230,6 +268,15 @@ class PulseStimulation(StimulationChannel):
         
         return result
     
+    def _to_bytes_c256(self):
+        result = int(self.current_max * 1000000 ).to_bytes(4, 'little')
+        result += int(self.frequency).to_bytes(2, 'little')
+        result += bytes.fromhex("0000")
+        result += struct.pack('<f', self.duty_cycle)
+        result = int(self.current_min * 1000000 ).to_bytes(4, 'little')
+        result += self._ext_bytes()
+        return  result
+    
     def to_json(self):
         return {
             "channel_id": self.channel_id,
@@ -287,6 +334,17 @@ class StimulationParadigm(object):
             result += channel.to_bytes()
         return result
     
+    def to_bytes_c256(self):
+        result = to_bytes(list(self.channels.keys()), 256)
+        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 {
@@ -306,8 +364,70 @@ class StimulationParadigm(object):
     def clear(self):
         self.channels = None
         self.duration = None
-        self.interval_time = 0
+        self.interval_time = 25000
         self.characteristic = 1
         self.mode = 0
         self.repeats = 0
 
+
+# 刺激范式
+class C256StimulationParadigm(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

{qlsdk2-0.6.0a3 → qlsdk2-0.6.0a5}/src/qlsdk2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qlsdk2
-Version: 0.6.0a3
+Version: 0.6.0a5
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun