sensor-sdk 0.0.3__tar.gz → 0.0.5__tar.gz

{sensor-sdk-0.0.3 → sensor-sdk-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.3
+Version: 0.0.5
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye
@@ -68,6 +68,12 @@ success = SensorControllerInstance.startScan(6000)
 
 returns true if start scan success, periodInMS means onDeviceCallback will be called every periodInMS
 
+Use `def scan(period_in_ms: int) -> list[BLEDevice]` to scan once time
+
+```python
+bleDevices = SensorControllerInstance.scan(6000)
+```
+
 ### 3. Stop scan
 
 Use `def stopScan() -> None` to stop scan
@@ -122,7 +128,7 @@ sensorProfiles = SensorControllerInstance.getConnectedSensors()
 
 ### 9. Get Connected BLE Devices
 
-Use `def getConnectedDevices() -> list[SensorProfile]` to get connected BLE Devices.
+Use `def getConnectedDevices() -> list[BLEDevice]` to get connected BLE Devices.
 
 ```python
 bleDevices = SensorControllerInstance.getConnectedDevices()
@@ -340,3 +346,9 @@ batteryPower = sensorProfile.getBatteryLevel()
 ```
 
 Please check console.py in examples directory
+
+## Async methods
+
+all methods start with async is async methods, they has same params and return result as sync methods.
+
+Please check async_console.py in examples directory

{sensor-sdk-0.0.3 → sensor-sdk-0.0.5}/README.md

@@ -57,6 +57,12 @@ success = SensorControllerInstance.startScan(6000)
 
 returns true if start scan success, periodInMS means onDeviceCallback will be called every periodInMS
 
+Use `def scan(period_in_ms: int) -> list[BLEDevice]` to scan once time
+
+```python
+bleDevices = SensorControllerInstance.scan(6000)
+```
+
 ### 3. Stop scan
 
 Use `def stopScan() -> None` to stop scan
@@ -111,7 +117,7 @@ sensorProfiles = SensorControllerInstance.getConnectedSensors()
 
 ### 9. Get Connected BLE Devices
 
-Use `def getConnectedDevices() -> list[SensorProfile]` to get connected BLE Devices.
+Use `def getConnectedDevices() -> list[BLEDevice]` to get connected BLE Devices.
 
 ```python
 bleDevices = SensorControllerInstance.getConnectedDevices()
@@ -329,3 +335,9 @@ batteryPower = sensorProfile.getBatteryLevel()
 ```
 
 Please check console.py in examples directory
+
+## Async methods
+
+all methods start with async is async methods, they has same params and return result as sync methods.
+
+Please check async_console.py in examples directory

{sensor-sdk-0.0.3 → sensor-sdk-0.0.5}/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-sdk-0.0.3 → sensor-sdk-0.0.5}/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()