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

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

@@ -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.7 → sensor-sdk-0.0.10}/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-sdk-0.0.7 → sensor-sdk-0.0.10}/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-sdk-0.0.7 → sensor-sdk-0.0.10}/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-sdk-0.0.7 → sensor-sdk-0.0.10}/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