sensor-sdk 0.0.1__py3-none-any.whl

sensor/sensor_controller.py

@@ -0,0 +1,223 @@
+from concurrent.futures import ThreadPoolExecutor
+import threading
+from typing import Callable, Dict, List, Optional, Tuple
+
+import bleak
+
+from sensor import sensor_profile
+from sensor.sensor_profile import DeviceStateEx, SensorProfile
+import asyncio
+
+from sensor.utils import start_loop, sync_timer, timer
+from bleak import (
+    BleakScanner,
+    AdvertisementData,
+)
+SERVICE_GUID = "0000ffd0-0000-1000-8000-00805f9b34fb"
+RFSTAR_SERVICE_GUID = "00001812-0000-1000-8000-00805f9b34fb"
+
+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
+
+    """
+    SensorController 类的操作包括扫描蓝牙设备以及回调，创建SensorProfile等。
+    """
+
+    def __init__(self):
+        """
+        初始化 SensorController 实例。
+        """
+        self._event_loop = asyncio.new_event_loop()
+        self._event_thread = threading.Thread(target=start_loop, args=(self._event_loop,))
+        self._event_thread.daemon = True
+        self._event_thread.name = "SensorController event"
+        self._event_thread.start()
+        self._gforce_event_loop = asyncio.new_event_loop()
+        self._gforce_event_thread = threading.Thread(target=start_loop, args=(self._gforce_event_loop,))
+        self._gforce_event_thread.daemon = True
+        self._gforce_event_thread.name = "BLE operation"
+        self._gforce_event_thread.start()
+        self._scanner = BleakScanner(detection_callback=self._match_device,service_uuids=[SERVICE_GUID,RFSTAR_SERVICE_GUID])
+        self._is_scanning = False
+        self._device_callback: Callable[[List[sensor_profile.BLEDevice]], None] = None
+        self._device_callback_period = 0
+        self._enable_callback: Callable[[bool], None] = None
+        self._sensor_profiles: Dict[str, SensorProfile] = dict()
+
+    def __del__(self) -> None:
+        """
+        反初始化 SensorController 类的实例。
+
+        """
+        self._event_loop.close()
+        self._gforce_event_loop.close()
+
+    def terminate(self):
+        for sensor in self._sensor_profiles.values():
+            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
+                sensor.destroy()
+            
+
+    def _match_device(self, _device: bleak.BLEDevice, adv: AdvertisementData):
+        if _device.name == None:
+            return False
+
+        if (
+            SERVICE_GUID in adv.service_uuids
+        ):
+            print("Device found: {0}, RSSI: {1}".format(_device.name, adv.rssi))
+            return True
+
+        return False
+
+    @property
+    def isScaning(self) -> bool:
+        """
+        检查是否正在扫描。
+
+        :return:            bool: 是否正在扫描
+        """
+        return self._is_scanning
+
+    @property
+    def isEnable(self) -> bool:
+        """
+        检查蓝牙是否启用。
+
+        :return:            bool: 是否启用
+        """
+        return True
+
+    @isEnable.setter
+    def onEnableCallback(self, callback: Callable[[bool], None]):
+        """
+        设置蓝牙开关变化回调，当系统蓝牙开关发生变化时调用。
+
+        :param            callback (Callable[[bool], None]): 扫描蓝牙开关状态回调函数
+        """
+        self._enable_callback = callback
+
+    @property
+    def hasDeviceCallback(self) -> bool:
+        """
+        检查是否有扫描设备回调。
+
+        :return:            bool: 是否有设备回调
+        """
+        return self._device_callback != None
+
+    @hasDeviceCallback.setter
+    def onDeviceFoundCallback(self, callback: Callable[[List[sensor_profile.BLEDevice]], None]):
+        """
+        设置扫描设备回调。
+
+        :param            callback (Callable[[List[BLEDevice]], None]): 扫描设备回调函数
+        """
+        self._device_callback = callback
+
+    async def _device_scan_callback(self, found_devices: Dict[str, Tuple[bleak.BLEDevice, AdvertisementData]]):
+        if self._device_callback:
+            devices:List[sensor_profile.BLEDevice] = list()
+            deviceMap :Dict[str, SensorProfile] = self._sensor_profiles.copy()
+            for mac in found_devices:
+                device = found_devices[mac][0]
+                adv = found_devices[mac][1]
+                if SERVICE_GUID in adv.service_uuids:
+                    if deviceMap.get(mac) != None:
+                        devices.append(self._sensor_profiles[mac].BLEDevice)
+                    else:
+                        newSensor = SensorProfile(device, adv,self._gforce_event_loop)
+                        deviceMap[mac] = newSensor
+                        devices.append(newSensor.BLEDevice)
+            self._sensor_profiles = deviceMap
+            self._device_callback(devices)
+
+        if self._is_scanning:
+            timer(self._gforce_event_loop, 0, self._startScan())
+
+    async def _startScan(self) -> bool:
+        devices = await self._scanner.discover(timeout=self._device_callback_period / 1000, return_adv=True)
+        timer(self._event_loop, 0, self._device_scan_callback(devices))
+    def startScan(self, periodInMs: int) -> bool:
+        """
+        开始扫描。
+
+        :param            periodInMs (int): 扫描时长（毫秒）
+
+        :return:            bool: 扫描是否成功启动
+        """
+        if (self._is_scanning):
+            return True
+        
+        self._is_scanning = True
+        self._device_callback_period = periodInMs
+        
+        timer(self._gforce_event_loop, 0, self._startScan())
+        return True
+
+    def stopScan(self) -> None:
+        """
+        停止扫描。
+        """
+        if (not self._is_scanning):
+            return 
+        
+        self._is_scanning = False
+
+    def requireSensor(self, device: sensor_profile.BLEDevice) -> Optional[SensorProfile]:
+        """
+        根据设备信息获取或创建SensorProfile。
+
+        :param            device (BLEDevice): 蓝牙设备信息
+
+        :return:            Optional[SensorProfile]: SensorProfile
+        """
+        if self._sensor_profiles.get(device.Address) == None:
+            newSensor = SensorProfile(device)
+            self._sensor_profiles[device.Address] = newSensor
+
+        return self._sensor_profiles[device.Address]
+
+    def getSensor(self, deviceMac: str) -> Optional[SensorProfile]:
+        """
+        根据设备 MAC 地址获取SensorProfile。
+
+        :params deviceMac (str): 设备 MAC 地址
+
+        :return:  Optional[SensorProfile]: SensorProfile
+        """
+        return self._sensor_profiles[deviceMac]
+
+    def getConnectedSensors(self) -> List[SensorProfile]:
+        """
+        获取已连接的SensorProfile列表。
+
+        :return:            List[SensorProfile]: 已连接的SensorProfile列表
+        """
+        sensors:List[SensorProfile] = list()
+        for sensor in self._sensor_profiles.values():
+            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
+                sensors.append(sensor)
+
+        return sensors
+
+    def getConnectedDevices(self) -> List[sensor_profile.BLEDevice]:
+        """
+        获取已连接的蓝牙设备列表。
+
+        :return:            List[BLEDevice]: 已连接的蓝牙设备列表
+        """
+        devices:List[sensor_profile.BLEDevice] = list()
+        for sensor in self._sensor_profiles.values():
+            if sensor.deviceState == DeviceStateEx.Connected or sensor.deviceState == DeviceStateEx.Ready:
+                devices.append(sensor.BLEDevice)
+
+        return devices
+
+SensorControllerInstance = SensorController()

sensor/sensor_data.py

@@ -0,0 +1,91 @@
+from enum import Enum, IntEnum
+from typing import Dict, List
+
+# 一个采样数据
+# 该类用于存储单个采样数据的相关信息，包括数据值、阻抗、饱和度、采样索引和是否丢包的标志
+class Sample:
+    # """
+    # Initialize a Sample instance.
+
+    # :param data: 数据值，单位为 uV
+    # :param impedance:  阻抗值，单位为 Ω
+    # :param saturation: 饱和度值，单位为 % ，值 0-100
+    # :param sample_index: 采样索引，用于标识采样的顺序
+    # :param is_lost: 是否丢包的标志，True 表示丢包，False 表示正常
+    # """
+    # def __init__(self, data: int, impedance: int, saturation: int, sample_index: int, is_lost: bool):
+    #     self.data = data                                    
+    #     self.impedance = impedance                          
+    #     self.saturation = saturation                        
+    #     self.sampleIndex = sample_index                     
+    #     self.isLost = is_lost                               
+
+    def __init__(self):
+        self.rawData = 0
+        self.data = 0                                    
+        self.impedance = 0                          
+        self.saturation = 0                        
+        self.sampleIndex = 0                     
+        self.isLost = False      
+        self.timeStampInMs = 0
+        self.channelIndex = 0
+        self.sampleIndex = 0
+
+# 对应 DataType 枚举
+# 该枚举类定义了不同类型的数据，用于区分传感器采集的不同类型的数据
+class DataType(IntEnum):
+    NTF_ACC = 0x1       # 加速度，用于标识加速度传感器采集的数据
+    NTF_GYRO = 0x2      # 陀螺仪，用于标识陀螺仪传感器采集的数据
+    NTF_EEG = 0x10      # EEG，用于标识脑电传感器采集的数据
+    NTF_ECG = 0x11      # ECG，用于标识心电传感器采集的数据
+    NTF_IMPEDANCE = 0x12, # 阻抗数据
+    NTF_IMU = 0x13,     # 包含ACC和GYRO数据
+    NTF_ADS = 0x14,     # 无单位ads数据
+    NTF_BRTH = 0x15     # 呼吸，用于标识呼吸传感器采集的数据
+
+# 一次采样的数据，包含多个通道的数据，channal_samples 为一个二维数组, 第一个维度为通道索引，第二个维度为采样索引
+# 该类用于存储一次采样的完整数据，包括设备 MAC 地址、数据类型、采样率、通道数量、包中采样数量以及通道采样数据
+class SensorData:
+    # """
+    # Initialize a SensorData instance.
+
+    # :param device_mac: The MAC address of the device.
+    # :param data_type: The type of data being collected.
+    # :param sample_rate: The rate at which samples are collected.
+    # :param channel_count: The number of channels in the data.
+    # :param package_sample_count: The number of samples in the package.
+    # :param channel_samples: A list of lists containing the sample data for each channel.
+    # """ 
+    # def __init__(self, device_mac: str, data_type: DataType, sample_rate: int, channel_count: int,
+    #              package_sample_count: int, channel_samples: List[List[Sample]]):
+    #     self.deviceMac = device_mac                        
+    #     self.dataType = data_type                           
+    #     self.sampleRate = sample_rate                      
+    #     self.channelCount = channel_count                  
+    #     self.packageSampleCount = package_sample_count     
+    #     self.channelSamples = channel_samples   
+    #     self.lastPackageCounter = 0
+    #     self.lastPackageIndex = 0           
+    #     self.resolutionBits = 0    
+    #     self.channelMask = 0    
+    #     self.minPackageSampleCount = 0    
+    #     self.K = 0    
+
+    def __init__(self):
+        self.deviceMac = ""                        
+        self.dataType = DataType.NTF_EEG                           
+        self.sampleRate = 0                      
+        self.channelCount = 0                  
+        self.packageSampleCount = 0     
+        self.channelSamples:List[List[Sample]] = list()   
+        self.lastPackageCounter = 0
+        self.lastPackageIndex = 0           
+        self.resolutionBits = 0    
+        self.channelMask = 0    
+        self.minPackageSampleCount = 0    
+        self.K = 0   
+
+    def clear(self):
+        self.channelSamples.clear()
+        self.lastPackageCounter = 0
+        self.lastPackageIndex = 0