sensor-sdk 0.0.18__py3-none-any.whl → 0.0.31__py3-none-any.whl

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,9 +374,19 @@ 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.responses: Dict[Command, Queue] = {}
@@ -393,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
 
@@ -402,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 = []
@@ -443,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]:
@@ -564,12 +522,18 @@ 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))
-            if response.cmd in self.responses:
+            if self.responses.get(response.cmd) != None:
                 self.responses[response.cmd].put_nowait(
                     response.data,
                 )
+            else:
+                print("invalid response:" + bytes(bs))
         except Exception as e:
             raise Exception("Failed to parse response: %s" % e)
 
@@ -750,6 +714,17 @@ class GForce:
             )
         )
 
+    async def set_function_switch(self, funcSwitch):
+        body = [0xFF & funcSwitch]
+        body = bytes(body)
+        ret = await self._send_request(
+            Request(
+                cmd=Command.SET_FUNCTION_SWITCH,
+                body=body,
+                has_res=True,
+            )
+        )
+
     async def set_firmware_filter_switch(self, switchStatus: int):
         body = [0xFF & switchStatus]
         body = bytes(body)
@@ -854,22 +829,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)
 
@@ -879,29 +852,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:
-        q = Queue()
-        self.responses[cmd] = q
-        return q
+        if self.responses.get(cmd) != None:
+            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)
 
+        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
+
         bs = bytes([req.cmd])
         if req.body is not None:
             bs += req.body
-        await asyncio.wait_for(self.client.write_gatt_char(self.cmd_char, bs), sensor_utils._TIMEOUT)
+
+        # print(str(req.cmd) + str(req.body))
+        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.responses[req.cmd] = None
             return None
 
         try:
-            return await asyncio.wait_for(q.get(), sensor_utils._TIMEOUT)
+            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.responses[req.cmd] = None
             return None

sensor/sensor_data_context.py

@@ -138,6 +138,9 @@ class SensorProfileDataCtx:
         await self.gForce.set_emg_raw_data_config(config)
 
         await self.gForce.set_package_id(True)
+
+        await self.gForce.set_function_switch(2)
+
         return data.channelCount
 
     async def initEEG(self, packageCount: int) -> int:
@@ -350,8 +353,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 +376,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 +387,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 +400,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
@@ -673,7 +677,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:
@@ -708,21 +726,7 @@ class SensorProfileDataCtx:
                     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
-
                 elif self._concatDataBuffer[index] == 0xAA:
                     if (index + 1) >= data_size:
                         index += 1
@@ -737,10 +741,10 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
+
                     if not sensor_utils._terminated:
-                        asyncio.get_event_loop().run_in_executor(None, self.gForce._on_cmd_response, None, data_package)
+                        await sensor_utils.async_call(self.gForce.async_on_cmd_response(data_package), runloop=sensor._event_loop)
                     last_cut = index = index + 2 + n
-
                 else:
                     index += 1
 

sensor/sensor_profile.py

@@ -2,6 +2,7 @@
 # 该枚举类定义了设备的各种状态，用于表示设备在不同操作阶段的状态信息
 from enum import Enum, IntEnum
 from queue import Queue
+import threading
 import time
 from typing import Callable, Optional
 
@@ -60,7 +61,11 @@ class SensorProfile:
         self._data_ctx: SensorProfileDataCtx = None
         self._gforce: GForce = None
         self._data_event_loop: asyncio.AbstractEventLoop = None
+        self._data_event_thread: threading.Thread = None
+        self._gforce_event_loop: asyncio.AbstractEventLoop = None
+        self._gforce_event_thread: threading.Thread = None
         self._event_loop: asyncio.AbstractEventLoop = None
+        self._event_thread: threading.Thread = None
         self._is_starting = False
         self._is_setting_param = False
 
@@ -89,6 +94,17 @@ class SensorProfile:
             except Exception as e:
                 pass
 
+        if self._gforce_event_loop != None:
+            try:
+                self._gforce_event_loop.stop()
+                self._gforce_event_loop.close()
+                self._gforce_event_loop = None
+            except Exception as e:
+                pass
+
+        self._is_starting = False
+        self._is_setting_param = False
+
     @property
     def deviceState(self) -> DeviceStateEx:
         """
@@ -211,14 +227,13 @@ class SensorProfile:
         """
         self._on_power_changed = callback
 
-    async def _connect(self) -> bool:
-        if sensor_utils._terminated:
-            return False
+    async def _initGforce(self):
 
-        if self._event_loop == None:
-            self._event_loop = asyncio.new_event_loop()
-            self._data_buffer: Queue[SensorData] = Queue()
-            self._raw_data_buf: Queue[bytes] = Queue()
+        self._gforce_event_loop = asyncio.new_event_loop()
+        self._gforce_event_thread = threading.Thread(target=sensor_utils.start_loop, args=(self._gforce_event_loop,))
+        self._gforce_event_thread.daemon = True
+        self._gforce_event_thread.name = self._detail_device.name + "data event"
+        self._gforce_event_thread.start()
 
         if self._gforce == None:
             if self._adv.service_data.get(SERVICE_GUID) != None:
@@ -228,30 +243,57 @@ class SensorProfile:
                     OYM_CMD_NOTIFY_CHAR_UUID,
                     OYM_DATA_NOTIFY_CHAR_UUID,
                     False,
+                    self._event_loop,
+                    self._gforce_event_loop,
                 )
             elif self._adv.service_data.get(RFSTAR_SERVICE_GUID) != None:
                 # print("RFSTAR_SERVICE:" + self._detail_device.name)
-                self._gforce = GForce(self._detail_device, RFSTAR_CMD_UUID, RFSTAR_DATA_UUID, True)
-                self._data_event_loop = asyncio.new_event_loop()
+                self._gforce = GForce(
+                    self._detail_device, RFSTAR_CMD_UUID, RFSTAR_DATA_UUID, True, self._event_loop, self._gforce_event_loop
+                )
+
             else:
                 print("Invalid device service uuid:" + self._detail_device.name + str(self._adv))
                 return False
 
+        self._data_event_loop = asyncio.new_event_loop()
+        self._data_event_thread = threading.Thread(target=sensor_utils.start_loop, args=(self._data_event_loop,))
+        self._data_event_thread.daemon = True
+        self._data_event_thread.name = self._detail_device.name + "data event"
+        self._data_event_thread.start()
+
         if self._data_ctx == None and self._gforce != None:
             self._data_ctx = SensorProfileDataCtx(self._gforce, self._device.Address, self._raw_data_buf)
         if self._data_ctx.isUniversalStream:
-            async_exec(self._process_universal_data())
+            async_exec(self._process_universal_data(), self._data_event_loop)
         else:
-            async_exec(self._process_data())
+            async_exec(self._process_data(), self._data_event_loop)
+
+    async def _connect(self) -> bool:
+        if sensor_utils._terminated:
+            return False
+
+        if self._event_loop == None:
+            self._event_loop = asyncio.new_event_loop()
+            self._event_thread = threading.Thread(target=sensor_utils.start_loop, args=(self._event_loop,))
+            self._event_thread.daemon = True
+            self._event_thread.name = self._detail_device.name + "event"
+            self._event_thread.start()
+
+            self._data_buffer: Queue[SensorData] = Queue()
+            self._raw_data_buf: Queue[bytes] = Queue()
 
         if self.deviceState == DeviceStateEx.Connected or self.deviceState == DeviceStateEx.Ready:
             return True
+
         self._set_device_state(DeviceStateEx.Connecting)
 
+        await async_call(self._initGforce(), runloop=self._event_loop)
+
         def handle_disconnect(_: BleakClient):
             if self._data_ctx != None:
                 self._data_ctx.close()
-                time.sleep(1)
+                time.sleep(0.2)
                 self._data_buffer.queue.clear()
                 self._data_ctx = None
                 self._gforce = None
@@ -293,7 +335,7 @@ class SensorProfile:
 
     async def _waitForDisconnect(self) -> bool:
         while not sensor_utils._terminated and self.deviceState != DeviceStateEx.Disconnected:
-            await asyncio.sleep(1)
+            await asyncio.sleep(0.1)
         return True
 
     async def _disconnect(self) -> bool:
@@ -330,6 +372,7 @@ class SensorProfile:
 
     async def _process_universal_data(self):
         await self._data_ctx.processUniversalData(self._data_buffer, self, self._on_data_callback)
+        print("finished")
 
     async def _startDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -342,16 +385,12 @@ class SensorProfile:
         if self._data_ctx.isDataTransfering:
             return True
 
-        if self._data_event_loop == None:
-            self._data_event_loop = asyncio.new_event_loop()
-
         self._raw_data_buf.queue.clear()
         self._data_buffer.queue.clear()
 
-        result = await self._data_ctx.start_streaming()
+        result = await async_call(self._data_ctx.start_streaming(), runloop=None)
         await asyncio.sleep(0.2)
 
-        self._is_starting = False
         return result
 
     def startDataNotification(self) -> bool:
@@ -364,8 +403,14 @@ class SensorProfile:
         if self._is_starting:
             return False
 
-        self._is_starting = True
-        return sync_call(self._startDataNotification())
+        try:
+            self._is_starting = True
+            ret = sync_call(self._startDataNotification())
+            self._is_starting = False
+            return ret
+        except Exception as e:
+            self._is_starting = False
+            print(e)
 
     async def asyncStartDataNotification(self) -> bool:
         """
@@ -377,8 +422,14 @@ class SensorProfile:
         if self._is_starting:
             return False
 
-        self._is_starting = True
-        return await async_call(self._startDataNotification())
+        try:
+            self._is_starting = True
+            ret = await async_call(self._startDataNotification())
+            self._is_starting = False
+            return ret
+        except Exception as e:
+            self._is_starting = False
+            print(e)
 
     async def _stopDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -391,8 +442,7 @@ class SensorProfile:
         if not self._data_ctx.isDataTransfering:
             return True
 
-        result = await self._data_ctx.stop_streaming()
-        self._is_starting = False
+        result = await async_call(self._data_ctx.stop_streaming(), runloop=None)
         return result
 
     def stopDataNotification(self) -> bool:
@@ -405,8 +455,14 @@ class SensorProfile:
         if self._is_starting:
             return False
 
-        self._is_starting = True
-        return sync_call(self._stopDataNotification())
+        try:
+            self._is_starting = True
+            ret = sync_call(self._stopDataNotification())
+            self._is_starting = False
+            return ret
+        except Exception as e:
+            self._is_starting = False
+            print(e)
 
     async def asyncStopDataNotification(self) -> bool:
         """
@@ -418,8 +474,14 @@ class SensorProfile:
         if self._is_starting:
             return False
 
-        self._is_starting = True
-        return await async_call(self._stopDataNotification())
+        try:
+            self._is_starting = True
+            ret = await async_call(self._stopDataNotification())
+            self._is_starting = False
+            return ret
+        except Exception as e:
+            self._is_starting = False
+            print(e)
 
     async def _refresh_power(self):
         while not sensor_utils._terminated and self.deviceState == DeviceStateEx.Ready:
@@ -443,6 +505,7 @@ class SensorProfile:
 
         if await self._data_ctx.init(packageSampleCount):
             self._power_interval = powerRefreshInterval
+            self._power = await self._gforce.get_battery_level()
             sensor_utils.async_exec(self._refresh_power())
 
         return self._data_ctx.hasInit()
@@ -477,6 +540,23 @@ class SensorProfile:
             20,
         )
 
+    async def _asyncGetBatteryLevel(self) -> int:
+        if self.deviceState != DeviceStateEx.Ready:
+            return -1
+        if self._data_ctx == None:
+            return -1
+        self._power = await self._gforce.get_battery_level()
+        return self._power
+
+    async def asyncGetBatteryLevel(self) -> int:
+        """
+        获取传感器的电池电量。
+
+        :return:            int: 传感器的电池电量。 正常0-100，-1为未知。
+
+        """
+        return await async_call(self._asyncGetBatteryLevel())
+
     def getBatteryLevel(self) -> int:
         """
         获取传感器的电池电量。
@@ -509,23 +589,11 @@ class SensorProfile:
 
         if key in ["FILTER_50Hz", "FILTER_60Hz", "FILTER_HPF", "FILTER_LPF"]:
             if value in ["ON", "OFF"]:
-                needPauseTransfer = self.isDataTransfering
-                if needPauseTransfer:
-                    if self._is_starting:
-                        self._is_setting_param = False
-                        return "Error: Please pause data transfer first"
-
-                    self._is_starting = True
-                    await self._stopDataNotification()
                 result = await self._data_ctx.setFilter(key, value)
-                if needPauseTransfer:
-                    self._is_starting = True
-                    await self._startDataNotification()
 
         if key == "DEBUG_BLE_DATA_PATH":
             result = await self._data_ctx.setDebugCSV(value)
 
-        self._is_setting_param = False
         return result
 
     def setParam(self, key: str, value: str) -> str:
@@ -541,11 +609,17 @@ class SensorProfile:
         if self._is_setting_param:
             return "Error: Please wait for the previous operation to complete"
 
-        self._is_setting_param = True
-        return sync_call(
-            self._setParam(key, value),
-            20,
-        )
+        try:
+            self._is_setting_param = True
+            ret = sync_call(
+                self._setParam(key, value),
+                1,
+            )
+            self._is_setting_param = False
+            return ret
+        except Exception as e:
+            self._is_setting_param = False
+            print(e)
 
     async def asyncSetParam(self, key: str, value: str) -> str:
         """
@@ -560,8 +634,14 @@ class SensorProfile:
         if self._is_setting_param:
             return "Error: Please wait for the previous operation to complete"
 
-        self._is_setting_param = True
-        return await async_call(
-            self._setParam(key, value),
-            20,
-        )
+        try:
+            self._is_setting_param = True
+            ret = await async_call(
+                self._setParam(key, value),
+                1,
+            )
+            self._is_setting_param = False
+            return ret
+        except Exception as e:
+            self._is_setting_param = False
+            print(e)

sensor/sensor_utils.py

@@ -15,7 +15,7 @@ _needCloseRunloop = False
 
 def checkRunLoop():
     global _runloop, _needCloseRunloop, _event_thread
-    if _runloop == None:
+    if _runloop == None or not _runloop.is_running():
         try:
             _runloop = asyncio.get_running_loop()
         except Exception as e:
@@ -45,11 +45,13 @@ def Terminate():
             pass
 
 
-def async_exec(function):
+def async_exec(function, runloop=None):
     checkRunLoop()
+    if runloop == None:
+        runloop = _runloop
     task: asyncio.Future = None
     try:
-        task = asyncio.run_coroutine_threadsafe(function, _runloop)
+        task = asyncio.run_coroutine_threadsafe(function, runloop)
         running_tasks.add(task)
         task.add_done_callback(lambda t: running_tasks.remove(t))
     except Exception as e:
@@ -57,11 +59,13 @@ def async_exec(function):
         pass
 
 
-def sync_call(function, _timeout=_TIMEOUT) -> any:
+def sync_call(function, _timeout=_TIMEOUT, runloop=None) -> any:
     checkRunLoop()
     task: asyncio.Future = None
+    if runloop == None:
+        runloop = _runloop
     try:
-        task = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _runloop)
+        task = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), runloop)
         running_tasks.add(task)
         task.add_done_callback(lambda t: running_tasks.remove(t))
         return task.result(timeout=_timeout)
@@ -70,11 +74,13 @@ def sync_call(function, _timeout=_TIMEOUT) -> any:
         pass
 
 
-async def async_call(function, _timeout=_TIMEOUT) -> any:
+async def async_call(function, _timeout=_TIMEOUT, runloop=None) -> any:
     checkRunLoop()
     task: asyncio.Future = None
+    if runloop == None:
+        runloop = _runloop
     try:
-        task = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), _runloop)
+        task = asyncio.run_coroutine_threadsafe(asyncio.wait_for(function, _timeout), runloop)
         running_tasks.add(task)
         task.add_done_callback(lambda t: running_tasks.remove(t))
     except Exception as e:

{sensor_sdk-0.0.18.dist-info → sensor_sdk-0.0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.0.18
+Version: 0.0.31
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye
@@ -11,6 +11,15 @@ 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
 

sensor_sdk-0.0.31.dist-info/RECORD

@@ -0,0 +1,14 @@
+sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
+sensor/gforce.py,sha256=k6nHsNV_IM8ymGYrZXXD3oHC5Ed0qODlvk8W6dhtMMk,26291
+sensor/sensor_controller.py,sha256=cjVOcGaU9_8_eWFamtOpXsqSZMzD7lGU24gC_rsm2FQ,9546
+sensor/sensor_data.py,sha256=vKreLHZs7WbQcnfqHiLLfHQ3cCmvD1K2xl2WUQg8vv0,4005
+sensor/sensor_data_context.py,sha256=YGDEbUYElHE8PZLQIcCR08N8Jk3j5UNH2odo43nmba8,30856
+sensor/sensor_device.py,sha256=eO1vaqjxCc2UCPBoKXqlk6o498uRyWt6IYs7r7wXSD0,3042
+sensor/sensor_profile.py,sha256=KDmOQjBM_diG5PDVth9s1ALN-Sd4Y_zpEVkDjW-khSk,22654
+sensor/sensor_utils.py,sha256=7JIZF6uhOcHuAPXwwrQi5FwGU5BVLc6Aml-n9QXzupM,6998
+sensor_sdk-0.0.31.dist-info/licenses/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
+sensor_sdk-0.0.31.dist-info/METADATA,sha256=Y25zWQWh_rF42spGr1eZf9DDQtQ_fS33vxJNYfHReTQ,10029
+sensor_sdk-0.0.31.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+sensor_sdk-0.0.31.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
+sensor_sdk-0.0.31.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+sensor_sdk-0.0.31.dist-info/RECORD,,

{sensor_sdk-0.0.18.dist-info → sensor_sdk-0.0.31.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

sensor_sdk-0.0.18.dist-info/RECORD

@@ -1,14 +0,0 @@
-sensor/__init__.py,sha256=L1VyAP0EDEnJIMeMTzp4iXHSRUUHyHScF_GIl3iYKRI,123
-sensor/gforce.py,sha256=aWE4qFSnr5fLqsXE0uNg4t-sp0QVNreKQIEfjk2vVgs,26148
-sensor/sensor_controller.py,sha256=cjVOcGaU9_8_eWFamtOpXsqSZMzD7lGU24gC_rsm2FQ,9546
-sensor/sensor_data.py,sha256=vKreLHZs7WbQcnfqHiLLfHQ3cCmvD1K2xl2WUQg8vv0,4005
-sensor/sensor_data_context.py,sha256=5I8AZ6e-qlnCLRydbW9MXLJTpNpI0uzPLqflVFzpVeA,30878
-sensor/sensor_device.py,sha256=eO1vaqjxCc2UCPBoKXqlk6o498uRyWt6IYs7r7wXSD0,3042
-sensor/sensor_profile.py,sha256=xe9QT3_lbrwS8pcVUVvVQavXZrRFKLl4Dj9eUs5hsFk,19747
-sensor/sensor_utils.py,sha256=TkAY6tv3hWEsTbMipI7DCelVYZUpRuILLQ-b2IxFIC4,6771
-sensor_sdk-0.0.18.dist-info/LICENSE.txt,sha256=8CSivOpub3IuXODTyqBRI91AxouJZk02YrcKuOAkWu8,1111
-sensor_sdk-0.0.18.dist-info/METADATA,sha256=JYfyaSXzq8L1C9xbsZk66ny4sDFl2ut7Ed6gG8LaiI8,9821
-sensor_sdk-0.0.18.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-sensor_sdk-0.0.18.dist-info/top_level.txt,sha256=Ftq49B6bH0Ffdc7c8LkcyakHo6lsg_snlBbpEUoILSk,7
-sensor_sdk-0.0.18.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-sensor_sdk-0.0.18.dist-info/RECORD,,