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

{sensor_sdk-0.1.2 → sensor_sdk-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.1.2
+Version: 0.1.5
 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.5/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.2 → sensor_sdk-0.1.5}/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
 
 
@@ -69,6 +70,7 @@ class BleakHost:
         try:
             self._cmd_queue.close()
             self._result_queue.close()
+            self._data_queue.close()
         except Exception as e:
             SdkLog.exception(_TAG, "Error closing queues")
 
@@ -125,38 +127,68 @@ class BleakHost:
 
     async def _consume_results(self):
 
+        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.1
+                    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.2 → sensor_sdk-0.1.5}/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.
@@ -845,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:

sensor_sdk-0.1.5/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.5/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()

sensor_sdk-0.1.5/sensor/fb/SensorData.py

@@ -0,0 +1,296 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: fb
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# SensorData 统一数据表
+# samples 为一维扁平数组，按通道顺序存放；samples_per_channel 记录每个通道的 sample 数量。
+class SensorData(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SensorData()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSensorData(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    # SensorData
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SensorData
+    def DeviceMac(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # SensorData
+    def DataType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def LastPackageCounter(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def LastPackageIndex(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def LostPackageCount(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def ResolutionBits(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def ResolutionSigned(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def SampleRate(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # SensorData
+    def ChannelCount(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def ChannelMask(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def MinPackageSampleCount(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def PackageSampleCount(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def PackageIndexLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # SensorData
+    def K(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # SensorData
+    def Samples(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 32
+            from sensor.fb.Sample import Sample
+            obj = Sample()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # SensorData
+    def SamplesLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SensorData
+    def SamplesIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        return o == 0
+
+    # SensorData
+    def SamplesPerChannel(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # SensorData
+    def SamplesPerChannelAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # SensorData
+    def SamplesPerChannelLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SensorData
+    def SamplesPerChannelIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        return o == 0
+
+def SensorDataStart(builder):
+    builder.StartObject(16)
+
+def Start(builder):
+    SensorDataStart(builder)
+
+def SensorDataAddDeviceMac(builder, deviceMac):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(deviceMac), 0)
+
+def AddDeviceMac(builder, deviceMac):
+    SensorDataAddDeviceMac(builder, deviceMac)
+
+def SensorDataAddDataType(builder, dataType):
+    builder.PrependUint8Slot(1, dataType, 0)
+
+def AddDataType(builder, dataType):
+    SensorDataAddDataType(builder, dataType)
+
+def SensorDataAddLastPackageCounter(builder, lastPackageCounter):
+    builder.PrependInt32Slot(2, lastPackageCounter, 0)
+
+def AddLastPackageCounter(builder, lastPackageCounter):
+    SensorDataAddLastPackageCounter(builder, lastPackageCounter)
+
+def SensorDataAddLastPackageIndex(builder, lastPackageIndex):
+    builder.PrependInt32Slot(3, lastPackageIndex, 0)
+
+def AddLastPackageIndex(builder, lastPackageIndex):
+    SensorDataAddLastPackageIndex(builder, lastPackageIndex)
+
+def SensorDataAddLostPackageCount(builder, lostPackageCount):
+    builder.PrependInt32Slot(4, lostPackageCount, 0)
+
+def AddLostPackageCount(builder, lostPackageCount):
+    SensorDataAddLostPackageCount(builder, lostPackageCount)
+
+def SensorDataAddResolutionBits(builder, resolutionBits):
+    builder.PrependInt32Slot(5, resolutionBits, 0)
+
+def AddResolutionBits(builder, resolutionBits):
+    SensorDataAddResolutionBits(builder, resolutionBits)
+
+def SensorDataAddResolutionSigned(builder, resolutionSigned):
+    builder.PrependInt32Slot(6, resolutionSigned, 0)
+
+def AddResolutionSigned(builder, resolutionSigned):
+    SensorDataAddResolutionSigned(builder, resolutionSigned)
+
+def SensorDataAddSampleRate(builder, sampleRate):
+    builder.PrependFloat32Slot(7, sampleRate, 0.0)
+
+def AddSampleRate(builder, sampleRate):
+    SensorDataAddSampleRate(builder, sampleRate)
+
+def SensorDataAddChannelCount(builder, channelCount):
+    builder.PrependInt32Slot(8, channelCount, 0)
+
+def AddChannelCount(builder, channelCount):
+    SensorDataAddChannelCount(builder, channelCount)
+
+def SensorDataAddChannelMask(builder, channelMask):
+    builder.PrependUint64Slot(9, channelMask, 0)
+
+def AddChannelMask(builder, channelMask):
+    SensorDataAddChannelMask(builder, channelMask)
+
+def SensorDataAddMinPackageSampleCount(builder, minPackageSampleCount):
+    builder.PrependInt32Slot(10, minPackageSampleCount, 0)
+
+def AddMinPackageSampleCount(builder, minPackageSampleCount):
+    SensorDataAddMinPackageSampleCount(builder, minPackageSampleCount)
+
+def SensorDataAddPackageSampleCount(builder, packageSampleCount):
+    builder.PrependInt32Slot(11, packageSampleCount, 0)
+
+def AddPackageSampleCount(builder, packageSampleCount):
+    SensorDataAddPackageSampleCount(builder, packageSampleCount)
+
+def SensorDataAddPackageIndexLength(builder, packageIndexLength):
+    builder.PrependInt32Slot(12, packageIndexLength, 0)
+
+def AddPackageIndexLength(builder, packageIndexLength):
+    SensorDataAddPackageIndexLength(builder, packageIndexLength)
+
+def SensorDataAddK(builder, k):
+    builder.PrependFloat64Slot(13, k, 0.0)
+
+def AddK(builder, k):
+    SensorDataAddK(builder, k)
+
+def SensorDataAddSamples(builder, samples):
+    builder.PrependUOffsetTRelativeSlot(14, flatbuffers.number_types.UOffsetTFlags.py_type(samples), 0)
+
+def AddSamples(builder, samples):
+    SensorDataAddSamples(builder, samples)
+
+def SensorDataStartSamplesVector(builder, numElems):
+    return builder.StartVector(32, numElems, 4)
+
+def StartSamplesVector(builder, numElems):
+    return SensorDataStartSamplesVector(builder, numElems)
+
+def SensorDataAddSamplesPerChannel(builder, samplesPerChannel):
+    builder.PrependUOffsetTRelativeSlot(15, flatbuffers.number_types.UOffsetTFlags.py_type(samplesPerChannel), 0)
+
+def AddSamplesPerChannel(builder, samplesPerChannel):
+    SensorDataAddSamplesPerChannel(builder, samplesPerChannel)
+
+def SensorDataStartSamplesPerChannelVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartSamplesPerChannelVector(builder, numElems):
+    return SensorDataStartSamplesPerChannelVector(builder, numElems)
+
+def SensorDataEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return SensorDataEnd(builder)

{sensor_sdk-0.1.2 → sensor_sdk-0.1.5}/sensor/gforce.py

@@ -680,7 +680,13 @@ class GForce:
                 has_res=True,
             )
         )
-        return buf.decode("utf-8")
+        # 硬件版本定义：temp[2]=SYS_HARDWARE_REV_ADDR, temp[3]=SYS_HARDWARE_TYPE_ADDR
+        # 响应数据中前两个字节分别为硬件版本号和硬件类型
+        if len(buf) >= 2:
+            return f"{buf[0]}.{buf[1]}"
+        if len(buf) == 1:
+            return str(buf[0])
+        return "0"
 
     async def get_model_number(self) -> str:
         buf = await self._send_request(
@@ -727,6 +733,8 @@ class GForce:
                 has_res=True,
             )
         )
+        if buf is None or len(buf) == 0:
+            return -1
         return int.from_bytes(buf, byteorder="big")
 
     async def get_temperature(self) -> int:
@@ -736,6 +744,8 @@ class GForce:
                 has_res=True,
             )
         )
+        if buf is None or len(buf) == 0:
+            return -1
         return int.from_bytes(buf, byteorder="big")
 
     async def power_off(self) -> None: