sensor-sdk 1.3.3__py3-none-win_amd64.whl

sensor/sensor_controller.py

@@ -0,0 +1,666 @@
+import asyncio
+import ctypes
+import os
+import re
+import threading
+import time
+import traceback
+from typing import Callable, List, Optional
+
+from . import _dll
+from . import _sync
+from .sensor_device import BLEDevice
+from .sensor_profile import SensorProfile, _decode_str, _resolve_future, _raise_on_sdk_thread, _mark_sdk_thread
+
+_MAC_PATTERN = re.compile(r"^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$")
+
+def _validate_scan_period(periodInMs):
+    if not isinstance(periodInMs, int) or periodInMs <= 0:
+        raise ValueError("invalid scan period: %r" % (periodInMs,))
+
+async def _async_wait_replay_done(profile, timeout):
+    loop = asyncio.get_running_loop()
+    fut = loop.create_future()
+    prev = profile._on_data_transfer_state_change
+
+    def _on_state(p, transferring):
+        if not transferring:
+            _resolve_future(loop, fut, True)
+        if prev is not None:
+            try:
+                prev(p, transferring)
+            except Exception:
+                traceback.print_exc()
+
+    profile.on_data_transfer_state_change = _on_state
+    try:
+        if not profile.isDataTransfering:
+            return
+        try:
+            await asyncio.wait_for(fut, timeout)
+        except asyncio.TimeoutError:
+            pass
+    finally:
+        if profile._on_data_transfer_state_change is _on_state:
+            profile.on_data_transfer_state_change = prev
+
+class SensorController:
+    _instance_lock = threading.Lock()
+
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(SensorController, "_instance"):
+            with SensorController._instance_lock:
+                if not hasattr(SensorController, "_instance"):
+                    SensorController._instance = object.__new__(cls)
+        return SensorController._instance
+
+    def __init__(self):
+        if getattr(self, "_inited", False):
+            return
+        self._inited = True
+
+        self._handle = _dll.load_dll().sen_controller_create()
+        if not self._handle:
+            raise RuntimeError("sen_controller_create failed")
+
+        self._on_sensor_scan_result: Optional[Callable[[List[BLEDevice]], None]] = None
+        self._on_sensor_controller_enable_changed: Optional[Callable[[bool], None]] = None
+
+        self._profiles = {}
+        self._profiles_lock = threading.Lock()
+
+        self._pending_cbs = []
+
+        self._ctx = ctypes.py_object(self)
+        self._ctx_ptr = ctypes.cast(ctypes.pointer(self._ctx), ctypes.c_void_p)
+        self._c_on_scan = _dll._sen_scan_result_cb(SensorController._c_scan_result)
+        self._c_on_enable = _dll._sen_enable_changed_cb(SensorController._c_enable_changed)
+        self._cbs = _dll.sen_controller_cbs_t()
+        self._cbs.structSize = ctypes.sizeof(self._cbs)
+        self._cbs.onScanResult = self._c_on_scan
+        self._cbs.onEnableChanged = self._c_on_enable
+        _dll.load_dll().sen_controller_set_callbacks(
+            self._handle, ctypes.byref(self._cbs), self._ctx_ptr)
+
+    @staticmethod
+    def _c_scan_result(ctx, devices, count):
+        _mark_sdk_thread()
+        try:
+            self = ctypes.cast(ctx, ctypes.POINTER(ctypes.py_object)).contents.value
+            cb = self._on_sensor_scan_result
+            if cb is None:
+                return
+            device_list = [BLEDevice._from_c(devices[i]) for i in range(count)]
+            cb(device_list)
+        except Exception:
+            traceback.print_exc()
+
+    @staticmethod
+    def _c_enable_changed(ctx, enabled):
+        _mark_sdk_thread()
+        try:
+            self = ctypes.cast(ctx, ctypes.POINTER(ctypes.py_object)).contents.value
+            cb = self._on_sensor_controller_enable_changed
+            if cb is not None:
+                cb(enabled != 0)
+        except Exception:
+            traceback.print_exc()
+
+    @property
+    def on_sensor_scan_result(self):
+        return self._on_sensor_scan_result
+
+    @on_sensor_scan_result.setter
+    def on_sensor_scan_result(self, callback):
+        self._on_sensor_scan_result = callback
+
+    @property
+    def on_sensor_controller_enable_changed(self):
+        return self._on_sensor_controller_enable_changed
+
+    @on_sensor_controller_enable_changed.setter
+    def on_sensor_controller_enable_changed(self, callback):
+        self._on_sensor_controller_enable_changed = callback
+
+    @property
+    def onDeviceFoundCallback(self):
+        return self._on_sensor_scan_result
+
+    @onDeviceFoundCallback.setter
+    def onDeviceFoundCallback(self, callback):
+        self._on_sensor_scan_result = callback
+
+    @property
+    def onEnableCallback(self):
+        return self._on_sensor_controller_enable_changed
+
+    @onEnableCallback.setter
+    def onEnableCallback(self, callback):
+        self._on_sensor_controller_enable_changed = callback
+
+    @property
+    def hasDeviceFoundCallback(self) -> bool:
+        return self._on_sensor_scan_result is not None
+
+    def terminate(self):
+        handle = getattr(self, "_handle", None)
+        if handle:
+            self._handle = None
+            _dll.load_dll().sen_controller_destroy(handle)
+        _dll.load_dll().sen_terminate()
+
+    @property
+    def isScanning(self) -> bool:
+        return _dll.load_dll().sen_controller_is_scanning(self._handle) != 0
+
+    @property
+    def isEnable(self) -> bool:
+        return _dll.load_dll().sen_controller_is_enable(self._handle) != 0
+
+    def startScan(self, periodInMs: int) -> bool:
+        _validate_scan_period(periodInMs)
+        return _dll.load_dll().sen_controller_start_scan(self._handle, periodInMs) != 0
+
+    def stopScan(self) -> bool:
+        return _dll.load_dll().sen_controller_stop_scan(self._handle) != 0
+
+    def _wrap_profile(self, handle) -> Optional[SensorProfile]:
+        if not handle:
+            return None
+        with self._profiles_lock:
+            profile = self._profiles.get(handle)
+            if profile is None:
+                profile = SensorProfile(self, handle)
+                self._profiles[handle] = profile
+            return profile
+
+    def requireSensor(self, device: BLEDevice) -> Optional[SensorProfile]:
+        address = getattr(device, "Address", None)
+        if not isinstance(address, str) or _MAC_PATTERN.match(address) is None:
+            return None
+        handle = _dll.load_dll().sen_controller_require_sensor(
+            self._handle, address.encode())
+        return self._wrap_profile(handle)
+
+    def getSensor(self, deviceMac: str) -> Optional[SensorProfile]:
+        handle = _dll.load_dll().sen_controller_get_sensor(
+            self._handle, deviceMac.encode())
+        return self._wrap_profile(handle)
+
+    def getSensors(self) -> List[SensorProfile]:
+        dll = _dll.load_dll()
+        count = dll.sen_controller_get_sensors(self._handle, None, 0)
+        if count == 0:
+            return []
+        arr = (ctypes.c_void_p * count)()
+        dll.sen_controller_get_sensors(self._handle, arr, count)
+        return [p for p in (self._wrap_profile(arr[i]) for i in range(count)) if p]
+
+    def getConnectedSensors(self) -> List[SensorProfile]:
+        dll = _dll.load_dll()
+        count = dll.sen_controller_get_connected_sensors(self._handle, None, 0)
+        if count == 0:
+            return []
+        arr = (ctypes.c_void_p * count)()
+        dll.sen_controller_get_connected_sensors(self._handle, arr, count)
+        return [p for p in (self._wrap_profile(arr[i]) for i in range(count)) if p]
+
+    def getConnectedDevices(self) -> List[BLEDevice]:
+        return [p.BLEDevice for p in self.getConnectedSensors()]
+
+    def _track(self, cb_obj):
+        self._pending_cbs.append(cb_obj)
+        return cb_obj
+
+    def _discard(self, cb_obj):
+        try:
+            self._pending_cbs.remove(cb_obj)
+        except ValueError:
+            pass
+
+    def _multiStartDataNotification(self, sensors: List[SensorProfile],
+                                    timeoutInMs: int = 0,
+                                    maxDelayDispersionMs: int = 5,
+                                    maxAttempts: int = 3,
+                                    cb: Optional[Callable[[dict, str], None]] = None):
+        @_dll._sen_multi_result_cb
+        def _cb(ctx, macs, oks, errors, count):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    results = {_decode_str(macs[i]): oks[i] != 0 for i in range(count)}
+                    cb(results, "")
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        arr = (ctypes.c_void_p * len(sensors))(*[s._handle for s in sensors])
+        _dll.load_dll().sen_controller_multi_start_data(
+            self._handle, arr, len(sensors), timeoutInMs,
+            maxDelayDispersionMs, maxAttempts, _cb, None)
+
+    def _multiStopDataNotification(self, sensors: List[SensorProfile],
+                                   timeoutInMs: int = 0,
+                                   cb: Optional[Callable[[dict, str], None]] = None):
+        @_dll._sen_multi_result_cb
+        def _cb(ctx, macs, oks, errors, count):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    results = {_decode_str(macs[i]): oks[i] != 0 for i in range(count)}
+                    cb(results, "")
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        arr = (ctypes.c_void_p * len(sensors))(*[s._handle for s in sensors])
+        _dll.load_dll().sen_controller_multi_stop_data(
+            self._handle, arr, len(sensors), timeoutInMs, _cb, None)
+
+    def multiStartDataNotification(self, sensors: List[SensorProfile],
+                                   timeout: float = 0.0,
+                                   maxDelayDispersionMs: int = 5,
+                                   maxAttempts: int = 3) -> dict:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(
+                self.asyncMultiStartDataNotification(
+                    sensors, timeout, maxDelayDispersionMs, maxAttempts),
+                max(timeout, 60.0) + 45.0)
+        except _sync.FuturesTimeoutError:
+            return {}
+
+    def multiStopDataNotification(self, sensors: List[SensorProfile],
+                                  timeout: float = 0.0) -> dict:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(
+                self.asyncMultiStopDataNotification(sensors, timeout),
+                timeout + 45.0)
+        except _sync.FuturesTimeoutError:
+            return {}
+
+    def log(self, message: str, level: str = "I"):
+        try:
+            _dll.load_dll().sen_controller_log(
+                self._handle, str(message).encode(), str(level).encode())
+        except Exception:
+            traceback.print_exc()
+
+    def onSuspend(self):
+        try:
+            _dll.load_dll().sen_controller_on_suspend(self._handle)
+        except Exception:
+            traceback.print_exc()
+
+    _BIN_INFO_PREFIXES_V2 = (
+        ("Ppg", "Ppg"), ("Spo2", "Spo2"), ("Impe", "Impe"),
+        ("Emg", "EMG"), ("Eeg", "EEG"), ("Ecg", "ECG"),
+        ("Acc", "Acc"), ("Gyro", "Gyro"), ("Brth", "BRTH"),
+        ("MagAngle", "MagAngle"), ("Euler", "Euler"), ("Quat", "Quat"),
+    )
+    _BIN_INFO_PREFIXES_V3 = _BIN_INFO_PREFIXES_V2 + (("Imu", "Imu"),)
+
+    @staticmethod
+    def _bin_device_info(d, version):
+        def _cstr(raw):
+            return bytes(raw).split(b"\0", 1)[0].decode("utf-8", errors="replace")
+        out = {
+            "DeviceName": _cstr(d.deviceName),
+            "ModelName": _cstr(d.modelName),
+            "HardwareVersion": _cstr(d.hardwareVersion),
+            "FirmwareVersion": _cstr(d.firmwareVersion),
+            "MTUSize": d.MTUSize,
+        }
+        prefixes = (SensorController._BIN_INFO_PREFIXES_V2 if version < 3
+                    else SensorController._BIN_INFO_PREFIXES_V3)
+        for key_prefix, field_prefix in prefixes:
+            out[key_prefix + "ChannelCount"] = getattr(d, field_prefix + "ChannelCount")
+            out[key_prefix + "SampleRate"] = getattr(d, field_prefix + "SampleRate")
+        return out
+
+    def getBinFileInfo(self, file_path: str) -> Optional[dict]:
+        info = _dll.sen_bin_file_info_t()
+        info.structSize = ctypes.sizeof(info)
+        valid = _dll.load_dll().sen_controller_get_bin_file_info(
+            self._handle, file_path.encode(), ctypes.byref(info))
+        if not valid:
+            return None
+        version = info.configVersion
+        sensor_datas = []
+        count = min(info.sensorDataCount, _dll.SEN_BIN_MAX_SENSOR_DATAS)
+        for i in range(count):
+            s = info.sensorDatas[i]
+            if s.packageSampleCount <= 0 or s.channelCount <= 0:
+                continue
+            sensor_datas.append({
+                "type_index": s.typeIndex,
+                "data_type": s.dataType,
+                "sample_rate": s.sampleRate,
+                "channel_count": s.channelCount,
+                "package_sample_count": s.packageSampleCount,
+                "min_package_sample_count": s.minPackageSampleCount,
+                "package_index_length": s.packageIndexLength,
+                "resolution_bits": s.resolutionBits,
+                "resolution_signed": s.resolutionSigned,
+                "channel_mask": s.channelMask,
+                "k": s.k,
+                "raw_data_bias": s.rawDataBias,
+            })
+        return {
+            "version": version,
+            "first_data_ts_ms": info.firstDataTsMs,
+            "last_data_ts_ms": info.lastDataTsMs,
+            "device_mac": bytes(info.mac).split(b"\0", 1)[0].decode("utf-8", errors="replace"),
+            "device_name": bytes(info.deviceName).split(b"\0", 1)[0].decode("utf-8", errors="replace"),
+            "chip_type": info.chipType,
+            "is_universal_stream": bool(info.isUniversalStream),
+            "feature_map": info.featureMap,
+            "notify_data_flag": info.notifyDataFlag,
+            "is_new_emg": bool(info.isNewEmg),
+            "is_contain_qat6": bool(info.isContainQat6),
+            "ppg_model": info.ppgModel,
+            "device_info": SensorController._bin_device_info(info.deviceInfo, version),
+            "sensor_datas": sensor_datas,
+            "replay_duration": info.durationSec,
+        }
+
+    def _start_replay(self, file_path: str, sensor: Optional[SensorProfile],
+                      realtime: bool, timeoutMs: int) -> Optional[SensorProfile]:
+        if sensor is None:
+            info = self.getBinFileInfo(file_path)
+            if info is None or not info["device_mac"]:
+                return None
+            sensor = self.requireSensor(
+                BLEDevice(info["device_name"] or "", info["device_mac"], 0))
+            if sensor is None:
+                return None
+        mac = sensor if isinstance(sensor, str) else sensor.BLEDevice.Address
+        handle = _dll.load_dll().sen_controller_replay_bin_file(
+            self._handle, file_path.encode(), mac.encode(), 1 if realtime else 0, timeoutMs)
+        return self._wrap_profile(handle)
+
+    def replayBinFile(self, file_path: str, sensor: Optional[SensorProfile] = None,
+                      realtime: bool = True, timeout: Optional[float] = None,
+                      block: bool = True, timeoutMs: int = 0
+                      ) -> Optional[SensorProfile]:
+        profile = self._start_replay(file_path, sensor, realtime, timeoutMs)
+        if profile is None or not block:
+            return profile
+        _raise_on_sdk_thread()
+        if timeout is None:
+            info = self.getBinFileInfo(file_path)
+            duration = info["replay_duration"] if info else 0
+            timeout = max(60.0, duration + 30.0) if realtime else 600.0
+        try:
+            _sync.run_sync(_async_wait_replay_done(profile, timeout), timeout + 15.0)
+        except _sync.FuturesTimeoutError:
+            pass
+        return profile
+
+    def multiReplayBinFile(self, file_paths, sensors, realtime: bool = True,
+                           timeout: Optional[float] = None, block: bool = True,
+                           timeoutMs: int = 0) -> list:
+        dll = _dll.load_dll()
+        count = len(file_paths)
+        if len(sensors) != count:
+            raise ValueError("sensors must align with file_paths")
+        macs = []
+        for s in sensors:
+            if s is None:
+                raise ValueError("sensors must not contain None entries")
+            macs.append(s if isinstance(s, str) else s.BLEDevice.Address)
+        path_arr = (ctypes.c_char_p * count)(*[p.encode() for p in file_paths])
+        mac_arr = (ctypes.c_char_p * count)(*[m.encode() for m in macs])
+        out_arr = (ctypes.c_void_p * count)()
+        dll.sen_controller_multi_replay_bin_file(
+            self._handle, path_arr, mac_arr, count,
+            1 if realtime else 0, timeoutMs, out_arr)
+        profiles = [self._wrap_profile(h) for h in out_arr]
+        if not block:
+            return profiles
+        _raise_on_sdk_thread()
+        if timeout is None:
+            durations = []
+            for p in file_paths:
+                info = self.getBinFileInfo(p)
+                durations.append(info["replay_duration"] if info else 0)
+            timeout = max(60.0, max(durations + [0]) + 30.0) if realtime else 600.0
+
+        async def _wait_all():
+            deadline = time.monotonic() + timeout
+            for profile in profiles:
+                if profile is not None:
+                    await _async_wait_replay_done(
+                        profile, max(0.0, deadline - time.monotonic()))
+
+        try:
+            _sync.run_sync(_wait_all(), timeout + 15.0)
+        except _sync.FuturesTimeoutError:
+            pass
+        return profiles
+
+    def _bin_replay_cmd(self, fn, sensor: Optional[SensorProfile]) -> str:
+        if sensor is None:
+            return "Error: no sensor"
+        mac = sensor if isinstance(sensor, str) else sensor.BLEDevice.Address
+        buf = ctypes.create_string_buffer(256)
+        fn(self._handle, mac.encode(), buf, len(buf))
+        return buf.value.decode("utf-8", errors="replace")
+
+    def pauseBinReplay(self, sensor: Optional[SensorProfile]) -> str:
+        return self._bin_replay_cmd(_dll.load_dll().sen_controller_pause_bin_replay, sensor)
+
+    def resumeBinReplay(self, sensor: Optional[SensorProfile]) -> str:
+        return self._bin_replay_cmd(_dll.load_dll().sen_controller_resume_bin_replay, sensor)
+
+    def stopBinReplay(self, sensor: Optional[SensorProfile]) -> str:
+        return self._bin_replay_cmd(_dll.load_dll().sen_controller_stop_bin_replay, sensor)
+
+    def _parseBinToCsv(self, bin_path: str, csv_path: Optional[str] = None,
+                       cb: Optional[Callable[[str, str], None]] = None):
+        if not csv_path:
+            root, _ = os.path.splitext(bin_path)
+            csv_path = root + ".csv"
+        @_dll._sen_param_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(_decode_str(result), _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_controller_parse_bin_to_csv(
+            self._handle, bin_path.encode(), csv_path.encode(), _cb, None)
+
+    def parseBinToCsv(self, bin_path: str, csv_path: Optional[str] = None) -> str:
+        if not os.path.isfile(bin_path):
+            raise FileNotFoundError(bin_path)
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncParseBinToCsv(bin_path, csv_path), 320.0)
+        except _sync.FuturesTimeoutError:
+            return "Error: Timeout"
+
+    def getVersion(self) -> str:
+        buf = ctypes.create_string_buffer(256)
+        _dll.load_dll().sen_controller_get_version(self._handle, buf, len(buf))
+        return buf.value.decode("utf-8", errors="replace")
+
+    def _checkSetupDongle(self, cb: Optional[Callable[[str, str], None]] = None):
+        @_dll._sen_param_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(_decode_str(result), _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_controller_check_setup_dongle(self._handle, _cb, None)
+
+    def checkSetupDongle(self) -> str:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncCheckSetupDongle(), 320.0)
+        except _sync.FuturesTimeoutError:
+            return "Error: Timeout"
+
+    def _getParam(self, key: str, cb: Optional[Callable[[str, str], None]] = None):
+        @_dll._sen_param_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(_decode_str(result), _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_controller_get_param(self._handle, key.encode(), _cb, None)
+
+    def _setParam(self, key: str, value: str, cb: Optional[Callable[[str, str], None]] = None):
+        @_dll._sen_param_cb
+        def _cb(ctx, result, errorMsg):
+            _mark_sdk_thread()
+            try:
+                if cb is not None:
+                    cb(_decode_str(result), _decode_str(errorMsg))
+            finally:
+                self._discard(_cb)
+        self._track(_cb)
+        _dll.load_dll().sen_controller_set_param(
+            self._handle, key.encode(), value.encode(), _cb, None)
+
+    def getParam(self, key: str) -> str:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncGetParam(key), 20.0)
+        except _sync.FuturesTimeoutError:
+            return "Error: Timeout"
+
+    def setParam(self, key: str, value: str) -> str:
+        _raise_on_sdk_thread()
+        try:
+            return _sync.run_sync(self.asyncSetParam(key, value), 20.0)
+        except _sync.FuturesTimeoutError:
+            return "Error: Timeout"
+
+    def setDebugEnabled(self, enabled: bool):
+        self.setParam("DEBUG_ENABLED", "True" if enabled else "False")
+
+    def setLogPath(self, enabled: bool = True, path: str = ""):
+        if not enabled:
+            self.setParam("LOG_PATH", "False")
+        elif path:
+            self.setParam("LOG_PATH", path)
+        else:
+            self.setParam("LOG_PATH", "True")
+
+    def getBLEBackendName(self) -> str:
+        return self.getParam("BACK_END")
+
+    def scan(self, period) -> List[BLEDevice]:
+        _raise_on_sdk_thread()
+        _validate_scan_period(period)
+        try:
+            return _sync.run_sync(self.asyncScan(period), period / 1000.0 + 15.0)
+        except _sync.FuturesTimeoutError:
+            return []
+
+    async def asyncScan(self, period) -> List[BLEDevice]:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+
+        @_dll._sen_scan_result_cb
+        def _cb(ctx, devices, count):
+            _mark_sdk_thread()
+            try:
+                device_list = [BLEDevice._from_c(devices[i]) for i in range(count)]
+                _resolve_future(loop, fut, device_list)
+            finally:
+                self._discard(_cb)
+
+        self._track(_cb)
+        _dll.load_dll().sen_controller_scan_once(self._handle, int(period), _cb, None)
+        try:
+            return await asyncio.wait_for(fut, period / 1000.0 + 15.0)
+        except asyncio.TimeoutError:
+            return []
+
+    async def asyncMultiStartDataNotification(self, sensors: List[SensorProfile],
+                                              timeout: float = 0.0,
+                                              maxDelayDispersionMs: int = 5,
+                                              maxAttempts: int = 3) -> dict:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._multiStartDataNotification(
+            sensors, int(timeout * 1000), maxDelayDispersionMs, maxAttempts,
+            cb=lambda res, err: _resolve_future(loop, fut, res))
+        try:
+            return await asyncio.wait_for(fut, max(timeout, 60.0) + 30.0)
+        except asyncio.TimeoutError:
+            return {}
+
+    async def asyncMultiStopDataNotification(self, sensors: List[SensorProfile],
+                                             timeout: float = 0.0) -> dict:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._multiStopDataNotification(
+            sensors, int(timeout * 1000),
+            cb=lambda res, err: _resolve_future(loop, fut, res))
+        try:
+            return await asyncio.wait_for(fut, timeout + 30.0)
+        except asyncio.TimeoutError:
+            return {}
+
+    async def asyncParseBinToCsv(self, bin_path: str, csv_path: Optional[str] = None) -> str:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._parseBinToCsv(bin_path, csv_path,
+                            cb=lambda res, err: _resolve_future(loop, fut, err if err and res in ('', 'Error') else res))
+        try:
+            return await asyncio.wait_for(fut, 300.0)
+        except asyncio.TimeoutError:
+            return "Error: Timeout"
+
+    async def asyncCheckSetupDongle(self) -> str:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._checkSetupDongle(cb=lambda res, err: _resolve_future(loop, fut, err if err and res in ('', 'Error') else res))
+        try:
+            return await asyncio.wait_for(fut, 300.0)
+        except asyncio.TimeoutError:
+            return "Error: Timeout"
+
+    async def asyncGetParam(self, key: str) -> str:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._getParam(key, cb=lambda res, err: _resolve_future(loop, fut, err if err and res in ('', 'Error') else res))
+        try:
+            return await asyncio.wait_for(fut, 12.0)
+        except asyncio.TimeoutError:
+            return "Error: Timeout"
+
+    async def asyncSetParam(self, key: str, value: str) -> str:
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+        self._setParam(key, str(value), cb=lambda res, err: _resolve_future(loop, fut, err if err and res in ('', 'Error') else res))
+        try:
+            result = await asyncio.wait_for(fut, 12.0)
+        except asyncio.TimeoutError:
+            return "Error: Timeout"
+        if key == "CMD_TIMEOUT_MS" and result.startswith("OK"):
+            _sync.note_cmd_timeout_ms(value)
+        return result
+
+_instance = None
+_instance_create_lock = threading.Lock()
+
+def __getattr__(name):
+    if name == "SensorControllerInstance":
+        global _instance
+        if _instance is None:
+            with _instance_create_lock:
+                if _instance is None:
+                    _instance = SensorController()
+        return _instance
+    raise AttributeError("module %r has no attribute %r" % (__name__, name))