qlsdk2 0.5.1.1__tar.gz → 0.6.0a1__tar.gz

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: qlsdk2
-Version: 0.5.1.1
+Version: 0.6.0a1
 Summary: SDK for quanlan device
 Home-page: https://github.com/hehuajun/qlsdk
 Author: hehuajun
@@ -16,6 +16,15 @@ 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.1.1** (2025-08-24)
 #### 🐛 Bug Fixed

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/setup.py

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

qlsdk2-0.6.0a1/src/qlsdk/core/entity/__init__.py

@@ -0,0 +1,164 @@
+from qlsdk.core.utils import to_channels
+from loguru import logger
+
+class Packet(object):
+    def __init__(self):
+        self.time_stamp = None
+        self.pkg_id = None
+        self.result = None
+        self.channels = None
+        
+            
+class RscPacket(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')
+        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(packet.channels) * packet.resolution + 4)
+        b_eeg = body[63:]
+        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 * 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 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}
+        """
+        
+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.debug(f"impedance: {self}")
+        
+    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}
+        """
+        
+    
+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

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/src/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)

qlsdk2-0.6.0a1/src/qlsdk/interface/__init__.py

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

qlsdk2-0.6.0a1/src/qlsdk/interface/analyzer.py

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

qlsdk2-0.6.0a1/src/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__()

qlsdk2-0.6.0a1/src/qlsdk/interface/device.py

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

qlsdk2-0.6.0a1/src/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

qlsdk2-0.6.0a1/src/qlsdk/interface/stimulator.py

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

qlsdk2-0.6.0a1/src/qlsdk/interface/store.py

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

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/src/qlsdk/persist/rsc_edf.py

@@ -260,6 +260,8 @@ class RscEDFHandler(object):
             self._device_type = "C64RS"
         elif device_type == 0x40:
             self._device_type = "LJ64S1"
+        elif device_type == 0x51:
+            self._device_type = "C256RS"
         elif device_type == 0x60:
             self._device_type = "ARSKindling"
         elif device_type == 0x339:

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/src/qlsdk/rsc/command/__init__.py

@@ -309,11 +309,11 @@ class SignalDataCommand(DeviceCommand):
         return super().unpack(payload)
     
     def parse_body(self, body: bytes):     
-        # 解析数据包
-        packet = RscPacket()
-        packet.transfer(body)  
+        # # 解析数据包
+        # packet = RscPacket()
+        # packet.transfer(body)  
         # 将数据包传递给设备
-        self.device.produce(packet)
+        self.device.produce(body)
                 
             
 

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/src/qlsdk/rsc/device/__init__.py

@@ -4,4 +4,5 @@ from .device_factory import DeviceFactory
 # import devices
 from .c64_rs import C64RS
 from .c16_rs import C16RS
-from .arskindling import ARSKindling
+from .arskindling import ARSKindling
+from .c256_rs import C256RS

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/src/qlsdk/rsc/device/base.py

@@ -1,4 +1,3 @@
-
 from multiprocessing import Queue
 from threading import Thread
 from time import sleep, time_ns
@@ -8,10 +7,9 @@ from loguru import logger
 import numpy as np
 from qlsdk.core.entity import RscPacket
 from qlsdk.core.utils import to_bytes
-from qlsdk.persist import RscEDFHandler
 from qlsdk.rsc.interface import IDevice, IParser
-from qlsdk.rsc.parser import TcpMessageParser
 from qlsdk.rsc.command import StartImpedanceCommand, StopImpedanceCommand, StartStimulationCommand, StopStimulationCommand, SetAcquisitionParamCommand, StartAcquisitionCommand, StopAcquisitionCommand
+from qlsdk.rsc.parser.base import TcpMessageParser
 
 class QLBaseDevice(IDevice):
     def __init__(self, socket):
@@ -137,12 +135,18 @@ class QLBaseDevice(IDevice):
         self._record_duration = record_duration      
     
     # 数据包处理
-    def produce(self, data: RscPacket, type:Literal['signal', 'impedance']="signal"):
-        if data is None: return     
+    def produce(self, body: bytes, type:Literal['signal', 'impedance']="signal"):
+        if body is None: return     
         
         # 处理信号数据
-        self._signal_wrapper(data)   
-        
+        data = self._signal_wrapper(body)   
+        # logger.debug("pkg_id: {}, eeg len: {}".format(data.pkg_id, len(data.eeg)))
+        # 
+        trigger_positions = [index for index, value in enumerate(data.trigger) if value != 0]
+        if len(trigger_positions) > 0:
+            # logger.debug(f"Trigger触发点位置: {trigger_positions}, 触发点时间戳: {[data.time_stamp + int(pos * 1000 / data.sample_rate) for pos in trigger_positions]}")
+            for pos in trigger_positions:
+                self.trigger(data.trigger[pos])
         # 存储
         if self.storage_enable:
             self._write_signal(data)
@@ -159,9 +163,9 @@ class QLBaseDevice(IDevice):
                     
                 q.put(data)
                 
-    # 信号数据转换(默认不处理)
-    def _signal_wrapper(self, data: RscPacket):
-        pass
+    # 信号数据转换
+    def _signal_wrapper(self, body: bytes):
+        return RscPacket().transfer(body)
                 
     def _write_signal(self, data: RscPacket):
         # 文件写入到edf
@@ -175,8 +179,10 @@ class QLBaseDevice(IDevice):
     def start_listening(self):        
         
         try:
+            # 启动消息解析器
             self.start_message_parser()
             
+            # 启动消息监听器
             self.start_message_listening()
         except Exception as e:
             logger.error(f"设备{self.device_no}准备失败: {str(e)}")
@@ -188,7 +194,22 @@ class QLBaseDevice(IDevice):
         logger.trace(f"设备{self.device_no}停止socket监听")
         self._listening = False        
         self._parser.stop()
-        
+     
+    def read_msg(self, size: int) -> bytes:
+        try:
+            self.socket.settimeout(2.0)
+            return self.socket.recv(size)
+        except Exception as e:
+            logger.error(f"read_msg exception: {str(e)}")
+            raise ValueError("read_msg exception") from e
+      
+    @classmethod
+    def from_parent(cls, parent:IDevice) -> IDevice:
+        rlt = cls(parent.socket)
+        rlt.device_id = parent.device_id
+        rlt._device_no = parent.device_no
+        return rlt
+         
     @property
     def device_type(self) -> int:
         return self._device_type
@@ -196,18 +217,21 @@ class QLBaseDevice(IDevice):
     def start_message_parser(self) -> None:
         self._parser = TcpMessageParser(self)
         self._parser.start()
-        logger.debug("TCP消息解析器已启动")
+        logger.debug("RSC消息解析器已启动")
     
     def start_message_listening(self) -> None:
         def _accept():
             while self._listening:
-                # 缓冲区4M
-                data = self.socket.recv(4096*1024)
-                if not data:
-                    logger.warning(f"设备[{self.device_name}]连接结束")
+                try:
+                    # 缓冲区4M
+                    data = self.socket.recv(4096*1024)
+                    if not data:
+                        logger.warning(f"设备[{self.device_name}]连接结束")
+                        break
+                    self._parser.append(data)
+                except Exception as e:
+                    logger.debug(f"设备[{self.device_name}]接收数据异常: {str(e)}")
                     break
-                
-                self._parser.append(data)
     
         # 启动数据接收线程
         self._listening = True
@@ -252,11 +276,6 @@ class QLBaseDevice(IDevice):
     def init_edf_handler(self):
         logger.warning("init_edf_handler not implemented in base class, should be overridden in subclass")
         pass
-    #     self._edf_handler = RscEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
-    #     self._edf_handler.set_device_type(self.device_type)
-    #     self._edf_handler.set_device_no(self.device_no)
-    #     self._edf_handler.set_storage_path(self._storage_path)
-    #     self._edf_handler.set_file_prefix(self._file_prefix)
         
     # eeg数字值转物理值
     def eeg2phy(self, digital:int):
@@ -444,12 +463,26 @@ class QLBaseDevice(IDevice):
         
         return body
     
+    def disconnect(self):
+        logger.info(f"[断开设备-{self.device_no}]的连接...")  
+        self._listening = False
+        try:
+            sleep(0.1)
+            self.socket.shutdown(2)
+            self.socket.close()
+            logger.info(f"[设备-{self.device_no}]设备连接已断开")  
+        except Exception as e:
+            logger.error(f"断开设备连接异常: {str(e)}")
+         
+        # 关闭解析器
+        self._parser.stop()   
+    
     def __str__(self):
         return f''' 
             Device: 
                 Name: {self.device_name}, 
                 Type: {hex(self.device_type) if self.device_type else None}, 
-                ID: {self.device_id if self.device_id else None}, 
+                ID: {self.device_no if self.device_no else None}, 
                 Software: {self.software_version}, 
                 Hardware: {self.hardware_version}, 
                 Connect Time: {self.connect_time},
@@ -459,8 +492,8 @@ class QLBaseDevice(IDevice):
                 Battery Total: {str(self.battery_total) + "%" if self.battery_total else None}
             '''
 
-    def __eq__(self, other):
-        return self.device_name == other.device_name and self.device_type == other.device_type and self.device_id == other.device_id
+    def __eq__(self, other:IDevice):
+        return self.device_type == other.device_type and self.device_no == other.device_no
 
     def __hash__(self):
-        return hash((self.device_name, self.device_type, self.device_id))    
+        return hash((self.device_type, self.device_no))    

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/src/qlsdk/rsc/device/c256_rs.py

@@ -5,15 +5,15 @@ from time import sleep, time_ns
 from typing import Any, Dict, Literal
 
 from loguru import logger
+from qlsdk.core.entity import C256RSPacket
 from qlsdk.persist import RscEDFHandler
-from qlsdk.rsc.interface import IDevice, IParser
+from qlsdk.rsc.device.device_factory import DeviceFactory
 from qlsdk.rsc.command import *
-from qlsdk.rsc.parser.base import TcpMessageParser
 from qlsdk.rsc.device.base import QLBaseDevice
 
 class C256RS(QLBaseDevice):
     
-    device_type = 0x40  # C64RS设备类型标识符
+    device_type = 0x51  # C64RS设备类型标识符
     
     def __init__(self, socket):
         super().__init__(socket)
@@ -125,13 +125,13 @@ class C256RS(QLBaseDevice):
         self._edf_handler = None       
         self.storage_enable = True 
         
-        self._parser: IParser = TcpMessageParser(self)
-        self._parser.start()
+        # self._parser: IParser = RSCMessageParser(self)
+        # self._parser.start()
         
         # 启动数据接收线程
-        self._accept = Thread(target=self.accept)
-        self._accept.daemon = True
-        self._accept.start()
+        # self._accept = Thread(target=self.accept)
+        # self._accept.daemon = True
+        # self._accept.start()
         
     @property
     def device_no(self):
@@ -140,21 +140,14 @@ class C256RS(QLBaseDevice):
     @device_no.setter
     def device_no(self, value: str):
         self._device_no = value
-    
-    @classmethod
-    def from_parent(cls, parent:IDevice) -> IDevice:
-        rlt = cls(parent.socket)
-        rlt.device_id = parent.device_id
-        rlt._device_no = parent.device_no
-        return rlt
-        
+            
         
     def init_edf_handler(self):
         self._edf_handler = RscEDFHandler(self.sample_rate,  self.sample_range * 1000 , - self.sample_range * 1000, self.resolution)  
         self._edf_handler.set_device_type(self.device_type)
-        self._edf_handler.set_device_no(self.device_name)
+        self._edf_handler.set_device_no(self.device_no)
         self._edf_handler.set_storage_path(self._storage_path)
-        self._edf_handler.set_file_prefix(self._file_prefix)
+        self._edf_handler.set_file_prefix(self._file_prefix if self._file_prefix else 'C256RS')
         
     @property
     def edf_handler(self):
@@ -169,7 +162,7 @@ class C256RS(QLBaseDevice):
     @property
     def acq_channels(self):
         if self._acq_channels is None:
-            self._acq_channels = [i for i in range(1, 63)]
+            self._acq_channels = [i for i in range(1, 256)]
         return self._acq_channels
     @property
     def sample_range(self):
@@ -199,15 +192,15 @@ class C256RS(QLBaseDevice):
         
     # 接收socket消息
     def accept(self):
-        while True:
-            # 缓冲去4M
-            data = self.socket.recv(4096*1024)
-            if not data:
-                logger.warning(f"设备{self.device_name}连接结束")
-                break
-            
-            self._parser.append(data)
+        pass
+        # while True:
+        #     # 缓冲去4M
+        #     data = self.socket.recv(4096*1024)
+        #     if not data:
+        #         logger.warning(f"设备{self.device_name}连接结束")
+        #         break
             
+        #     self._parser.append(data)            
        
     # socket发送数据    
     def send(self, data):
@@ -226,9 +219,8 @@ class C256RS(QLBaseDevice):
         self._sample_rate = sample_rate
         self._sample_range = sample_range
     
-    # 通用配置-TODO
-    def set_config(self, key:str, val: str):
-        pass      
+    def _signal_wrapper(self, body: bytes):
+        return C256RSPacket().transfer(body)
         
     def start_impedance(self):
         logger.info("启动阻抗测量")  
@@ -297,7 +289,7 @@ class C256RS(QLBaseDevice):
             
         # 数据队列
         if q is None:
-            q = Queue(maxsize=1000)
+            q = Queue(maxsize=10240000)  # 10M缓存
             
         # 队列名称     
         if topic is None:
@@ -362,4 +354,5 @@ class C256RS(QLBaseDevice):
     def __hash__(self):
         return hash((self.device_name, self.device_type, self.device_id))    
     
-    
+    
+DeviceFactory.register(C256RS.device_type, C256RS) 

{qlsdk2-0.5.1.1 → qlsdk2-0.6.0a1}/src/qlsdk/rsc/device/device_factory.py

@@ -30,5 +30,6 @@ DeviceFactory.register(C64RS.device_type, C64RS)
 DeviceFactory.register(ARSKindling.device_type, ARSKindling) 
 
 
+
     
     

qlsdk2-0.6.0a1/src/qlsdk/rsc/interface/device.py

@@ -0,0 +1,64 @@
+from abc import ABC, abstractmethod
+import abc
+from typing import Literal
+
+class  IDevice(ABC):     
+    
+    @property
+    @abc.abstractmethod   
+    def device_type(self) -> int:
+        pass
+    
+    def set_device_type(self, value: int):
+        raise NotImplementedError("Not Supported")
+    
+    def set_storage_path(self, path: str):
+        raise NotImplementedError("Not Supported")
+    
+    def set_file_prefix(self, pre: str):
+        raise NotImplementedError("Not Supported")
+    
+    def set_acq_param(self, channels, sample_rate = 500, sample_range = 188):
+        raise NotImplementedError("Not Supported")
+    
+    @property
+    def device_no(self) -> str:
+        pass
+    
+    def read_msg(self, size: int) -> bytes:
+        raise NotImplementedError("Not Supported")
+        
+    def produce(self, body: bytes, type:Literal['signal', 'impedance']="signal") -> None:
+        raise NotImplementedError("Not Supported")
+    
+    def start_listening(self):
+        raise NotImplementedError("Not Supported")
+    
+    def stop_listening(self):
+        raise NotImplementedError("Not Supported")
+    
+    def set_device_no(self, value: str):
+        raise NotImplementedError("Not Supported")
+    
+    def from_parent(cls, parent) :
+        raise NotImplementedError("Not Supported")
+    
+    def start_acquisition(self) -> None:
+        raise NotImplementedError("Not Supported")
+    
+    def stop_acquisition(self) -> None:
+        raise NotImplementedError("Not Supported")
+    
+    def subscribe(self, type="signal") -> None:
+        raise NotImplementedError("Not Supported")
+    def unsubscribe(self, topic) -> None:
+        raise NotImplementedError("Not Supported")
+    
+    def start_stimulation(self, type="signal", duration=0) -> None:
+        raise NotImplementedError("Not Supported")
+    
+    def stop_stimulation(self) -> None:
+        raise NotImplementedError("Not Supported")
+    def disconnect(self) -> None:
+        raise NotImplementedError("Not Supported")
+