sensor-sdk 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

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_call, start_loop, sync_call, async_exec, 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
@@ -76,15 +78,13 @@ 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:
                 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 +92,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,11 +109,9 @@ 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
-                    )
+                    self._event_loop.call_soon_threadsafe(self._on_state_changed, self, newState)
                 except Exception as e:
                     print(e)
                     pass
@@ -158,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]):
         """
         设置状态变化的回调函数。
 
@@ -223,17 +220,48 @@ class SensorProfile:
         self._on_power_changed = callback
 
     async def _connect(self) -> bool:
-        if (
-            self.deviceState == DeviceStateEx.Connected
-            or self.deviceState == DeviceStateEx.Ready
-        ):
+        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.daemon = True
+            self._event_thread.name = self._device.Name + " event"
+            self._event_thread.start()
+            self._data_buffer: Queue[SensorData] = Queue()
+            self._raw_data_buf: Queue[bytes] = Queue()
+
+        if self._gforce == None:
+            if self._adv.service_data.get(SERVICE_GUID) != None:
+                # print("OYM_SERVICE:" + self._detail_device.name)
+                self._gforce = GForce(
+                    self._detail_device,
+                    OYM_CMD_NOTIFY_CHAR_UUID,
+                    OYM_DATA_NOTIFY_CHAR_UUID,
+                    False,
+                )
+            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._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.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))
+                return False
+
+        if self._data_ctx == None and self._gforce != None:
+            self._data_ctx = SensorProfileDataCtx(self._gforce, self._device.Address, self._raw_data_buf)
+        if self._data_ctx.isUniversalStream:
+            async_exec(self._data_event_loop, 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.stopDataNotification()
             self._data_ctx.close()
-            time.sleep(1)
+            time.sleep(0.1)
             self._data_buffer.queue.clear()
             self._data_ctx = None
             self._gforce = None
@@ -244,10 +272,11 @@ class SensorProfile:
 
         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()
+            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)
 
@@ -260,55 +289,17 @@ class SensorProfile:
         :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
         """
-        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.daemon = True
-            self._event_thread.name = self._device.Name + " event"
-            self._event_thread.start()
-            self._data_buffer: Queue[SensorData] = Queue()
-            self._raw_data_buf: Queue[bytes] = Queue()
+        result = sync_call(self._gforce_event_loop, self._connect())
+        return result
 
-        if self._gforce == None:
-            if self._adv.service_data.get(SERVICE_GUID) != None:
-                # print("OYM_SERVICE:" + self._detail_device.name)
-                self._gforce = GForce(
-                    self._detail_device,
-                    OYM_CMD_NOTIFY_CHAR_UUID,
-                    OYM_DATA_NOTIFY_CHAR_UUID,
-                    False,
-                )
-            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._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.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)
-                )
-                return False
+    async def asyncConnect(self) -> bool:
+        """
+        连接传感器。
 
-        if self._data_ctx == None and self._gforce != None:
-            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())
+        :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
-        result = sync_timer(self._gforce_event_loop, 0, self._connect())
-        return result
+        """
+        return await async_call(self._gforce_event_loop, self._connect())
 
     async def _waitForDisconnect(self) -> bool:
         while self.deviceState != DeviceStateEx.Disconnected:
@@ -316,16 +307,13 @@ 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
         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:
@@ -335,46 +323,37 @@ 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:
+        """
+        断开传感器连接。
+
+        :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
+
+        """
+        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:
-            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
-                        )
+                        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
-        )
+        self._data_ctx.processUniversalData(self._data_buffer, self._event_loop, self, self._on_data_callback)
 
     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:
@@ -387,26 +366,37 @@ 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()
 
-        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:
+            async_exec(self._data_event_loop, self._process_data())
+        return result
+
+    def startDataNotification(self) -> bool:
+        """
+        开始数据通知。
 
-    async def _stopDataNotification(self) -> bool:
+        :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
-        return not await self._data_ctx.stop_streaming()
+        """
+        return sync_call(self._gforce_event_loop, self._startDataNotification())
 
-    def stopDataNotification(self) -> bool:
+    async def asyncStartDataNotification(self) -> bool:
         """
-        停止数据通知。
+        开始数据通知。
 
-        :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
+        :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
+        return await async_call(self._gforce_event_loop, self._startDataNotification())
+
+    async def _stopDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
             return False
         if self._data_ctx == None:
@@ -417,16 +407,32 @@ class SensorProfile:
         if not self._data_ctx.isDataTransfering:
             return True
 
-        return sync_timer(self._gforce_event_loop, 0, self._stopDataNotification())
+        return not await self._data_ctx.stop_streaming()
+
+    def stopDataNotification(self) -> bool:
+        """
+        停止数据通知。
+
+        :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
+
+        """
+        return sync_call(self._gforce_event_loop, self._stopDataNotification())
+
+    async def asyncStopDataNotification(self) -> bool:
+        """
+        停止数据通知。
+
+        :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
+
+        """
+        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._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
-                )
+                self._event_loop.call_soon_threadsafe(self._on_power_changed, self, self._power)
             except Exception as e:
                 print(e)
 
@@ -465,10 +471,26 @@ class SensorProfile:
         :return:            bool: 初始化结果。True 表示成功，False 表示失败。
 
         """
-        return sync_timer(
+        return sync_call(
             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_call(
+            self._gforce_event_loop,
+            self._init(packageSampleCount, powerRefreshInterval),
+            120,
         )
 
     def getBatteryLevel(self) -> int:
@@ -502,3 +524,15 @@ class SensorProfile:
 
         """
         return ""
+
+    async def AsyncSetParam(self, key: str, value: str) -> str:
+        """
+        设置传感器的参数。
+
+        :param    key (str): 参数的键。
+        :param    value (str): 参数的值。
+
+        :return:            str: 设置参数的结果。
+
+        """
+        return ""

sensor/utils.py

@@ -1,30 +1,73 @@
 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)
+
+async def delay(_time: float, function) -> any:
+    await asyncio.sleep(_time)
     return await function
 
 
-def timer(_loop: asyncio.AbstractEventLoop, time: float, 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 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:
-        asyncio.run_coroutine_threadsafe(delay(time, function), _loop)
+        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _loop)
+        return f.result(timeout=_timeout)
     except Exception as e:
         print(e)
         pass
 
 
-def sync_timer(_loop: asyncio.AbstractEventLoop, time: float, function) -> any:
+async def async_call(_loop: asyncio.AbstractEventLoop, function, _timeout=_TIMEOUT) -> any:
+    if _loop == None:
+        return
+
     try:
-        f = asyncio.run_coroutine_threadsafe(delay(time, function), _loop)
-        return f.result()
+        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _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.dist-info → sensor_sdk-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.4
+Version: 0.0.6
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye
@@ -71,6 +71,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
@@ -125,7 +131,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()
@@ -343,3 +349,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.6.dist-info/RECORD

@@ -0,0 +1,14 @@
+sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
+sensor/gforce.py,sha256=z-w9POiw5rtj6AgTvwFAI6tZt_5jv_3eSiKt_0jA1Ps,25229
+sensor/sensor_controller.py,sha256=lNi7i3T_aAHEJvv963OvVv_PNAYy_5-BwXD82XNvnGg,10028
+sensor/sensor_data.py,sha256=Hu7Ql0LgQ7V24xYZhaLrKPwU4KWZeWE655v8Gy8xphY,3934
+sensor/sensor_data_context.py,sha256=7GQwthoAH-qJsimWwCf8JcQAP8TivG3X0lwxfyHabo4,28575
+sensor/sensor_device.py,sha256=LCjBzm2TuOh2KpHsFTjm1sF8hzwvS22LhF_ueAct0Jo,2848
+sensor/sensor_profile.py,sha256=SFecXPCauvadRJdssu9iWMgCdxRinTqGlzLAQsZ8-k8,19625
+sensor/utils.py,sha256=ybmByBldCQ_x-sVtjA2mdXWo0QOafPAupfnWAxLrkV0,1773
+sensor_sdk-0.0.6.dist-info/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
+sensor_sdk-0.0.6.dist-info/METADATA,sha256=JP3HgNyVlwNe2AkT7LMm1PCVAxGtLr4XrdkfHZKBmL0,8374
+sensor_sdk-0.0.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+sensor_sdk-0.0.6.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
+sensor_sdk-0.0.6.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+sensor_sdk-0.0.6.dist-info/RECORD,,

sensor_sdk-0.0.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
-sensor/gforce.py,sha256=ZVOHV6_NiwGMPAf4BXqlxEHsDrynUBr0rcgqmbJT5oc,24586
-sensor/sensor_controller.py,sha256=UcFsbkXbJsknkVARADB_wT0ZGIDVjHfBFMsmxglF1_0,8334
-sensor/sensor_data.py,sha256=Hu7Ql0LgQ7V24xYZhaLrKPwU4KWZeWE655v8Gy8xphY,3934
-sensor/sensor_data_context.py,sha256=fcGEYWOu5x9UGZ-psvKVKA-nxAKfA8vqMEeA4LjsxAA,27978
-sensor/sensor_device.py,sha256=LCjBzm2TuOh2KpHsFTjm1sF8hzwvS22LhF_ueAct0Jo,2848
-sensor/sensor_profile.py,sha256=NuWYSVGrHWA8y2Goi9UyNyZ3bXE8unKrQ560q8looNw,17873
-sensor/utils.py,sha256=LPLnLTOrrsLnVkL65L10PLtqpjgMYkomyVenRc7pUUo,744
-sensor_sdk-0.0.4.dist-info/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
-sensor_sdk-0.0.4.dist-info/METADATA,sha256=EYBnMeflySNLB1qxF0OtqRx-xW-FiUo_CFAB89w4el8,8055
-sensor_sdk-0.0.4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-sensor_sdk-0.0.4.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
-sensor_sdk-0.0.4.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-sensor_sdk-0.0.4.dist-info/RECORD,,