sensor-sdk 0.0.7__py3-none-any.whl → 0.0.10__py3-none-any.whl

sensor/gforce.py

@@ -397,16 +397,20 @@ class GForce:
 
         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 asyncio.wait_for(
-                client.start_notify(self.data_char, self._on_universal_response),
-                utils._TIMEOUT,
-            )
+
+        try:
+            if not self._is_universal_stream:
+                await asyncio.wait_for(
+                    client.start_notify(self.cmd_char, self._on_cmd_response),
+                    utils._TIMEOUT,
+                )
+            else:
+                await asyncio.wait_for(
+                    client.start_notify(self.data_char, self._on_universal_response),
+                    utils._TIMEOUT,
+                )
+        except Exception as e:
+            return
 
     def _on_data_response(self, q: Queue[bytes], bs: bytearray):
         bs = bytes(bs)
@@ -875,4 +879,7 @@ class GForce:
         if not req.has_res:
             return None
 
-        return await asyncio.wait_for(q.get(), utils._TIMEOUT)
+        try:
+            return await asyncio.wait_for(q.get(), utils._TIMEOUT)
+        except Exception as e:
+            return None

sensor/sensor_controller.py

@@ -1,3 +1,4 @@
+import asyncio
 from concurrent.futures import ThreadPoolExecutor
 import threading
 from typing import Callable, Dict, List, Optional, Tuple
@@ -7,9 +8,8 @@ import bleak
 from sensor import sensor_profile
 from sensor import utils
 from sensor.sensor_profile import DeviceStateEx, SensorProfile
-import asyncio
 
-from sensor.utils import async_call, start_loop, sync_call, async_exec, timer
+from sensor.utils import async_call, sync_call, async_exec
 from bleak import (
     BleakScanner,
     AdvertisementData,
@@ -27,6 +27,7 @@ class SensorController:
             with SensorController._instance_lock:
                 if not hasattr(SensorController, "_instance"):
                     SensorController._instance = object.__new__(cls)
+
         return SensorController._instance
 
     """
@@ -37,21 +38,8 @@ 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.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.daemon = True
-        self._gforce_event_thread.name = "BLE operation"
-        self._gforce_event_thread.start()
-        self._scanner = BleakScanner(
-            detection_callback=self._match_device,
-            service_uuids=[SERVICE_GUID, RFSTAR_SERVICE_GUID],
-        )
         self._is_scanning = False
+        self._scanner: BleakScanner = None
         self._device_callback: Callable[[List[sensor_profile.BLEDevice]], None] = None
         self._device_callback_period = 0
         self._enable_callback: Callable[[bool], None] = None
@@ -62,15 +50,16 @@ class SensorController:
         反初始化 SensorController 类的实例。
 
         """
-        self._event_loop.close()
-        self._gforce_event_loop.close()
 
     def terminate(self):
         utils._terminated = True
+
         for sensor in self._sensor_profiles.values():
             if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
                 sensor._destroy()
 
+        utils.Terminate()
+
     def _match_device(self, _device: bleak.BLEDevice, adv: AdvertisementData):
         if _device.name == None:
             return False
@@ -150,15 +139,23 @@ class SensorController:
                 if deviceMap.get(mac) != None:
                     devices.append(self._sensor_profiles[mac].BLEDevice)
                 else:
-                    newSensor = SensorProfile(device, adv, mac, self._gforce_event_loop)
+                    newSensor = SensorProfile(device, adv, mac)
                     deviceMap[mac] = newSensor
                     devices.append(newSensor.BLEDevice)
 
         self._sensor_profiles = deviceMap
         return devices
 
+    def _init_scan(self):
+        if self._scanner == None:
+            self._scanner = BleakScanner(
+                detection_callback=self._match_device,
+                service_uuids=[SERVICE_GUID, RFSTAR_SERVICE_GUID],
+            )
+
     async def _async_scan(self, period):
         self._is_scanning = True
+        self._init_scan()
         found_devices = await self._scanner.discover(timeout=period / 1000, return_adv=True)
         self._is_scanning = False
         return self._process_ble_devices(found_devices)
@@ -171,7 +168,7 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return sync_call(self._gforce_event_loop, self._async_scan(period))
+        return sync_call(self._async_scan(period))
 
     async def asyncScan(self, period) -> List[sensor_profile.BLEDevice]:
         """
@@ -181,22 +178,23 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return await async_call(self._gforce_event_loop, self._async_scan(period))
+        return await async_call(self._async_scan(period))
 
     async def _device_scan_callback(self, devices: List[sensor_profile.BLEDevice]):
         if self._device_callback:
             try:
-                self._device_callback(devices)
+                asyncio.get_event_loop().run_in_executor(None, self._device_callback, devices)
             except Exception as e:
                 print(e)
 
         if self._is_scanning:
-            async_exec(self._gforce_event_loop, self._startScan())
+            async_exec(self._startScan())
 
     async def _startScan(self) -> bool:
+        self._init_scan()
         found_devices = await self._scanner.discover(timeout=self._device_callback_period / 1000, return_adv=True)
         devices = self._process_ble_devices(found_devices)
-        async_exec(self._event_loop, self._device_scan_callback(devices))
+        async_exec(self._device_scan_callback(devices))
 
     def startScan(self, periodInMs: int) -> bool:
         """
@@ -212,7 +210,7 @@ class SensorController:
         self._is_scanning = True
         self._device_callback_period = periodInMs
 
-        async_exec(self._gforce_event_loop, self._startScan())
+        async_exec(self._startScan())
         return True
 
     def stopScan(self) -> None:

sensor/sensor_data_context.py

@@ -5,13 +5,13 @@ from queue import Queue
 import struct
 from typing import Deque, List
 
+from sensor import utils
 from sensor.gforce import DataSubscription, GForce
 from sensor.sensor_data import DataType, Sample, SensorData
 
 from enum import Enum, IntEnum
 
 from sensor.sensor_device import DeviceInfo
-from sensor.utils import timer
 
 
 class SensorDataType(IntEnum):
@@ -228,20 +228,25 @@ class SensorProfileDataCtx:
             if self.hasEEG():
                 # print("initEEG")
                 info.EegChannelCount = await self.initEEG(packageCount)
+                info.EegSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_EEG].sampleRate
 
             if self.hasECG():
                 # print("initECG")
                 info.EcgChannelCount = await self.initECG(packageCount)
+                info.EcgSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_ECG].sampleRate
 
             if self.hasBrth():
                 # print("initBrth")
                 info.BrthChannelCount = await self.initBrth(packageCount)
+                info.BrthSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_BRTH].sampleRate
 
             if self.hasIMU():
                 # print("initIMU")
                 imuChannelCount = await self.initIMU(packageCount)
                 info.AccChannelCount = imuChannelCount
                 info.GyroChannelCount = imuChannelCount
+                info.AccSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_ACC].sampleRate
+                info.GyroSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_GYRO].sampleRate
 
             self._device_info = info
 
@@ -280,14 +285,32 @@ class SensorProfileDataCtx:
             await self.gForce.set_subscription(0)
             return True
 
-    def process_data(self, buf: Queue[SensorData], sensor):
-        try:
-            data: bytes = self._rawDataBuffer.get_nowait()
-        except Exception as e:
-            return
+    async def process_data(self, buf: Queue[SensorData], sensor, callback):
+        while self._is_running and self._rawDataBuffer.empty():
+            await asyncio.sleep(0.01)
 
-        self._processDataPackage(data, buf, sensor)
-        self._rawDataBuffer.task_done()
+            while self._is_running and not self._rawDataBuffer.empty():
+                try:
+                    data: bytes = self._rawDataBuffer.get_nowait()
+                except Exception as e:
+                    continue
+
+                self._processDataPackage(data, buf, sensor)
+                self._rawDataBuffer.task_done()
+
+                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 sensorData != None and callback != None:
+                        try:
+                            asyncio.get_event_loop().run_in_executor(None, callback, sensor, sensorData)
+                        except Exception as e:
+                            print(e)
+
+                    buf.task_done()
 
     def _processDataPackage(self, data: bytes, buf: Queue[SensorData], sensor):
         v = data[0]
@@ -366,7 +389,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)
+                        asyncio.get_event_loop().run_in_executor(None, sensor._on_error_callback, sensor, lostLog)
                     except Exception as e:
                         pass
 
@@ -518,277 +541,7 @@ class SensorProfileDataCtx:
         for sensorDataResult in sensorDataList:
             buf.put(sensorDataResult)
 
-    def calc_crc8(self, data):
-        crc8Table = [
-            0x00,
-            0x07,
-            0x0E,
-            0x09,
-            0x1C,
-            0x1B,
-            0x12,
-            0x15,
-            0x38,
-            0x3F,
-            0x36,
-            0x31,
-            0x24,
-            0x23,
-            0x2A,
-            0x2D,
-            0x70,
-            0x77,
-            0x7E,
-            0x79,
-            0x6C,
-            0x6B,
-            0x62,
-            0x65,
-            0x48,
-            0x4F,
-            0x46,
-            0x41,
-            0x54,
-            0x53,
-            0x5A,
-            0x5D,
-            0xE0,
-            0xE7,
-            0xEE,
-            0xE9,
-            0xFC,
-            0xFB,
-            0xF2,
-            0xF5,
-            0xD8,
-            0xDF,
-            0xD6,
-            0xD1,
-            0xC4,
-            0xC3,
-            0xCA,
-            0xCD,
-            0x90,
-            0x97,
-            0x9E,
-            0x99,
-            0x8C,
-            0x8B,
-            0x82,
-            0x85,
-            0xA8,
-            0xAF,
-            0xA6,
-            0xA1,
-            0xB4,
-            0xB3,
-            0xBA,
-            0xBD,
-            0xC7,
-            0xC0,
-            0xC9,
-            0xCE,
-            0xDB,
-            0xDC,
-            0xD5,
-            0xD2,
-            0xFF,
-            0xF8,
-            0xF1,
-            0xF6,
-            0xE3,
-            0xE4,
-            0xED,
-            0xEA,
-            0xB7,
-            0xB0,
-            0xB9,
-            0xBE,
-            0xAB,
-            0xAC,
-            0xA5,
-            0xA2,
-            0x8F,
-            0x88,
-            0x81,
-            0x86,
-            0x93,
-            0x94,
-            0x9D,
-            0x9A,
-            0x27,
-            0x20,
-            0x29,
-            0x2E,
-            0x3B,
-            0x3C,
-            0x35,
-            0x32,
-            0x1F,
-            0x18,
-            0x11,
-            0x16,
-            0x03,
-            0x04,
-            0x0D,
-            0x0A,
-            0x57,
-            0x50,
-            0x59,
-            0x5E,
-            0x4B,
-            0x4C,
-            0x45,
-            0x42,
-            0x6F,
-            0x68,
-            0x61,
-            0x66,
-            0x73,
-            0x74,
-            0x7D,
-            0x7A,
-            0x89,
-            0x8E,
-            0x87,
-            0x80,
-            0x95,
-            0x92,
-            0x9B,
-            0x9C,
-            0xB1,
-            0xB6,
-            0xBF,
-            0xB8,
-            0xAD,
-            0xAA,
-            0xA3,
-            0xA4,
-            0xF9,
-            0xFE,
-            0xF7,
-            0xF0,
-            0xE5,
-            0xE2,
-            0xEB,
-            0xEC,
-            0xC1,
-            0xC6,
-            0xCF,
-            0xC8,
-            0xDD,
-            0xDA,
-            0xD3,
-            0xD4,
-            0x69,
-            0x6E,
-            0x67,
-            0x60,
-            0x75,
-            0x72,
-            0x7B,
-            0x7C,
-            0x51,
-            0x56,
-            0x5F,
-            0x58,
-            0x4D,
-            0x4A,
-            0x43,
-            0x44,
-            0x19,
-            0x1E,
-            0x17,
-            0x10,
-            0x05,
-            0x02,
-            0x0B,
-            0x0C,
-            0x21,
-            0x26,
-            0x2F,
-            0x28,
-            0x3D,
-            0x3A,
-            0x33,
-            0x34,
-            0x4E,
-            0x49,
-            0x40,
-            0x47,
-            0x52,
-            0x55,
-            0x5C,
-            0x5B,
-            0x76,
-            0x71,
-            0x78,
-            0x7F,
-            0x6A,
-            0x6D,
-            0x64,
-            0x63,
-            0x3E,
-            0x39,
-            0x30,
-            0x37,
-            0x22,
-            0x25,
-            0x2C,
-            0x2B,
-            0x06,
-            0x01,
-            0x08,
-            0x0F,
-            0x1A,
-            0x1D,
-            0x14,
-            0x13,
-            0xAE,
-            0xA9,
-            0xA0,
-            0xA7,
-            0xB2,
-            0xB5,
-            0xBC,
-            0xBB,
-            0x96,
-            0x91,
-            0x98,
-            0x9F,
-            0x8A,
-            0x8D,
-            0x84,
-            0x83,
-            0xDE,
-            0xD9,
-            0xD0,
-            0xD7,
-            0xC2,
-            0xC5,
-            0xCC,
-            0xCB,
-            0xE6,
-            0xE1,
-            0xE8,
-            0xEF,
-            0xFA,
-            0xFD,
-            0xF4,
-            0xF3,
-        ]
-        crc8 = 0
-        len_data = len(data)
-
-        for i in range(len_data):
-            crc8 ^= data[i]
-            crc8 = crc8Table[crc8]
-
-        return crc8
-
-    async def processUniversalData(
-        self, buf: Queue[SensorData], event_loop: asyncio.AbstractEventLoop, cmd_loop: asyncio.AbstractEventLoop, sensor, callback
-    ):
+    async def processUniversalData(self, buf: Queue[SensorData], sensor, callback):
 
         while self._is_running:
             while self._is_running and self._rawDataBuffer.empty():
@@ -820,7 +573,7 @@ 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 = utils.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
@@ -833,9 +586,9 @@ class SensorProfileDataCtx:
                                 sensorData = buf.get_nowait()
                             except Exception as e:
                                 break
-                            if event_loop != None and sensorData != None and callback != None:
+                            if sensorData != None and callback != None:
                                 try:
-                                    event_loop.call_soon_threadsafe(callback, sensor, sensorData)
+                                    asyncio.get_event_loop().run_in_executor(None, callback, sensor, sensorData)
                                 except Exception as e:
                                     print(e)
 
@@ -851,13 +604,12 @@ 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 = utils.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 cmd_loop != None:
-                        cmd_loop.call_soon_threadsafe(self.gForce._on_cmd_response, None, data_package)
+                    asyncio.get_event_loop().run_in_executor(None, self.gForce._on_cmd_response, None, data_package)
                     last_cut = index = index + 2 + n
 
                 else:
@@ -865,3 +617,5 @@ class SensorProfileDataCtx:
 
                 if last_cut > 0:
                     self._concatDataBuffer = self._concatDataBuffer[last_cut + 1 :]
+                    last_cut = -1
+                    index = 0

sensor/sensor_device.py

@@ -40,11 +40,17 @@ class DeviceInfo:
         self.HardwareVersion = ""
         self.FirmwareVersion = ""
         self.EmgChannelCount = 0
+        self.EmgSampleRate = 0
         self.EegChannelCount = 0
+        self.EegSampleRate = 0
         self.EcgChannelCount = 0
+        self.EcgSampleRate = 0
         self.AccChannelCount = 0
+        self.AccSampleRate = 0
         self.GyroChannelCount = 0
+        self.GyroSampleRate = 0
         self.BrthChannelCount = 0
+        self.BrthSampleRate = 0
         self.MTUSize = 0
 
 

sensor/sensor_profile.py

@@ -2,28 +2,23 @@
 # 该枚举类定义了设备的各种状态，用于表示设备在不同操作阶段的状态信息
 from enum import Enum, IntEnum
 from queue import Queue
-import struct
 import time
-from typing import Callable, Dict, List, Optional
+from typing import Callable, Optional
 
 import bleak
 from bleak import (
     BleakClient,
-    BleakGATTCharacteristic,
 )
 
-import sensor
 from sensor import utils
 from sensor.gforce import GForce
-from sensor.sensor_data import DataType, Sample, SensorData
+from sensor.sensor_data import SensorData
 import asyncio
-import threading
+
 
 from sensor.sensor_data_context import SensorProfileDataCtx
 from sensor.sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
-from sensor.utils import async_call, start_loop, sync_call, async_exec, timer
-from contextlib import suppress
-from dataclasses import dataclass
+from sensor.utils import async_call, sync_call, async_exec, timer
 
 SERVICE_GUID = "0000ffd0-0000-1000-8000-00805f9b34fb"
 OYM_CMD_NOTIFY_CHAR_UUID = "f000ffe1-0451-4000-b000-000000000000"
@@ -46,7 +41,6 @@ class SensorProfile:
         device: bleak.BLEDevice,
         adv: bleak.AdvertisementData,
         mac: str,
-        gforce_event_loop: asyncio.AbstractEventLoop,
     ):
         """
         初始化 SensorProfile 类的实例。
@@ -66,9 +60,7 @@ class SensorProfile:
         self._data_ctx: SensorProfileDataCtx = None
         self._gforce: GForce = None
         self._data_event_loop: asyncio.AbstractEventLoop = None
-        self._gforce_event_loop: asyncio.AbstractEventLoop = gforce_event_loop
         self._event_loop: asyncio.AbstractEventLoop = None
-        self._event_thread = None
 
     def __del__(self) -> None:
         """
@@ -85,7 +77,6 @@ class SensorProfile:
                 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
         if self._event_loop != None:
@@ -93,7 +84,6 @@ class SensorProfile:
                 self._event_loop.stop()
                 self._event_loop.close()
                 self._event_loop = None
-                self._event_thread.join()
             except Exception as e:
                 pass
 
@@ -111,7 +101,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)
+                    asyncio.get_event_loop().run_in_executor(None, self._on_state_changed, self, newState)
                 except Exception as e:
                     print(e)
                     pass
@@ -220,12 +210,11 @@ class SensorProfile:
         self._on_power_changed = callback
 
     async def _connect(self) -> bool:
-        if self._event_thread == None:
+        if utils._terminated:
+            return False
+
+        if self._event_loop == 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()
 
@@ -242,10 +231,6 @@ class SensorProfile:
                 # 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
@@ -253,24 +238,25 @@ class SensorProfile:
         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())
+            async_exec(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
+            if self._data_ctx != None:
+                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:
+        if self._gforce != None and self._gforce.client.is_connected:
             self._set_device_state(DeviceStateEx.Connected)
             self._set_device_state(DeviceStateEx.Ready)
             # if self._gforce.client.mtu_size >= 80:
@@ -289,7 +275,7 @@ class SensorProfile:
         :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
         """
-        result = sync_call(self._gforce_event_loop, self._connect())
+        result = sync_call(self._connect())
         return result
 
     async def asyncConnect(self) -> bool:
@@ -299,7 +285,7 @@ class SensorProfile:
         :return:            bool: 如果连接成功，返回 True；否则返回 False。
 
         """
-        return await async_call(self._gforce_event_loop, self._connect())
+        return await async_call(self._connect())
 
     async def _waitForDisconnect(self) -> bool:
         while self.deviceState != DeviceStateEx.Disconnected:
@@ -314,6 +300,7 @@ class SensorProfile:
         self._set_device_state(DeviceStateEx.Disconnecting)
         await self._gforce.disconnect()
         await asyncio.wait_for(self._waitForDisconnect(), utils._TIMEOUT)
+
         return True
 
     def disconnect(self) -> bool:
@@ -323,7 +310,7 @@ class SensorProfile:
         :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
 
         """
-        return sync_call(self._gforce_event_loop, self._disconnect())
+        return sync_call(self._disconnect())
 
     async def asyncDisconnect(self) -> bool:
         """
@@ -332,28 +319,13 @@ class SensorProfile:
         :return:            bool: 如果断开连接成功，返回 True;否则返回 False。
 
         """
-        return await async_call(self._gforce_event_loop, self._disconnect())
+        return await async_call(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)
-            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 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)
-                    except Exception as e:
-                        print(e)
-                self._data_buffer.task_done()
+        await self._data_ctx.process_data(self._data_buffer, self, self._on_data_callback)
 
     async def _process_universal_data(self):
-        await self._data_ctx.processUniversalData(
-            self._data_buffer, self._event_loop, self._gforce_event_loop, self, self._on_data_callback
-        )
+        await self._data_ctx.processUniversalData(self._data_buffer, self, self._on_data_callback)
 
     async def _startDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -368,16 +340,12 @@ 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.daemon = True
-            self._data_event_thread.name = self.BLEDevice.Name + " data"
-            self._data_event_thread.start()
 
         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())
+            async_exec(self._process_data())
         return result
 
     def startDataNotification(self) -> bool:
@@ -387,7 +355,7 @@ class SensorProfile:
         :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
-        return sync_call(self._gforce_event_loop, self._startDataNotification())
+        return sync_call(self._startDataNotification())
 
     async def asyncStartDataNotification(self) -> bool:
         """
@@ -396,7 +364,7 @@ class SensorProfile:
         :return:            bool: 如果开始数据通知成功，返回 True；否则返回 False。
 
         """
-        return await async_call(self._gforce_event_loop, self._startDataNotification())
+        return await async_call(self._startDataNotification())
 
     async def _stopDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -418,7 +386,7 @@ class SensorProfile:
         :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
 
         """
-        return sync_call(self._gforce_event_loop, self._stopDataNotification())
+        return sync_call(self._stopDataNotification())
 
     async def asyncStopDataNotification(self) -> bool:
         """
@@ -427,23 +395,19 @@ class SensorProfile:
         :return:            bool: 如果停止数据通知成功，返回 True；否则返回 False。
 
         """
-        return await async_call(self._gforce_event_loop, self._stopDataNotification())
+        return await async_call(self._stopDataNotification())
 
     async def _refresh_power(self):
-        self._power = await self._gforce.get_battery_level()
+        while not utils._terminated and self.deviceState == DeviceStateEx.Ready:
+            await asyncio.sleep(self._power_interval / 1000)
 
-        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)
-            except Exception as e:
-                print(e)
+            self._power = await self._gforce.get_battery_level()
 
-        if self.deviceState == DeviceStateEx.Ready:
-            timer(
-                self._gforce_event_loop,
-                self._power_interval / 1000,
-                self._refresh_power(),
-            )
+            if self._event_loop != None and self._on_power_changed != None:
+                try:
+                    asyncio.get_event_loop().run_in_executor(None, self._on_power_changed, self, self._power)
+                except Exception as e:
+                    print(e)
 
     async def _init(self, packageSampleCount: int, powerRefreshInterval: int) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -455,11 +419,7 @@ class SensorProfile:
 
         if await self._data_ctx.init(packageSampleCount):
             self._power_interval = powerRefreshInterval
-            timer(
-                self._gforce_event_loop,
-                self._power_interval / 1000,
-                self._refresh_power(),
-            )
+            utils.async_exec(self._refresh_power())
 
         return self._data_ctx.hasInit()
 
@@ -474,7 +434,6 @@ class SensorProfile:
 
         """
         return sync_call(
-            self._gforce_event_loop,
             self._init(packageSampleCount, powerRefreshInterval),
             20,
         )
@@ -490,7 +449,6 @@ class SensorProfile:
 
         """
         return await async_call(
-            self._gforce_event_loop,
             self._init(packageSampleCount, powerRefreshInterval),
             20,
         )

sensor/utils.py

@@ -2,72 +2,381 @@ import asyncio
 import platform
 import queue
 import signal
+import threading
 import time
 
 _terminated = False
 _TIMEOUT = 10
+running_tasks = set()
+_runloop: asyncio.AbstractEventLoop = None
+_event_thread: threading.Thread = None
+_needCloseRunloop = False
+
+
+def checkRunLoop():
+    global _runloop, _needCloseRunloop, _event_thread
+    if _runloop == None:
+        try:
+            _runloop = asyncio.get_running_loop()
+        except Exception as e:
+            _needCloseRunloop = True
+            _runloop = asyncio.new_event_loop()
+            _event_thread = threading.Thread(target=start_loop, args=(_runloop,))
+            _event_thread.daemon = True
+            _event_thread.name = "SensorController event"
+            _event_thread.start()
+
+
+def Terminate():
+    global _runloop, _needCloseRunloop, _event_thread
+    if _needCloseRunloop:
+        try:
+            _runloop.stop()
+            _runloop.close()
+        except Exception as e:
+            pass
 
 
 async def delay(_time: float, function) -> any:
-    await asyncio.sleep(_time)
-    return await function
+    try:
+        await asyncio.sleep(_time)
+    except Exception as e:
+        pass
 
+    try:
+        return await function
+    except Exception as e:
+        pass
 
-def timer(_loop: asyncio.AbstractEventLoop, _delay: float, function):
-    if _loop == None:
-        return
+
+def timer(_delay: float, function):
+    checkRunLoop()
+    task: asyncio.Future = None
     try:
-        asyncio.run_coroutine_threadsafe(delay(_delay, function), _loop)
+        task = asyncio.run_coroutine_threadsafe(delay(_delay, function), _runloop)
+        running_tasks.add(task)
+        task.add_done_callback(lambda t: running_tasks.remove(t))
     except Exception as e:
         print(e)
         pass
 
 
-def async_exec(_loop: asyncio.AbstractEventLoop, function):
-    if _loop == None:
-        return
+def async_exec(function):
+    checkRunLoop()
+    task: asyncio.Future = None
     try:
-        asyncio.run_coroutine_threadsafe(function, _loop)
+        task = asyncio.run_coroutine_threadsafe(function, _runloop)
+        running_tasks.add(task)
+        task.add_done_callback(lambda t: running_tasks.remove(t))
     except Exception as e:
         print(e)
         pass
 
 
-def sync_call(_loop: asyncio.AbstractEventLoop, function, _timeout=_TIMEOUT) -> any:
-    if _loop == None:
-        return
-
+def sync_call(function, _timeout=_TIMEOUT) -> any:
+    checkRunLoop()
+    task: asyncio.Future = None
     try:
-        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _loop)
-        return f.result(timeout=_timeout)
+        task = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _runloop)
+        running_tasks.add(task)
+        task.add_done_callback(lambda t: running_tasks.remove(t))
+        return task.result(timeout=_timeout)
     except Exception as e:
         print(e)
         pass
 
 
-async def async_call(_loop: asyncio.AbstractEventLoop, function, _timeout=_TIMEOUT) -> any:
-    if _loop == None:
-        return
-
+async def async_call(function, _timeout=_TIMEOUT) -> any:
+    checkRunLoop()
+    task: asyncio.Future = None
     try:
-        f = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _loop)
+        task = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _runloop)
+        running_tasks.add(task)
+        task.add_done_callback(lambda t: running_tasks.remove(t))
     except Exception as e:
         print(e)
         pass
 
-    while not _terminated and not f.done():
+    while not _terminated and not task.done():
         await asyncio.sleep(0.1)
 
     try:
-        if not f.cancelled():
-            return f.result()
+        if not task.cancelled():
+            return task.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()
+
+
+def calc_crc8(data):
+    crc8Table = [
+        0x00,
+        0x07,
+        0x0E,
+        0x09,
+        0x1C,
+        0x1B,
+        0x12,
+        0x15,
+        0x38,
+        0x3F,
+        0x36,
+        0x31,
+        0x24,
+        0x23,
+        0x2A,
+        0x2D,
+        0x70,
+        0x77,
+        0x7E,
+        0x79,
+        0x6C,
+        0x6B,
+        0x62,
+        0x65,
+        0x48,
+        0x4F,
+        0x46,
+        0x41,
+        0x54,
+        0x53,
+        0x5A,
+        0x5D,
+        0xE0,
+        0xE7,
+        0xEE,
+        0xE9,
+        0xFC,
+        0xFB,
+        0xF2,
+        0xF5,
+        0xD8,
+        0xDF,
+        0xD6,
+        0xD1,
+        0xC4,
+        0xC3,
+        0xCA,
+        0xCD,
+        0x90,
+        0x97,
+        0x9E,
+        0x99,
+        0x8C,
+        0x8B,
+        0x82,
+        0x85,
+        0xA8,
+        0xAF,
+        0xA6,
+        0xA1,
+        0xB4,
+        0xB3,
+        0xBA,
+        0xBD,
+        0xC7,
+        0xC0,
+        0xC9,
+        0xCE,
+        0xDB,
+        0xDC,
+        0xD5,
+        0xD2,
+        0xFF,
+        0xF8,
+        0xF1,
+        0xF6,
+        0xE3,
+        0xE4,
+        0xED,
+        0xEA,
+        0xB7,
+        0xB0,
+        0xB9,
+        0xBE,
+        0xAB,
+        0xAC,
+        0xA5,
+        0xA2,
+        0x8F,
+        0x88,
+        0x81,
+        0x86,
+        0x93,
+        0x94,
+        0x9D,
+        0x9A,
+        0x27,
+        0x20,
+        0x29,
+        0x2E,
+        0x3B,
+        0x3C,
+        0x35,
+        0x32,
+        0x1F,
+        0x18,
+        0x11,
+        0x16,
+        0x03,
+        0x04,
+        0x0D,
+        0x0A,
+        0x57,
+        0x50,
+        0x59,
+        0x5E,
+        0x4B,
+        0x4C,
+        0x45,
+        0x42,
+        0x6F,
+        0x68,
+        0x61,
+        0x66,
+        0x73,
+        0x74,
+        0x7D,
+        0x7A,
+        0x89,
+        0x8E,
+        0x87,
+        0x80,
+        0x95,
+        0x92,
+        0x9B,
+        0x9C,
+        0xB1,
+        0xB6,
+        0xBF,
+        0xB8,
+        0xAD,
+        0xAA,
+        0xA3,
+        0xA4,
+        0xF9,
+        0xFE,
+        0xF7,
+        0xF0,
+        0xE5,
+        0xE2,
+        0xEB,
+        0xEC,
+        0xC1,
+        0xC6,
+        0xCF,
+        0xC8,
+        0xDD,
+        0xDA,
+        0xD3,
+        0xD4,
+        0x69,
+        0x6E,
+        0x67,
+        0x60,
+        0x75,
+        0x72,
+        0x7B,
+        0x7C,
+        0x51,
+        0x56,
+        0x5F,
+        0x58,
+        0x4D,
+        0x4A,
+        0x43,
+        0x44,
+        0x19,
+        0x1E,
+        0x17,
+        0x10,
+        0x05,
+        0x02,
+        0x0B,
+        0x0C,
+        0x21,
+        0x26,
+        0x2F,
+        0x28,
+        0x3D,
+        0x3A,
+        0x33,
+        0x34,
+        0x4E,
+        0x49,
+        0x40,
+        0x47,
+        0x52,
+        0x55,
+        0x5C,
+        0x5B,
+        0x76,
+        0x71,
+        0x78,
+        0x7F,
+        0x6A,
+        0x6D,
+        0x64,
+        0x63,
+        0x3E,
+        0x39,
+        0x30,
+        0x37,
+        0x22,
+        0x25,
+        0x2C,
+        0x2B,
+        0x06,
+        0x01,
+        0x08,
+        0x0F,
+        0x1A,
+        0x1D,
+        0x14,
+        0x13,
+        0xAE,
+        0xA9,
+        0xA0,
+        0xA7,
+        0xB2,
+        0xB5,
+        0xBC,
+        0xBB,
+        0x96,
+        0x91,
+        0x98,
+        0x9F,
+        0x8A,
+        0x8D,
+        0x84,
+        0x83,
+        0xDE,
+        0xD9,
+        0xD0,
+        0xD7,
+        0xC2,
+        0xC5,
+        0xCC,
+        0xCB,
+        0xE6,
+        0xE1,
+        0xE8,
+        0xEF,
+        0xFA,
+        0xFD,
+        0xF4,
+        0xF3,
+    ]
+    crc8 = 0
+    len_data = len(data)
+
+    for i in range(len_data):
+        crc8 ^= data[i]
+        crc8 = crc8Table[crc8]
+
+    return crc8

{sensor_sdk-0.0.7.dist-info → sensor_sdk-0.0.10.dist-info}/METADATA

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

sensor_sdk-0.0.10.dist-info/RECORD

@@ -0,0 +1,14 @@
+sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
+sensor/gforce.py,sha256=mTw0VVQSxPiTzZmjK7I9knTlTkEeu4PISQdlAkMU6WE,25232
+sensor/sensor_controller.py,sha256=qnM9mVwpJn9PCnxlvbgWFeaLktqVnmaquZgasYGEHqs,9451
+sensor/sensor_data.py,sha256=Hu7Ql0LgQ7V24xYZhaLrKPwU4KWZeWE655v8Gy8xphY,3934
+sensor/sensor_data_context.py,sha256=9IvXAHhCSQGnkNW5nFNz4Rs6kVq1hEyxxu6ROKjb-Dk,25033
+sensor/sensor_device.py,sha256=eO1vaqjxCc2UCPBoKXqlk6o498uRyWt6IYs7r7wXSD0,3042
+sensor/sensor_profile.py,sha256=64MFNyLJajX6HeGS_tmN9R9wfEW1qjsP_MjH3ZRPq4s,17322
+sensor/utils.py,sha256=FuBEChpJYbXnUaDvlta3aT6dYGAK2fQdGbIB7BYMQp4,7077
+sensor_sdk-0.0.10.dist-info/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
+sensor_sdk-0.0.10.dist-info/METADATA,sha256=OjhjiuAo0t9cgFCyuIC-5PB_O7KTi8duBZz-H2RCTAw,8375
+sensor_sdk-0.0.10.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+sensor_sdk-0.0.10.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
+sensor_sdk-0.0.10.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+sensor_sdk-0.0.10.dist-info/RECORD,,

sensor_sdk-0.0.7.dist-info/RECORD

@@ -1,14 +0,0 @@
-sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
-sensor/gforce.py,sha256=wHnZ9fJiqzD9TpHekWsEqp3VIyIBhbXwJSj5k6FjVNw,25049
-sensor/sensor_controller.py,sha256=lNi7i3T_aAHEJvv963OvVv_PNAYy_5-BwXD82XNvnGg,10028
-sensor/sensor_data.py,sha256=Hu7Ql0LgQ7V24xYZhaLrKPwU4KWZeWE655v8Gy8xphY,3934
-sensor/sensor_data_context.py,sha256=6bhpPRwTrVemdkCz43FTYIElKLW_S4ESSg6xgelTQow,28846
-sensor/sensor_device.py,sha256=LCjBzm2TuOh2KpHsFTjm1sF8hzwvS22LhF_ueAct0Jo,2848
-sensor/sensor_profile.py,sha256=mjqOEZLGJQYY8zhH8TA0HRVxrFC4AjjKAj_zGOQMgHg,19678
-sensor/utils.py,sha256=ybmByBldCQ_x-sVtjA2mdXWo0QOafPAupfnWAxLrkV0,1773
-sensor_sdk-0.0.7.dist-info/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
-sensor_sdk-0.0.7.dist-info/METADATA,sha256=oAl9HPAImzRPcLdVyjOaPTxBCrlJIsAAXqZtNAghh-c,8374
-sensor_sdk-0.0.7.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-sensor_sdk-0.0.7.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
-sensor_sdk-0.0.7.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-sensor_sdk-0.0.7.dist-info/RECORD,,