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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.5
+Version: 0.0.7
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor-sdk-0.0.5 → sensor-sdk-0.0.7}/sensor/gforce.py

@@ -370,9 +370,7 @@ 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
@@ -412,6 +410,7 @@ class GForce:
 
     def _on_data_response(self, q: Queue[bytes], bs: bytearray):
         bs = bytes(bs)
+
         full_packet = []
 
         is_partial_data = bs[0] == ResponseCode.PARTIAL_PACKET
@@ -500,9 +499,7 @@ class GForce:
     def _convert_acceleration_to_g(data: bytes) -> np.ndarray[np.float32]:
         normalizing_factor = 65536.0
 
-        acceleration_data = (
-            np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
-        )
+        acceleration_data = np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
         num_channels = 3
 
         return acceleration_data.reshape(-1, num_channels)
@@ -511,9 +508,7 @@ class GForce:
     def _convert_gyro_to_dps(data: bytes) -> np.ndarray[np.float32]:
         normalizing_factor = 65536.0
 
-        gyro_data = (
-            np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
-        )
+        gyro_data = np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
         num_channels = 3
 
         return gyro_data.reshape(-1, num_channels)
@@ -522,9 +517,7 @@ class GForce:
     def _convert_magnetometer_to_ut(data: bytes) -> np.ndarray[np.float32]:
         normalizing_factor = 65536.0
 
-        magnetometer_data = (
-            np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
-        )
+        magnetometer_data = np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
         num_channels = 3
 
         return magnetometer_data.reshape(-1, num_channels)
@@ -846,15 +839,11 @@ class GForce:
     async def stop_streaming(self):
         exceptions = []
         try:
-            await asyncio.wait_for(
-                self.set_subscription(DataSubscription.OFF), utils._TIMEOUT
-            )
+            await asyncio.wait_for(self.set_subscription(DataSubscription.OFF), utils._TIMEOUT)
         except Exception as e:
             exceptions.append(e)
         try:
-            await asyncio.wait_for(
-                self.client.stop_notify(self.data_char), utils._TIMEOUT
-            )
+            await asyncio.wait_for(self.client.stop_notify(self.data_char), utils._TIMEOUT)
         except Exception as e:
             exceptions.append(e)
 
@@ -881,9 +870,7 @@ class GForce:
         bs = bytes([req.cmd])
         if req.body is not None:
             bs += req.body
-        await asyncio.wait_for(
-            self.client.write_gatt_char(self.cmd_char, bs), utils._TIMEOUT
-        )
+        await asyncio.wait_for(self.client.write_gatt_char(self.cmd_char, bs), utils._TIMEOUT)
 
         if not req.has_res:
             return None

{sensor-sdk-0.0.5 → sensor-sdk-0.0.7}/sensor/sensor_controller.py

@@ -9,7 +9,7 @@ from sensor import utils
 from sensor.sensor_profile import DeviceStateEx, SensorProfile
 import asyncio
 
-from sensor.utils import async_timer, start_loop, sync_timer, timer
+from sensor.utils import async_call, start_loop, sync_call, async_exec, timer
 from bleak import (
     BleakScanner,
     AdvertisementData,
@@ -38,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()
@@ -72,10 +68,7 @@ class SensorController:
     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):
@@ -125,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]):
         """
         设置扫描设备回调。
 
@@ -168,9 +159,7 @@ class SensorController:
 
     async def _async_scan(self, period):
         self._is_scanning = True
-        found_devices = await self._scanner.discover(
-            timeout=period / 1000, return_adv=True
-        )
+        found_devices = await self._scanner.discover(timeout=period / 1000, return_adv=True)
         self._is_scanning = False
         return self._process_ble_devices(found_devices)
 
@@ -182,7 +171,7 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return sync_timer(self._gforce_event_loop, 0, self._async_scan(period))
+        return sync_call(self._gforce_event_loop, self._async_scan(period))
 
     async def asyncScan(self, period) -> List[sensor_profile.BLEDevice]:
         """
@@ -192,7 +181,7 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return await async_timer(self._gforce_event_loop, 0, self._async_scan(period))
+        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:
@@ -202,14 +191,12 @@ class SensorController:
                 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:
-        found_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))
+        async_exec(self._event_loop, self._device_scan_callback(devices))
 
     def startScan(self, periodInMs: int) -> bool:
         """
@@ -225,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:
@@ -237,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。
 
@@ -271,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
@@ -287,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

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

@@ -82,9 +82,7 @@ class SensorProfileDataCtx:
         return self._is_data_transfering
 
     def hasInit(self):
-        return (
-            not self._is_initing and 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
@@ -207,13 +205,13 @@ class SensorProfileDataCtx:
             info.MTUSize = self.gForce.client.mtu_size
         else:
             info.MTUSize = 0
-        print("get_device_name")
+        # print("get_device_name")
         info.DeviceName = await self.gForce.get_device_name()
-        print("get_model_number")
+        # print("get_model_number")
         info.ModelName = await self.gForce.get_model_number()
-        print("get_hardware_revision")
+        # print("get_hardware_revision")
         info.HardwareVersion = await self.gForce.get_hardware_revision()
-        print("get_firmware_revision")
+        # print("get_firmware_revision")
         info.FirmwareVersion = await self.gForce.get_firmware_revision()
         return info
 
@@ -228,19 +226,19 @@ class SensorProfileDataCtx:
                 self.notifyDataFlag |= DataSubscription.DNF_IMPEDANCE
 
             if self.hasEEG():
-                print("initEEG")
+                # print("initEEG")
                 info.EegChannelCount = await self.initEEG(packageCount)
 
             if self.hasECG():
-                print("initECG")
+                # print("initECG")
                 info.EcgChannelCount = await self.initECG(packageCount)
 
             if self.hasBrth():
-                print("initBrth")
+                # print("initBrth")
                 info.BrthChannelCount = await self.initBrth(packageCount)
 
             if self.hasIMU():
-                print("initIMU")
+                # print("initIMU")
                 imuChannelCount = await self.initIMU(packageCount)
                 info.AccChannelCount = imuChannelCount
                 info.GyroChannelCount = imuChannelCount
@@ -337,9 +335,7 @@ class SensorProfileDataCtx:
             if self.checkReadSamples(sensor, data, sensor_data_gyro, 9, 6):
                 self.sendSensorData(sensor_data_gyro, buf)
 
-    def checkReadSamples(
-        self, sensor, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int
-    ):
+    def checkReadSamples(self, sensor, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int):
         offset = 1
         v = data[0]
         if not self._is_data_transfering:
@@ -358,9 +354,7 @@ class SensorProfileDataCtx:
 
             deltaPackageIndex = packageIndex - lastPackageIndex
             if deltaPackageIndex > 1:
-                lostSampleCount = sensorData.packageSampleCount * (
-                    deltaPackageIndex - 1
-                )
+                lostSampleCount = sensorData.packageSampleCount * (deltaPackageIndex - 1)
                 lostLog = (
                     "MSG|LOST SAMPLE|MAC|"
                     + str(sensorData.deviceMac)
@@ -372,9 +366,7 @@ class SensorProfileDataCtx:
                 # 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
-                        )
+                        sensor._event_loop.call_soon_threadsafe(sensor._on_error_callback, sensor, lostLog)
                     except Exception as e:
                         pass
 
@@ -418,18 +410,14 @@ class SensorProfileDataCtx:
                 channelSamples.append([])
 
         for sampleIndex in range(sampleCount):
-            for channelIndex, impedanceChannelIndex in enumerate(
-                range(sensorData.channelCount)
-            ):
+            for channelIndex, impedanceChannelIndex in enumerate(range(sensorData.channelCount)):
                 if (sensorData.channelMask & (1 << channelIndex)) != 0:
                     samples = channelSamples[channelIndex]
                     impedance = 0.0
                     saturation = 0.0
 
                     if sensorData.dataType == DataType.NTF_ECG:
-                        impedanceChannelIndex = self.sensorDatas[
-                            SensorDataType.DATA_TYPE_EEG
-                        ].channelCount
+                        impedanceChannelIndex = self.sensorDatas[SensorDataType.DATA_TYPE_EEG].channelCount
 
                     if impedanceChannelIndex < len(_impedanceData):
                         impedance = _impedanceData[impedanceChannelIndex]
@@ -461,11 +449,7 @@ class SensorProfileDataCtx:
                             )
                             offset += 2
                         elif sensorData.resolutionBits == 24:
-                            rawData = (
-                                (data[offset] << 16)
-                                | (data[offset + 1] << 8)
-                                | data[offset + 2]
-                            )
+                            rawData = (data[offset] << 16) | (data[offset + 1] << 8) | data[offset + 2]
                             rawData -= 8388608
                             offset += 3
 
@@ -802,11 +786,15 @@ class SensorProfileDataCtx:
 
         return crc8
 
-    def processUniversalData(
-        self, buf: Queue[SensorData], loop: asyncio.AbstractEventLoop, sensor, callback
+    async def processUniversalData(
+        self, buf: Queue[SensorData], event_loop: asyncio.AbstractEventLoop, cmd_loop: asyncio.AbstractEventLoop, sensor, callback
     ):
 
         while self._is_running:
+            while self._is_running and self._rawDataBuffer.empty():
+                await asyncio.sleep(0.01)
+                continue
+
             try:
                 while self._is_running and not self._rawDataBuffer.empty():
                     data = self._rawDataBuffer.get_nowait()
@@ -832,34 +820,28 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = self.calc_crc8(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
+                    calc_crc = self.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
                     if self._is_data_transfering:
-                        data_package = bytes(
-                            self._concatDataBuffer[index + 2 : index + 2 + n]
-                        )
+                        data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
                         self._processDataPackage(data_package, buf, sensor)
-                        while self._is_running and self.isDataTransfering:
+                        while self._is_running and self.isDataTransfering and not buf.empty():
                             sensorData: SensorData = None
                             try:
                                 sensorData = buf.get_nowait()
                             except Exception as e:
                                 break
-                            if loop != None and sensorData != None and callback != None:
+                            if event_loop != None and sensorData != None and callback != None:
                                 try:
-                                    loop.call_soon_threadsafe(
-                                        callback, sensor, sensorData
-                                    )
+                                    event_loop.call_soon_threadsafe(callback, sensor, sensorData)
                                 except Exception as e:
                                     print(e)
 
                             buf.task_done()
-
                     last_cut = index = index + 2 + n
+
                 elif self._concatDataBuffer[index] == 0xAA:
                     if (index + 1) >= data_size:
                         index += 1
@@ -869,22 +851,17 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = self.calc_crc8(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
+                    calc_crc = self.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
-                    data_package = bytes(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
-                    if loop != None:
-                        loop.call_soon_threadsafe(
-                            self.gForce._on_cmd_response, None, data_package
-                        )
+                    data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
+                    if cmd_loop != None:
+                        cmd_loop.call_soon_threadsafe(self.gForce._on_cmd_response, None, data_package)
                     last_cut = index = index + 2 + n
+
                 else:
                     index += 1
 
-            if last_cut > 0:
-                self._concatDataBuffer = self._concatDataBuffer[last_cut + 1 :]
+                if last_cut > 0:
+                    self._concatDataBuffer = self._concatDataBuffer[last_cut + 1 :]

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

@@ -21,7 +21,7 @@ import threading
 
 from sensor.sensor_data_context import SensorProfileDataCtx
 from sensor.sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
-from sensor.utils import async_timer, start_loop, sync_timer, timer
+from sensor.utils import async_call, start_loop, sync_call, async_exec, timer
 from contextlib import suppress
 from dataclasses import dataclass
 
@@ -78,10 +78,7 @@ class SensorProfile:
         self._destroy()
 
     def _destroy(self):
-        if (
-            self._device_state == DeviceStateEx.Connected
-            or self._device_state == DeviceStateEx.Ready
-        ):
+        if self._device_state == DeviceStateEx.Connected or self._device_state == DeviceStateEx.Ready:
             self.disconnect()
         if self._data_event_loop != None:
             try:
@@ -114,9 +111,7 @@ class SensorProfile:
             self._device_state = newState
             if self._event_loop != None and self._on_state_changed != None:
                 try:
-                    self._event_loop.call_soon_threadsafe(
-                        self._on_state_changed, self, newState
-                    )
+                    self._event_loop.call_soon_threadsafe(self._on_state_changed, self, newState)
                 except Exception as e:
                     print(e)
                     pass
@@ -162,9 +157,7 @@ class SensorProfile:
         return self._on_state_changed
 
     @onStateChanged.setter
-    def onStateChanged(
-        self, callback: Callable[["SensorProfile", DeviceStateEx], None]
-    ):
+    def onStateChanged(self, callback: Callable[["SensorProfile", DeviceStateEx], None]):
         """
         设置状态变化的回调函数。
 
@@ -229,9 +222,7 @@ class SensorProfile:
     async def _connect(self) -> bool:
         if self._event_thread == None:
             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 = self._device.Name + " event"
             self._event_thread.start()
@@ -249,35 +240,22 @@ class SensorProfile:
                 )
             elif self._adv.service_data.get(RFSTAR_SERVICE_GUID) != None:
                 # print("RFSTAR_SERVICE:" + self._detail_device.name)
-                self._gforce = GForce(
-                    self._detail_device, RFSTAR_CMD_UUID, RFSTAR_DATA_UUID, True
-                )
+                self._gforce = GForce(self._detail_device, RFSTAR_CMD_UUID, RFSTAR_DATA_UUID, True)
                 self._data_event_loop = asyncio.new_event_loop()
-                self._data_event_thread = threading.Thread(
-                    target=start_loop, args=(self._data_event_loop,)
-                )
+                self._data_event_thread = threading.Thread(target=start_loop, args=(self._data_event_loop,))
                 self._data_event_thread.daemon = True
                 self._data_event_thread.name = self._detail_device.name + " data"
                 self._data_event_thread.start()
             else:
-                print(
-                    "Invalid device service uuid:"
-                    + self._detail_device.name
-                    + str(self._adv)
-                )
+                print("Invalid device service uuid:" + self._detail_device.name + str(self._adv))
                 return False
 
         if self._data_ctx == None and self._gforce != None:
-            self._data_ctx = SensorProfileDataCtx(
-                self._gforce, self._device.Address, self._raw_data_buf
-            )
+            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())
+            async_exec(self._data_event_loop, self._process_universal_data())
 
-        if (
-            self.deviceState == DeviceStateEx.Connected
-            or self.deviceState == DeviceStateEx.Ready
-        ):
+        if self.deviceState == DeviceStateEx.Connected or self.deviceState == DeviceStateEx.Ready:
             return True
         self._set_device_state(DeviceStateEx.Connecting)
 
@@ -311,7 +289,7 @@ class SensorProfile:
         :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
         """
-        result = sync_timer(self._gforce_event_loop, 0, self._connect())
+        result = sync_call(self._gforce_event_loop, self._connect())
         return result
 
     async def asyncConnect(self) -> bool:
@@ -321,7 +299,7 @@ class SensorProfile:
         :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
         """
-        return await async_timer(self._gforce_event_loop, 0, self._connect())
+        return await async_call(self._gforce_event_loop, self._connect())
 
     async def _waitForDisconnect(self) -> bool:
         while self.deviceState != DeviceStateEx.Disconnected:
@@ -329,10 +307,7 @@ class SensorProfile:
         return True
 
     async def _disconnect(self) -> bool:
-        if (
-            self.deviceState != DeviceStateEx.Connected
-            and self.deviceState != DeviceStateEx.Ready
-        ):
+        if self.deviceState != DeviceStateEx.Connected and self.deviceState != DeviceStateEx.Ready:
             return True
         if self._data_ctx == None:
             return False
@@ -348,7 +323,7 @@ class SensorProfile:
         :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
 
         """
-        return sync_timer(self._gforce_event_loop, 0, self._disconnect())
+        return sync_call(self._gforce_event_loop, self._disconnect())
 
     async def asyncDisconnect(self) -> bool:
         """
@@ -357,7 +332,7 @@ class SensorProfile:
         :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
 
         """
-        return await async_timer(self._gforce_event_loop, 0, self._disconnect())
+        return await async_call(self._gforce_event_loop, self._disconnect())
 
     async def _process_data(self):
         while self._data_ctx._is_running and self._data_ctx.isDataTransfering:
@@ -368,22 +343,16 @@ class SensorProfile:
                     sensorData = self._data_buffer.get_nowait()
                 except Exception as e:
                     break
-                if (
-                    self._event_loop != None
-                    and 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
-                        )
+                        self._event_loop.call_soon_threadsafe(self._on_data_callback, self, sensorData)
                     except Exception as e:
                         print(e)
                 self._data_buffer.task_done()
 
     async def _process_universal_data(self):
-        self._data_ctx.processUniversalData(
-            self._data_buffer, self._event_loop, self, self._on_data_callback
+        await self._data_ctx.processUniversalData(
+            self._data_buffer, self._event_loop, self._gforce_event_loop, self, self._on_data_callback
         )
 
     async def _startDataNotification(self) -> bool:
@@ -399,9 +368,7 @@ class SensorProfile:
 
         if self._data_event_loop == None:
             self._data_event_loop = asyncio.new_event_loop()
-            self._data_event_thread = threading.Thread(
-                target=start_loop, args=(self._data_event_loop,)
-            )
+            self._data_event_thread = threading.Thread(target=start_loop, args=(self._data_event_loop,))
             self._data_event_thread.daemon = True
             self._data_event_thread.name = self.BLEDevice.Name + " data"
             self._data_event_thread.start()
@@ -410,7 +377,7 @@ class SensorProfile:
         self._data_buffer.queue.clear()
         self._data_ctx.clear()
         if not self._data_ctx.isUniversalStream:
-            timer(self._data_event_loop, 0, self._process_data())
+            async_exec(self._data_event_loop, self._process_data())
         return result
 
     def startDataNotification(self) -> bool:
@@ -420,7 +387,7 @@ class SensorProfile:
         :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
-        return sync_timer(self._gforce_event_loop, 0, self._startDataNotification())
+        return sync_call(self._gforce_event_loop, self._startDataNotification())
 
     async def asyncStartDataNotification(self) -> bool:
         """
@@ -429,9 +396,7 @@ class SensorProfile:
         :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
-        return await async_timer(
-            self._gforce_event_loop, 0, self._startDataNotification()
-        )
+        return await async_call(self._gforce_event_loop, self._startDataNotification())
 
     async def _stopDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -453,7 +418,7 @@ class SensorProfile:
         :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
 
         """
-        return sync_timer(self._gforce_event_loop, 0, self._stopDataNotification())
+        return sync_call(self._gforce_event_loop, self._stopDataNotification())
 
     async def asyncStopDataNotification(self) -> bool:
         """
@@ -462,18 +427,14 @@ class SensorProfile:
         :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
 
         """
-        return await async_timer(
-            self._gforce_event_loop, 0, self._stopDataNotification()
-        )
+        return await async_call(self._gforce_event_loop, self._stopDataNotification())
 
     async def _refresh_power(self):
         self._power = await self._gforce.get_battery_level()
 
         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
-                )
+                self._event_loop.call_soon_threadsafe(self._on_power_changed, self, self._power)
             except Exception as e:
                 print(e)
 
@@ -512,16 +473,13 @@ class SensorProfile:
         :return:            bool: 初始化结果。True 表示成功，False 表示失败。
 
         """
-        return sync_timer(
+        return sync_call(
             self._gforce_event_loop,
-            0,
             self._init(packageSampleCount, powerRefreshInterval),
-            120,
+            20,
         )
 
-    async def asyncInit(
-        self, packageSampleCount: int, powerRefreshInterval: int
-    ) -> bool:
+    async def asyncInit(self, packageSampleCount: int, powerRefreshInterval: int) -> bool:
         """
         初始化数据采集。
 
@@ -531,11 +489,10 @@ class SensorProfile:
         :return:            bool: 初始化结果。True 表示成功，False 表示失败。
 
         """
-        return await async_timer(
+        return await async_call(
             self._gforce_event_loop,
-            0,
             self._init(packageSampleCount, powerRefreshInterval),
-            120,
+            20,
         )
 
     def getBatteryLevel(self) -> int:

{sensor-sdk-0.0.5 → sensor-sdk-0.0.7}/sensor/utils.py

@@ -9,8 +9,7 @@ _TIMEOUT = 10
 
 
 async def delay(_time: float, function) -> any:
-    if _time > 0:
-        await asyncio.sleep(_time)
+    await asyncio.sleep(_time)
     return await function
 
 
@@ -24,32 +23,34 @@ def timer(_loop: asyncio.AbstractEventLoop, _delay: float, function):
         pass
 
 
-def sync_timer(
-    _loop: asyncio.AbstractEventLoop, _delay: float, function, _timeout=_TIMEOUT
-) -> any:
+def async_exec(_loop: asyncio.AbstractEventLoop, function):
+    if _loop == None:
+        return
+    try:
+        asyncio.run_coroutine_threadsafe(function, _loop)
+    except Exception as e:
+        print(e)
+        pass
+
+
+def sync_call(_loop: asyncio.AbstractEventLoop, function, _timeout=_TIMEOUT) -> any:
     if _loop == None:
         return
 
     try:
-        f = asyncio.run_coroutine_threadsafe(
-            asyncio.wait_for(delay(_delay, function), _delay + _timeout), _loop
-        )
+        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _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:
+async def async_call(_loop: asyncio.AbstractEventLoop, function, _timeout=_TIMEOUT) -> any:
     if _loop == None:
         return
 
     try:
-        f = asyncio.run_coroutine_threadsafe(
-            asyncio.wait_for(delay(_delay, function), _delay + _timeout), _loop
-        )
+        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _loop)
     except Exception as e:
         print(e)
         pass

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.5
+Version: 0.0.7
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor-sdk-0.0.5 → sensor-sdk-0.0.7}/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.5",
+    version="0.0.7",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",