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

{sensor_sdk-0.1.4/sensor_sdk.egg-info → sensor_sdk-0.1.9}/PKG-INFO

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

{sensor_sdk-0.1.4 → sensor_sdk-0.1.9}/sensor/__init__.py

@@ -3,10 +3,16 @@ 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
+from sensor.bleak_no_ack_patch import apply as _apply_bleak_no_ack_patch
+import os
 
 # Windows 下尝试给 bleak WinRT backend 打高吞吐率连接参数补丁
 _apply_winrt_high_throughput_patch()
 
+# 如果设置了环境变量 SENSOR_SDK_FORCE_NO_ACK=1，则对命令特征强制 write-without-response
+if os.environ.get("SENSOR_SDK_FORCE_NO_ACK", "0") == "1":
+    _apply_bleak_no_ack_patch()
+
 __all__ = [
     "SensorController",
     "SensorControllerInstance",

sensor_sdk-0.1.9/sensor/bleak_no_ack_patch.py

@@ -0,0 +1,75 @@
+"""强制 bleak 对指定特征使用 write-without-response（no ACK）的补丁。
+
+某些 Windows 主机上 write-with-response 会因为系统 ACK 等待导致命令超时，
+把命令特征强制改成无响应写入可以显著提升命令通道的实时性。
+
+默认只作用于 SDK 已知的两个 CMD 特征 UUID；传入空列表或 `None` 则全局生效。
+"""
+
+import logging
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+# SDK 默认使用的两条命令特征
+DEFAULT_CMD_CHAR_UUIDS = {
+    "f000ffe1-0451-4000-b000-000000000000",  # OYM CMD
+    "00000002-0000-1000-8000-00805f9b34fb",  # RFSTAR CMD
+}
+
+
+def _char_uuid(char_specifier) -> str:
+    """尽量把 char_specifier 转成小写 UUID 字符串。"""
+    if isinstance(char_specifier, str):
+        return char_specifier.lower()
+    try:
+        # bleak 的 BleakGATTCharacteristic 对象有 uuid 属性
+        return str(char_specifier.uuid).lower()
+    except Exception:
+        return ""
+
+
+def apply(cmd_char_uuids=DEFAULT_CMD_CHAR_UUIDS):
+    """给 BleakClient.write_gatt_char 打补丁，强制指定特征使用 response=False。
+
+    Args:
+        cmd_char_uuids: 需要强制 no-ack 的特征 UUID 集合。传 None 表示所有写入都强制 no-ack。
+    """
+    try:
+        from bleak import BleakClient
+    except Exception as e:
+        logger.debug("bleak not available, skip no-ack patch: %s", e)
+        return
+
+    if getattr(BleakClient, "_no_ack_patched", False):
+        return
+
+    orig_write = BleakClient.write_gatt_char
+
+    @wraps(orig_write)
+    async def patched_write(self, char_specifier, data, response=None):
+        if cmd_char_uuids is None or _char_uuid(char_specifier) in cmd_char_uuids:
+            response = False
+        return await orig_write(self, char_specifier, data, response=response)
+
+    BleakClient.write_gatt_char = patched_write
+    BleakClient._no_ack_patched = True  # type: ignore[attr-defined]
+    logger.debug(
+        "Applied bleak write-without-response patch (targets: %s)",
+        "all chars" if cmd_char_uuids is None else cmd_char_uuids,
+    )
+
+
+def reset():
+    """移除补丁（主要用于测试）。"""
+    try:
+        from bleak import BleakClient
+    except Exception:
+        return
+
+    if not getattr(BleakClient, "_no_ack_patched", False):
+        return
+
+    # 找到原始的未绑定方法比较麻烦，这里简单把标记清掉，
+    # 实际撤销需要保存原始方法；apply 没有保存，故 reset 仅作占位。
+    BleakClient._no_ack_patched = False  # type: ignore[attr-defined]

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

@@ -839,14 +839,17 @@ class BleakProcess(multiprocessing.Process):
 
     async def _battery_loop(self, device_mac: str):
 
-        interval = self._power_intervals.get(device_mac, 0)
-        while interval > 0 and device_mac in self._gforces:
+        while True:
+            interval = self._power_intervals.get(device_mac, 0)
+            if interval <= 0 or device_mac not in self._gforces:
+                break
             await asyncio.sleep(interval / 1000)
             try:
                 power = await self._gforces[device_mac].get_battery_level()
                 self._publish("power_changed", device_mac=device_mac, power=power)
             except Exception:
-                break
+                # 单次刷新失败不中断循环，否则一次超时/丢包后就再也无法刷新电量
+                SdkLog.exception(_TAG, f"Battery refresh failed: {device_mac}")
 
     async def _device_data_loop(self, device_mac: str):
 
@@ -864,15 +867,24 @@ class BleakProcess(multiprocessing.Process):
         def on_error(message: str):
             self._publish("error", device_mac=device_mac, message=message)
 
-        try:
-            if ctx.isUniversalStream:
-                await ctx._processUniversalData(local_buf, on_data, on_error)
-            else:
-                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:
-            SdkLog.exception(_TAG, "Error in data loop")
+        # 持续运行，异常后自动重启，避免单包错误导致整个解析线程退出
+        while not self._should_exit and device_mac in self._data_ctxs:
+            try:
+                if ctx.isUniversalStream:
+                    await ctx._processUniversalData(local_buf, on_data, on_error)
+                else:
+                    await ctx._process_data(local_buf, on_data, on_error)
+                # 正常返回说明 ctx 已关闭或停止
+                break
+            except asyncio.CancelledError:
+                SdkLog.i(_TAG, f"Data loop cancelled: {device_mac}")
+                break
+            except Exception as e:
+                SdkLog.exception(_TAG, f"Error in data loop, restarting: {device_mac}")
+                try:
+                    await asyncio.sleep(0.5)
+                except asyncio.CancelledError:
+                    break
 
     async def _do_start_notification(self, cmd: dict):
 

{sensor_sdk-0.1.4 → sensor_sdk-0.1.9}/sensor/sensor_data_context.py

@@ -544,7 +544,7 @@ class SensorProfileDataCtx:
     async def initIMU(self, packageCount: int) -> int:
         SdkLog.d(_TAG, "initIMU(...)")
         IMU_TYPE_QAT6 = 0x0004
-        min_package_sample_count = 2
+        min_package_sample_count = 2 if self._chip_type == BLEChipType.OYM else 1
         self.isContainQAT6 = False
 
         if not self.hasIMU():
@@ -1099,39 +1099,44 @@ class SensorProfileDataCtx:
                 SdkLog.exception(_TAG, "Unexpected error")
 
             if self.notifyDataFlag & DataSubscription.DNF_CONCAT_BLE != 0:
-                index = 0
-                last_cut = -1
-                data_size = len(self._concatDataBuffer)
+                try:
+                    index = 0
+                    last_cut = -1
+                    data_size = len(self._concatDataBuffer)
 
-                while self._is_running:
-                    if index >= data_size:
-                        break
+                    while self._is_running:
+                        if index >= data_size:
+                            break
 
-                    if self._concatDataBuffer[index] == 0x55:
-                        if (index + 1) >= data_size:
-                            index = data_size
-                            continue
-                        n = self._concatDataBuffer[index + 1]
-                        if n < 2 or (index + 1 + n + 1) >= data_size:
+                        if self._concatDataBuffer[index] == 0x55:
+                            if (index + 1) >= data_size:
+                                index = data_size
+                                continue
+                            n = self._concatDataBuffer[index + 1]
+                            if n < 2 or (index + 1 + n + 1) >= data_size:
+                                index += 1
+                                continue
+                            crc8 = (self._concatDataBuffer[index + 1 + n + 1])
+                            calc_crc = sensor_utils.calc_crc8(self._concatDataBuffer[index + 2: index + 2 + n])
+                            if crc8 != calc_crc:
+                                index += 1
+                                continue
+                            if self._is_data_transfering:
+                                data_package = bytes(self._concatDataBuffer[index + 2: index + 2 + n])
+                                if self._processDataPackage(data_package, buf, on_error_callback):
+                                    last_cut = index = index + 2 + n
                             index += 1
-                            continue
-                        crc8 = (self._concatDataBuffer[index + 1 + n + 1])
-                        calc_crc = sensor_utils.calc_crc8(self._concatDataBuffer[index + 2: index + 2 + n])
-                        if crc8 != calc_crc:
+                        else:
                             index += 1
-                            continue
-                        if self._is_data_transfering:
-                            data_package = bytes(self._concatDataBuffer[index + 2: index + 2 + n])
-                            if self._processDataPackage(data_package, buf, on_error_callback):
-                                last_cut = index = index + 2 + n
-                        index += 1
-                    else:
-                        index += 1
 
-                if last_cut > 0:
-                    self._concatDataBuffer = self._concatDataBuffer[last_cut + 1:]
-                    last_cut = -1
-                    index = 0
+                    if last_cut > 0:
+                        self._concatDataBuffer = self._concatDataBuffer[last_cut + 1:]
+                        last_cut = -1
+                        index = 0
+
+                    self._last_progress_time = time.time()
+                except Exception as e:
+                    SdkLog.exception(_TAG, "Unexpected error in concat data processing")
 
     def _processDataPackage(self, data: bytes, buf: Queue[bytes], on_error_callback=None) -> bool:
         if not data:
@@ -1240,7 +1245,11 @@ class SensorProfileDataCtx:
             if on_error_callback:
                 on_error_callback("Incomplete Impedance packet received")
             return False
-        
+
+        sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_IMPEDANCE]
+        self.checkReadSamples(data, sensor_data, 0, -1, on_error_callback)
+        sampleInterval = 1000.0 / sensor_data.sampleRate if sensor_data.sampleRate > 0 else 0
+
         for index in range(channelCount):
             impedance = struct.unpack_from("<f", data, offset)[0]
             offset += 4
@@ -1257,20 +1266,24 @@ class SensorProfileDataCtx:
 
         self.impedanceData = impedanceData
         self.saturationData = saturationData
-
-        sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_IMPEDANCE]
-        self.checkReadSamples(data, sensor_data, 0, -1)
-        sampleInterval = 1000.0 / sensor_data.sampleRate if sensor_data.sampleRate > 0 else 0
         lastSampleIndex = sensor_data.lastPackageCounter * sensor_data.packageSampleCount
 
         sensor_data.channelSamples = []
         for index in range(channelCount):
             samples = []
             sample = self._object_pool.acquire_sample()
-            sample.rawData = int(saturationData[index])
-            sample.data = impedanceData[index]
-            sample.impedance = impedanceData[index]
-            sample.saturation = saturationData[index]
+
+            impedanceValue = impedanceData[index]
+            saturationValue = saturationData[index]
+            if not math.isfinite(impedanceValue):
+                impedanceValue = 0.0
+            if not math.isfinite(saturationValue):
+                saturationValue = 0.0
+
+            sample.rawData = int(saturationValue)
+            sample.data = impedanceValue
+            sample.impedance = impedanceValue
+            sample.saturation = saturationValue
             sample.sampleIndex = lastSampleIndex
             sample.timeStampInMs = int(lastSampleIndex * sampleInterval)
             sample.channelIndex = index
@@ -1291,7 +1304,8 @@ class SensorProfileDataCtx:
         if sensor_data_quat is not None:
             frameSize += 12
 
-        return len(data) >= dataOffset + sensor_data_ref.packageSampleCount * frameSize
+        expected = dataOffset + sensor_data_ref.packageSampleCount * frameSize
+        return len(data) == expected
     
     def _process_imu_samples(self, data: bytes, buf: Queue[bytes], on_error_callback=None) -> bool:
         sensor_data_acc = self.sensorDatas[SensorDataType.DATA_TYPE_ACC]
@@ -1398,6 +1412,47 @@ class SensorProfileDataCtx:
             return ReadSamplesResult.Error
         if sensorData is None or sensorData.packageSampleCount <= 0 or sensorData.channelCount <= 0 or sensorData.minPackageSampleCount <= 0 or sensorData.K <= 0:
             return ReadSamplesResult.Error
+
+        def _type_name():
+            try:
+                return DataType(sensorData.dataType).name
+            except Exception:
+                return str(sensorData.dataType)
+
+        # 长度预检：在解析包序号/样本前就发现数据长度不足，并报告数据类型
+        if dataGap >= 0 and sensorData.packageSampleCount > 0:
+            if sensorData.resolutionBits in (7, 8):
+                bytesPerChannel = 1
+            elif sensorData.resolutionBits in (12, 16, 17, 0):
+                bytesPerChannel = 2
+            elif sensorData.resolutionBits == 24:
+                bytesPerChannel = 3
+            elif sensorData.resolutionBits in (31, 32, 33):
+                bytesPerChannel = 4
+            else:
+                bytesPerChannel = 2
+
+            realChannelCount = 0
+            for i in range(sensorData.channelCount):
+                if (sensorData.channelMask & (1 << i)) != 0:
+                    realChannelCount += 1
+
+            expected = (
+                dataOffset
+                + bytesPerChannel * realChannelCount * sensorData.packageSampleCount
+                + dataGap * (sensorData.packageSampleCount - 1)
+            )
+            if dataGap == 0:
+                # 单一流数据包：要求长度完全一致
+                if expected != len(data):
+                    SdkLog.i(_TAG, f"Invalid dataLength:{len(data)} (expected {expected}) for data type {_type_name()}")
+                    return ReadSamplesResult.Error
+            else:
+                # IMU 复合包：允许包含多个子流，只检查长度不足
+                if expected > len(data):
+                    SdkLog.i(_TAG, f"Invalid dataLength:{len(data)} (expected at least {expected}) for data type {_type_name()}")
+                    return ReadSamplesResult.Error
+
         try:
             packageIndex = 0
             maxPackageIndex = 0
@@ -1416,39 +1471,58 @@ class SensorProfileDataCtx:
                 offset += sensorData.packageIndexLength
                 newPackageIndex = packageIndex
                 lastPackageIndex = sensorData.lastPackageIndex
-                if sensorData.lastPackageCounter < 0 and newPackageIndex > 0:
-                    sensorData.lastPackageIndex = lastPackageIndex = newPackageIndex - 1
+
+                # 首包：把上一包序号设为合法的前一个值，便于后续统一判断
+                if sensorData.lastPackageCounter < 0:
                     sensorData.lastPackageCounter = 0
+                    if newPackageIndex > 0:
+                        lastPackageIndex = newPackageIndex - 1
+                    else:
+                        lastPackageIndex = maxPackageIndex
+                    sensorData.lastPackageIndex = lastPackageIndex
 
-                if packageIndex < lastPackageIndex:
-                    packageIndex += (maxPackageIndex + 1)
-                elif packageIndex == lastPackageIndex:
+                # 合法翻卷区间：last 在 [max-2, max] 且 new 在 [0, 2]
+                if newPackageIndex <= 2 and lastPackageIndex >= maxPackageIndex - 2:
+                    packageIndex = maxPackageIndex + 1 + newPackageIndex
+                elif newPackageIndex == lastPackageIndex:
                     return ReadSamplesResult.Repeated
+                elif newPackageIndex < lastPackageIndex:
+                    SdkLog.i(_TAG, (
+                        "Illegal package index backward|MAC|" + str(sensorData.deviceMac)
+                        + "|TYPE|" + str(sensorData.dataType)
+                        + "|LAST_IDX|" + str(lastPackageIndex)
+                        + "|CURR_IDX|" + str(newPackageIndex)
+                        + "|DELTA|" + str(lastPackageIndex - newPackageIndex)
+                    ))
+                    return ReadSamplesResult.Error
 
                 deltaPackageIndex = packageIndex - lastPackageIndex
+                if deltaPackageIndex > 20:
+                    SdkLog.i(_TAG, (
+                        "Illegal package index jump|MAC|" + str(sensorData.deviceMac)
+                        + "|TYPE|" + str(sensorData.dataType)
+                        + "|LAST_IDX|" + str(lastPackageIndex)
+                        + "|CURR_IDX|" + str(newPackageIndex)
+                        + "|DELTA|" + str(deltaPackageIndex)
+                    ))
+                    return ReadSamplesResult.Error
+
                 lostPackageCounter = deltaPackageIndex - 1
-                if lostPackageCounter > 65534:
-                    lostPackageCounter = 1
-                elif lostPackageCounter > 50:
-                    lostPackageCounter = 50
                 sensorData.lostPackageCount = sensorData.lostPackageCount + lostPackageCounter
 
                 if deltaPackageIndex > 1:
-                    lostSampleCount = sensorData.packageSampleCount * (deltaPackageIndex - 1)
+                    lostSampleCount = sensorData.packageSampleCount * lostPackageCounter
                     SdkLog.i(_TAG, (
                         "MSG|LOST SAMPLE|MAC|" + str(sensorData.deviceMac)
                         + "|TYPE|" + str(sensorData.dataType)
                         + "|COUNT|" + str(lostSampleCount)
                     ))
 
-                    if lostSampleCount < 100:
+                    if lostPackageCounter < 20:
                         self.readSamples(data, sensorData, 0, dataGap, lostSampleCount)
 
-                    if newPackageIndex == 0:
-                        sensorData.lastPackageIndex = maxPackageIndex
-                    else:
-                        sensorData.lastPackageIndex = newPackageIndex - 1
-                    sensorData.lastPackageCounter += deltaPackageIndex - 1
+                    sensorData.lastPackageIndex = newPackageIndex - 1
+                    sensorData.lastPackageCounter += lostPackageCounter
 
                 sensorData.lastPackageIndex = newPackageIndex
 
@@ -1476,31 +1550,15 @@ class SensorProfileDataCtx:
             lostSampleCount: int,
     ):
         sampleCount = sensorData.packageSampleCount
+        def _type_name():
+            try:
+                return DataType(sensorData.dataType).name
+            except Exception:
+                return str(sensorData.dataType)
+
         if lostSampleCount <= 0:
             if data is None or offset < 0 or offset > len(data):
-                raise ValueError("Invalid data or offset")
-
-            if sensorData.resolutionBits in (7, 8):
-                bytesPerChannel = 1
-            elif sensorData.resolutionBits in (12, 16, 17, 0):
-                bytesPerChannel = 2
-            elif sensorData.resolutionBits == 24:
-                bytesPerChannel = 3
-            elif sensorData.resolutionBits in (31, 32, 33):
-                bytesPerChannel = 4
-            else:
-                bytesPerChannel = 2
-
-            dataLength = len(data)
-
-            realChannelCount = 0
-            for channelIndex, impedanceChannelIndex in enumerate(range(sensorData.channelCount)):
-                if (sensorData.channelMask & (1 << channelIndex)) != 0:
-                    realChannelCount += 1
-
-            if offset + ((bytesPerChannel  * realChannelCount * sampleCount) + (dataGap * (sampleCount - 1)))  > dataLength:
-                raise ValueError(f"Invalid dataLength:{dataLength}")
-        
+                raise ValueError(f"Invalid data or offset for data type {_type_name()}")
 
         sampleInterval = (
             int(1000.0 / sensorData.sampleRate) if sensorData.sampleRate > 0 else 0
@@ -1742,55 +1800,60 @@ class SensorProfileDataCtx:
             except Exception as e:
                 SdkLog.exception(_TAG, "Error reading raw data buffer")
 
-            index = 0
-            last_cut = -1
-            data_size = len(self._concatDataBuffer)
+            try:
+                index = 0
+                last_cut = -1
+                data_size = len(self._concatDataBuffer)
 
-            while self._is_running:
-                if index >= data_size:
-                    break
+                while self._is_running:
+                    if index >= data_size:
+                        break
 
-                if self._concatDataBuffer[index] == 0x55:
-                    if (index + 1) >= data_size:
-                        index = data_size
-                        continue
-                    n = self._concatDataBuffer[index + 1]
-                    if n < 2 or (index + 1 + n + 2) >= data_size:
-                        index += 1
-                        continue
-                    crc16 = (self._concatDataBuffer[index + 1 + n + 2] << 8) | self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = sensor_utils.crc16_cal(self._concatDataBuffer[index + 2: index + 2 + n], n)
-                    if crc16 != calc_crc:
+                    if self._concatDataBuffer[index] == 0x55:
+                        if (index + 1) >= data_size:
+                            index = data_size
+                            continue
+                        n = self._concatDataBuffer[index + 1]
+                        if n < 2 or (index + 1 + n + 2) >= data_size:
+                            index += 1
+                            continue
+                        crc16 = (self._concatDataBuffer[index + 1 + n + 2] << 8) | self._concatDataBuffer[index + 1 + n + 1]
+                        calc_crc = sensor_utils.crc16_cal(self._concatDataBuffer[index + 2: index + 2 + n], n)
+                        if crc16 != calc_crc:
+                            index += 1
+                            continue
+                        if self._is_data_transfering:
+                            data_package = bytes(self._concatDataBuffer[index + 2: index + 2 + n])
+                            if self._processDataPackage(data_package, buf, on_error_callback):
+                                last_cut = index = index + 2 + n + 1
                         index += 1
-                        continue
-                    if self._is_data_transfering:
+                    elif self._concatDataBuffer[index] == 0xAA:
+                        if (index + 1) >= data_size:
+                            index = data_size
+                            continue
+                        n = self._concatDataBuffer[index + 1]
+                        if n < 2 or (index + 1 + n + 2) >= data_size:
+                            index += 1
+                            continue
+                        crc16 = (self._concatDataBuffer[index + 1 + n + 2] << 8) | self._concatDataBuffer[index + 1 + n + 1]
+                        calc_crc = sensor_utils.crc16_cal(self._concatDataBuffer[index + 2: index + 2 + n], n)
+                        if crc16 != calc_crc:
+                            index += 1
+                            continue
                         data_package = bytes(self._concatDataBuffer[index + 2: index + 2 + n])
-                        if self._processDataPackage(data_package, buf, on_error_callback):
-                            last_cut = index = index + 2 + n + 1
-                    index += 1
-                elif self._concatDataBuffer[index] == 0xAA:
-                    if (index + 1) >= data_size:
-                        index = data_size
-                        continue
-                    n = self._concatDataBuffer[index + 1]
-                    if n < 2 or (index + 1 + n + 2) >= data_size:
+
+                        if not sensor_utils._terminated:
+                            await self.gForce.async_on_cmd_response(data_package)
+                        last_cut = index = index + 2 + n + 1
                         index += 1
-                        continue
-                    crc16 = (self._concatDataBuffer[index + 1 + n + 2] << 8) | self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = sensor_utils.crc16_cal(self._concatDataBuffer[index + 2: index + 2 + n], n)
-                    if crc16 != calc_crc:
+                    else:
                         index += 1
-                        continue
-                    data_package = bytes(self._concatDataBuffer[index + 2: index + 2 + n])
 
-                    if not sensor_utils._terminated:
-                        await self.gForce.async_on_cmd_response(data_package)
-                    last_cut = index = index + 2 + n + 1
-                    index += 1
-                else:
-                    index += 1
+                if last_cut > 0:
+                    self._concatDataBuffer = self._concatDataBuffer[last_cut + 1:]
+                    last_cut = -1
+                    index = 0
 
-            if last_cut > 0:
-                self._concatDataBuffer = self._concatDataBuffer[last_cut + 1:]
-                last_cut = -1
-                index = 0
+                self._last_progress_time = time.time()
+            except Exception as e:
+                SdkLog.exception(_TAG, "Unexpected error in universal concat data processing")

{sensor_sdk-0.1.4 → sensor_sdk-0.1.9}/sensor/sensor_utils.py

@@ -38,33 +38,34 @@ def Terminate():
     global _runloop, _needCloseRunloop, _event_thread, _terminated
     _terminated = True
 
+    # 如果不是我们创建的 loop（例如用户自己的 qasync/Qt loop），不要动它
+    if not _needCloseRunloop or _runloop is None:
+        return
+
     def _cancel_tasks():
-        for task in asyncio.all_tasks():
-            task.cancel()
+        try:
+            # 在 loop 线程内部调用，有运行中的事件循环
+            for task in asyncio.all_tasks():
+                if not task.done():
+                    task.cancel()
+        except Exception:
+            # 取消任务失败时不阻塞终止流程
+            pass
 
     try:
-        _cancel_tasks()
-    except RuntimeError:
-        # 当前线程没有运行的事件循环，尝试在管理的 runloop 上取消任务
-        if _runloop is not None and _runloop.is_running():
-            try:
-                _runloop.call_soon_threadsafe(_cancel_tasks)
-                time.sleep(0.1)
-            except Exception as e:
-                SdkLog.exception(_TAG, "Error cancelling tasks during terminate")
-    except Exception as e:
-        SdkLog.exception(_TAG, "Error cancelling tasks during terminate")
+        # 取消 / stop 都必须在 loop 所在线程执行，避免跨线程调用 asyncio API 抛异常
+        if _runloop.is_running():
+            _runloop.call_soon_threadsafe(_cancel_tasks)
+            time.sleep(0.2)
+            _runloop.call_soon_threadsafe(_runloop.stop)
 
-    if _needCloseRunloop:
-        try:
-            if _runloop is not None and _runloop.is_running():
-                _runloop.call_soon_threadsafe(_runloop.stop)
-            if _event_thread is not None and _event_thread.is_alive():
-                _event_thread.join(timeout=2.0)
-            if _runloop is not None and not _runloop.is_running():
-                _runloop.close()
-        except Exception as e:
-            SdkLog.exception(_TAG, "Error closing runloop during terminate")
+        if _event_thread is not None and _event_thread.is_alive():
+            _event_thread.join(timeout=3.0)
+
+        # 不再主动 close loop：Windows 的 ProactorEventLoop 在 still-running 时 close()
+        # 会抛 RuntimeError。守护线程会在 loop stop 后自然退出，进程退出时回收资源。
+    except Exception as e:
+        SdkLog.exception(_TAG, "Error during terminate")
 
 
 def async_exec(function, runloop=None):

{sensor_sdk-0.1.4 → sensor_sdk-0.1.9/sensor_sdk.egg-info}/PKG-INFO

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

{sensor_sdk-0.1.4 → sensor_sdk-0.1.9}/sensor_sdk.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 setup.py
 sensor/__init__.py
 sensor/bleak_host.py
+sensor/bleak_no_ack_patch.py
 sensor/bleak_process.py
 sensor/gforce.py
 sensor/sdk_log.py

{sensor_sdk-0.1.4 → sensor_sdk-0.1.9}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), "r", encoding="utf-8") as f
 
 setup(
     name="sensor-sdk",
-    version="0.1.4",
+    version="0.1.9",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",