sensor-sdk 0.1.1__tar.gz → 0.1.4__tar.gz

{sensor_sdk-0.1.1 → sensor_sdk-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.1.1
+Version: 0.1.4
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye
@@ -11,6 +11,7 @@ License-File: LICENSE.txt
 Requires-Dist: numpy
 Requires-Dist: setuptools
 Requires-Dist: bleak>=3.0.2
+Requires-Dist: flatbuffers>=25.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

sensor_sdk-0.1.4/sensor/__init__.py

@@ -0,0 +1,20 @@
+from sensor.sensor_controller import SensorController, SensorControllerInstance
+from sensor.sensor_profile import SensorProfile
+from sensor.sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
+from sensor.sensor_data import DataType, Sample, SensorData
+from sensor.winrt_high_throughput import apply as _apply_winrt_high_throughput_patch
+
+# Windows 下尝试给 bleak WinRT backend 打高吞吐率连接参数补丁
+_apply_winrt_high_throughput_patch()
+
+__all__ = [
+    "SensorController",
+    "SensorControllerInstance",
+    "SensorProfile",
+    "BLEDevice",
+    "DeviceInfo",
+    "DeviceStateEx",
+    "DataType",
+    "Sample",
+    "SensorData",
+]

{sensor_sdk-0.1.1 → sensor_sdk-0.1.4}/sensor/bleak_host.py

@@ -17,7 +17,8 @@ class BleakHost:
     def __init__(self):
         self._cmd_queue = multiprocessing.Queue(maxsize=50)
         self._result_queue = multiprocessing.Queue(maxsize=sensor_utils.BLEAK_RESULT_QUEUE_MAXSIZE)
-        self._bleak_process = BleakProcess(self._cmd_queue, self._result_queue, SdkLog.get_log_path())
+        self._data_queue = multiprocessing.Queue(maxsize=sensor_utils.BLEAK_DATA_QUEUE_MAXSIZE)
+        self._bleak_process = BleakProcess(self._cmd_queue, self._result_queue, self._data_queue, SdkLog.get_log_path())
         self._started = False
 
 
@@ -51,6 +52,7 @@ class BleakHost:
     def stop(self):
         if not self._started:
             return
+        self._should_exit = True
         try:
             self._cmd_queue.put({"type": "terminate"})
         except Exception as e:
@@ -60,9 +62,23 @@ class BleakHost:
             self._bleak_process.join(timeout=5)
         if self._bleak_process.is_alive():
             self._bleak_process.terminate()
+            self._bleak_process.join(timeout=2)
 
         self._stop_result_loop()
         self._stop_cmd_loop()
+
+        try:
+            self._cmd_queue.close()
+            self._result_queue.close()
+            self._data_queue.close()
+        except Exception as e:
+            SdkLog.exception(_TAG, "Error closing queues")
+
+        try:
+            self._bleak_process.close()
+        except Exception as e:
+            SdkLog.exception(_TAG, "Error closing bleak process")
+
         self._started = False
 
     # ------------------------------------------------------------------
@@ -77,9 +93,23 @@ class BleakHost:
         result_thread.start()
         self._result_loop = result_loop
         self._result_thread = result_thread
-        asyncio.run_coroutine_threadsafe(self._consume_results(), result_loop)
+
+        def _create_consume_task():
+            self._consume_task = result_loop.create_task(self._consume_results())
+
+        result_loop.call_soon_threadsafe(_create_consume_task)
 
     def _stop_result_loop(self):
+        task = getattr(self, '_consume_task', None)
+        if task is not None:
+            try:
+                loop = task.get_loop()
+                if loop is not None and not loop.is_closed():
+                    loop.call_soon_threadsafe(task.cancel)
+            except Exception as e:
+                SdkLog.exception(_TAG, "Unexpected error")
+        self._consume_task = None
+
         loop = getattr(self, '_result_loop', None)
         thread = getattr(self, '_result_thread', None)
         if loop is not None and not loop.is_closed():
@@ -97,38 +127,68 @@ class BleakHost:
 
     async def _consume_results(self):
 
-        while True:
+        def _try_get(q, timeout):
+            try:
+                return q.get(True, timeout)
+            except queue.Empty:
+                return None
+
+        while not getattr(self, '_should_exit', False):
             try:
+                # Prioritize control/result messages; data messages are drained in batch below.
                 msg = await asyncio.get_event_loop().run_in_executor(
-                    None, self._result_queue.get, True, 0.5
+                    None, _try_get, self._result_queue, 0.02
                 )
-            except queue.Empty:
-                continue
             except Exception:
+                msg = None
+
+            if msg is None:
+                try:
+                    msg = await asyncio.get_event_loop().run_in_executor(
+                        None, _try_get, self._data_queue, 0.02
+                    )
+                except Exception:
+                    msg = None
+
+            if msg is None:
+                await asyncio.sleep(0.001)
                 continue
 
-            msg_type = msg.get("type")
-            if msg_type == "scan_once_result":
-                if self.on_scan_once_result is not None:
-                    try:
-                        self.on_scan_once_result(msg)
-                    except Exception as e:
-                        SdkLog.exception(_TAG, "Unexpected error")
-            elif msg_type == "devices":
-                if self.on_scan_result is not None:
-                    try:
-                        self.on_scan_result(msg)
-                    except Exception as e:
-                        SdkLog.exception(_TAG, "Unexpected error")
-            elif msg_type == "command_result":
-                self._handle_command_result(msg)
-            elif msg_type in ("state_changed", "power_changed", "sensor_data", "error"):
-                if self.on_device_message is not None:
-                    device_mac = msg.get("device_mac")
+            self._dispatch_message(msg)
+
+            # Batch drain both queues to catch up quickly and reduce per-get overhead.
+            for q in (self._result_queue, self._data_queue):
+                while True:
                     try:
-                        self.on_device_message(device_mac, msg)
-                    except Exception as e:
-                        SdkLog.exception(_TAG, "Unexpected error")
+                        self._dispatch_message(q.get_nowait())
+                    except queue.Empty:
+                        break
+                    except Exception:
+                        break
+
+    def _dispatch_message(self, msg):
+        msg_type = msg.get("type")
+        if msg_type == "scan_once_result":
+            if self.on_scan_once_result is not None:
+                try:
+                    self.on_scan_once_result(msg)
+                except Exception as e:
+                    SdkLog.exception(_TAG, "Unexpected error")
+        elif msg_type == "devices":
+            if self.on_scan_result is not None:
+                try:
+                    self.on_scan_result(msg)
+                except Exception as e:
+                    SdkLog.exception(_TAG, "Unexpected error")
+        elif msg_type == "command_result":
+            self._handle_command_result(msg)
+        elif msg_type in ("state_changed", "power_changed", "sensor_data", "error"):
+            if self.on_device_message is not None:
+                device_mac = msg.get("device_mac")
+                try:
+                    self.on_device_message(device_mac, msg)
+                except Exception as e:
+                    SdkLog.exception(_TAG, "Unexpected error")
 
     def _handle_command_result(self, msg):
 

{sensor_sdk-0.1.1 → sensor_sdk-0.1.4}/sensor/bleak_process.py

@@ -72,11 +72,13 @@ class BleakProcess(multiprocessing.Process):
         self,
         cmd_queue: multiprocessing.Queue,
         result_queue: multiprocessing.Queue,
+        data_queue: multiprocessing.Queue,
         log_path: str = None,
     ):
         super().__init__(daemon=True)
         self.cmd_queue = cmd_queue
         self.result_queue = result_queue
+        self.data_queue = data_queue
         self._log_path = log_path
         self._scanner = None
         self._is_scanning = False
@@ -141,15 +143,23 @@ class BleakProcess(multiprocessing.Process):
 
     def _flush_msg_queue(self):
 
+        def _route_and_put(msg):
+            msg_type = msg.get("type")
+            if msg_type == "sensor_data":
+                try:
+                    self.data_queue.put_nowait(msg)
+                except queue.Full:
+                    pass
+            elif msg_type in self._DROPABLE_MSG_TYPES:
+                self.result_queue.put_nowait(msg)
+            else:
+                # Use a short timeout during shutdown so the child process can exit cleanly.
+                self.result_queue.put(msg, timeout=2.0)
+
         while True:
             try:
                 msg = self._msg_queue.get_nowait()
-                msg_type = msg.get("type")
-                if msg_type in self._DROPABLE_MSG_TYPES:
-                    self.result_queue.put_nowait(msg)
-                else:
-                    # Use a short timeout during shutdown so the child process can exit cleanly.
-                    self.result_queue.put(msg, timeout=2.0)
+                _route_and_put(msg)
             except queue.Empty:
                 break
             except queue.Full:
@@ -170,6 +180,7 @@ class BleakProcess(multiprocessing.Process):
     async def _publisher_task(self):
         # Throttle queue-full logs to avoid blocking stdout on Windows.
         _last_queue_full_log = 0.0
+        _last_data_queue_full_log = 0.0
 
         while True:
             msg = None
@@ -177,7 +188,17 @@ class BleakProcess(multiprocessing.Process):
             try:
                 msg = self._msg_queue.get_nowait()
                 msg_type = msg.get("type")
-                if msg_type in self._DROPABLE_MSG_TYPES:
+                if msg_type == "sensor_data":
+                    # High-frequency data: use a dedicated drop-capable queue so it cannot
+                    # block control/result messages in the main result queue.
+                    try:
+                        self.data_queue.put_nowait(msg)
+                    except queue.Full:
+                        now = time.time()
+                        if now - _last_data_queue_full_log >= 2.0:
+                            _last_data_queue_full_log = now
+                            SdkLog.w(_TAG, "Data queue is full, dropping sensor_data")
+                elif msg_type in self._DROPABLE_MSG_TYPES:
                     self.result_queue.put_nowait(msg)
                 else:
                     # Use a short timeout for important messages so the publisher does not stall.
@@ -261,6 +282,17 @@ class BleakProcess(multiprocessing.Process):
 
     def _stop_device_loops(self, device_mac: str):
 
+        # Cancel battery task if still running in event_loop
+        if device_mac in self._battery_tasks:
+            task = self._battery_tasks.pop(device_mac, None)
+            if task:
+                try:
+                    loop = self._event_loops.get(device_mac)
+                    if loop and not loop.is_closed():
+                        loop.call_soon_threadsafe(task.cancel)
+                except Exception as e:
+                    SdkLog.exception(_TAG, "Unexpected error")
+
         # Cancel data task first if still running in data_event_loop
         if device_mac in self._data_tasks:
             task = self._data_tasks.pop(device_mac, None)
@@ -684,7 +716,12 @@ class BleakProcess(multiprocessing.Process):
 
             # Cancel battery task
             if device_mac in self._battery_tasks:
-                self._battery_tasks.pop(device_mac, None)
+                task = self._battery_tasks.pop(device_mac, None)
+                if task is not None:
+                    try:
+                        task.cancel()
+                    except Exception as e:
+                        SdkLog.exception(_TAG, "Unexpected error")
 
             # Stop streaming and optionally disconnect client
             if disconnect_client and device_mac in self._gforces:
@@ -829,9 +866,9 @@ class BleakProcess(multiprocessing.Process):
 
         try:
             if ctx.isUniversalStream:
-                await ctx.processUniversalData(local_buf, on_data, on_error)
+                await ctx._processUniversalData(local_buf, on_data, on_error)
             else:
-                await ctx.process_data(local_buf, on_data, on_error)
+                await ctx._process_data(local_buf, on_data, on_error)
         except asyncio.CancelledError as e:
             SdkLog.exception(_TAG, "Data loop cancelled")
         except Exception as e:
@@ -1119,10 +1156,12 @@ class BleakProcess(multiprocessing.Process):
                 if key == "NTF_PPG_RAW":
                     map_key = "NTF_PPG"
 
-                # 老版本 EMG 设备上 Gesture 与 EMG 互斥，与 initGesture 逻辑保持一致
+                # 老版本 EMG 设备上 Gesture 与 EMG 互斥，自动切换
                 if not ctx.isNewEMG:
                     if map_key == "NTF_GEST" and value == "ON" and ctx.notify_map.get("NTF_EMG") == "ON":
-                        result = "Error: NTF_GEST conflicts with NTF_EMG on legacy EMG device"
+                        ctx.notify_map["NTF_EMG"] = "OFF"
+                        ctx.notify_map[map_key] = value
+                        result = "OK"
                     elif map_key == "NTF_EMG" and value == "ON" and ctx.notify_map.get("NTF_GEST") == "ON":
                         ctx.notify_map["NTF_GEST"] = "OFF"
                         ctx.notify_map[map_key] = value
@@ -1165,14 +1204,12 @@ class BleakProcess(multiprocessing.Process):
             try:
                 if value == "False" or value == "":
                     SdkLog.set_log_path("")
-                    result = "OK"
                 elif value == "True":
                     path = SdkLog.get_default_log_path()
                     SdkLog.set_log_path(path)
-                    result = path
                 else:
                     SdkLog.set_log_path(value)
-                    result = value
+                result = "OK"
             except Exception as e:
                 SdkLog.exception(_TAG, f"_do_set_param DEBUG_LOG_PATH failed: {e}")
                 result = "ERROR: " + str(e)
@@ -1182,16 +1219,14 @@ class BleakProcess(multiprocessing.Process):
                 if value == "False" or value == "":
                     SdkLog.set_data_log_enabled(False)
                     await ctx.setDebugCSV("")
-                    result = "OK"
                 elif value == "True":
                     SdkLog.set_data_log_enabled(True)
                     path = SdkLog.get_default_data_log_path()
-                    csv_result = await ctx.setDebugCSV(path)
-                    result = path if csv_result == "OK" else csv_result
+                    await ctx.setDebugCSV(path)
                 else:
                     SdkLog.set_data_log_enabled(True)
-                    csv_result = await ctx.setDebugCSV(value)
-                    result = value if csv_result == "OK" else csv_result
+                    await ctx.setDebugCSV(value)
+                result = "OK"
             except Exception as e:
                 SdkLog.exception(_TAG, f"_do_set_param setDebugCSV failed: {device_mac} path={value}")
                 result = "ERROR: " + str(e)

sensor_sdk-0.1.4/sensor/fb/DataType.py

@@ -0,0 +1,32 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: fb
+
+# BLE 数据通知类型，与 SensorSDKCXX src/SensorProfileImpl.h 中的 NotifyDataType 保持一致
+class DataType(object):
+    NONE = 0
+    NTF_ACC_DATA = 1
+    NTF_GYO_DATA = 2
+    NTF_MAG_DATA = 3
+    NTF_EULER_DATA = 4
+    NTF_QUAT_FLOAT_DATA = 5
+    NTF_ROTA_DATA = 6
+    NTF_EMG_GEST_DATA = 7
+    NTF_EMG_ADC_DATA = 8
+    NTF_HID_MOUSE = 9
+    NTF_HID_JOYSTICK = 10
+    NTF_DEV_STATUS = 11
+    NTF_LOG_DATA = 12
+    NTF_MAG_ANGLE_DATA = 13
+    NTF_MOT_CURRENT_DATA = 14
+    NTF_NEUCIR_STATUS = 15
+    NTF_EEG = 16
+    NTF_ECG = 17
+    NTF_IMPEDANCE = 18
+    NTF_IMU = 19
+    NTF_ADS = 20
+    NTF_BRTH = 21
+    NTF_IMPEDANCE_EXT = 22
+    NTF_SPO2 = 23
+    NTF_PPG = 24
+    NTF_PARTIAL_DATA = 255

sensor_sdk-0.1.4/sensor/fb/Sample.py

@@ -0,0 +1,49 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: fb
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# 单个采样点，内存紧凑的 struct
+class Sample(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls):
+        return 32
+
+    # Sample
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Sample
+    def TimeStampInMs(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0))
+    # Sample
+    def ChannelIndex(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(4))
+    # Sample
+    def SampleIndex(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(8))
+    # Sample
+    def RawData(self): return self._tab.Get(flatbuffers.number_types.Int32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(12))
+    # Sample
+    def Data(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(16))
+    # Sample
+    def Impedance(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(20))
+    # Sample
+    def Saturation(self): return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(24))
+    # Sample
+    def IsLost(self): return self._tab.Get(flatbuffers.number_types.BoolFlags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(28))
+
+def CreateSample(builder, timeStampInMs, channelIndex, sampleIndex, rawData, data, impedance, saturation, isLost):
+    builder.Prep(4, 32)
+    builder.Pad(3)
+    builder.PrependBool(isLost)
+    builder.PrependFloat32(saturation)
+    builder.PrependFloat32(impedance)
+    builder.PrependFloat32(data)
+    builder.PrependInt32(rawData)
+    builder.PrependInt32(sampleIndex)
+    builder.PrependInt32(channelIndex)
+    builder.PrependInt32(timeStampInMs)
+    return builder.Offset()