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

{sensor-sdk-0.0.6/sensor_sdk.egg-info → sensor_sdk-0.0.33}/PKG-INFO

@@ -1,13 +1,25 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: sensor-sdk
-Version: 0.0.6
+Version: 0.0.33
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye
 Author-email: yecq_82@hotmail.com
-Requires-Python: >=3.8.0
+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
 
@@ -92,10 +104,10 @@ isScanning = SensorControllerInstance.isScanning
 
 ### 5. Check if bluetooth is enabled
 
-Use `property isEnabled: bool` to check if bluetooth is enabled
+Use `property isEnable: bool` to check if bluetooth is enable
 
 ```python
-isEnabled = SensorControllerInstance.isEnabled
+isEnable = SensorControllerInstance.isEnable
 ```
 
 ### 6. Create SensorProfile
@@ -347,8 +359,47 @@ batteryPower = sensorProfile.getBatteryLevel()
 
 Please check console.py in examples directory
 
-## Async methods
+### Async methods
 
 all methods start with async is async methods, they has same params and return result as sync methods.
 
 Please check async_console.py in examples directory
+
+### setParam method
+
+Use `def setParam(self, key: str, value: str) -> str` to set parameter of sensor profile. Please call after device in 'Ready' state.
+
+Below is available key and value:
+
+```python
+result = sensorProfile.setParam("NTF_EMG", "ON")
+# set EMG data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_EEG", "ON")
+# set EEG data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_ECG", "ON")
+# set ECG data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_IMU", "ON")
+# set IMU data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_BRTH", "ON")
+# set BRTH data to ON or OFF, result is "OK" if succeed
+
+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")
+# set 60Hz notch filter to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("FILTER_HPF", "ON")
+# set 0.5Hz hpf filter to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("FILTER_LPF", "ON")
+# set 80Hz lpf filter to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("DEBUG_BLE_DATA_PATH", "d:/temp/test.csv")
+# set debug ble data path, result is "OK" if succeed
+# please give an absolute path and make sure it is valid and writeable by yourself
+```

sensor-sdk-0.0.6/PKG-INFO → sensor_sdk-0.0.33/README.md

@@ -1,14 +1,3 @@
-Metadata-Version: 2.1
-Name: sensor-sdk
-Version: 0.0.6
-Summary: Python sdk for Synchroni
-Home-page: https://github.com/oymotion/SynchroniSDKPython
-Author: Martin Ye
-Author-email: yecq_82@hotmail.com
-Requires-Python: >=3.8.0
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-
 # sensor-sdk
 
 Synchroni sdk for Python
@@ -92,10 +81,10 @@ isScanning = SensorControllerInstance.isScanning
 
 ### 5. Check if bluetooth is enabled
 
-Use `property isEnabled: bool` to check if bluetooth is enabled
+Use `property isEnable: bool` to check if bluetooth is enable
 
 ```python
-isEnabled = SensorControllerInstance.isEnabled
+isEnable = SensorControllerInstance.isEnable
 ```
 
 ### 6. Create SensorProfile
@@ -347,8 +336,47 @@ batteryPower = sensorProfile.getBatteryLevel()
 
 Please check console.py in examples directory
 
-## Async methods
+### Async methods
 
 all methods start with async is async methods, they has same params and return result as sync methods.
 
 Please check async_console.py in examples directory
+
+### setParam method
+
+Use `def setParam(self, key: str, value: str) -> str` to set parameter of sensor profile. Please call after device in 'Ready' state.
+
+Below is available key and value:
+
+```python
+result = sensorProfile.setParam("NTF_EMG", "ON")
+# set EMG data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_EEG", "ON")
+# set EEG data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_ECG", "ON")
+# set ECG data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_IMU", "ON")
+# set IMU data to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("NTF_BRTH", "ON")
+# set BRTH data to ON or OFF, result is "OK" if succeed
+
+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")
+# set 60Hz notch filter to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("FILTER_HPF", "ON")
+# set 0.5Hz hpf filter to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("FILTER_LPF", "ON")
+# set 80Hz lpf filter to ON or OFF, result is "OK" if succeed
+
+result = sensorProfile.setParam("DEBUG_BLE_DATA_PATH", "d:/temp/test.csv")
+# set debug ble data path, result is "OK" if succeed
+# please give an absolute path and make sure it is valid and writeable by yourself
+```

{sensor-sdk-0.0.6 → 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
@@ -16,7 +17,7 @@ from bleak import (
     BleakGATTCharacteristic,
 )
 
-from sensor import utils
+from sensor import sensor_utils
 
 
 @dataclass
@@ -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,)
@@ -103,6 +105,8 @@ class Command(IntEnum):
     CMD_GET_BLE_MTU_INFO = (0xAE,)
     CMD_GET_BRT_CONFIG = (0xB3,)
 
+    CMD_SET_FRIMWARE_FILTER_SWITCH = (0xAA,)
+    CMD_GET_FRIMWARE_FILTER_SWITCH = (0xA9,)
     # Partial command packet, format: [CMD_PARTIAL_DATA, packet number in reverse order, packet content]
     MD_PARTIAL_DATA = 0xFF
 
@@ -371,10 +375,18 @@ class Response:
 
 class GForce:
     def __init__(
-        self, device: BLEDevice, cmd_char: str, data_char: str, isUniversalStream: bool
+        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,25 +405,33 @@ class GForce:
         self._raw_data_buf = buf
 
         try:
-            await asyncio.wait_for(client.connect(), utils._TIMEOUT)
+            await sensor_utils.async_call(client.connect(), sensor_utils._TIMEOUT, self.gforce_event_loop)
         except Exception as e:
             return
 
         if not client.is_connected:
             return
-        if not self._is_universal_stream:
-            await asyncio.wait_for(
-                client.start_notify(self.cmd_char, self._on_cmd_response),
-                utils._TIMEOUT,
-            )
-        else:
-            await asyncio.wait_for(
-                client.start_notify(self.data_char, self._on_universal_response),
-                utils._TIMEOUT,
-            )
 
-    def _on_data_response(self, q: Queue[bytes], bs: bytearray):
+        try:
+            if not self._is_universal_stream:
+                await sensor_utils.async_call(
+                    client.start_notify(self.cmd_char, self._on_cmd_response),
+                    sensor_utils._TIMEOUT,
+                    self.gforce_event_loop,
+                )
+
+            else:
+                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.Queue[bytes], bs: bytearray):
         bs = bytes(bs)
+
         full_packet = []
 
         is_partial_data = bs[0] == ResponseCode.PARTIAL_PACKET
@@ -438,71 +458,12 @@ 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]:
         normalizing_factor = 65536.0
 
-        acceleration_data = (
-            np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
-        )
+        acceleration_data = np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
         num_channels = 3
 
         return acceleration_data.reshape(-1, num_channels)
@@ -511,9 +472,7 @@ class GForce:
     def _convert_gyro_to_dps(data: bytes) -> np.ndarray[np.float32]:
         normalizing_factor = 65536.0
 
-        gyro_data = (
-            np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
-        )
+        gyro_data = np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
         num_channels = 3
 
         return gyro_data.reshape(-1, num_channels)
@@ -522,9 +481,7 @@ class GForce:
     def _convert_magnetometer_to_ut(data: bytes) -> np.ndarray[np.float32]:
         normalizing_factor = 65536.0
 
-        magnetometer_data = (
-            np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
-        )
+        magnetometer_data = np.frombuffer(data, dtype=np.int32).astype(np.float32) / normalizing_factor
         num_channels = 3
 
         return magnetometer_data.reshape(-1, num_channels)
@@ -565,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)
 
@@ -729,6 +692,17 @@ class GForce:
             )
         )
 
+    async def set_package_id(self, switchStatus):
+        body = [switchStatus == True]
+        body = bytes(body)
+        ret = await self._send_request(
+            Request(
+                cmd=Command.PACKAGE_ID_CONTROL,
+                body=body,
+                has_res=True,
+            )
+        )
+
     async def set_log_level(self, logLevel):
         body = [0xFF & logLevel]
         body = bytes(body)
@@ -740,9 +714,32 @@ 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)
+        await self._send_request(Request(cmd=Command.CMD_SET_FRIMWARE_FILTER_SWITCH, body=body, has_res=True))
+
+    async def get_firmware_filter_switch(self):
+        buf = await self._send_request(Request(cmd=Command.CMD_GET_FRIMWARE_FILTER_SWITCH, has_res=True))
+        return buf[0]
+
     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,
@@ -750,7 +747,7 @@ class GForce:
             )
         )
 
-        # print('_send_request returned:', ret)
+        # print('set_emg_raw_data_config returned:', ret)
 
         self.resolution = cfg.resolution
 
@@ -835,26 +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),
             ),
-            utils._TIMEOUT,
+            sensor_utils._TIMEOUT,
+            self.gforce_event_loop,
         )
 
     async def stop_streaming(self):
         exceptions = []
+
         try:
-            await asyncio.wait_for(
-                self.set_subscription(DataSubscription.OFF), utils._TIMEOUT
-            )
-        except Exception as e:
-            exceptions.append(e)
-        try:
-            await asyncio.wait_for(
-                self.client.stop_notify(self.data_char), 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)
 
@@ -864,28 +855,62 @@ class GForce:
     async def disconnect(self):
         with suppress(asyncio.CancelledError):
             try:
-                await asyncio.wait_for(self.client.disconnect(), 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), 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
 
-        return await asyncio.wait_for(q.get(), utils._TIMEOUT)
+        try:
+            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-sdk-0.0.6 → sensor_sdk-0.0.33}/sensor/sensor_controller.py

@@ -1,3 +1,4 @@
+import asyncio
 from concurrent.futures import ThreadPoolExecutor
 import threading
 from typing import Callable, Dict, List, Optional, Tuple
@@ -5,11 +6,10 @@ from typing import Callable, Dict, List, Optional, Tuple
 import bleak
 
 from sensor import sensor_profile
-from sensor import utils
+from sensor import sensor_utils
 from sensor.sensor_profile import DeviceStateEx, SensorProfile
-import asyncio
 
-from sensor.utils import async_call, start_loop, sync_call, async_exec, timer
+from sensor.sensor_utils import async_call, sync_call, async_exec
 from bleak import (
     BleakScanner,
     AdvertisementData,
@@ -27,6 +27,7 @@ class SensorController:
             with SensorController._instance_lock:
                 if not hasattr(SensorController, "_instance"):
                     SensorController._instance = object.__new__(cls)
+
         return SensorController._instance
 
     """
@@ -37,21 +38,8 @@ class SensorController:
         """
         初始化 SensorController 实例。
         """
-        self._event_loop = asyncio.new_event_loop()
-        self._event_thread = threading.Thread(target=start_loop, args=(self._event_loop,))
-        self._event_thread.daemon = True
-        self._event_thread.name = "SensorController event"
-        self._event_thread.start()
-        self._gforce_event_loop = asyncio.new_event_loop()
-        self._gforce_event_thread = threading.Thread(target=start_loop, args=(self._gforce_event_loop,))
-        self._gforce_event_thread.daemon = True
-        self._gforce_event_thread.name = "BLE operation"
-        self._gforce_event_thread.start()
-        self._scanner = BleakScanner(
-            detection_callback=self._match_device,
-            service_uuids=[SERVICE_GUID, RFSTAR_SERVICE_GUID],
-        )
         self._is_scanning = False
+        self._scanner: BleakScanner = None
         self._device_callback: Callable[[List[sensor_profile.BLEDevice]], None] = None
         self._device_callback_period = 0
         self._enable_callback: Callable[[bool], None] = None
@@ -62,15 +50,16 @@ class SensorController:
         反初始化 SensorController 类的实例。
 
         """
-        self._event_loop.close()
-        self._gforce_event_loop.close()
 
     def terminate(self):
-        utils._terminated = True
+        sensor_utils._terminated = True
+
         for sensor in self._sensor_profiles.values():
             if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
                 sensor._destroy()
 
+        sensor_utils.Terminate()
+
     def _match_device(self, _device: bleak.BLEDevice, adv: AdvertisementData):
         if _device.name == None:
             return False
@@ -82,7 +71,7 @@ class SensorController:
         return False
 
     @property
-    def isScaning(self) -> bool:
+    def isScanning(self) -> bool:
         """
         检查是否正在扫描。
 
@@ -150,15 +139,23 @@ class SensorController:
                 if deviceMap.get(mac) != None:
                     devices.append(self._sensor_profiles[mac].BLEDevice)
                 else:
-                    newSensor = SensorProfile(device, adv, mac, self._gforce_event_loop)
+                    newSensor = SensorProfile(device, adv, mac)
                     deviceMap[mac] = newSensor
                     devices.append(newSensor.BLEDevice)
 
         self._sensor_profiles = deviceMap
         return devices
 
+    def _init_scan(self):
+        if self._scanner == None:
+            self._scanner = BleakScanner(
+                detection_callback=self._match_device,
+                service_uuids=[SERVICE_GUID, RFSTAR_SERVICE_GUID],
+            )
+
     async def _async_scan(self, period):
         self._is_scanning = True
+        self._init_scan()
         found_devices = await self._scanner.discover(timeout=period / 1000, return_adv=True)
         self._is_scanning = False
         return self._process_ble_devices(found_devices)
@@ -171,7 +168,7 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return sync_call(self._gforce_event_loop, self._async_scan(period))
+        return sync_call(self._async_scan(period))
 
     async def asyncScan(self, period) -> List[sensor_profile.BLEDevice]:
         """
@@ -181,22 +178,23 @@ class SensorController:
 
         :return:           List[sensor_profile.BLEDevice]： BLEDevice列表
         """
-        return await async_call(self._gforce_event_loop, self._async_scan(period))
+        return await async_call(self._async_scan(period))
 
     async def _device_scan_callback(self, devices: List[sensor_profile.BLEDevice]):
-        if self._device_callback:
+        if not sensor_utils._terminated and self._device_callback:
             try:
-                self._device_callback(devices)
+                asyncio.get_event_loop().run_in_executor(None, self._device_callback, devices)
             except Exception as e:
                 print(e)
 
-        if self._is_scanning:
-            async_exec(self._gforce_event_loop, self._startScan())
+        if not sensor_utils._terminated and self._is_scanning:
+            async_exec(self._startScan())
 
     async def _startScan(self) -> bool:
+        self._init_scan()
         found_devices = await self._scanner.discover(timeout=self._device_callback_period / 1000, return_adv=True)
         devices = self._process_ble_devices(found_devices)
-        async_exec(self._event_loop, self._device_scan_callback(devices))
+        async_exec(self._device_scan_callback(devices))
 
     def startScan(self, periodInMs: int) -> bool:
         """
@@ -212,7 +210,7 @@ class SensorController:
         self._is_scanning = True
         self._device_callback_period = periodInMs
 
-        async_exec(self._gforce_event_loop, self._startScan())
+        async_exec(self._startScan())
         return True
 
     def stopScan(self) -> None: