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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.4
+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.4 → 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.4 → 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.4 → sensor-sdk-0.0.5}/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_timer, start_loop, sync_timer, timer
 from bleak import (
     BleakScanner,
     AdvertisementData,
@@ -69,6 +70,7 @@ 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
@@ -133,32 +135,80 @@ 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_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(
+        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:

{sensor-sdk-0.0.4 → sensor-sdk-0.0.5}/sensor/sensor_data_context.py

@@ -1,6 +1,8 @@
 import asyncio
 from collections import deque
+import platform
 from queue import Queue
+import struct
 from typing import Deque, List
 
 from sensor.gforce import DataSubscription, GForce
@@ -42,6 +44,7 @@ class SensorProfileDataCtx:
         self.deviceMac = deviceMac
         self._device_info: DeviceInfo = None
 
+        self._is_initing = False
         self._is_running = True
         self._is_data_transfering = False
         self.isUniversalStream: bool = gForce._is_universal_stream
@@ -79,7 +82,9 @@ class SensorProfileDataCtx:
         return self._is_data_transfering
 
     def hasInit(self):
-        return self.featureMap != 0 and self.notifyDataFlag != 0
+        return (
+            not self._is_initing and self.featureMap != 0 and self.notifyDataFlag != 0
+        )
 
     def hasEMG(self):
         return (self.featureMap & FeatureMaps.GFD_FEAT_EMG.value) != 0
@@ -198,32 +203,44 @@ class SensorProfileDataCtx:
 
     async def fetchDeviceInfo(self) -> DeviceInfo:
         info = DeviceInfo()
-        info.MTUSize = self.gForce.client.mtu_size
+        if platform.system() != "Linux":
+            info.MTUSize = self.gForce.client.mtu_size
+        else:
+            info.MTUSize = 0
+        print("get_device_name")
         info.DeviceName = await self.gForce.get_device_name()
+        print("get_model_number")
         info.ModelName = await self.gForce.get_model_number()
+        print("get_hardware_revision")
         info.HardwareVersion = await self.gForce.get_hardware_revision()
+        print("get_firmware_revision")
         info.FirmwareVersion = await self.gForce.get_firmware_revision()
         return info
 
     async def init(self, packageCount: int) -> bool:
+        if self._is_initing:
+            return False
         try:
+            self._is_initing = True
             info = await self.fetchDeviceInfo()
-
             await self.initDataTransfer(True)
-
             if self.hasImpedance():
                 self.notifyDataFlag |= DataSubscription.DNF_IMPEDANCE
 
             if self.hasEEG():
+                print("initEEG")
                 info.EegChannelCount = await self.initEEG(packageCount)
 
             if self.hasECG():
+                print("initECG")
                 info.EcgChannelCount = await self.initECG(packageCount)
 
             if self.hasBrth():
+                print("initBrth")
                 info.BrthChannelCount = await self.initBrth(packageCount)
 
             if self.hasIMU():
+                print("initIMU")
                 imuChannelCount = await self.initIMU(packageCount)
                 info.AccChannelCount = imuChannelCount
                 info.GyroChannelCount = imuChannelCount
@@ -233,9 +250,11 @@ class SensorProfileDataCtx:
             if not self.isUniversalStream:
                 await self.initDataTransfer(False)
 
+            self._is_initing = False
             return True
         except Exception as e:
             print(e)
+            self._is_initing = False
             return False
 
     async def start_streaming(self) -> bool:
@@ -263,16 +282,16 @@ class SensorProfileDataCtx:
             await self.gForce.set_subscription(0)
             return True
 
-    def process_data(self, buf: Queue[SensorData]):
+    def process_data(self, buf: Queue[SensorData], sensor):
         try:
             data: bytes = self._rawDataBuffer.get_nowait()
         except Exception as e:
             return
 
-        self._processDataPackage(data, buf)
+        self._processDataPackage(data, buf, sensor)
         self._rawDataBuffer.task_done()
 
-    def _processDataPackage(self, data: bytes, buf: Queue[SensorData]):
+    def _processDataPackage(self, data: bytes, buf: Queue[SensorData], sensor):
         v = data[0]
         if v == DataType.NTF_IMPEDANCE:
             offset = 1
@@ -283,15 +302,14 @@ class SensorProfileDataCtx:
             saturationData = []
 
             dataCount = (len(data) - 3) // 4 // 2
+
             for index in range(dataCount):
-                impedance_bytes = data[offset : offset + 4]
-                impedance = int.from_bytes(impedance_bytes, byteorder="little")
+                impedance = struct.unpack_from("<f", data, offset)[0]
                 offset += 4
                 impedanceData.append(impedance)
 
             for index in range(dataCount):
-                saturation_bytes = data[offset : offset + 4]
-                saturation = int.from_bytes(saturation_bytes, byteorder="little")
+                saturation = struct.unpack_from("<f", data, offset)[0]
                 offset += 4
                 saturationData.append(saturation / 10)  # firmware value range 0 - 1000
 
@@ -300,27 +318,27 @@ class SensorProfileDataCtx:
 
         elif v == DataType.NTF_EEG:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_EEG]
-            if self.checkReadSamples(data, sensor_data, 3, 0):
+            if self.checkReadSamples(sensor, data, sensor_data, 3, 0):
                 self.sendSensorData(sensor_data, buf)
         elif v == DataType.NTF_ECG:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_ECG]
-            if self.checkReadSamples(data, sensor_data, 3, 0):
+            if self.checkReadSamples(sensor, data, sensor_data, 3, 0):
                 self.sendSensorData(sensor_data, buf)
         elif v == DataType.NTF_BRTH:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_BRTH]
-            if self.checkReadSamples(data, sensor_data, 3, 0):
+            if self.checkReadSamples(sensor, data, sensor_data, 3, 0):
                 self.sendSensorData(sensor_data, buf)
         elif v == DataType.NTF_IMU:
             sensor_data_acc = self.sensorDatas[SensorDataType.DATA_TYPE_ACC]
-            if self.checkReadSamples(data, sensor_data_acc, 3, 6):
+            if self.checkReadSamples(sensor, data, sensor_data_acc, 3, 6):
                 self.sendSensorData(sensor_data_acc, buf)
 
             sensor_data_gyro = self.sensorDatas[SensorDataType.DATA_TYPE_GYRO]
-            if self.checkReadSamples(data, sensor_data_gyro, 9, 6):
+            if self.checkReadSamples(sensor, data, sensor_data_gyro, 9, 6):
                 self.sendSensorData(sensor_data_gyro, buf)
 
     def checkReadSamples(
-        self, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int
+        self, sensor, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int
     ):
         offset = 1
         v = data[0]
@@ -343,9 +361,23 @@ class SensorProfileDataCtx:
                 lostSampleCount = sensorData.packageSampleCount * (
                     deltaPackageIndex - 1
                 )
-                print(
-                    f"lost dataType {sensorData.dataType} -> data {sensorData.deviceMac} {lostSampleCount}"
+                lostLog = (
+                    "MSG|LOST SAMPLE|MAC|"
+                    + str(sensorData.deviceMac)
+                    + "|TYPE|"
+                    + str(sensorData.dataType)
+                    + "|COUNT|"
+                    + str(lostSampleCount)
                 )
+                # print(lostLog)
+                if sensor._event_loop != None and sensor._on_error_callback != None:
+                    try:
+                        sensor._event_loop.call_soon_threadsafe(
+                            sensor._on_error_callback, sensor, lostLog
+                        )
+                    except Exception as e:
+                        pass
+
                 self.readSamples(data, sensorData, 0, dataGap, lostSampleCount)
                 if newPackageIndex == 0:
                     sensorData.lastPackageIndex = 65535
@@ -356,7 +388,8 @@ class SensorProfileDataCtx:
             self.readSamples(data, sensorData, dataOffset, dataGap, 0)
             sensorData.lastPackageIndex = newPackageIndex
             sensorData.lastPackageCounter += 1
-        except Exception:
+        except Exception as e:
+            print(e)
             return False
         return True
 
@@ -392,12 +425,16 @@ class SensorProfileDataCtx:
                     samples = channelSamples[channelIndex]
                     impedance = 0.0
                     saturation = 0.0
+
                     if sensorData.dataType == DataType.NTF_ECG:
                         impedanceChannelIndex = self.sensorDatas[
                             SensorDataType.DATA_TYPE_EEG
                         ].channelCount
-                    impedance = _impedanceData[impedanceChannelIndex]
-                    saturation = _saturationData[impedanceChannelIndex]
+
+                    if impedanceChannelIndex < len(_impedanceData):
+                        impedance = _impedanceData[impedanceChannelIndex]
+                        saturation = _saturationData[impedanceChannelIndex]
+
                     impedanceChannelIndex += 1
 
                     dataItem = Sample()
@@ -805,14 +842,14 @@ class SensorProfileDataCtx:
                         data_package = bytes(
                             self._concatDataBuffer[index + 2 : index + 2 + n]
                         )
-                        self._processDataPackage(data_package, buf)
+                        self._processDataPackage(data_package, buf, sensor)
                         while self._is_running and self.isDataTransfering:
                             sensorData: SensorData = None
                             try:
                                 sensorData = buf.get_nowait()
                             except Exception as e:
                                 break
-                            if sensorData != None and callback != None:
+                            if loop != None and sensorData != None and callback != None:
                                 try:
                                     loop.call_soon_threadsafe(
                                         callback, sensor, sensorData
@@ -841,9 +878,10 @@ class SensorProfileDataCtx:
                     data_package = bytes(
                         self._concatDataBuffer[index + 2 : index + 2 + n]
                     )
-                    loop.call_soon_threadsafe(
-                        self.gForce._on_cmd_response, None, data_package
-                    )
+                    if loop != None:
+                        loop.call_soon_threadsafe(
+                            self.gForce._on_cmd_response, None, data_package
+                        )
                     last_cut = index = index + 2 + n
                 else:
                     index += 1

{sensor-sdk-0.0.4 → sensor-sdk-0.0.5}/sensor/sensor_profile.py

@@ -13,6 +13,7 @@ from bleak import (
 )
 
 import sensor
+from sensor import utils
 from sensor.gforce import GForce
 from sensor.sensor_data import DataType, Sample, SensorData
 import asyncio
@@ -20,7 +21,7 @@ import threading
 
 from sensor.sensor_data_context import SensorProfileDataCtx
 from sensor.sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
-from sensor.utils import start_loop, sync_timer, timer
+from sensor.utils import async_timer, start_loop, sync_timer, timer
 from contextlib import suppress
 from dataclasses import dataclass
 
@@ -44,6 +45,7 @@ class SensorProfile:
         self,
         device: bleak.BLEDevice,
         adv: bleak.AdvertisementData,
+        mac: str,
         gforce_event_loop: asyncio.AbstractEventLoop,
     ):
         """
@@ -52,7 +54,7 @@ class SensorProfile:
         :param            device (BLEDevice): 蓝牙设备对象，包含设备的名称、地址和信号强度等信息。
         """
         self._detail_device = device
-        self._device = BLEDevice(device.name, device.address, adv.rssi)
+        self._device = BLEDevice(device.name, mac, adv.rssi)
         self._device_state = DeviceStateEx.Disconnected
         self._on_state_changed: Callable[["SensorProfile", DeviceStateEx], None] = None
         self._on_error_callback: Callable[["SensorProfile", str], None] = None
@@ -85,6 +87,7 @@ class SensorProfile:
             try:
                 self._data_event_loop.stop()
                 self._data_event_loop.close()
+                self._data_event_loop = None
                 self._data_event_thread.join()
             except Exception as e:
                 pass
@@ -92,6 +95,7 @@ class SensorProfile:
             try:
                 self._event_loop.stop()
                 self._event_loop.close()
+                self._event_loop = None
                 self._event_thread.join()
             except Exception as e:
                 pass
@@ -108,7 +112,7 @@ class SensorProfile:
     def _set_device_state(self, newState: DeviceStateEx):
         if self._device_state != newState:
             self._device_state = newState
-            if self._on_state_changed != None:
+            if self._event_loop != None and self._on_state_changed != None:
                 try:
                     self._event_loop.call_soon_threadsafe(
                         self._on_state_changed, self, newState
@@ -223,43 +227,6 @@ class SensorProfile:
         self._on_power_changed = callback
 
     async def _connect(self) -> bool:
-        if (
-            self.deviceState == DeviceStateEx.Connected
-            or self.deviceState == DeviceStateEx.Ready
-        ):
-            return True
-        self._set_device_state(DeviceStateEx.Connecting)
-
-        def handle_disconnect(_: BleakClient):
-            self.stopDataNotification()
-            self._data_ctx.close()
-            time.sleep(1)
-            self._data_buffer.queue.clear()
-            self._data_ctx = None
-            self._gforce = None
-            self._set_device_state(DeviceStateEx.Disconnected)
-            pass
-
-        await self._gforce.connect(handle_disconnect, self._raw_data_buf)
-
-        if self._gforce.client.is_connected:
-            self._set_device_state(DeviceStateEx.Connected)
-            if self._gforce.client.mtu_size >= 80:
-                self._set_device_state(DeviceStateEx.Ready)
-            else:
-                self.disconnect()
-        else:
-            self._set_device_state(DeviceStateEx.Disconnected)
-
-        return True
-
-    def connect(self) -> bool:
-        """
-        连接传感器。
-
-        :return:            bool: 如果连接成功，返回 True；否则返回 False。
-
-        """
         if self._event_thread == None:
             self._event_loop = asyncio.new_event_loop()
             self._event_thread = threading.Thread(
@@ -304,12 +271,58 @@ class SensorProfile:
             self._data_ctx = SensorProfileDataCtx(
                 self._gforce, self._device.Address, self._raw_data_buf
             )
-            if self._data_ctx.isUniversalStream:
-                timer(self._data_event_loop, 0, self._process_universal_data())
+        if self._data_ctx.isUniversalStream:
+            timer(self._data_event_loop, 0, self._process_universal_data())
+
+        if (
+            self.deviceState == DeviceStateEx.Connected
+            or self.deviceState == DeviceStateEx.Ready
+        ):
+            return True
+        self._set_device_state(DeviceStateEx.Connecting)
 
+        def handle_disconnect(_: BleakClient):
+            self._data_ctx.close()
+            time.sleep(0.1)
+            self._data_buffer.queue.clear()
+            self._data_ctx = None
+            self._gforce = None
+            self._set_device_state(DeviceStateEx.Disconnected)
+            pass
+
+        await self._gforce.connect(handle_disconnect, self._raw_data_buf)
+
+        if self._gforce.client.is_connected:
+            self._set_device_state(DeviceStateEx.Connected)
+            self._set_device_state(DeviceStateEx.Ready)
+            # if self._gforce.client.mtu_size >= 80:
+            #     self._set_device_state(DeviceStateEx.Ready)
+            # else:
+            #     self.disconnect()
+        else:
+            self._set_device_state(DeviceStateEx.Disconnected)
+
+        return True
+
+    def connect(self) -> bool:
+        """
+        连接传感器。
+
+        :return:            bool: 如果连接成功，返回 True；否则返回 False。
+
+        """
         result = sync_timer(self._gforce_event_loop, 0, self._connect())
         return result
 
+    async def asyncConnect(self) -> bool:
+        """
+        连接传感器。
+
+        :return:            bool: 如果连接成功，返回 True；否则返回 False。
+
+        """
+        return await async_timer(self._gforce_event_loop, 0, self._connect())
+
     async def _waitForDisconnect(self) -> bool:
         while self.deviceState != DeviceStateEx.Disconnected:
             asyncio.sleep(1)
@@ -325,7 +338,7 @@ class SensorProfile:
             return False
         self._set_device_state(DeviceStateEx.Disconnecting)
         await self._gforce.disconnect()
-        await asyncio.wait_for(self._waitForDisconnect(), 5)
+        await asyncio.wait_for(self._waitForDisconnect(), utils._TIMEOUT)
         return True
 
     def disconnect(self) -> bool:
@@ -337,16 +350,29 @@ class SensorProfile:
         """
         return sync_timer(self._gforce_event_loop, 0, self._disconnect())
 
+    async def asyncDisconnect(self) -> bool:
+        """
+        断开传感器连接。
+
+        :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
+
+        """
+        return await async_timer(self._gforce_event_loop, 0, self._disconnect())
+
     async def _process_data(self):
         while self._data_ctx._is_running and self._data_ctx.isDataTransfering:
-            self._data_ctx.process_data(self._data_buffer)
+            self._data_ctx.process_data(self._data_buffer, self)
             while self._data_ctx._is_running and self._data_ctx.isDataTransfering:
                 sensorData: SensorData = None
                 try:
                     sensorData = self._data_buffer.get_nowait()
                 except Exception as e:
                     break
-                if sensorData != None and self._on_data_callback != None:
+                if (
+                    self._event_loop != None
+                    and sensorData != None
+                    and self._on_data_callback != None
+                ):
                     try:
                         self._event_loop.call_soon_threadsafe(
                             self._on_data_callback, self, sensorData
@@ -361,20 +387,6 @@ class SensorProfile:
         )
 
     async def _startDataNotification(self) -> bool:
-        result = await self._data_ctx.start_streaming()
-        self._data_buffer.queue.clear()
-        self._data_ctx.clear()
-        if not self._data_ctx.isUniversalStream:
-            timer(self._data_event_loop, 0, self._process_data())
-        return result
-
-    def startDataNotification(self) -> bool:
-        """
-        开始数据通知。
-
-        :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
-
-        """
         if self.deviceState != DeviceStateEx.Ready:
             return False
         if self._data_ctx == None:
@@ -394,19 +406,34 @@ class SensorProfile:
             self._data_event_thread.name = self.BLEDevice.Name + " data"
             self._data_event_thread.start()
 
-        return sync_timer(self._gforce_event_loop, 0, self._startDataNotification())
+        result = await self._data_ctx.start_streaming()
+        self._data_buffer.queue.clear()
+        self._data_ctx.clear()
+        if not self._data_ctx.isUniversalStream:
+            timer(self._data_event_loop, 0, self._process_data())
+        return result
 
-    async def _stopDataNotification(self) -> bool:
+    def startDataNotification(self) -> bool:
+        """
+        开始数据通知。
 
-        return not await self._data_ctx.stop_streaming()
+        :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
-    def stopDataNotification(self) -> bool:
         """
-        停止数据通知。
+        return sync_timer(self._gforce_event_loop, 0, self._startDataNotification())
 
-        :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
+    async def asyncStartDataNotification(self) -> bool:
+        """
+        开始数据通知。
+
+        :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
+        return await async_timer(
+            self._gforce_event_loop, 0, self._startDataNotification()
+        )
+
+    async def _stopDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
             return False
         if self._data_ctx == None:
@@ -417,12 +444,32 @@ class SensorProfile:
         if not self._data_ctx.isDataTransfering:
             return True
 
+        return not await self._data_ctx.stop_streaming()
+
+    def stopDataNotification(self) -> bool:
+        """
+        停止数据通知。
+
+        :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
+
+        """
         return sync_timer(self._gforce_event_loop, 0, self._stopDataNotification())
 
+    async def asyncStopDataNotification(self) -> bool:
+        """
+        停止数据通知。
+
+        :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
+
+        """
+        return await async_timer(
+            self._gforce_event_loop, 0, self._stopDataNotification()
+        )
+
     async def _refresh_power(self):
         self._power = await self._gforce.get_battery_level()
 
-        if self._on_power_changed != None:
+        if self._event_loop != None and self._on_power_changed != None:
             try:
                 self._event_loop.call_soon_threadsafe(
                     self._on_power_changed, self, self._power
@@ -469,6 +516,26 @@ class SensorProfile:
             self._gforce_event_loop,
             0,
             self._init(packageSampleCount, powerRefreshInterval),
+            120,
+        )
+
+    async def asyncInit(
+        self, packageSampleCount: int, powerRefreshInterval: int
+    ) -> bool:
+        """
+        初始化数据采集。
+
+        :param    packageSampleCount (int): 数据包中的样本数量。
+        :param    powerRefreshInterval (int): 电量刷新间隔。
+
+        :return:            bool: 初始化结果。True 表示成功，False 表示失败。
+
+        """
+        return await async_timer(
+            self._gforce_event_loop,
+            0,
+            self._init(packageSampleCount, powerRefreshInterval),
+            120,
         )
 
     def getBatteryLevel(self) -> int:
@@ -502,3 +569,15 @@ class SensorProfile:
 
         """
         return ""
+
+    async def AsyncSetParam(self, key: str, value: str) -> str:
+        """
+        设置传感器的参数。
+
+        :param    key (str): 参数的键。
+        :param    value (str): 参数的值。
+
+        :return:            str: 设置参数的结果。
+
+        """
+        return ""

sensor-sdk-0.0.5/sensor/utils.py

@@ -0,0 +1,72 @@
+import asyncio
+import platform
+import queue
+import signal
+import time
+
+_terminated = False
+_TIMEOUT = 10
+
+
+async def delay(_time: float, function) -> any:
+    if _time > 0:
+        await asyncio.sleep(_time)
+    return await function
+
+
+def timer(_loop: asyncio.AbstractEventLoop, _delay: float, function):
+    if _loop == None:
+        return
+    try:
+        asyncio.run_coroutine_threadsafe(delay(_delay, function), _loop)
+    except Exception as e:
+        print(e)
+        pass
+
+
+def sync_timer(
+    _loop: asyncio.AbstractEventLoop, _delay: float, function, _timeout=_TIMEOUT
+) -> any:
+    if _loop == None:
+        return
+
+    try:
+        f = asyncio.run_coroutine_threadsafe(
+            asyncio.wait_for(delay(_delay, function), _delay + _timeout), _loop
+        )
+        return f.result(timeout=_timeout)
+    except Exception as e:
+        print(e)
+        pass
+
+
+async def async_timer(
+    _loop: asyncio.AbstractEventLoop, _delay: float, function, _timeout=_TIMEOUT
+) -> any:
+    if _loop == None:
+        return
+
+    try:
+        f = asyncio.run_coroutine_threadsafe(
+            asyncio.wait_for(delay(_delay, function), _delay + _timeout), _loop
+        )
+    except Exception as e:
+        print(e)
+        pass
+
+    while not _terminated and not f.done():
+        await asyncio.sleep(0.1)
+
+    try:
+        if not f.cancelled():
+            return f.result()
+    except Exception as e:
+        print(e)
+        return
+
+
+def start_loop(loop: asyncio.BaseEventLoop):
+    if platform.system() == "Darwin":
+        asyncio.get_running_loop = asyncio.get_event_loop
+    asyncio.set_event_loop(loop)
+    loop.run_forever()

{sensor-sdk-0.0.4 → sensor-sdk-0.0.5}/sensor_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.4
+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.4 → sensor-sdk-0.0.5}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), "r", encoding="utf-8") as f
 
 setup(
     name="sensor-sdk",
-    version="0.0.4",
+    version="0.0.5",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",

sensor-sdk-0.0.4/sensor/utils.py

@@ -1,30 +0,0 @@
-import asyncio
-import signal
-
-
-async def delay(time: float, function) -> any:
-    if time > 0:
-        await asyncio.sleep(time)
-    return await function
-
-
-def timer(_loop: asyncio.AbstractEventLoop, time: float, function):
-    try:
-        asyncio.run_coroutine_threadsafe(delay(time, function), _loop)
-    except Exception as e:
-        print(e)
-        pass
-
-
-def sync_timer(_loop: asyncio.AbstractEventLoop, time: float, function) -> any:
-    try:
-        f = asyncio.run_coroutine_threadsafe(delay(time, function), _loop)
-        return f.result()
-    except Exception as e:
-        print(e)
-        pass
-
-
-def start_loop(loop: asyncio.BaseEventLoop):
-    asyncio.set_event_loop(loop)
-    loop.run_forever()