sensor-sdk 1.3.3__py3-none-win_amd64.whl

sensor/sensor_data.py

@@ -0,0 +1,294 @@
+import ctypes
+import struct
+from enum import IntEnum
+
+from ._dll import sen_data_info_t
+
+SAMPLE_SIZE = 40
+_OFF_ABS_TIMESTAMP = 0
+_OFF_CHANNEL_INDEX = 8
+_OFF_SAMPLE_INDEX = 12
+_OFF_RAW_DATA = 16
+_OFF_DATA = 20
+_OFF_IMPEDANCE = 24
+_OFF_SATURATION = 28
+_OFF_IS_LOST = 32
+_SAMPLE_FMT = "<d3i3fB"
+
+class Sample:
+    __slots__ = [
+        "rawData",
+        "data",
+        "impedance",
+        "saturation",
+        "sampleIndex",
+        "isLost",
+        "absTimeStampInSec",
+        "channelIndex",
+    ]
+
+    def __init__(self):
+        self.rawData = 0
+        self.data = 0.0
+        self.impedance = 0.0
+        self.saturation = 0.0
+        self.sampleIndex = 0
+        self.isLost = False
+        self.absTimeStampInSec = 0.0
+        self.channelIndex = 0
+
+class DataType(IntEnum):
+    NTF_ACC = 0x1
+    NTF_GYRO = 0x2
+    NTF_EULER_DATA = 0x4
+    NTF_QUATERNION = 0x5
+    NTF_GEST = 0x07
+    NTF_EMG = 0x8
+    NTF_MAG_ANGLE_DATA = 0x0D
+    NTF_EEG = 0x10
+    NTF_ECG = 0x11
+    NTF_IMPEDANCE = 0x12
+    NTF_IMU = 0x13
+    NTF_ADS = 0x14
+    NTF_BRTH = 0x15
+    NTF_IMPEDANCE_EXT = 0x16
+    NTF_SPO2 = 0x17
+    NTF_PPG = 0x18
+
+def _info_field(field_name, default):
+
+    @property
+    def prop(self):
+        i = self._read_info()
+        return getattr(i, field_name) if i is not None else default
+
+    @prop.setter
+    def prop(self, value):
+        setattr(self._ensure_own_info(), field_name, value)
+
+    return prop
+
+class SensorData:
+    __slots__ = [
+        "_startSampleIndex",
+        "_info",
+        "_own_info",
+        "_buf",
+        "_view_start_time_stamp",
+    ]
+
+    def __init__(self):
+        self._startSampleIndex = 0
+        self._info = None
+        self._own_info = None
+        self._buf = b""
+        self._view_start_time_stamp = 0
+
+    @property
+    def startSampleIndex(self) -> int:
+        return self._startSampleIndex
+
+    def _read_info(self):
+        if self._own_info is not None:
+            return self._own_info
+        if self._info:
+            return self._info.contents
+        return None
+
+    def _ensure_own_info(self):
+        if self._own_info is None:
+            own = sen_data_info_t()
+            src = self._read_info()
+            if src is not None:
+                ctypes.memmove(ctypes.byref(own), ctypes.byref(src),
+                               ctypes.sizeof(own))
+            self._own_info = own
+        return self._own_info
+
+    @property
+    def deviceMac(self) -> str:
+        i = self._read_info()
+        if i is None:
+            return ""
+        return bytes(i.deviceMac).split(b"\0", 1)[0].decode("utf-8", errors="replace")
+
+    @deviceMac.setter
+    def deviceMac(self, value: str):
+        raw = str(value).encode("utf-8", errors="replace")[:17]
+        mac = self._ensure_own_info().deviceMac
+        for idx, b in enumerate(raw):
+            mac[idx] = b
+
+    @property
+    def deviceName(self) -> str:
+        i = self._read_info()
+        if i is None:
+            return ""
+        return bytes(i.deviceName).split(b"\0", 1)[0].decode("utf-8", errors="replace")
+
+    @deviceName.setter
+    def deviceName(self, value: str):
+        raw = str(value).encode("utf-8", errors="replace")[:31]
+        name = self._ensure_own_info().deviceName
+        for idx, b in enumerate(raw):
+            name[idx] = b
+
+    @property
+    def dataType(self):
+        i = self._read_info()
+        if i is None:
+            return DataType.NTF_EEG
+        try:
+            return DataType(i.dataType)
+        except ValueError:
+            return i.dataType
+
+    @dataType.setter
+    def dataType(self, value):
+        self._ensure_own_info().dataType = int(value)
+
+    lostPackageCount = _info_field("lostPackageCount", 0)
+    sampleRate = _info_field("sampleRate", 0.0)
+    channelCount = _info_field("channelCount", 0)
+    channelMask = _info_field("channelMask", 0)
+    sampleCount = _info_field("sampleCount", 0)
+    startTimeStamp = _info_field("startTimeStamp", 0)
+    delay = _info_field("delay", 0)
+    startTimeSec = _info_field("startTimeSec", 0.0)
+
+    def getDeviceMac(self) -> str:
+        return self.deviceMac
+
+    def getDeviceName(self) -> str:
+        return self.deviceName
+
+    def getDataType(self):
+        return self.dataType
+
+    def getLostPackageCount(self) -> int:
+        return self.lostPackageCount
+
+    def getSampleRate(self) -> float:
+        return self.sampleRate
+
+    def getChannelCount(self) -> int:
+        return self.channelCount
+
+    def getChannelMask(self) -> int:
+        return self.channelMask
+
+    def getSampleCount(self) -> int:
+        return self.sampleCount
+
+    def getStartTimeStamp(self) -> int:
+        return self.startTimeStamp
+
+    def getDelay(self) -> int:
+        return self.delay
+
+    def getStartTimeSec(self) -> float:
+        return self.startTimeSec
+
+    def _slot_offset(self, channelIndex: int, sampleIndex: int) -> int:
+        return (channelIndex * self.sampleCount + sampleIndex) * SAMPLE_SIZE
+
+    def _check_slot(self, channelIndex: int, sampleIndex: int) -> int:
+        if (not self._buf
+                or channelIndex < 0 or channelIndex >= self.channelCount
+                or sampleIndex < 0 or sampleIndex >= self.sampleCount):
+            raise IndexError(
+                "sample (%d, %d) out of range (%d channels x %d samples)"
+                % (channelIndex, sampleIndex, self.channelCount, self.sampleCount))
+        return self._slot_offset(channelIndex, sampleIndex)
+
+    def isDataValid(self, channelIndex: int = 0, sampleIndex: int = 0) -> bool:
+        if (not self._buf
+                or channelIndex < 0 or channelIndex >= self.channelCount
+                or sampleIndex < 0 or sampleIndex >= self.sampleCount):
+            return False
+        if self.startTimeStamp != self._view_start_time_stamp:
+            return False
+        off = self._slot_offset(channelIndex, sampleIndex)
+        return (struct.unpack_from("<i", self._buf, off + _OFF_SAMPLE_INDEX)[0]
+                == self.startSampleIndex + sampleIndex)
+
+    def isChannelEnabled(self, channelIndex: int) -> bool:
+        if channelIndex < 0 or channelIndex >= 64:
+            return False
+        return ((self.channelMask >> channelIndex) & 1) != 0
+
+    def getChannelSample(self, channelIndex: int, sampleIndex: int) -> Sample:
+        off = self._check_slot(channelIndex, sampleIndex)
+        (abs_ts, ch, idx, raw, data, impedance, saturation, is_lost) = \
+            struct.unpack_from(_SAMPLE_FMT, self._buf, off)
+        s = Sample()
+        s.rawData = raw
+        s.data = data
+        s.impedance = impedance
+        s.saturation = saturation
+        s.sampleIndex = idx
+        s.isLost = is_lost != 0
+        s.absTimeStampInSec = abs_ts
+        s.channelIndex = ch
+        return s
+
+    def _read(self, fmt, field_off, channelIndex, sampleIndex):
+        off = self._check_slot(channelIndex, sampleIndex)
+        return struct.unpack_from(fmt, self._buf, off + field_off)[0]
+
+    def getTimeStampInMs(self, channelIndex: int, sampleIndex: int) -> int:
+        idx = self.getSampleIndex(channelIndex, sampleIndex)
+        rate = self.sampleRate
+        if rate <= 0:
+            return 0
+        return int(idx * 1000.0 / rate)
+
+    def getAbsTimeStampInSec(self, channelIndex: int, sampleIndex: int) -> float:
+        return self._read("<d", _OFF_ABS_TIMESTAMP, channelIndex, sampleIndex)
+
+    def getSampleIndex(self, channelIndex: int, sampleIndex: int) -> int:
+        return self._read("<i", _OFF_SAMPLE_INDEX, channelIndex, sampleIndex)
+
+    def getRawData(self, channelIndex: int, sampleIndex: int) -> int:
+        return self._read("<i", _OFF_RAW_DATA, channelIndex, sampleIndex)
+
+    def getData(self, channelIndex: int, sampleIndex: int) -> float:
+        return self._read("<f", _OFF_DATA, channelIndex, sampleIndex)
+
+    def getImpedance(self, channelIndex: int, sampleIndex: int) -> float:
+        return self._read("<f", _OFF_IMPEDANCE, channelIndex, sampleIndex)
+
+    def getSaturation(self, channelIndex: int, sampleIndex: int) -> float:
+        return self._read("<f", _OFF_SATURATION, channelIndex, sampleIndex)
+
+    def isLost(self, channelIndex: int, sampleIndex: int) -> bool:
+        return self._read("<B", _OFF_IS_LOST, channelIndex, sampleIndex) != 0
+
+    def as_numpy(self):
+        try:
+            import numpy as np
+        except ImportError as e:
+            raise ImportError(
+                "SensorData.as_numpy() requires numpy (pip install numpy); "
+                "the sensor package itself only needs the stdlib") from e
+        dtype = np.dtype({
+            "names": ["absTimeStampInSec", "channelIndex", "sampleIndex", "rawData",
+                      "data", "impedance", "saturation", "isLost", "_pad"],
+            "formats": ["<f8", "<i4", "<i4", "<i4",
+                        "<f4", "<f4", "<f4", "<u1", "V7"],
+            "offsets": [0, 8, 12, 16, 20, 24, 28, 32, 33],
+            "itemsize": SAMPLE_SIZE,
+        })
+        arr = np.frombuffer(self._buf, dtype=dtype)
+        return arr.reshape(self.channelCount, self.sampleCount)
+
+    def clone(self) -> "SensorData":
+        out = SensorData()
+        src = self._read_info()
+        if src is not None:
+            ctypes.memmove(ctypes.byref(out._ensure_own_info()),
+                           ctypes.byref(src), ctypes.sizeof(sen_data_info_t))
+        out._startSampleIndex = self._startSampleIndex
+        out._view_start_time_stamp = self._view_start_time_stamp
+        out._buf = bytes(self._buf)
+        return out

sensor/sensor_device.py

@@ -0,0 +1,120 @@
+from enum import Enum
+
+from . import _dll
+
+class DeviceInfo:
+    def __init__(self):
+        self.DeviceName = ""
+        self.ModelName = ""
+        self.HardwareVersion = ""
+        self.FirmwareVersion = ""
+        self.PpgChannelCount = 0
+        self.PpgSampleRate = 0
+        self.Spo2ChannelCount = 0
+        self.Spo2SampleRate = 0
+        self.ImpeChannelCount = 0
+        self.ImpeSampleRate = 0
+        self.EmgChannelCount = 0
+        self.EmgSampleRate = 0
+        self.EegChannelCount = 0
+        self.EegSampleRate = 0
+        self.EcgChannelCount = 0
+        self.EcgSampleRate = 0
+        self.EmgMaxSampleRate = 0
+        self.EegMaxSampleRate = 0
+        self.EcgMaxSampleRate = 0
+        self.ConnectionIntervalMs = 0.0
+        self.PeripheralLatency = -1
+        self.SupervisionTimeoutMs = 0
+        self.Backend = ""
+        self.AccChannelCount = 0
+        self.AccSampleRate = 0
+        self.GyroChannelCount = 0
+        self.GyroSampleRate = 0
+        self.BrthChannelCount = 0
+        self.BrthSampleRate = 0
+        self.MagAngleChannelCount = 0
+        self.MagAngleSampleRate = 0
+        self.EulerChannelCount = 0
+        self.EulerSampleRate = 0
+        self.QuatChannelCount = 0
+        self.QuatSampleRate = 0
+        self.ImuChannelCount = 0
+        self.ImuSampleRate = 0
+        self.MTUSize = 0
+        self.IsMTUFine = 0
+        self.EmgGain = 0
+        self.EegGain = 0
+        self.EcgGain = 0
+        self.GestChannelCount = 0
+        self.GestSampleRate = 0
+
+    @classmethod
+    def _from_c(cls, info: "_dll.sen_device_info_t") -> "DeviceInfo":
+        d = cls()
+        d.DeviceName = _decode(info.deviceName)
+        d.ModelName = _decode(info.modelName)
+        d.HardwareVersion = _decode(info.hardwareVersion)
+        d.FirmwareVersion = _decode(info.firmwareVersion)
+        d.PpgChannelCount = info.PpgChannelCount
+        d.PpgSampleRate = info.PpgSampleRate
+        d.Spo2ChannelCount = info.Spo2ChannelCount
+        d.Spo2SampleRate = info.Spo2SampleRate
+        d.ImpeChannelCount = info.ImpeChannelCount
+        d.ImpeSampleRate = info.ImpeSampleRate
+        d.EmgChannelCount = info.EMGChannelCount
+        d.EmgSampleRate = info.EMGSampleRate
+        d.EegChannelCount = info.EEGChannelCount
+        d.EegSampleRate = info.EEGSampleRate
+        d.EcgChannelCount = info.ECGChannelCount
+        d.EcgSampleRate = info.ECGSampleRate
+        d.EmgMaxSampleRate = info.EmgMaxSampleRate
+        d.EegMaxSampleRate = info.EegMaxSampleRate
+        d.EcgMaxSampleRate = info.EcgMaxSampleRate
+        d.ConnectionIntervalMs = info.ConnectionIntervalMs
+        d.PeripheralLatency = info.PeripheralLatency
+        d.SupervisionTimeoutMs = info.SupervisionTimeoutMs
+        d.Backend = _decode(info.backend)
+        d.AccChannelCount = info.AccChannelCount
+        d.AccSampleRate = info.AccSampleRate
+        d.GyroChannelCount = info.GyroChannelCount
+        d.GyroSampleRate = info.GyroSampleRate
+        d.BrthChannelCount = info.BRTHChannelCount
+        d.BrthSampleRate = info.BRTHSampleRate
+        d.MagAngleChannelCount = info.MagAngleChannelCount
+        d.MagAngleSampleRate = info.MagAngleSampleRate
+        d.EulerChannelCount = info.EulerChannelCount
+        d.EulerSampleRate = info.EulerSampleRate
+        d.QuatChannelCount = info.QuatChannelCount
+        d.QuatSampleRate = info.QuatSampleRate
+        d.ImuChannelCount = info.ImuChannelCount
+        d.ImuSampleRate = info.ImuSampleRate
+        d.MTUSize = info.MTUSize
+        d.IsMTUFine = info.isMTUFine
+        d.EmgGain = info.EMGGain
+        d.EegGain = info.EEGGain
+        d.EcgGain = info.ECGGain
+        d.GestChannelCount = info.GestChannelCount
+        d.GestSampleRate = info.GestSampleRate
+        return d
+
+class DeviceStateEx(Enum):
+    Disconnected = 0
+    Connecting = 1
+    Connected = 2
+    Ready = 3
+    Disconnecting = 4
+    Invalid = 5
+
+class BLEDevice:
+    def __init__(self, name: str, address: str, rssi: int):
+        self.Name = name
+        self.Address = address
+        self.RSSI = rssi
+
+    @classmethod
+    def _from_c(cls, dev: "_dll.sen_ble_device_t") -> "BLEDevice":
+        return cls(_decode(dev.name), _decode(dev.mac), dev.rssi)
+
+def _decode(raw) -> str:
+    return bytes(raw).split(b"\0", 1)[0].decode("utf-8", errors="replace")