sensor-sdk 0.0.4__py3-none-any.whl → 0.0.6__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,10 +5,11 @@ 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_call, start_loop, sync_call, async_exec, timer
 from bleak import (
     BleakScanner,
     AdvertisementData,
@@ -37,16 +38,12 @@ 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()
@@ -69,11 +66,9 @@ 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):
@@ -123,9 +118,7 @@ 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]):
         """
         设置扫描设备回调。
 
@@ -133,33 +126,77 @@ class SensorController:
         """
         self._device_callback = callback
 
-    async def _device_scan_callback(
+    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_call(self._gforce_event_loop, 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_call(self._gforce_event_loop, 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_exec(self._gforce_event_loop, self._startScan())
 
     async def _startScan(self) -> bool:
-        devices = await self._scanner.discover(
-            timeout=self._device_callback_period / 1000, return_adv=True
-        )
-        timer(self._event_loop, 0, self._device_scan_callback(devices))
+        found_devices = await self._scanner.discover(timeout=self._device_callback_period / 1000, return_adv=True)
+        devices = self._process_ble_devices(found_devices)
+        async_exec(self._event_loop, self._device_scan_callback(devices))
 
     def startScan(self, periodInMs: int) -> bool:
         """
@@ -175,7 +212,7 @@ class SensorController:
         self._is_scanning = True
         self._device_callback_period = periodInMs
 
-        timer(self._gforce_event_loop, 0, self._startScan())
+        async_exec(self._gforce_event_loop, self._startScan())
         return True
 
     def stopScan(self) -> None:
@@ -187,9 +224,7 @@ class SensorController:
 
         self._is_scanning = False
 
-    def requireSensor(
-        self, device: sensor_profile.BLEDevice
-    ) -> Optional[SensorProfile]:
+    def requireSensor(self, device: sensor_profile.BLEDevice) -> Optional[SensorProfile]:
         """
         根据设备信息获取或创建SensorProfile。
 
@@ -221,10 +256,7 @@ class SensorController:
         """
         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
@@ -237,10 +269,7 @@ class SensorController:
         """
         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