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

{sensor-sdk-0.0.6 → sensor-sdk-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.6
+Version: 0.0.8
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor-sdk-0.0.6 → sensor-sdk-0.0.8}/sensor/gforce.py

@@ -370,9 +370,7 @@ 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):
         self.device_name = ""
         self.client = None
         self.cmd_char = cmd_char
@@ -412,6 +410,7 @@ class GForce:
 
     def _on_data_response(self, q: Queue[bytes], bs: bytearray):
         bs = bytes(bs)
+
         full_packet = []
 
         is_partial_data = bs[0] == ResponseCode.PARTIAL_PACKET
@@ -500,9 +499,7 @@ class GForce:
     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 +508,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 +517,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)
@@ -846,15 +839,11 @@ class GForce:
     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), 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), utils._TIMEOUT)
         except Exception as e:
             exceptions.append(e)
 
@@ -881,9 +870,7 @@ class GForce:
         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
-        )
+        await asyncio.wait_for(self.client.write_gatt_char(self.cmd_char, bs), utils._TIMEOUT)
 
         if not req.has_res:
             return None

{sensor-sdk-0.0.6 → sensor-sdk-0.0.8}/sensor/sensor_data_context.py

@@ -11,7 +11,6 @@ from sensor.sensor_data import DataType, Sample, SensorData
 from enum import Enum, IntEnum
 
 from sensor.sensor_device import DeviceInfo
-from sensor.utils import timer
 
 
 class SensorDataType(IntEnum):
@@ -205,13 +204,13 @@ class SensorProfileDataCtx:
             info.MTUSize = self.gForce.client.mtu_size
         else:
             info.MTUSize = 0
-        print("get_device_name")
+        # print("get_device_name")
         info.DeviceName = await self.gForce.get_device_name()
-        print("get_model_number")
+        # print("get_model_number")
         info.ModelName = await self.gForce.get_model_number()
-        print("get_hardware_revision")
+        # print("get_hardware_revision")
         info.HardwareVersion = await self.gForce.get_hardware_revision()
-        print("get_firmware_revision")
+        # print("get_firmware_revision")
         info.FirmwareVersion = await self.gForce.get_firmware_revision()
         return info
 
@@ -226,22 +225,27 @@ class SensorProfileDataCtx:
                 self.notifyDataFlag |= DataSubscription.DNF_IMPEDANCE
 
             if self.hasEEG():
-                print("initEEG")
+                # print("initEEG")
                 info.EegChannelCount = await self.initEEG(packageCount)
+                info.EegSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_EEG].sampleRate
 
             if self.hasECG():
-                print("initECG")
+                # print("initECG")
                 info.EcgChannelCount = await self.initECG(packageCount)
+                info.EcgSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_ECG].sampleRate
 
             if self.hasBrth():
-                print("initBrth")
+                # print("initBrth")
                 info.BrthChannelCount = await self.initBrth(packageCount)
+                info.BrthSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_BRTH].sampleRate
 
             if self.hasIMU():
-                print("initIMU")
+                # print("initIMU")
                 imuChannelCount = await self.initIMU(packageCount)
                 info.AccChannelCount = imuChannelCount
                 info.GyroChannelCount = imuChannelCount
+                info.AccSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_ACC].sampleRate
+                info.GyroSampleRate = self.sensorDatas[SensorDataType.DATA_TYPE_GYRO].sampleRate
 
             self._device_info = info
 
@@ -786,9 +790,15 @@ class SensorProfileDataCtx:
 
         return crc8
 
-    def processUniversalData(self, buf: Queue[SensorData], loop: asyncio.AbstractEventLoop, sensor, callback):
+    async def processUniversalData(
+        self, buf: Queue[SensorData], event_loop: asyncio.AbstractEventLoop, cmd_loop: asyncio.AbstractEventLoop, sensor, callback
+    ):
 
         while self._is_running:
+            while self._is_running and self._rawDataBuffer.empty():
+                await asyncio.sleep(0.01)
+                continue
+
             try:
                 while self._is_running and not self._rawDataBuffer.empty():
                     data = self._rawDataBuffer.get_nowait()
@@ -821,21 +831,21 @@ 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:
+                        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 loop != None and sensorData != None and callback != None:
+                            if event_loop != None and sensorData != None and callback != None:
                                 try:
-                                    loop.call_soon_threadsafe(callback, sensor, sensorData)
+                                    event_loop.call_soon_threadsafe(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
@@ -850,11 +860,14 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
-                    if loop != None:
-                        loop.call_soon_threadsafe(self.gForce._on_cmd_response, None, data_package)
+                    if cmd_loop != None:
+                        cmd_loop.call_soon_threadsafe(self.gForce._on_cmd_response, None, data_package)
                     last_cut = index = index + 2 + n
+
                 else:
                     index += 1
 
-            if last_cut > 0:
-                self._concatDataBuffer = self._concatDataBuffer[last_cut + 1 :]
+                if last_cut > 0:
+                    self._concatDataBuffer = self._concatDataBuffer[last_cut + 1 :]
+                    last_cut = -1
+                    index = 0

{sensor-sdk-0.0.6 → sensor-sdk-0.0.8}/sensor/sensor_device.py

@@ -40,11 +40,17 @@ class DeviceInfo:
         self.HardwareVersion = ""
         self.FirmwareVersion = ""
         self.EmgChannelCount = 0
+        self.EmgSampleRate = 0
         self.EegChannelCount = 0
+        self.EegSampleRate = 0
         self.EcgChannelCount = 0
+        self.EcgSampleRate = 0
         self.AccChannelCount = 0
+        self.AccSampleRate = 0
         self.GyroChannelCount = 0
+        self.GyroSampleRate = 0
         self.BrthChannelCount = 0
+        self.BrthSampleRate = 0
         self.MTUSize = 0
 
 

{sensor-sdk-0.0.6 → sensor-sdk-0.0.8}/sensor/sensor_profile.py

@@ -351,7 +351,9 @@ class SensorProfile:
                 self._data_buffer.task_done()
 
     async def _process_universal_data(self):
-        self._data_ctx.processUniversalData(self._data_buffer, self._event_loop, self, self._on_data_callback)
+        await self._data_ctx.processUniversalData(
+            self._data_buffer, self._event_loop, self._gforce_event_loop, self, self._on_data_callback
+        )
 
     async def _startDataNotification(self) -> bool:
         if self.deviceState != DeviceStateEx.Ready:
@@ -474,7 +476,7 @@ class SensorProfile:
         return sync_call(
             self._gforce_event_loop,
             self._init(packageSampleCount, powerRefreshInterval),
-            120,
+            20,
         )
 
     async def asyncInit(self, packageSampleCount: int, powerRefreshInterval: int) -> bool:
@@ -490,7 +492,7 @@ class SensorProfile:
         return await async_call(
             self._gforce_event_loop,
             self._init(packageSampleCount, powerRefreshInterval),
-            120,
+            20,
         )
 
     def getBatteryLevel(self) -> int:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sensor-sdk
-Version: 0.0.6
+Version: 0.0.8
 Summary: Python sdk for Synchroni
 Home-page: https://github.com/oymotion/SynchroniSDKPython
 Author: Martin Ye

{sensor-sdk-0.0.6 → sensor-sdk-0.0.8}/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.6",
+    version="0.0.8",
     description="Python sdk for Synchroni",
     long_description=long_description,
     long_description_content_type="text/markdown",