sensor-sdk 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

sensor/sensor_data_context.py

@@ -1,6 +1,8 @@
 import asyncio
 from collections import deque
+import platform
 from queue import Queue
+import struct
 from typing import Deque, List
 
 from sensor.gforce import DataSubscription, GForce
@@ -42,6 +44,7 @@ class SensorProfileDataCtx:
         self.deviceMac = deviceMac
         self._device_info: DeviceInfo = None
 
+        self._is_initing = False
         self._is_running = True
         self._is_data_transfering = False
         self.isUniversalStream: bool = gForce._is_universal_stream
@@ -79,7 +82,7 @@ class SensorProfileDataCtx:
         return self._is_data_transfering
 
     def hasInit(self):
-        return self.featureMap != 0 and self.notifyDataFlag != 0
+        return not self._is_initing and self.featureMap != 0 and self.notifyDataFlag != 0
 
     def hasEMG(self):
         return (self.featureMap & FeatureMaps.GFD_FEAT_EMG.value) != 0
@@ -198,32 +201,44 @@ class SensorProfileDataCtx:
 
     async def fetchDeviceInfo(self) -> DeviceInfo:
         info = DeviceInfo()
-        info.MTUSize = self.gForce.client.mtu_size
+        if platform.system() != "Linux":
+            info.MTUSize = self.gForce.client.mtu_size
+        else:
+            info.MTUSize = 0
+        print("get_device_name")
         info.DeviceName = await self.gForce.get_device_name()
+        print("get_model_number")
         info.ModelName = await self.gForce.get_model_number()
+        print("get_hardware_revision")
         info.HardwareVersion = await self.gForce.get_hardware_revision()
+        print("get_firmware_revision")
         info.FirmwareVersion = await self.gForce.get_firmware_revision()
         return info
 
     async def init(self, packageCount: int) -> bool:
+        if self._is_initing:
+            return False
         try:
+            self._is_initing = True
             info = await self.fetchDeviceInfo()
-
             await self.initDataTransfer(True)
-
             if self.hasImpedance():
                 self.notifyDataFlag |= DataSubscription.DNF_IMPEDANCE
 
             if self.hasEEG():
+                print("initEEG")
                 info.EegChannelCount = await self.initEEG(packageCount)
 
             if self.hasECG():
+                print("initECG")
                 info.EcgChannelCount = await self.initECG(packageCount)
 
             if self.hasBrth():
+                print("initBrth")
                 info.BrthChannelCount = await self.initBrth(packageCount)
 
             if self.hasIMU():
+                print("initIMU")
                 imuChannelCount = await self.initIMU(packageCount)
                 info.AccChannelCount = imuChannelCount
                 info.GyroChannelCount = imuChannelCount
@@ -233,9 +248,11 @@ class SensorProfileDataCtx:
             if not self.isUniversalStream:
                 await self.initDataTransfer(False)
 
+            self._is_initing = False
             return True
         except Exception as e:
             print(e)
+            self._is_initing = False
             return False
 
     async def start_streaming(self) -> bool:
@@ -263,16 +280,16 @@ class SensorProfileDataCtx:
             await self.gForce.set_subscription(0)
             return True
 
-    def process_data(self, buf: Queue[SensorData]):
+    def process_data(self, buf: Queue[SensorData], sensor):
         try:
             data: bytes = self._rawDataBuffer.get_nowait()
         except Exception as e:
             return
 
-        self._processDataPackage(data, buf)
+        self._processDataPackage(data, buf, sensor)
         self._rawDataBuffer.task_done()
 
-    def _processDataPackage(self, data: bytes, buf: Queue[SensorData]):
+    def _processDataPackage(self, data: bytes, buf: Queue[SensorData], sensor):
         v = data[0]
         if v == DataType.NTF_IMPEDANCE:
             offset = 1
@@ -283,15 +300,14 @@ class SensorProfileDataCtx:
             saturationData = []
 
             dataCount = (len(data) - 3) // 4 // 2
+
             for index in range(dataCount):
-                impedance_bytes = data[offset : offset + 4]
-                impedance = int.from_bytes(impedance_bytes, byteorder="little")
+                impedance = struct.unpack_from("<f", data, offset)[0]
                 offset += 4
                 impedanceData.append(impedance)
 
             for index in range(dataCount):
-                saturation_bytes = data[offset : offset + 4]
-                saturation = int.from_bytes(saturation_bytes, byteorder="little")
+                saturation = struct.unpack_from("<f", data, offset)[0]
                 offset += 4
                 saturationData.append(saturation / 10)  # firmware value range 0 - 1000
 
@@ -300,28 +316,26 @@ class SensorProfileDataCtx:
 
         elif v == DataType.NTF_EEG:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_EEG]
-            if self.checkReadSamples(data, sensor_data, 3, 0):
+            if self.checkReadSamples(sensor, data, sensor_data, 3, 0):
                 self.sendSensorData(sensor_data, buf)
         elif v == DataType.NTF_ECG:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_ECG]
-            if self.checkReadSamples(data, sensor_data, 3, 0):
+            if self.checkReadSamples(sensor, data, sensor_data, 3, 0):
                 self.sendSensorData(sensor_data, buf)
         elif v == DataType.NTF_BRTH:
             sensor_data = self.sensorDatas[SensorDataType.DATA_TYPE_BRTH]
-            if self.checkReadSamples(data, sensor_data, 3, 0):
+            if self.checkReadSamples(sensor, data, sensor_data, 3, 0):
                 self.sendSensorData(sensor_data, buf)
         elif v == DataType.NTF_IMU:
             sensor_data_acc = self.sensorDatas[SensorDataType.DATA_TYPE_ACC]
-            if self.checkReadSamples(data, sensor_data_acc, 3, 6):
+            if self.checkReadSamples(sensor, data, sensor_data_acc, 3, 6):
                 self.sendSensorData(sensor_data_acc, buf)
 
             sensor_data_gyro = self.sensorDatas[SensorDataType.DATA_TYPE_GYRO]
-            if self.checkReadSamples(data, sensor_data_gyro, 9, 6):
+            if self.checkReadSamples(sensor, data, sensor_data_gyro, 9, 6):
                 self.sendSensorData(sensor_data_gyro, buf)
 
-    def checkReadSamples(
-        self, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int
-    ):
+    def checkReadSamples(self, sensor, data: bytes, sensorData: SensorData, dataOffset: int, dataGap: int):
         offset = 1
         v = data[0]
         if not self._is_data_transfering:
@@ -340,12 +354,22 @@ class SensorProfileDataCtx:
 
             deltaPackageIndex = packageIndex - lastPackageIndex
             if deltaPackageIndex > 1:
-                lostSampleCount = sensorData.packageSampleCount * (
-                    deltaPackageIndex - 1
-                )
-                print(
-                    f"lost dataType {sensorData.dataType} -> data {sensorData.deviceMac} {lostSampleCount}"
+                lostSampleCount = sensorData.packageSampleCount * (deltaPackageIndex - 1)
+                lostLog = (
+                    "MSG|LOST SAMPLE|MAC|"
+                    + str(sensorData.deviceMac)
+                    + "|TYPE|"
+                    + str(sensorData.dataType)
+                    + "|COUNT|"
+                    + str(lostSampleCount)
                 )
+                # print(lostLog)
+                if sensor._event_loop != None and sensor._on_error_callback != None:
+                    try:
+                        sensor._event_loop.call_soon_threadsafe(sensor._on_error_callback, sensor, lostLog)
+                    except Exception as e:
+                        pass
+
                 self.readSamples(data, sensorData, 0, dataGap, lostSampleCount)
                 if newPackageIndex == 0:
                     sensorData.lastPackageIndex = 65535
@@ -356,7 +380,8 @@ class SensorProfileDataCtx:
             self.readSamples(data, sensorData, dataOffset, dataGap, 0)
             sensorData.lastPackageIndex = newPackageIndex
             sensorData.lastPackageCounter += 1
-        except Exception:
+        except Exception as e:
+            print(e)
             return False
         return True
 
@@ -385,19 +410,19 @@ class SensorProfileDataCtx:
                 channelSamples.append([])
 
         for sampleIndex in range(sampleCount):
-            for channelIndex, impedanceChannelIndex in enumerate(
-                range(sensorData.channelCount)
-            ):
+            for channelIndex, impedanceChannelIndex in enumerate(range(sensorData.channelCount)):
                 if (sensorData.channelMask & (1 << channelIndex)) != 0:
                     samples = channelSamples[channelIndex]
                     impedance = 0.0
                     saturation = 0.0
+
                     if sensorData.dataType == DataType.NTF_ECG:
-                        impedanceChannelIndex = self.sensorDatas[
-                            SensorDataType.DATA_TYPE_EEG
-                        ].channelCount
-                    impedance = _impedanceData[impedanceChannelIndex]
-                    saturation = _saturationData[impedanceChannelIndex]
+                        impedanceChannelIndex = self.sensorDatas[SensorDataType.DATA_TYPE_EEG].channelCount
+
+                    if impedanceChannelIndex < len(_impedanceData):
+                        impedance = _impedanceData[impedanceChannelIndex]
+                        saturation = _saturationData[impedanceChannelIndex]
+
                     impedanceChannelIndex += 1
 
                     dataItem = Sample()
@@ -424,11 +449,7 @@ class SensorProfileDataCtx:
                             )
                             offset += 2
                         elif sensorData.resolutionBits == 24:
-                            rawData = (
-                                (data[offset] << 16)
-                                | (data[offset + 1] << 8)
-                                | data[offset + 2]
-                            )
+                            rawData = (data[offset] << 16) | (data[offset + 1] << 8) | data[offset + 2]
                             rawData -= 8388608
                             offset += 3
 
@@ -765,9 +786,7 @@ class SensorProfileDataCtx:
 
         return crc8
 
-    def processUniversalData(
-        self, buf: Queue[SensorData], loop: asyncio.AbstractEventLoop, sensor, callback
-    ):
+    def processUniversalData(self, buf: Queue[SensorData], loop: asyncio.AbstractEventLoop, sensor, callback):
 
         while self._is_running:
             try:
@@ -795,28 +814,22 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = self.calc_crc8(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
+                    calc_crc = self.calc_crc8(self._concatDataBuffer[index + 2 : index + 2 + n])
                     if crc != calc_crc:
                         index += 1
                         continue
                     if self._is_data_transfering:
-                        data_package = bytes(
-                            self._concatDataBuffer[index + 2 : index + 2 + n]
-                        )
-                        self._processDataPackage(data_package, buf)
+                        data_package = bytes(self._concatDataBuffer[index + 2 : index + 2 + n])
+                        self._processDataPackage(data_package, buf, sensor)
                         while self._is_running and self.isDataTransfering:
                             sensorData: SensorData = None
                             try:
                                 sensorData = buf.get_nowait()
                             except Exception as e:
                                 break
-                            if sensorData != None and callback != None:
+                            if loop != None and sensorData != None and callback != None:
                                 try:
-                                    loop.call_soon_threadsafe(
-                                        callback, sensor, sensorData
-                                    )
+                                    loop.call_soon_threadsafe(callback, sensor, sensorData)
                                 except Exception as e:
                                     print(e)
 
@@ -832,18 +845,13 @@ class SensorProfileDataCtx:
                         index += 1
                         continue
                     crc = self._concatDataBuffer[index + 1 + n + 1]
-                    calc_crc = self.calc_crc8(
-                        self._concatDataBuffer[index + 2 : index + 2 + n]
-                    )
+                    calc_crc = self.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]
-                    )
-                    loop.call_soon_threadsafe(
-                        self.gForce._on_cmd_response, None, data_package
-                    )
+                    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)
                     last_cut = index = index + 2 + n
                 else:
                     index += 1