sensor-sdk 0.1.5__tar.gz → 0.2.0__tar.gz

{sensor_sdk-0.1.5/sensor_sdk.egg-info → sensor_sdk-0.2.0}/PKG-INFO

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

{sensor_sdk-0.1.5 → sensor_sdk-0.2.0}/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.2.0/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.5 → sensor_sdk-0.2.0}/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):
 
@@ -1099,6 +1111,12 @@ class BleakProcess(multiprocessing.Process):
             sorted_keys = sorted(ctx.notify_map.keys())
             result = "|".join(f"{k}|{ctx.notify_map[k]}" for k in sorted_keys)
 
+        if key == "NTF_IMU":
+            imu_sub_keys = ["NTF_GFORCE_ACC", "NTF_GFORCE_GYRO", "NTF_GFORCE_QUAT", "NTF_GFORCE_EULER"]
+            result = "ON" if all(ctx.notify_map.get(k) == "ON" for k in imu_sub_keys) else "OFF"
+        elif key in ctx.notify_map:
+            result = ctx.notify_map[key]
+
         if key == "DEBUG_LOG_PATH":
             result = SdkLog.get_log_path() or ""
 
@@ -1156,6 +1174,12 @@ class BleakProcess(multiprocessing.Process):
                 if key == "NTF_PPG_RAW":
                     map_key = "NTF_PPG"
 
+                # IMU 总开关同时控制 ACC/GYRO/QUAT/EULER
+                imu_sub_keys = ["NTF_GFORCE_ACC", "NTF_GFORCE_GYRO", "NTF_GFORCE_QUAT", "NTF_GFORCE_EULER"]
+                if map_key == "NTF_IMU":
+                    for sub in imu_sub_keys:
+                        ctx.notify_map[sub] = value
+
                 # 老版本 EMG 设备上 Gesture 与 EMG 互斥，自动切换
                 if not ctx.isNewEMG:
                     if map_key == "NTF_GEST" and value == "ON" and ctx.notify_map.get("NTF_EMG") == "ON":
@@ -1170,17 +1194,40 @@ class BleakProcess(multiprocessing.Process):
                         ctx.notify_map[map_key] = value
                         result = "OK"
                 else:
+                    # 新 EMG：Gesture 依赖 EMG 数据，关闭 EMG 时同步关闭 Gesture；打开 Gesture 时自动打开 EMG
+                    if map_key == "NTF_EMG" and value == "OFF":
+                        ctx.notify_map["NTF_GEST"] = "OFF"
+                    elif map_key == "NTF_GEST" and value == "ON" and ctx.notify_map.get("NTF_EMG") != "ON":
+                        ctx.notify_map["NTF_EMG"] = "ON"
                     ctx.notify_map[map_key] = value
                     result = "OK"
-                if result == "OK" and ctx.hasInit() and ctx.isDataTransfering:
+
+                # 单个 IMU 子开关变化时，同步更新 NTF_IMU 总开关的聚合状态
+                if map_key in imu_sub_keys:
+                    ctx.notify_map["NTF_IMU"] = "ON" if all(ctx.notify_map.get(k) == "ON" for k in imu_sub_keys) else "OFF"
+
+                if result == "OK" and ctx.hasInit():
                     ctx._buildNotifyDataFlag()
-                    needs_restart = True
-                    if ctx.getChipType() == BLEChipType.OYM:
+
+                    # 新 EMG 设备通过 function switch 控制 EMG/Gesture 输出，bit0=gesture, bit1=emg
+                    if ctx.isNewEMG and map_key in ("NTF_EMG", "NTF_GEST"):
+                        emg_bit = 1 if ctx.notify_map.get("NTF_EMG") == "ON" else 0
+                        gest_bit = 1 if (emg_bit and ctx.notify_map.get("NTF_GEST") == "ON") else 0
+                        func_switch = (emg_bit << 1) | gest_bit
                         try:
-                            await ctx.gForce.set_subscription(ctx.notifyDataFlag)
+                            await ctx.gForce.set_function_switch(func_switch)
+                            await asyncio.sleep(0.5)
                         except Exception as e:
-                            SdkLog.exception(_TAG, f"_do_set_param set_subscription failed: {device_mac}")
-                            result = "ERROR: set_subscription fail: " + str(e)
+                            SdkLog.exception(_TAG, f"_do_set_param set_function_switch failed: {device_mac}")
+                            result = "ERROR: set_function_switch fail: " + str(e)
+                    elif ctx.isDataTransfering:
+                        needs_restart = True
+                        if ctx.getChipType() == BLEChipType.OYM:
+                            try:
+                                await ctx.gForce.set_subscription(ctx.notifyDataFlag)
+                            except Exception as e:
+                                SdkLog.exception(_TAG, f"_do_set_param set_subscription failed: {device_mac}")
+                                result = "ERROR: set_subscription fail: " + str(e)
 
         if key in ["FILTER_50HZ", "FILTER_60HZ", "FILTER_HPF", "FILTER_LPF"]:
             if value in ["ON", "OFF"]:

{sensor_sdk-0.1.5 → sensor_sdk-0.2.0}/sensor/sensor_data_context.py

@@ -390,8 +390,12 @@ class SensorProfileDataCtx:
         config.batch_len = 128
 
         if isNewEMG:
-            await self.gForce.set_function_switch(0b11)
-    
+            # 新版 EMG：bit0=gesture，bit1=emg；Gesture 依赖 EMG，EMG 关闭时 Gesture 同步关闭
+            emg_bit = 1 if self.notify_map.get("NTF_EMG") == "ON" else 0
+            gest_bit = 1 if (emg_bit and self.notify_map.get("NTF_GEST") == "ON") else 0
+            await self.gForce.set_function_switch((emg_bit << 1) | gest_bit)
+            await asyncio.sleep(0.5)
+
         await self.gForce.set_emg_raw_data_config(config)
         await self.gForce.set_package_id(True)
 
@@ -544,7 +548,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 +1103,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 +1249,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 +1270,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 +1308,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 +1416,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 +1475,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
 
@@ -1486,28 +1564,6 @@ class SensorProfileDataCtx:
             if data is None or offset < 0 or offset > len(data):
                 raise ValueError(f"Invalid data or offset for data type {_type_name()}")
 
-            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} for data type {_type_name()}")
-        
-
         sampleInterval = (
             int(1000.0 / sensorData.sampleRate) if sensorData.sampleRate > 0 else 0
         )
@@ -1748,55 +1804,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.5 → sensor_sdk-0.2.0/sensor_sdk.egg-info}/PKG-INFO

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

{sensor_sdk-0.1.5 → sensor_sdk-0.2.0}/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.5 → sensor_sdk-0.2.0}/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.5",
+    version="0.2.0",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",