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

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/PKG-INFO

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

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/README.md

@@ -81,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

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/sensor/gforce.py

@@ -16,7 +16,7 @@ from bleak import (
     BleakGATTCharacteristic,
 )
 
-from sensor import utils
+from sensor import sensor_utils
 
 
 @dataclass
@@ -377,6 +377,7 @@ class GForce:
         self.client = None
         self.cmd_char = cmd_char
         self.data_char = data_char
+        self.current_request: Request = None
         self.responses: Dict[Command, Queue] = {}
         self.resolution = SampleResolution.BITS_8
         self._num_channels = 8
@@ -393,7 +394,7 @@ class GForce:
         self._raw_data_buf = buf
 
         try:
-            await asyncio.wait_for(client.connect(), utils._TIMEOUT)
+            await asyncio.wait_for(client.connect(), sensor_utils._TIMEOUT)
         except Exception as e:
             return
 
@@ -404,12 +405,12 @@ class GForce:
             if not self._is_universal_stream:
                 await asyncio.wait_for(
                     client.start_notify(self.cmd_char, self._on_cmd_response),
-                    utils._TIMEOUT,
+                    sensor_utils._TIMEOUT,
                 )
             else:
                 await asyncio.wait_for(
                     client.start_notify(self.data_char, self._on_universal_response),
-                    utils._TIMEOUT,
+                    sensor_utils._TIMEOUT,
                 )
         except Exception as e:
             return
@@ -565,11 +566,14 @@ class GForce:
 
     def _on_cmd_response(self, _: BleakGATTCharacteristic, 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)
 
@@ -859,17 +863,17 @@ class GForce:
                 self.data_char,
                 lambda _, data: self._on_data_response(q, data),
             ),
-            utils._TIMEOUT,
+            sensor_utils._TIMEOUT,
         )
 
     async def stop_streaming(self):
         exceptions = []
         # try:
-        #     await asyncio.wait_for(self.set_subscription(DataSubscription.OFF), utils._TIMEOUT)
+        #     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), utils._TIMEOUT)
+            await asyncio.wait_for(self.client.stop_notify(self.data_char), sensor_utils._TIMEOUT)
         except Exception as e:
             exceptions.append(e)
 
@@ -879,29 +883,49 @@ class GForce:
     async def disconnect(self):
         with suppress(asyncio.CancelledError):
             try:
-                await asyncio.wait_for(self.client.disconnect(), utils._TIMEOUT)
+                await asyncio.wait_for(self.client.disconnect(), sensor_utils._TIMEOUT)
             except Exception as e:
                 pass
 
     def _get_response_channel(self, cmd: Command) -> Queue:
+        if self.responses.get(cmd) != None:
+            return None
+
         q = Queue()
         self.responses[cmd] = q
         return q
 
     async def _send_request(self, req: Request) -> Optional[bytes]:
+
         q = None
         if req.has_res:
             q = self._get_response_channel(req.cmd)
+            if q == None:
+                # print("duplicate")
+                return None
+
+        while self.current_request != None:
+            # print("wait")
+            await asyncio.sleep(0.1)
 
+        self.current_request = req
         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))
+        await asyncio.wait_for(self.client.write_gatt_char(self.cmd_char, bs, response=False), 0.1)
 
         if not req.has_res:
+            self.current_request = None
             return None
 
         try:
-            return await asyncio.wait_for(q.get(), utils._TIMEOUT)
+            ret = await asyncio.wait_for(q.get(), 0.5)
+            self.current_request = None
+            self.responses[req.cmd] = None
+            return ret
         except Exception as e:
+            self.current_request = None
+            self.responses[req.cmd] = None
             return None

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/sensor/sensor_controller.py

@@ -6,10 +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
 
-from sensor.utils import async_call, sync_call, async_exec
+from sensor.sensor_utils import async_call, sync_call, async_exec
 from bleak import (
     BleakScanner,
     AdvertisementData,
@@ -52,13 +52,13 @@ class SensorController:
         """
 
     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()
 
-        utils.Terminate()
+        sensor_utils.Terminate()
 
     def _match_device(self, _device: bleak.BLEDevice, adv: AdvertisementData):
         if _device.name == None:
@@ -71,7 +71,7 @@ class SensorController:
         return False
 
     @property
-    def isScaning(self) -> bool:
+    def isScanning(self) -> bool:
         """
         检查是否正在扫描。
 
@@ -181,13 +181,13 @@ class SensorController:
         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:
                 asyncio.get_event_loop().run_in_executor(None, self._device_callback, devices)
             except Exception as e:
                 print(e)
 
-        if self._is_scanning:
+        if not sensor_utils._terminated and self._is_scanning:
             async_exec(self._startScan())
 
     async def _startScan(self) -> bool:

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/sensor/sensor_data_context.py

@@ -7,7 +7,7 @@ import struct
 from typing import Deque, List
 from concurrent.futures import ThreadPoolExecutor
 import csv
-from sensor import utils
+from sensor import sensor_utils
 from sensor.gforce import DataSubscription, GForce, SamplingRate
 from sensor.sensor_data import DataType, Sample, SensorData
 
@@ -351,7 +351,7 @@ class SensorProfileDataCtx:
                     switch |= 8
         try:
             await self.gForce.set_firmware_filter_switch(switch)
-            await asyncio.sleep(0.1)
+            # await asyncio.sleep(0.1)
             return "OK"
         except Exception as e:
             return "ERROR: " + str(e)
@@ -391,7 +391,7 @@ class SensorProfileDataCtx:
                     sensorData = buf.get_nowait()
                 except Exception as e:
                     break
-                if sensorData != None and callback != None:
+                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:
@@ -459,6 +459,8 @@ class SensorProfileDataCtx:
             offset += 2
             newPackageIndex = packageIndex
             lastPackageIndex = sensorData.lastPackageIndex
+            if sensorData.lastPackageCounter == 0 and sensorData.lastPackageIndex == 0 and packageIndex > 1:
+                return False
 
             if packageIndex < lastPackageIndex:
                 packageIndex += 65536  # 包索引是 U16 类型
@@ -477,7 +479,7 @@ class SensorProfileDataCtx:
                     + str(lostSampleCount)
                 )
                 # print(lostLog)
-                if sensor._event_loop != None and sensor._on_error_callback != None:
+                if not sensor_utils._terminated and sensor._event_loop != None and sensor._on_error_callback != None:
                     try:
                         asyncio.get_event_loop().run_in_executor(None, sensor._on_error_callback, sensor, lostLog)
                     except Exception as e:
@@ -699,7 +701,7 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = utils.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
+                    calc_crc = sensor_utils.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
@@ -712,7 +714,7 @@ class SensorProfileDataCtx:
                                 sensorData = buf.get_nowait()
                             except Exception as e:
                                 break
-                            if sensorData != None and callback != None:
+                            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:
@@ -730,12 +732,13 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = utils.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
+                    calc_crc = sensor_utils.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
                     data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
-                    asyncio.get_event_loop().run_in_executor(None, self.gForce._on_cmd_response, None, data_package)
+                    if not sensor_utils._terminated:
+                        self.gForce._on_cmd_response(None, data_package)
                     last_cut = index = index + 2 + n
 
                 else:

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/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
 
@@ -10,7 +11,7 @@ from bleak import (
     BleakClient,
 )
 
-from sensor import utils
+from sensor import sensor_utils
 from sensor.gforce import GForce
 from sensor.sensor_data import SensorData
 import asyncio
@@ -18,7 +19,7 @@ import asyncio
 
 from sensor.sensor_data_context import SensorProfileDataCtx
 from sensor.sensor_device import BLEDevice, DeviceInfo, DeviceStateEx
-from sensor.utils import async_call, sync_call, async_exec
+from sensor.sensor_utils import async_call, sync_call, async_exec
 
 SERVICE_GUID = "0000ffd0-0000-1000-8000-00805f9b34fb"
 OYM_CMD_NOTIFY_CHAR_UUID = "f000ffe1-0451-4000-b000-000000000000"
@@ -60,7 +61,9 @@ 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._event_loop: asyncio.AbstractEventLoop = None
+        self._event_thread: threading.Thread = None
         self._is_starting = False
         self._is_setting_param = False
 
@@ -211,15 +214,7 @@ class SensorProfile:
         """
         self._on_power_changed = callback
 
-    async def _connect(self) -> bool:
-        if utils._terminated:
-            return False
-
-        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()
-
+    async def _initGforce(self):
         if self._gforce == None:
             if self._adv.service_data.get(SERVICE_GUID) != None:
                 # print("OYM_SERVICE:" + self._detail_device.name)
@@ -240,25 +235,41 @@ class SensorProfile:
         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._event_loop)
         else:
-            async_exec(self._process_data())
+            async_exec(self._process_data(), self._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
             self._set_device_state(DeviceStateEx.Disconnected)
             pass
 
-        await self._gforce.connect(handle_disconnect, self._raw_data_buf)
+        await async_call(self._gforce.connect(handle_disconnect, self._raw_data_buf), runloop=self._event_loop)
 
         if self._gforce != None and self._gforce.client.is_connected:
             self._set_device_state(DeviceStateEx.Connected)
@@ -292,8 +303,8 @@ class SensorProfile:
         return await async_call(self._connect())
 
     async def _waitForDisconnect(self) -> bool:
-        while not utils._terminated and self.deviceState != DeviceStateEx.Disconnected:
-            await asyncio.sleep(1)
+        while not sensor_utils._terminated and self.deviceState != DeviceStateEx.Disconnected:
+            await asyncio.sleep(0.1)
         return True
 
     async def _disconnect(self) -> bool:
@@ -302,8 +313,8 @@ class SensorProfile:
         if self._data_ctx == None:
             return False
         self._set_device_state(DeviceStateEx.Disconnecting)
-        await self._gforce.disconnect()
-        await asyncio.wait_for(self._waitForDisconnect(), utils._TIMEOUT)
+        async_exec(self._gforce.disconnect(), self._event_loop)
+        await asyncio.wait_for(self._waitForDisconnect(), sensor_utils._TIMEOUT)
 
         return True
 
@@ -348,10 +359,9 @@ class SensorProfile:
         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=self._event_loop)
         await asyncio.sleep(0.2)
 
-        self._is_starting = False
         return result
 
     def startDataNotification(self) -> bool:
@@ -364,8 +374,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 +393,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,9 +413,8 @@ class SensorProfile:
         if not self._data_ctx.isDataTransfering:
             return True
 
-        result = await self._data_ctx.stop_streaming()
-        self._is_starting = False
-        return not result
+        result = await async_call(self._data_ctx.stop_streaming(), runloop=self._event_loop)
+        return result
 
     def stopDataNotification(self) -> bool:
         """
@@ -405,8 +426,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,16 +445,22 @@ 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 utils._terminated and self.deviceState == DeviceStateEx.Ready:
+        while not sensor_utils._terminated and self.deviceState == DeviceStateEx.Ready:
             await asyncio.sleep(self._power_interval / 1000)
 
             self._power = await self._gforce.get_battery_level()
 
-            if self._event_loop != None and self._on_power_changed != None:
+            if not sensor_utils._terminated and self._event_loop != None and self._on_power_changed != None:
                 try:
                     asyncio.get_event_loop().run_in_executor(None, self._on_power_changed, self, self._power)
                 except Exception as e:
@@ -443,7 +476,8 @@ class SensorProfile:
 
         if await self._data_ctx.init(packageSampleCount):
             self._power_interval = powerRefreshInterval
-            utils.async_exec(self._refresh_power())
+            self._power = await self._gforce.get_battery_level()
+            sensor_utils.async_exec(self._refresh_power())
 
         return self._data_ctx.hasInit()
 
@@ -477,6 +511,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,18 +560,7 @@ 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)

sensor-sdk-0.0.16/sensor/utils.py → sensor-sdk-0.0.27/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:
@@ -25,10 +25,18 @@ def checkRunLoop():
             _event_thread.daemon = True
             _event_thread.name = "SensorController event"
             _event_thread.start()
+            time.sleep(0.1)
 
 
 def Terminate():
-    global _runloop, _needCloseRunloop, _event_thread
+    global _runloop, _needCloseRunloop, _event_thread, _terminated
+    _terminated = True
+    try:
+        for task in asyncio.all_tasks():
+            task.cancel()
+    except Exception as e:
+        pass
+
     if _needCloseRunloop:
         try:
             _runloop.stop()
@@ -37,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:
@@ -49,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)
@@ -62,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:
@@ -85,6 +99,7 @@ async def async_call(function, _timeout=_TIMEOUT) -> any:
 
 
 def start_loop(loop: asyncio.BaseEventLoop):
+    # asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
     asyncio.set_event_loop(loop)
     loop.run_forever()
 

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/sensor_sdk.egg-info/PKG-INFO

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

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/sensor_sdk.egg-info/SOURCES.txt

@@ -8,7 +8,7 @@ sensor/sensor_data.py
 sensor/sensor_data_context.py
 sensor/sensor_device.py
 sensor/sensor_profile.py
-sensor/utils.py
+sensor/sensor_utils.py
 sensor_sdk.egg-info/PKG-INFO
 sensor_sdk.egg-info/SOURCES.txt
 sensor_sdk.egg-info/dependency_links.txt

{sensor-sdk-0.0.16 → sensor-sdk-0.0.27}/setup.py

@@ -8,7 +8,7 @@ with open(os.path.join(this_directory, "README.md"), "r", encoding="utf-8") as f
 
 setup(
     name="sensor-sdk",
-    version="0.0.16",
+    version="0.0.27",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",