sensor-sdk 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

sensor/gforce.py

@@ -16,6 +16,8 @@ from bleak import (
     BleakGATTCharacteristic,
 )
 
+from sensor import utils
+
 
 @dataclass
 class Characteristic:
@@ -146,15 +148,15 @@ class DataSubscription(IntEnum):
     LOG = (0x00000800,)
 
     DNF_EEG = (0x00010000,)
-    
+
     DNF_ECG = (0x00020000,)
-    
+
     DNF_IMPEDANCE = (0x00040000,)
-    
+
     DNF_IMU = (0x00080000,)
-    
+
     DNF_ADS = (0x00100000,)
-    
+
     DNF_BRTH = (0x00200000,)
 
     DNF_CONCAT_BLE = (0x80000000,)
@@ -181,8 +183,8 @@ class DataType(IntEnum):
 
 class SampleResolution(IntEnum):
     BITS_8 = (8,)
-    BITS_12 = 12,
-    BITS_16 = 16,
+    BITS_12 = (12,)
+    BITS_16 = (16,)
     BITS_24 = 24
 
 
@@ -215,6 +217,7 @@ class EmgRawDataConfig:
         )
         return cls(fs, channel_mask, batch_len, resolution)
 
+
 @dataclass
 class EegRawDataConfig:
     fs: SamplingRate = 0
@@ -240,6 +243,7 @@ class EegRawDataConfig:
         )
         return cls(fs, channel_mask, batch_len, resolution, K)
 
+
 @dataclass
 class EegRawDataCap:
     fs: SamplingRate = 0
@@ -262,7 +266,8 @@ class EegRawDataCap:
             data,
         )
         return cls(fs, channel_count, batch_len, resolution)
-    
+
+
 @dataclass
 class EcgRawDataConfig:
     fs: SamplingRate = SamplingRate.HZ_250
@@ -287,7 +292,8 @@ class EcgRawDataConfig:
             data,
         )
         return cls(fs, channel_mask, batch_len, resolution, K)
-    
+
+
 @dataclass
 class ImuRawDataConfig:
     channel_count: int = 0
@@ -295,6 +301,7 @@ class ImuRawDataConfig:
     batch_len: int = 0
     accK: float = 0
     gyroK: float = 0
+
     def to_bytes(self) -> bytes:
         body = b""
         body += struct.pack("<i", self.channel_count)
@@ -311,7 +318,8 @@ class ImuRawDataConfig:
             data,
         )
         return cls(channel_count, fs, batch_len, accK, gyroK)
-    
+
+
 @dataclass
 class BrthRawDataConfig:
     fs: SamplingRate = 0
@@ -336,7 +344,8 @@ class BrthRawDataConfig:
             data,
         )
         return cls(fs, channel_mask, batch_len, resolution, K)
-        
+
+
 @dataclass
 class Request:
     cmd: Command
@@ -361,7 +370,9 @@ class Response:
 
 
 class GForce:
-    def __init__(self, device: BLEDevice, cmd_char: str, data_char: str, isUniversalStream: bool):
+    def __init__(
+        self, device: BLEDevice, cmd_char: str, data_char: str, isUniversalStream: bool
+    ):
         self.device_name = ""
         self.client = None
         self.cmd_char = cmd_char
@@ -371,21 +382,33 @@ class GForce:
         self._num_channels = 8
         self._device = device
         self._is_universal_stream = isUniversalStream
-        self._raw_data_buf:queue.Queue[bytes] = None
+        self._raw_data_buf: queue.Queue[bytes] = None
         self.packet_id = 0
         self.data_packet = []
 
     async def connect(self, disconnect_cb, buf: queue.Queue[bytes]):
         client = BleakClient(self._device, disconnected_callback=disconnect_cb)
-        await client.connect()
-
         self.client = client
         self.device_name = self._device.name
         self._raw_data_buf = buf
-        if (not self._is_universal_stream):
-            await client.start_notify(self.cmd_char,self._on_cmd_response)
+
+        try:
+            await asyncio.wait_for(client.connect(), utils._TIMEOUT)
+        except Exception as e:
+            return
+
+        if not client.is_connected:
+            return
+        if not self._is_universal_stream:
+            await asyncio.wait_for(
+                client.start_notify(self.cmd_char, self._on_cmd_response),
+                utils._TIMEOUT,
+            )
         else:
-            await client.start_notify(self.data_char,self._on_universal_response)
+            await asyncio.wait_for(
+                client.start_notify(self.data_char, self._on_universal_response),
+                utils._TIMEOUT,
+            )
 
     def _on_data_response(self, q: Queue[bytes], bs: bytearray):
         bs = bytes(bs)
@@ -537,6 +560,7 @@ class GForce:
         num_channels = 6
 
         return emg_gesture_data.reshape(-1, num_channels)
+
     def _on_universal_response(self, _: BleakGATTCharacteristic, bs: bytearray):
         self._raw_data_buf.put_nowait(bytes(bs))
 
@@ -675,7 +699,6 @@ class GForce:
             )
         )
 
-
     async def system_reset(self):
         await self._send_request(
             Request(
@@ -684,11 +707,8 @@ class GForce:
             )
         )
 
-
     async def set_motor(self, switchStatus):
-        body = [
-            switchStatus == True
-        ]
+        body = [switchStatus == True]
         body = bytes(body)
         ret = await self._send_request(
             Request(
@@ -699,9 +719,7 @@ class GForce:
         )
 
     async def set_led(self, switchStatus):
-        body = [
-            switchStatus == True
-        ]
+        body = [switchStatus == True]
         body = bytes(body)
         ret = await self._send_request(
             Request(
@@ -712,9 +730,7 @@ class GForce:
         )
 
     async def set_log_level(self, logLevel):
-        body = [
-            0xFF & logLevel
-        ]
+        body = [0xFF & logLevel]
         body = bytes(body)
         ret = await self._send_request(
             Request(
@@ -724,7 +740,6 @@ class GForce:
             )
         )
 
-
     async def set_emg_raw_data_config(self, cfg=EmgRawDataConfig()):
         body = cfg.to_bytes()
         await self._send_request(
@@ -757,7 +772,7 @@ class GForce:
             )
         )
         return EmgRawDataConfig.from_bytes(buf)
-    
+
     async def get_eeg_raw_data_config(self) -> EegRawDataConfig:
         buf = await self._send_request(
             Request(
@@ -766,7 +781,7 @@ class GForce:
             )
         )
         return EegRawDataConfig.from_bytes(buf)
-    
+
     async def get_eeg_raw_data_cap(self) -> EegRawDataCap:
         buf = await self._send_request(
             Request(
@@ -784,7 +799,7 @@ class GForce:
             )
         )
         return EcgRawDataConfig.from_bytes(buf)
-    
+
     async def get_imu_raw_data_config(self) -> ImuRawDataConfig:
         buf = await self._send_request(
             Request(
@@ -792,8 +807,8 @@ class GForce:
                 has_res=True,
             )
         )
-        return ImuRawDataConfig.from_bytes(buf)     
-    
+        return ImuRawDataConfig.from_bytes(buf)
+
     async def get_brth_raw_data_config(self) -> BrthRawDataConfig:
         buf = await self._send_request(
             Request(
@@ -801,8 +816,8 @@ class GForce:
                 has_res=True,
             )
         )
-        return BrthRawDataConfig.from_bytes(buf)   
-             
+        return BrthRawDataConfig.from_bytes(buf)
+
     async def set_subscription(self, subscription: DataSubscription):
         body = [
             0xFF & subscription,
@@ -819,20 +834,27 @@ class GForce:
             )
         )
 
-    async def start_streaming(self, q:queue.Queue):
-        await self.client.start_notify(
-            self.data_char,
-            lambda _, data: self._on_data_response(q, data),
+    async def start_streaming(self, q: queue.Queue):
+        await asyncio.wait_for(
+            self.client.start_notify(
+                self.data_char,
+                lambda _, data: self._on_data_response(q, data),
+            ),
+            utils._TIMEOUT,
         )
 
     async def stop_streaming(self):
         exceptions = []
         try:
-            await self.set_subscription(DataSubscription.OFF)
+            await asyncio.wait_for(
+                self.set_subscription(DataSubscription.OFF), utils._TIMEOUT
+            )
         except Exception as e:
             exceptions.append(e)
         try:
-            await self.client.stop_notify(self.data_char)
+            await asyncio.wait_for(
+                self.client.stop_notify(self.data_char), utils._TIMEOUT
+            )
         except Exception as e:
             exceptions.append(e)
 
@@ -841,7 +863,10 @@ class GForce:
 
     async def disconnect(self):
         with suppress(asyncio.CancelledError):
-            await self.client.disconnect()
+            try:
+                await asyncio.wait_for(self.client.disconnect(), utils._TIMEOUT)
+            except Exception as e:
+                pass
 
     def _get_response_channel(self, cmd: Command) -> Queue:
         q = Queue()
@@ -856,9 +881,11 @@ class GForce:
         bs = bytes([req.cmd])
         if req.body is not None:
             bs += req.body
-        await self.client.write_gatt_char(self.cmd_char, bs)
+        await asyncio.wait_for(
+            self.client.write_gatt_char(self.cmd_char, bs), utils._TIMEOUT
+        )
 
         if not req.has_res:
             return None
 
-        return await asyncio.wait_for(q.get(), 3)
+        return await asyncio.wait_for(q.get(), utils._TIMEOUT)

sensor/sensor_controller.py

@@ -5,24 +5,28 @@ from typing import Callable, Dict, List, Optional, Tuple
 import bleak
 
 from sensor import sensor_profile
+from sensor import utils
 from sensor.sensor_profile import DeviceStateEx, SensorProfile
 import asyncio
 
-from sensor.utils import start_loop, sync_timer, timer
+from sensor.utils import async_timer, start_loop, sync_timer, timer
 from bleak import (
     BleakScanner,
     AdvertisementData,
 )
+
 SERVICE_GUID = "0000ffd0-0000-1000-8000-00805f9b34fb"
 RFSTAR_SERVICE_GUID = "00001812-0000-1000-8000-00805f9b34fb"
 
+
 class SensorController:
     _instance_lock = threading.Lock()
+
     def __new__(cls, *args, **kwargs):
         if not hasattr(SensorController, "_instance"):
             with SensorController._instance_lock:
                 if not hasattr(SensorController, "_instance"):
-                    SensorController._instance = object.__new__(cls)  
+                    SensorController._instance = object.__new__(cls)
         return SensorController._instance
 
     """
@@ -34,16 +38,23 @@ class SensorController:
         初始化 SensorController 实例。
         """
         self._event_loop = asyncio.new_event_loop()
-        self._event_thread = threading.Thread(target=start_loop, args=(self._event_loop,))
+        self._event_thread = threading.Thread(
+            target=start_loop, args=(self._event_loop,)
+        )
         self._event_thread.daemon = True
         self._event_thread.name = "SensorController event"
         self._event_thread.start()
         self._gforce_event_loop = asyncio.new_event_loop()
-        self._gforce_event_thread = threading.Thread(target=start_loop, args=(self._gforce_event_loop,))
+        self._gforce_event_thread = threading.Thread(
+            target=start_loop, args=(self._gforce_event_loop,)
+        )
         self._gforce_event_thread.daemon = True
         self._gforce_event_thread.name = "BLE operation"
         self._gforce_event_thread.start()
-        self._scanner = BleakScanner(detection_callback=self._match_device,service_uuids=[SERVICE_GUID,RFSTAR_SERVICE_GUID])
+        self._scanner = BleakScanner(
+            detection_callback=self._match_device,
+            service_uuids=[SERVICE_GUID, RFSTAR_SERVICE_GUID],
+        )
         self._is_scanning = False
         self._device_callback: Callable[[List[sensor_profile.BLEDevice]], None] = None
         self._device_callback_period = 0
@@ -59,18 +70,19 @@ class SensorController:
         self._gforce_event_loop.close()
 
     def terminate(self):
+        utils._terminated = True
         for sensor in self._sensor_profiles.values():
-            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
+            if (
+                sensor.deviceState == DeviceStateEx.Connected
+                or sensor.deviceState == DeviceStateEx.Ready
+            ):
                 sensor._destroy()
-            
 
     def _match_device(self, _device: bleak.BLEDevice, adv: AdvertisementData):
         if _device.name == None:
             return False
 
-        if (
-            SERVICE_GUID in adv.service_uuids
-        ):
+        if SERVICE_GUID in adv.service_uuids:
             print("Device found: {0}, RSSI: {1}".format(_device.name, adv.rssi))
             return True
 
@@ -113,7 +125,9 @@ class SensorController:
         return self._device_callback != None
 
     @hasDeviceFoundCallback.setter
-    def onDeviceFoundCallback(self, callback: Callable[[List[sensor_profile.BLEDevice]], None]):
+    def onDeviceFoundCallback(
+        self, callback: Callable[[List[sensor_profile.BLEDevice]], None]
+    ):
         """
         设置扫描设备回调。
 
@@ -121,29 +135,82 @@ class SensorController:
         """
         self._device_callback = callback
 
-    async def _device_scan_callback(self, found_devices: Dict[str, Tuple[bleak.BLEDevice, AdvertisementData]]):
+    def _process_ble_devices(
+        self, found_devices: Dict[str, Tuple[bleak.BLEDevice, AdvertisementData]]
+    ) -> List[sensor_profile.BLEDevice]:
+        devices: List[sensor_profile.BLEDevice] = list()
+        deviceMap: Dict[str, SensorProfile] = self._sensor_profiles.copy()
+        for uuid in found_devices:
+            device = found_devices[uuid][0]
+            if device.name == None:
+                continue
+            adv = found_devices[uuid][1]
+            if SERVICE_GUID in adv.service_uuids:
+                mac = None
+                if adv.service_data.get(SERVICE_GUID) != None:
+                    bytes_val = adv.service_data[SERVICE_GUID]
+                    mac = ":".join(f"{byte:02X}" for byte in bytes_val)
+                elif adv.service_data.get(RFSTAR_SERVICE_GUID) != None:
+                    bytes_val = adv.service_data[RFSTAR_SERVICE_GUID]
+                    mac = ":".join(f"{byte:02X}" for byte in reversed(bytes_val))
+
+                if mac == None:
+                    continue
+                if deviceMap.get(mac) != None:
+                    devices.append(self._sensor_profiles[mac].BLEDevice)
+                else:
+                    newSensor = SensorProfile(device, adv, mac, self._gforce_event_loop)
+                    deviceMap[mac] = newSensor
+                    devices.append(newSensor.BLEDevice)
+
+        self._sensor_profiles = deviceMap
+        return devices
+
+    async def _async_scan(self, period):
+        self._is_scanning = True
+        found_devices = await self._scanner.discover(
+            timeout=period / 1000, return_adv=True
+        )
+        self._is_scanning = False
+        return self._process_ble_devices(found_devices)
+
+    def scan(self, period) -> List[sensor_profile.BLEDevice]:
+        """
+        扫描一段时间后返回BLEDevice列表。
+
+        :param            periodInMs (int): 扫描时长（毫秒）
+
+        :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
+        """
+        return sync_timer(self._gforce_event_loop, 0, self._async_scan(period))
+
+    async def asyncScan(self, period) -> List[sensor_profile.BLEDevice]:
+        """
+        扫描一段时间后返回BLEDevice列表。
+
+        :param            periodInMs (int): 扫描时长（毫秒）
+
+        :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
+        """
+        return await async_timer(self._gforce_event_loop, 0, self._async_scan(period))
+
+    async def _device_scan_callback(self, devices: List[sensor_profile.BLEDevice]):
         if self._device_callback:
-            devices:List[sensor_profile.BLEDevice] = list()
-            deviceMap :Dict[str, SensorProfile] = self._sensor_profiles.copy()
-            for mac in found_devices:
-                device = found_devices[mac][0]
-                adv = found_devices[mac][1]
-                if SERVICE_GUID in adv.service_uuids:
-                    if deviceMap.get(mac) != None:
-                        devices.append(self._sensor_profiles[mac].BLEDevice)
-                    else:
-                        newSensor = SensorProfile(device, adv,self._gforce_event_loop)
-                        deviceMap[mac] = newSensor
-                        devices.append(newSensor.BLEDevice)
-            self._sensor_profiles = deviceMap
-            self._device_callback(devices)
+            try:
+                self._device_callback(devices)
+            except Exception as e:
+                print(e)
 
         if self._is_scanning:
             timer(self._gforce_event_loop, 0, self._startScan())
 
     async def _startScan(self) -> bool:
-        devices = await self._scanner.discover(timeout=self._device_callback_period / 1000, return_adv=True)
+        found_devices = await self._scanner.discover(
+            timeout=self._device_callback_period / 1000, return_adv=True
+        )
+        devices = self._process_ble_devices(found_devices)
         timer(self._event_loop, 0, self._device_scan_callback(devices))
+
     def startScan(self, periodInMs: int) -> bool:
         """
         开始扫描。
@@ -152,12 +219,12 @@ class SensorController:
 
         :return:            bool: 扫描是否成功启动
         """
-        if (self._is_scanning):
+        if self._is_scanning:
             return True
-        
+
         self._is_scanning = True
         self._device_callback_period = periodInMs
-        
+
         timer(self._gforce_event_loop, 0, self._startScan())
         return True
 
@@ -165,12 +232,14 @@ class SensorController:
         """
         停止扫描。
         """
-        if (not self._is_scanning):
-            return 
-        
+        if not self._is_scanning:
+            return
+
         self._is_scanning = False
 
-    def requireSensor(self, device: sensor_profile.BLEDevice) -> Optional[SensorProfile]:
+    def requireSensor(
+        self, device: sensor_profile.BLEDevice
+    ) -> Optional[SensorProfile]:
         """
         根据设备信息获取或创建SensorProfile。
 
@@ -200,9 +269,12 @@ class SensorController:
 
         :return:            List[SensorProfile]: 已连接的SensorProfile列表
         """
-        sensors:List[SensorProfile] = list()
+        sensors: List[SensorProfile] = list()
         for sensor in self._sensor_profiles.values():
-            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
+            if (
+                sensor.deviceState == DeviceStateEx.Connected
+                or sensor.deviceState == DeviceStateEx.Ready
+            ):
                 sensors.append(sensor)
 
         return sensors
@@ -213,11 +285,15 @@ class SensorController:
 
         :return:            List[BLEDevice]: 已连接的蓝牙设备列表
         """
-        devices:List[sensor_profile.BLEDevice] = list()
+        devices: List[sensor_profile.BLEDevice] = list()
         for sensor in self._sensor_profiles.values():
-            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
+            if (
+                sensor.deviceState == DeviceStateEx.Connected
+                or sensor.deviceState == DeviceStateEx.Ready
+            ):
                 devices.append(sensor.BLEDevice)
 
         return devices
 
+
 SensorControllerInstance = SensorController()

sensor/sensor_data.py

@@ -1,6 +1,7 @@
 from enum import Enum, IntEnum
 from typing import Dict, List
 
+
 # 一个采样数据
 # 该类用于存储单个采样数据的相关信息，包括数据值、阻抗、饱和度、采样索引和是否丢包的标志
 class Sample:
@@ -14,34 +15,36 @@ class Sample:
     # :param is_lost: 是否丢包的标志，True 表示丢包，False 表示正常
     # """
     # def __init__(self, data: int, impedance: int, saturation: int, sample_index: int, is_lost: bool):
-    #     self.data = data                                    
-    #     self.impedance = impedance                          
-    #     self.saturation = saturation                        
-    #     self.sampleIndex = sample_index                     
-    #     self.isLost = is_lost                               
+    #     self.data = data
+    #     self.impedance = impedance
+    #     self.saturation = saturation
+    #     self.sampleIndex = sample_index
+    #     self.isLost = is_lost
 
     def __init__(self):
         self.rawData = 0
-        self.data = 0                                    
-        self.impedance = 0                          
-        self.saturation = 0                        
-        self.sampleIndex = 0                     
-        self.isLost = False      
+        self.data = 0
+        self.impedance = 0
+        self.saturation = 0
+        self.sampleIndex = 0
+        self.isLost = False
         self.timeStampInMs = 0
         self.channelIndex = 0
         self.sampleIndex = 0
 
+
 # 对应 DataType 枚举
 # 该枚举类定义了不同类型的数据，用于区分传感器采集的不同类型的数据
 class DataType(IntEnum):
-    NTF_ACC = 0x1       # 加速度，用于标识加速度传感器采集的数据
-    NTF_GYRO = 0x2      # 陀螺仪，用于标识陀螺仪传感器采集的数据
-    NTF_EEG = 0x10      # EEG，用于标识脑电传感器采集的数据
-    NTF_ECG = 0x11      # ECG，用于标识心电传感器采集的数据
-    NTF_IMPEDANCE = 0x12, # 阻抗数据
-    NTF_IMU = 0x13,     # 包含ACC和GYRO数据
-    NTF_ADS = 0x14,     # 无单位ads数据
-    NTF_BRTH = 0x15     # 呼吸，用于标识呼吸传感器采集的数据
+    NTF_ACC = 0x1  # 加速度，用于标识加速度传感器采集的数据
+    NTF_GYRO = 0x2  # 陀螺仪，用于标识陀螺仪传感器采集的数据
+    NTF_EEG = 0x10  # EEG，用于标识脑电传感器采集的数据
+    NTF_ECG = 0x11  # ECG，用于标识心电传感器采集的数据
+    NTF_IMPEDANCE = (0x12,)  # 阻抗数据
+    NTF_IMU = (0x13,)  # 包含ACC和GYRO数据
+    NTF_ADS = (0x14,)  # 无单位ads数据
+    NTF_BRTH = 0x15  # 呼吸，用于标识呼吸传感器采集的数据
+
 
 # 一次采样的数据，包含多个通道的数据，channal_samples 为一个二维数组, 第一个维度为通道索引，第二个维度为采样索引
 # 该类用于存储一次采样的完整数据，包括设备 MAC 地址、数据类型、采样率、通道数量、包中采样数量以及通道采样数据
@@ -55,35 +58,35 @@ class SensorData:
     # :param channel_count: The number of channels in the data.
     # :param package_sample_count: The number of samples in the package.
     # :param channel_samples: A list of lists containing the sample data for each channel.
-    # """ 
+    # """
     # def __init__(self, device_mac: str, data_type: DataType, sample_rate: int, channel_count: int,
     #              package_sample_count: int, channel_samples: List[List[Sample]]):
-    #     self.deviceMac = device_mac                        
-    #     self.dataType = data_type                           
-    #     self.sampleRate = sample_rate                      
-    #     self.channelCount = channel_count                  
-    #     self.packageSampleCount = package_sample_count     
-    #     self.channelSamples = channel_samples   
+    #     self.deviceMac = device_mac
+    #     self.dataType = data_type
+    #     self.sampleRate = sample_rate
+    #     self.channelCount = channel_count
+    #     self.packageSampleCount = package_sample_count
+    #     self.channelSamples = channel_samples
     #     self.lastPackageCounter = 0
-    #     self.lastPackageIndex = 0           
-    #     self.resolutionBits = 0    
-    #     self.channelMask = 0    
-    #     self.minPackageSampleCount = 0    
-    #     self.K = 0    
+    #     self.lastPackageIndex = 0
+    #     self.resolutionBits = 0
+    #     self.channelMask = 0
+    #     self.minPackageSampleCount = 0
+    #     self.K = 0
 
     def __init__(self):
-        self.deviceMac = ""                        
-        self.dataType = DataType.NTF_EEG                           
-        self.sampleRate = 0                      
-        self.channelCount = 0                  
-        self.packageSampleCount = 0     
-        self.channelSamples:List[List[Sample]] = list()   
+        self.deviceMac = ""
+        self.dataType = DataType.NTF_EEG
+        self.sampleRate = 0
+        self.channelCount = 0
+        self.packageSampleCount = 0
+        self.channelSamples: List[List[Sample]] = list()
         self.lastPackageCounter = 0
-        self.lastPackageIndex = 0           
-        self.resolutionBits = 0    
-        self.channelMask = 0    
-        self.minPackageSampleCount = 0    
-        self.K = 0   
+        self.lastPackageIndex = 0
+        self.resolutionBits = 0
+        self.channelMask = 0
+        self.minPackageSampleCount = 0
+        self.K = 0
 
     def clear(self):
         self.channelSamples.clear()