sensor-sdk 0.0.27__tar.gz → 0.0.33__tar.gz

{sensor-sdk-0.0.27 → sensor_sdk-0.0.33}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.0.27
+Version: 0.0.33
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye
@@ -8,6 +8,18 @@ Author-email: yecq_82@hotmail.com
 Requires-Python: >=3.9.0
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: numpy
+Requires-Dist: setuptools
+Requires-Dist: bleak
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # sensor-sdk
 
@@ -375,10 +387,10 @@ result = sensorProfile.setParam("NTF_IMU", "ON")
 result = sensorProfile.setParam("NTF_BRTH", "ON")
 # set BRTH data to ON or OFF, result is "OK" if succeed
 
-result = sensorProfile.setParam("FILTER_50Hz", "ON")
+result = sensorProfile.setParam("FILTER_50HZ", "ON")
 # set 50Hz notch filter to ON or OFF, result is "OK" if succeed
 
-result = sensorProfile.setParam("FILTER_60Hz", "ON")
+result = sensorProfile.setParam("FILTER_60HZ", "ON")
 # set 60Hz notch filter to ON or OFF, result is "OK" if succeed
 
 result = sensorProfile.setParam("FILTER_HPF", "ON")

{sensor-sdk-0.0.27 → sensor_sdk-0.0.33}/README.md

@@ -364,10 +364,10 @@ result = sensorProfile.setParam("NTF_IMU", "ON")
 result = sensorProfile.setParam("NTF_BRTH", "ON")
 # set BRTH data to ON or OFF, result is "OK" if succeed
 
-result = sensorProfile.setParam("FILTER_50Hz", "ON")
+result = sensorProfile.setParam("FILTER_50HZ", "ON")
 # set 50Hz notch filter to ON or OFF, result is "OK" if succeed
 
-result = sensorProfile.setParam("FILTER_60Hz", "ON")
+result = sensorProfile.setParam("FILTER_60HZ", "ON")
 # set 60Hz notch filter to ON or OFF, result is "OK" if succeed
 
 result = sensorProfile.setParam("FILTER_HPF", "ON")

{sensor-sdk-0.0.27 → sensor_sdk-0.0.33}/sensor/gforce.py

@@ -3,6 +3,7 @@ import queue
 import struct
 from asyncio import Queue
 from contextlib import suppress
+from datetime import datetime
 from dataclasses import dataclass
 from enum import IntEnum
 from typing import Optional, Dict, List
@@ -88,6 +89,7 @@ class Command(IntEnum):
     GET_EMG_RAWDATA_CONFIG = (0x46,)
 
     SET_DATA_NOTIF_SWITCH = (0x4F,)
+    SET_FUNCTION_SWITCH = (0x85,)
 
     CMD_GET_EEG_CONFIG = (0xA0,)
     CMD_SET_EEG_CONFIG = (0xA1,)
@@ -372,12 +374,21 @@ class Response:
 
 
 class GForce:
-    def __init__(self, device: BLEDevice, cmd_char: str, data_char: str, isUniversalStream: bool):
+    def __init__(
+        self,
+        device: BLEDevice,
+        cmd_char: str,
+        data_char: str,
+        isUniversalStream: bool,
+        event_loop: asyncio.AbstractEventLoop,
+        gforce_event_loop: asyncio.AbstractEventLoop,
+    ):
         self.device_name = ""
         self.client = None
+        self.event_loop = event_loop
+        self.gforce_event_loop = gforce_event_loop
         self.cmd_char = cmd_char
         self.data_char = data_char
-        self.current_request: Request = None
         self.responses: Dict[Command, Queue] = {}
         self.resolution = SampleResolution.BITS_8
         self._num_channels = 8
@@ -394,7 +405,7 @@ class GForce:
         self._raw_data_buf = buf
 
         try:
-            await asyncio.wait_for(client.connect(), sensor_utils._TIMEOUT)
+            await sensor_utils.async_call(client.connect(), sensor_utils._TIMEOUT, self.gforce_event_loop)
         except Exception as e:
             return
 
@@ -403,19 +414,22 @@ class GForce:
 
         try:
             if not self._is_universal_stream:
-                await asyncio.wait_for(
+                await sensor_utils.async_call(
                     client.start_notify(self.cmd_char, self._on_cmd_response),
                     sensor_utils._TIMEOUT,
+                    self.gforce_event_loop,
                 )
+
             else:
-                await asyncio.wait_for(
+                await sensor_utils.async_call(
                     client.start_notify(self.data_char, self._on_universal_response),
                     sensor_utils._TIMEOUT,
+                    self.gforce_event_loop,
                 )
         except Exception as e:
             return
 
-    def _on_data_response(self, q: Queue[bytes], bs: bytearray):
+    def _on_data_response(self, q: queue.Queue[bytes], bs: bytearray):
         bs = bytes(bs)
 
         full_packet = []
@@ -444,63 +458,6 @@ class GForce:
             return
 
         q.put_nowait(bytes(full_packet))
-        # data = None
-        # data_type = DataType(full_packet[0])
-        # packet = full_packet[1:]
-        # match data_type:
-        #     case DataType.EMG_ADC:
-        #         data = self._convert_emg_to_raw(packet)
-
-        #     case DataType.ACC:
-        #         data = self._convert_acceleration_to_g(packet)
-
-        #     case DataType.GYO:
-        #         data = self._convert_gyro_to_dps(packet)
-
-        #     case DataType.MAG:
-        #         data = self._convert_magnetometer_to_ut(packet)
-
-        #     case DataType.EULER:
-        #         data = self._convert_euler(packet)
-
-        #     case DataType.QUAT:
-        #         data = self._convert_quaternion(packet)
-
-        #     case DataType.ROTA:
-        #         data = self._convert_rotation_matrix(packet)
-
-        #     case DataType.EMG_GEST:  # It is not supported by the device (?)
-        #         data = self._convert_emg_gesture(packet)
-
-        #     case DataType.HID_MOUSE:  # It is not supported by the device
-        #         pass
-
-        #     case DataType.HID_JOYSTICK:  # It is not supported by the device
-        #         pass
-
-        #     case DataType.PARTIAL:
-        #         pass
-        #     case _:
-        #         raise Exception(
-        #             f"Unknown data type {data_type}, full packet: {full_packet}"
-        #         )
-
-        # q.put_nowait(data)
-
-    # def _convert_emg_to_raw(self, data: bytes) -> np.ndarray[np.integer]:
-    #     match self.resolution:
-    #         case SampleResolution.BITS_8:
-    #             dtype = np.uint8
-
-    #         case SampleResolution.BITS_12:
-    #             dtype = np.uint16
-
-    #         case _:
-    #             raise Exception(f"Unsupported resolution {self.resolution}")
-
-    #     emg_data = np.frombuffer(data, dtype=dtype)
-
-    #     return emg_data.reshape(-1, self._num_channels)
 
     @staticmethod
     def _convert_acceleration_to_g(data: bytes) -> np.ndarray[np.float32]:
@@ -565,6 +522,9 @@ class GForce:
         self._raw_data_buf.put_nowait(bytes(bs))
 
     def _on_cmd_response(self, _: BleakGATTCharacteristic, bs: bytearray):
+        sensor_utils.async_exec(self.async_on_cmd_response(bs), self.event_loop)
+
+    async def async_on_cmd_response(self, bs: bytearray):
         try:
             # print(bytes(bs))
             response = self._parse_response(bytes(bs))
@@ -754,6 +714,20 @@ class GForce:
             )
         )
 
+    async def set_function_switch(self, funcSwitch)-> bool:
+        body = [0xFF & funcSwitch]
+        body = bytes(body)
+        ret = await self._send_request(
+            Request(
+                cmd=Command.SET_FUNCTION_SWITCH,
+                body=body,
+                has_res=True,
+            )
+        )
+        if (len(ret) > 0 and ret[0] == 0):
+            return True
+        return False
+
     async def set_firmware_filter_switch(self, switchStatus: int):
         body = [0xFF & switchStatus]
         body = bytes(body)
@@ -765,7 +739,7 @@ class GForce:
 
     async def set_emg_raw_data_config(self, cfg=EmgRawDataConfig()):
         body = cfg.to_bytes()
-        await self._send_request(
+        ret = await self._send_request(
             Request(
                 cmd=Command.SET_EMG_RAWDATA_CONFIG,
                 body=body,
@@ -773,7 +747,7 @@ class GForce:
             )
         )
 
-        # print('_send_request returned:', ret)
+        # print('set_emg_raw_data_config returned:', ret)
 
         self.resolution = cfg.resolution
 
@@ -858,22 +832,20 @@ class GForce:
         )
 
     async def start_streaming(self, q: queue.Queue):
-        await asyncio.wait_for(
+        await sensor_utils.async_call(
             self.client.start_notify(
                 self.data_char,
                 lambda _, data: self._on_data_response(q, data),
             ),
             sensor_utils._TIMEOUT,
+            self.gforce_event_loop,
         )
 
     async def stop_streaming(self):
         exceptions = []
-        # try:
-        #     await asyncio.wait_for(self.set_subscription(DataSubscription.OFF), sensor_utils._TIMEOUT)
-        # except Exception as e:
-        #     exceptions.append(e)
+
         try:
-            await asyncio.wait_for(self.client.stop_notify(self.data_char), sensor_utils._TIMEOUT)
+            await sensor_utils.async_call(self.client.stop_notify(self.data_char), sensor_utils._TIMEOUT, self.gforce_event_loop)
         except Exception as e:
             exceptions.append(e)
 
@@ -883,49 +855,62 @@ class GForce:
     async def disconnect(self):
         with suppress(asyncio.CancelledError):
             try:
-                await asyncio.wait_for(self.client.disconnect(), sensor_utils._TIMEOUT)
+                await sensor_utils.async_call(self.client.disconnect(), sensor_utils._TIMEOUT, self.gforce_event_loop)
             except Exception as e:
                 pass
 
     def _get_response_channel(self, cmd: Command) -> Queue:
         if self.responses.get(cmd) != None:
-            return None
-
-        q = Queue()
-        self.responses[cmd] = q
-        return q
+            return self.responses[cmd]
+        else:
+            q = Queue()
+            self.responses[cmd] = q
+            return q
 
     async def _send_request(self, req: Request) -> Optional[bytes]:
+        return await sensor_utils.async_call(self._send_request_internal(req=req), runloop=self.event_loop)
 
+    async def _send_request_internal(self, req: Request) -> Optional[bytes]:
         q = None
         if req.has_res:
             q = self._get_response_channel(req.cmd)
-            if q == None:
-                # print("duplicate")
-                return None
 
-        while self.current_request != None:
-            # print("wait")
-            await asyncio.sleep(0.1)
+        timeStamp_old = -1
+        while not q.empty():
+            timeStamp_old = q.get_nowait()
+
+        now = datetime.now()
+        timestamp_now = now.timestamp()
+        if (timeStamp_old > -1) and ((timestamp_now - timeStamp_old) < 3):
+            print("send request too fast")
+            q.put_nowait(timeStamp_old)
+            return None
 
-        self.current_request = req
         bs = bytes([req.cmd])
         if req.body is not None:
             bs += req.body
 
         # print(str(req.cmd) + str(req.body))
-        await asyncio.wait_for(self.client.write_gatt_char(self.cmd_char, bs, response=False), 0.1)
+        try:
+            await sensor_utils.async_call(
+                self.client.write_gatt_char(self.cmd_char, bs),
+                1,
+                runloop=self.gforce_event_loop,
+            )
+        except Exception as e:
+            self.responses[req.cmd] = None
+            return None
 
         if not req.has_res:
-            self.current_request = None
+            self.responses[req.cmd] = None
             return None
 
         try:
-            ret = await asyncio.wait_for(q.get(), 0.5)
-            self.current_request = None
-            self.responses[req.cmd] = None
+            ret = await asyncio.wait_for(q.get(), 2)
+            now = datetime.now()
+            timestamp_now = now.timestamp()
+            q.put_nowait(timestamp_now)
             return ret
         except Exception as e:
-            self.current_request = None
             self.responses[req.cmd] = None
             return None

{sensor-sdk-0.0.27 → sensor_sdk-0.0.33}/sensor/sensor_data.py

@@ -41,10 +41,12 @@ class DataType(IntEnum):
     NTF_EMG = 0x8  # EMG，用于标识肌电传感器采集的数据
     NTF_EEG = 0x10  # EEG，用于标识脑电传感器采集的数据
     NTF_ECG = 0x11  # ECG，用于标识心电传感器采集的数据
-    NTF_IMPEDANCE = (0x12,)  # 阻抗数据
-    NTF_IMU = (0x13,)  # 包含ACC和GYRO数据
-    NTF_ADS = (0x14,)  # 无单位ads数据
+    NTF_IMPEDANCE = 0x12  # 阻抗数据
+    NTF_IMU = 0x13  # 包含ACC和GYRO数据
+    NTF_ADS = 0x14  # 无单位ads数据
     NTF_BRTH = 0x15  # 呼吸，用于标识呼吸传感器采集的数据
+    NTF_IMPEDANCE_EXT = 0x16  # 阻抗数据扩展
+    NTF_DATA_TYPE_MAX = 0x17
 
 
 # 一次采样的数据，包含多个通道的数据，channal_samples 为一个二维数组, 第一个维度为通道索引，第二个维度为采样索引
@@ -81,6 +83,7 @@ class SensorData:
         self.sampleRate = 0
         self.channelCount = 0
         self.packageSampleCount = 0
+        self.packageIndexLength = 2
         self.channelSamples: List[List[Sample]] = list()
         self.lastPackageCounter = 0
         self.lastPackageIndex = 0

{sensor-sdk-0.0.27 → sensor_sdk-0.0.33}/sensor/sensor_data_context.py

@@ -61,7 +61,7 @@ class SensorProfileDataCtx:
         self.saturationData: List[float] = list()
         self.dataPool = ThreadPoolExecutor(1, "data")
         self.init_map = {"NTF_EMG": "ON", "NTF_EEG": "ON", "NTF_ECG": "ON", "NTF_IMU": "ON", "NTF_BRTH": "ON"}
-        self.filter_map = {"FILTER_50Hz": "ON", "FILTER_60Hz": "ON", "FILTER_HPF": "ON", "FILTER_LPF": "ON"}
+        self.filter_map = {"FILTER_50HZ": "ON", "FILTER_60HZ": "ON", "FILTER_HPF": "ON", "FILTER_LPF": "ON"}
         self.debugCSVWriter = None
         self.debugCSVPath = None
 
@@ -126,18 +126,41 @@ class SensorProfileDataCtx:
         data.channelMask = config.channel_mask
         data.minPackageSampleCount = packageCount
         data.packageSampleCount = 8
-        data.K = 4000000.0 / 8388607.0
+
         data.clear()
-        self.sensorDatas[SensorDataType.DATA_TYPE_EMG] = data
-        self.notifyDataFlag |= DataSubscription.EMG_RAW
+
+        await self.gForce.set_package_id(True)
+
+        isNewEMG = await self.gForce.set_function_switch(2)
+
+        if (isNewEMG):
+            #new emg
+            data.packageIndexLength = 2
+            data.packageSampleCount = 8
+            data.resolutionBits = 0
+            data.K = 4000000.0 / 8388607.0
+            config.resolution = 8
+        else:
+            #old emg
+            data.packageIndexLength = 1
+            data.packageSampleCount = 8
+            data.resolutionBits = 8
+            gain = 1200
+            min_voltage = -1.25 * 1000000 
+            max_voltage = 1.25 * 100000 
+            div = 127.0
+            conversion_factor = (max_voltage - min_voltage) / gain / div
+            data.K = conversion_factor
+            config.resolution = 8
 
         config.fs = SamplingRate.HZ_500
         config.channel_mask = 255
-        config.resolution = 8
         config.batch_len = 128
         await self.gForce.set_emg_raw_data_config(config)
 
-        await self.gForce.set_package_id(True)
+        self.sensorDatas[SensorDataType.DATA_TYPE_EMG] = data
+        self.notifyDataFlag |= DataSubscription.EMG_RAW
+        
         return data.channelCount
 
     async def initEEG(self, packageCount: int) -> int:
@@ -337,10 +360,10 @@ class SensorProfileDataCtx:
         switch = 0
         for filter in self.filter_map.keys():
             value = self.filter_map[filter]
-            if filter == "FILTER_50Hz":
+            if filter == "FILTER_50HZ":
                 if value == "ON":
                     switch |= 1
-            elif filter == "FILTER_60Hz":
+            elif filter == "FILTER_60HZ":
                 if value == "ON":
                     switch |= 2
             elif filter == "FILTER_HPF":
@@ -350,8 +373,9 @@ class SensorProfileDataCtx:
                 if value == "ON":
                     switch |= 8
         try:
-            await self.gForce.set_firmware_filter_switch(switch)
-            # await asyncio.sleep(0.1)
+            ret = await self.gForce.set_firmware_filter_switch(switch)
+            if ret == None:
+                return "ERROR: not success"
             return "OK"
         except Exception as e:
             return "ERROR: " + str(e)
@@ -372,10 +396,8 @@ class SensorProfileDataCtx:
     ####################################################################################
 
     async def process_data(self, buf: Queue[SensorData], sensor, callback):
-        while self._is_running and self._rawDataBuffer.empty():
-            await asyncio.sleep(0.1)
-
-            while self._is_running and not self._rawDataBuffer.empty():
+        while self._is_running:
+            while not self._rawDataBuffer.empty():
                 try:
                     data: bytes = self._rawDataBuffer.get_nowait()
                 except Exception as e:
@@ -385,7 +407,7 @@ class SensorProfileDataCtx:
                     self._processDataPackage(data, buf, sensor)
                 self._rawDataBuffer.task_done()
 
-            while self._is_running and self.isDataTransfering and not buf.empty():
+            if self.isDataTransfering and not buf.empty():
                 sensorData: SensorData = None
                 try:
                     sensorData = buf.get_nowait()
@@ -398,6 +420,8 @@ class SensorProfileDataCtx:
                         print(e)
 
                 buf.task_done()
+            else:
+                await asyncio.sleep(0.01)
 
     def _processDataPackage(self, data: bytes, buf: Queue[SensorData], sensor):
         v = data[0] & 0x7F
@@ -423,9 +447,32 @@ class SensorProfileDataCtx:
 
             self.impedanceData = impedanceData
             self.saturationData = saturationData
+        elif v == DataType.NTF_IMPEDANCE_EXT:
+            offset = 1
+            # packageIndex = ((data[offset + 1] & 0xff) << 8) | (data[offset] & 0xff)
+            offset += 2
+
+            impedanceData = []
+            saturationData = []
+
+            dataCount = self._device_info.EegChannelCount + self._device_info.EcgChannelCount
+
+            for index in range(dataCount):
+                impedance = struct.unpack_from("<f", data, offset)[0]
+                offset += 4
+                impedanceData.append(impedance)
+
+            for index in range(dataCount):
+                saturation = struct.unpack_from("<H", data, offset)[0]
+                offset += 2
+                saturationData.append(saturation / 10)  # firmware value range 0 - 1000
+
+            self.impedanceData = impedanceData
+            self.saturationData = saturationData
+
         elif v == DataType.NTF_EMG:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_EMG]
-            if self.checkReadSamples(sensor, data, sensor_data, 3, 0):
+            if self.checkReadSamples(sensor, data, sensor_data, sensor_data.packageIndexLength + 1, 0):
                 self.sendSensorData(sensor_data, buf)
         elif v == DataType.NTF_EEG:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_EEG]
@@ -454,16 +501,23 @@ class SensorProfileDataCtx:
         if not self._is_data_transfering:
             return False
         try:
+            packageIndex = 0
+            maxPackageIndex = 0
+            if (sensorData.packageIndexLength == 2):
+                packageIndex = ((data[offset + 1] & 0xFF) << 8) | (data[offset] & 0xFF)
+                maxPackageIndex = 65535
+            else:
+                packageIndex = (data[offset] & 0xFF)
+                maxPackageIndex = 255
 
-            packageIndex = ((data[offset + 1] & 0xFF) << 8) | (data[offset] & 0xFF)
-            offset += 2
+            offset += sensorData.packageIndexLength
             newPackageIndex = packageIndex
             lastPackageIndex = sensorData.lastPackageIndex
             if sensorData.lastPackageCounter == 0 and sensorData.lastPackageIndex == 0 and packageIndex > 1:
                 return False
 
             if packageIndex < lastPackageIndex:
-                packageIndex += 65536  # 包索引是 U16 类型
+                packageIndex += (maxPackageIndex + 1)
             elif packageIndex == lastPackageIndex:
                 return False
 
@@ -488,12 +542,14 @@ class SensorProfileDataCtx:
                     self.readSamples(data, sensorData, 0, dataGap, lostSampleCount)
 
                 if newPackageIndex == 0:
-                    sensorData.lastPackageIndex = 65535
+                    sensorData.lastPackageIndex = maxPackageIndex
                 else:
                     sensorData.lastPackageIndex = newPackageIndex - 1
                 sensorData.lastPackageCounter += deltaPackageIndex - 1
 
-            self.readSamples(data, sensorData, dataOffset, dataGap, 0)
+            if (dataGap >= 0):
+                self.readSamples(data, sensorData, dataOffset, dataGap, 0)
+
             sensorData.lastPackageIndex = newPackageIndex
             sensorData.lastPackageCounter += 1
         except Exception as e:
@@ -561,8 +617,15 @@ class SensorProfileDataCtx:
                         rawData = 0
                         if sensorData.resolutionBits == 8:
                             rawData = data[offset]
-                            rawData -= 128
+                            rawData -= 119
                             offset += 1
+                        elif sensorData.resolutionBits == 12:
+                            rawData = int.from_bytes(
+                                data[offset : offset + 2],
+                                byteorder="little",
+                                signed=True,
+                            )
+                            offset += 2
                         elif sensorData.resolutionBits == 16:
                             rawData = int.from_bytes(
                                 data[offset : offset + 2],
@@ -673,7 +736,21 @@ class SensorProfileDataCtx:
 
         while self._is_running:
             while self._is_running and self._rawDataBuffer.empty():
-                await asyncio.sleep(0.1)
+                if self._is_running and self.isDataTransfering and not buf.empty():
+                    sensorData: SensorData = None
+                    try:
+                        sensorData = buf.get_nowait()
+                    except Exception as e:
+                        break
+                    if not sensor_utils._terminated and sensorData != None and callback != None:
+                        try:
+                            asyncio.get_event_loop().run_in_executor(self.dataPool, callback, sensor, sensorData)
+                        except Exception as e:
+                            print(e)
+
+                    buf.task_done()
+                else:
+                    await asyncio.sleep(0.01)
                 continue
 
             try:
@@ -694,53 +771,39 @@ class SensorProfileDataCtx:
 
                 if self._concatDataBuffer[index] == 0x55:
                     if (index + 1) >= data_size:
-                        index += 1
+                        index = data_size
                         continue
                     n = self._concatDataBuffer[index + 1]
-                    if (index + 1 + n + 1) >= data_size:
-                        index += 1
+                    if (index + 1 + n + 2) >= data_size:
+                        index = data_size
                         continue
-                    crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = sensor_utils.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
-                    if crc != calc_crc:
+                    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])
                         self._processDataPackage(data_package, buf, sensor)
-                        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 not sensor_utils._terminated and sensorData != None and callback != None:
-                                try:
-                                    asyncio.get_event_loop().run_in_executor(self.dataPool, callback, sensor, sensorData)
-                                except Exception as e:
-                                    print(e)
-
-                            buf.task_done()
-                    last_cut = index = index + 2 + n
-
+                    last_cut = index = index + 2 + n + 1
                 elif self._concatDataBuffer[index] == 0xAA:
                     if (index + 1) >= data_size:
-                        index += 1
+                        index = data_size
                         continue
                     n = self._concatDataBuffer[index + 1]
-                    if (index + 1 + n + 1) >= data_size:
-                        index += 1
+                    if (index + 1 + n + 2) >= data_size:
+                        index = data_size
                         continue
-                    crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = sensor_utils.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
-                    if crc != calc_crc:
+                    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 not sensor_utils._terminated:
-                        self.gForce._on_cmd_response(None, data_package)
-                    last_cut = index = index + 2 + n
 
+                    if not sensor_utils._terminated:
+                        await sensor_utils.async_call(self.gForce.async_on_cmd_response(data_package), runloop=sensor._event_loop)
+                    last_cut = index = index + 2 + n + 1
                 else:
                     index += 1