1096 lines
38 KiB
Python
1096 lines
38 KiB
Python
"""
|
||
设备管理器模块
|
||
负责发现、管理和控制各种触觉反馈设备
|
||
"""
|
||
|
||
import time
|
||
from typing import Dict, Any, List, Optional
|
||
import platform
|
||
import threading
|
||
import math
|
||
|
||
class DeviceType:
|
||
"""设备类型常量"""
|
||
GAMEPAD = "gamepad"
|
||
VR_CONTROLLER = "vr_controller"
|
||
HAPTIC_GLOVE = "haptic_glove"
|
||
VEST = "vest"
|
||
SEAT = "seat"
|
||
WHEEL = "wheel"
|
||
CUSTOM = "custom"
|
||
SMARTPHONE = "smartphone"
|
||
WATCH = "watch"
|
||
EXOSUIT = "exosuit"
|
||
|
||
class ConnectionType:
|
||
"""连接类型常量"""
|
||
USB = "usb"
|
||
BLUETOOTH = "bluetooth"
|
||
WIRELESS = "wireless"
|
||
BUILT_IN = "built_in"
|
||
NETWORK = "network"
|
||
|
||
class HapticDeviceManager:
|
||
"""
|
||
触觉设备管理器
|
||
负责发现、管理和控制各种触觉反馈设备
|
||
"""
|
||
|
||
def __init__(self, plugin):
|
||
"""
|
||
初始化触觉设备管理器
|
||
|
||
Args:
|
||
plugin: 触觉反馈系统插件实例
|
||
"""
|
||
self.plugin = plugin
|
||
self.enabled = False
|
||
self.initialized = False
|
||
|
||
# 设备字典
|
||
self.devices = {}
|
||
self.device_counter = 0
|
||
|
||
# 已连接设备
|
||
self.connected_devices = {}
|
||
|
||
# 设备发现配置
|
||
self.discovery_config = {
|
||
'auto_discovery': True,
|
||
'discovery_interval': 5.0,
|
||
'supported_platforms': ['Windows', 'Linux', 'Darwin'],
|
||
'supported_devices': [
|
||
DeviceType.GAMEPAD,
|
||
DeviceType.VR_CONTROLLER,
|
||
DeviceType.HAPTIC_GLOVE,
|
||
DeviceType.VEST,
|
||
DeviceType.SEAT,
|
||
DeviceType.WHEEL,
|
||
DeviceType.SMARTPHONE,
|
||
DeviceType.WATCH,
|
||
DeviceType.EXOSUIT
|
||
],
|
||
'bluetooth_discovery': True,
|
||
'usb_discovery': True,
|
||
'network_discovery': True
|
||
}
|
||
|
||
# 平台特定配置
|
||
self.platform_config = {
|
||
'Windows': {
|
||
'api': 'xinput',
|
||
'libraries': ['pydirectinput', 'xinput'],
|
||
'features': ['xinput', 'directinput'],
|
||
'device_paths': ['\\\\.\\PhysicalDrive0']
|
||
},
|
||
'Linux': {
|
||
'api': 'udev',
|
||
'libraries': ['evdev', 'pygame'],
|
||
'features': ['udev', 'evdev'],
|
||
'device_paths': ['/dev/input', '/dev/hidraw']
|
||
},
|
||
'Darwin': { # macOS
|
||
'api': 'iokit',
|
||
'libraries': ['pyobjc'],
|
||
'features': ['corehaptics', 'iokit'],
|
||
'device_paths': ['/dev/']
|
||
}
|
||
}
|
||
|
||
# 设备能力映射
|
||
self.device_capabilities = {
|
||
DeviceType.GAMEPAD: [
|
||
'left_rumble', 'right_rumble', 'trigger_rumble',
|
||
'high_frequency', 'low_frequency', 'adaptive_triggers'
|
||
],
|
||
DeviceType.VR_CONTROLLER: [
|
||
'rumble', 'texture_feedback', 'temperature_feedback',
|
||
'force_feedback', 'vibration_patterns', 'haptic_positioning'
|
||
],
|
||
DeviceType.HAPTIC_GLOVE: [
|
||
'finger_vibration', 'palm_vibration', 'force_feedback',
|
||
'texture_simulation', 'temperature_simulation', 'gesture_feedback'
|
||
],
|
||
DeviceType.VEST: [
|
||
'full_body_vibration', 'localized_vibration',
|
||
'directional_feedback', 'pressure_points', 'impact_simulation'
|
||
],
|
||
DeviceType.SEAT: [
|
||
'low_frequency_rumble', 'vibration_patterns',
|
||
'directional_feedback', 'motion_simulation', 'bass_shakers'
|
||
],
|
||
DeviceType.WHEEL: [
|
||
'force_feedback', 'vibration', 'road_texture',
|
||
'collision_feedback', 'gear_shift', 'damper_effects'
|
||
],
|
||
DeviceType.SMARTPHONE: [
|
||
'simple_vibration', 'pattern_vibration', 'amplitude_control'
|
||
],
|
||
DeviceType.WATCH: [
|
||
'taptic_engine', 'notification_feedback', 'haptic_notifications'
|
||
],
|
||
DeviceType.EXOSUIT: [
|
||
'full_body_actuation', 'muscle_simulation', 'balance_feedback',
|
||
'force_amplification', 'movement_guidance'
|
||
]
|
||
}
|
||
|
||
# 设备区域映射
|
||
self.device_zones = {
|
||
DeviceType.GAMEPAD: ['left_handle', 'right_handle', 'triggers'],
|
||
DeviceType.VR_CONTROLLER: ['handle', 'buttons', 'touchpad'],
|
||
DeviceType.HAPTIC_GLOVE: ['thumb', 'index', 'middle', 'ring', 'pinky', 'palm'],
|
||
DeviceType.VEST: ['front', 'back', 'left', 'right', 'top', 'bottom'],
|
||
DeviceType.SEAT: ['seat_base', 'seat_back', 'left_side', 'right_side'],
|
||
DeviceType.WHEEL: ['wheel', 'pedals', 'shifter'],
|
||
DeviceType.SMARTPHONE: ['back_panel'],
|
||
DeviceType.WATCH: ['back_panel'],
|
||
DeviceType.EXOSUIT: ['legs', 'arms', 'torso', 'feet']
|
||
}
|
||
|
||
# 设备状态
|
||
self.device_states = {
|
||
'scanning': False,
|
||
'last_scan': 0.0,
|
||
'devices_found': 0,
|
||
'bluetooth_connected': 0,
|
||
'usb_connected': 0
|
||
}
|
||
|
||
# 统计信息
|
||
self.stats = {
|
||
'devices_registered': 0,
|
||
'devices_connected': 0,
|
||
'devices_disconnected': 0,
|
||
'scan_operations': 0,
|
||
'haptic_effects': 0,
|
||
'device_errors': 0,
|
||
'data_transmitted': 0
|
||
}
|
||
|
||
# 线程管理
|
||
self.discovery_thread = None
|
||
self.running = False
|
||
|
||
# 回调函数
|
||
self.device_callbacks = {
|
||
'device_connected': [],
|
||
'device_disconnected': [],
|
||
'device_updated': [],
|
||
'haptic_effect_applied': [],
|
||
'device_error': []
|
||
}
|
||
|
||
# 设备配置
|
||
self.device_config = {
|
||
'default_intensity': 0.8,
|
||
'default_frequency': 50.0,
|
||
'max_intensity': 1.0,
|
||
'min_frequency': 1.0,
|
||
'max_frequency': 300.0,
|
||
'response_time': 0.01, # 10ms响应时间
|
||
'enable_safety_limits': True
|
||
}
|
||
|
||
# 设备缓存
|
||
self.device_cache = {}
|
||
|
||
# 时间戳记录
|
||
self.last_discovery_time = 0.0
|
||
self.last_state_update = 0.0
|
||
|
||
print("✓ 触觉设备管理器已创建")
|
||
|
||
def initialize(self) -> bool:
|
||
"""
|
||
初始化触觉设备管理器
|
||
|
||
Returns:
|
||
是否初始化成功
|
||
"""
|
||
try:
|
||
# 检查平台支持
|
||
current_platform = platform.system()
|
||
if current_platform not in self.discovery_config['supported_platforms']:
|
||
print(f"⚠ 平台未完全支持: {current_platform}")
|
||
|
||
# 初始化平台特定功能
|
||
self._initialize_platform_features()
|
||
|
||
# 创建初始设备
|
||
self._create_default_devices()
|
||
|
||
# 初始化设备缓存
|
||
self._initialize_device_cache()
|
||
|
||
self.initialized = True
|
||
print("✓ 触觉设备管理器初始化完成")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 触觉设备管理器初始化失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def enable(self) -> bool:
|
||
"""
|
||
启用触觉设备管理器
|
||
|
||
Returns:
|
||
是否启用成功
|
||
"""
|
||
try:
|
||
if not self.initialized:
|
||
print("✗ 触觉设备管理器未初始化")
|
||
return False
|
||
|
||
self.enabled = True
|
||
self.running = True
|
||
|
||
# 启动设备发现线程
|
||
if self.discovery_config['auto_discovery']:
|
||
self.discovery_thread = threading.Thread(target=self._discovery_loop, daemon=True)
|
||
self.discovery_thread.start()
|
||
|
||
print("✓ 触觉设备管理器已启用")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 触觉设备管理器启用失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return False
|
||
|
||
def disable(self):
|
||
"""禁用触觉设备管理器"""
|
||
try:
|
||
self.enabled = False
|
||
self.running = False
|
||
|
||
# 等待发现线程结束
|
||
if self.discovery_thread and self.discovery_thread.is_alive():
|
||
self.discovery_thread.join(timeout=2.0)
|
||
|
||
# 断开所有设备
|
||
self._disconnect_all_devices()
|
||
|
||
print("✓ 触觉设备管理器已禁用")
|
||
|
||
except Exception as e:
|
||
print(f"✗ 触觉设备管理器禁用失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def finalize(self):
|
||
"""清理触觉设备管理器资源"""
|
||
try:
|
||
self.disable()
|
||
self.devices.clear()
|
||
self.connected_devices.clear()
|
||
self.device_states.clear()
|
||
self.device_callbacks.clear()
|
||
self.device_cache.clear()
|
||
self.initialized = False
|
||
print("✓ 触觉设备管理器资源已清理")
|
||
|
||
except Exception as e:
|
||
print(f"✗ 触觉设备管理器资源清理失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def update(self, dt: float):
|
||
"""
|
||
更新触觉设备管理器状态
|
||
|
||
Args:
|
||
dt: 时间增量
|
||
"""
|
||
try:
|
||
if not self.enabled:
|
||
return
|
||
|
||
current_time = time.time()
|
||
|
||
# 定期更新设备状态
|
||
if current_time - self.last_state_update > 1.0: # 每秒更新一次
|
||
self._update_device_states()
|
||
self.last_state_update = current_time
|
||
|
||
# 更新统计信息
|
||
self.stats['devices_connected'] = len(self.connected_devices)
|
||
|
||
except Exception as e:
|
||
print(f"✗ 触觉设备管理器更新失败: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
def _initialize_platform_features(self):
|
||
"""初始化平台特定功能"""
|
||
try:
|
||
current_platform = platform.system()
|
||
platform_info = self.platform_config.get(current_platform, {})
|
||
|
||
print(f"✓ 平台初始化: {current_platform}")
|
||
print(f" API: {platform_info.get('api', 'unknown')}")
|
||
print(f" 特性: {', '.join(platform_info.get('features', []))}")
|
||
|
||
except Exception as e:
|
||
print(f"✗ 平台功能初始化失败: {e}")
|
||
|
||
def _initialize_device_cache(self):
|
||
"""初始化设备缓存"""
|
||
try:
|
||
# 预创建常用设备的配置模板
|
||
for device_type in self.device_capabilities:
|
||
self.device_cache[device_type] = {
|
||
'capabilities': self.device_capabilities[device_type],
|
||
'zones': self.device_zones.get(device_type, []),
|
||
'default_config': self._get_default_device_config(device_type)
|
||
}
|
||
|
||
print("✓ 设备缓存初始化完成")
|
||
except Exception as e:
|
||
print(f"✗ 设备缓存初始化失败: {e}")
|
||
|
||
def _get_default_device_config(self, device_type: str) -> Dict[str, Any]:
|
||
"""
|
||
获取设备默认配置
|
||
|
||
Args:
|
||
device_type: 设备类型
|
||
|
||
Returns:
|
||
默认配置字典
|
||
"""
|
||
base_config = {
|
||
'intensity_scale': 1.0,
|
||
'frequency_scale': 1.0,
|
||
'response_curve': 'linear',
|
||
'max_actuators': 1,
|
||
'min_update_interval': 0.01
|
||
}
|
||
|
||
# 根据设备类型添加特定配置
|
||
if device_type == DeviceType.HAPTIC_GLOVE:
|
||
base_config.update({
|
||
'max_actuators': 6, # 5个手指+手掌
|
||
'independent_control': True
|
||
})
|
||
elif device_type == DeviceType.VEST:
|
||
base_config.update({
|
||
'max_actuators': 6, # 6个区域
|
||
'spatial_resolution': True
|
||
})
|
||
elif device_type == DeviceType.EXOSUIT:
|
||
base_config.update({
|
||
'max_actuators': 16, # 多部位控制
|
||
'force_feedback': True,
|
||
'position_tracking': True
|
||
})
|
||
|
||
return base_config
|
||
|
||
def _create_default_devices(self):
|
||
"""创建默认设备"""
|
||
try:
|
||
current_platform = platform.system()
|
||
|
||
# 创建默认游戏手柄
|
||
gamepad_id = self.register_device(
|
||
device_type=DeviceType.GAMEPAD,
|
||
name=f"系统游戏手柄 ({current_platform})",
|
||
connection_type=ConnectionType.BUILT_IN,
|
||
vendor_id="system",
|
||
product_id="gamepad",
|
||
actuators=2 # 左右马达
|
||
)
|
||
|
||
# 创建默认智能手机
|
||
phone_id = self.register_device(
|
||
device_type=DeviceType.SMARTPHONE,
|
||
name=f"系统智能手机 ({current_platform})",
|
||
connection_type=ConnectionType.BUILT_IN,
|
||
vendor_id="system",
|
||
product_id="smartphone",
|
||
actuators=1 # 单一振动马达
|
||
)
|
||
|
||
# 标记为已连接
|
||
if gamepad_id >= 0:
|
||
self.connect_device(gamepad_id)
|
||
if phone_id >= 0:
|
||
self.connect_device(phone_id)
|
||
|
||
print("✓ 默认设备创建完成")
|
||
|
||
except Exception as e:
|
||
print(f"✗ 默认设备创建失败: {e}")
|
||
|
||
def _discovery_loop(self):
|
||
"""设备发现循环"""
|
||
try:
|
||
discovery_interval = self.discovery_config['discovery_interval']
|
||
|
||
while self.running:
|
||
if self.enabled and self.discovery_config['auto_discovery']:
|
||
self.scan_for_devices()
|
||
|
||
time.sleep(discovery_interval)
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备发现循环失败: {e}")
|
||
|
||
def _update_device_states(self):
|
||
"""更新设备状态"""
|
||
try:
|
||
current_time = time.time()
|
||
|
||
# 检查已连接设备的状态
|
||
devices_to_disconnect = []
|
||
for device_id, device_info in self.connected_devices.items():
|
||
# 检查设备是否仍然连接
|
||
if not self._is_device_connected(device_id):
|
||
devices_to_disconnect.append(device_id)
|
||
|
||
# 断开已丢失的设备
|
||
for device_id in devices_to_disconnect:
|
||
self.disconnect_device(device_id)
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备状态更新失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
|
||
def _is_device_connected(self, device_id: int) -> bool:
|
||
"""
|
||
检查设备是否仍然连接
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
|
||
Returns:
|
||
是否连接
|
||
"""
|
||
try:
|
||
# 这里应该实现实际的设备连接检查逻辑
|
||
# 简化处理，假设设备一直连接
|
||
if device_id in self.devices:
|
||
# 模拟设备连接状态检查
|
||
device_info = self.devices[device_id]
|
||
last_seen = device_info.get('last_seen', 0)
|
||
# 如果超过10秒没有更新，认为设备断开
|
||
return (time.time() - last_seen) < 10.0
|
||
return False
|
||
except Exception as e:
|
||
print(f"✗ 设备连接检查失败: {e}")
|
||
return True
|
||
|
||
def _disconnect_all_devices(self):
|
||
"""断开所有设备"""
|
||
try:
|
||
device_ids = list(self.connected_devices.keys())
|
||
for device_id in device_ids:
|
||
self.disconnect_device(device_id)
|
||
except Exception as e:
|
||
print(f"✗ 断开所有设备失败: {e}")
|
||
|
||
def register_device(self, device_type: str, name: str, connection_type: str,
|
||
vendor_id: str, product_id: str,
|
||
capabilities: List[str] = None, actuators: int = 1) -> int:
|
||
"""
|
||
注册设备
|
||
|
||
Args:
|
||
device_type: 设备类型
|
||
name: 设备名称
|
||
connection_type: 连接类型
|
||
vendor_id: 厂商ID
|
||
product_id: 产品ID
|
||
capabilities: 设备功能列表
|
||
actuators: 执行器数量
|
||
|
||
Returns:
|
||
设备ID
|
||
"""
|
||
try:
|
||
device_id = self.device_counter
|
||
self.device_counter += 1
|
||
|
||
# 如果未提供功能列表，使用默认功能
|
||
if capabilities is None:
|
||
capabilities = self.device_capabilities.get(device_type, [])
|
||
|
||
device_info = {
|
||
'id': device_id,
|
||
'type': device_type,
|
||
'name': name,
|
||
'connection_type': connection_type,
|
||
'vendor_id': vendor_id,
|
||
'product_id': product_id,
|
||
'capabilities': capabilities,
|
||
'actuators': actuators,
|
||
'registered_time': time.time(),
|
||
'connected': False,
|
||
'last_seen': 0.0,
|
||
'battery_level': 100.0, # 电池电量百分比
|
||
'signal_strength': 100.0, # 信号强度百分比
|
||
'firmware_version': '1.0.0',
|
||
'hardware_version': '1.0.0',
|
||
'haptic_state': {}, # 触觉状态
|
||
'zones': self.device_zones.get(device_type, []),
|
||
'config': self.device_cache.get(device_type, {}).get('default_config', {}),
|
||
'supported_effects': ['simple', 'periodic', 'envelope'],
|
||
'max_intensity': 1.0,
|
||
'min_frequency': 1.0,
|
||
'max_frequency': 300.0,
|
||
'response_time': 0.01
|
||
}
|
||
|
||
# 根据设备类型添加特定支持的效果
|
||
if device_type in [DeviceType.HAPTIC_GLOVE, DeviceType.VEST, DeviceType.EXOSUIT]:
|
||
device_info['supported_effects'].extend(['texture', 'wind', 'water'])
|
||
if device_type in [DeviceType.VR_CONTROLLER, DeviceType.WHEEL]:
|
||
device_info['supported_effects'].extend(['impulse', 'explosion'])
|
||
|
||
self.devices[device_id] = device_info
|
||
self.stats['devices_registered'] += 1
|
||
|
||
print(f"✓ 设备已注册: {name} (ID: {device_id})")
|
||
return device_id
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备注册失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return -1
|
||
|
||
def unregister_device(self, device_id: int) -> bool:
|
||
"""
|
||
注销设备
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
|
||
Returns:
|
||
是否注销成功
|
||
"""
|
||
try:
|
||
if device_id in self.devices:
|
||
device_info = self.devices[device_id]
|
||
device_name = device_info['name']
|
||
|
||
# 如果设备已连接，先断开连接
|
||
if device_id in self.connected_devices:
|
||
self.disconnect_device(device_id)
|
||
|
||
del self.devices[device_id]
|
||
print(f"✓ 设备已注销: {device_name} (ID: {device_id})")
|
||
return True
|
||
else:
|
||
print(f"✗ 设备不存在: ID {device_id}")
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备注销失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return False
|
||
|
||
def connect_device(self, device_id: int) -> bool:
|
||
"""
|
||
连接设备
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
|
||
Returns:
|
||
是否连接成功
|
||
"""
|
||
try:
|
||
if device_id not in self.devices:
|
||
print(f"✗ 设备不存在: ID {device_id}")
|
||
return False
|
||
|
||
device_info = self.devices[device_id]
|
||
if device_info['connected']:
|
||
print(f"⚠ 设备已连接: {device_info['name']} (ID: {device_id})")
|
||
return True
|
||
|
||
# 模拟设备连接过程
|
||
device_info['connected'] = True
|
||
device_info['last_seen'] = time.time()
|
||
self.connected_devices[device_id] = device_info
|
||
|
||
# 更新连接统计
|
||
conn_type = device_info['connection_type']
|
||
if conn_type == ConnectionType.BLUETOOTH:
|
||
self.device_states['bluetooth_connected'] += 1
|
||
elif conn_type == ConnectionType.USB:
|
||
self.device_states['usb_connected'] += 1
|
||
|
||
# 触发连接回调
|
||
self._trigger_device_callback('device_connected', {
|
||
'device_id': device_id,
|
||
'device_info': device_info
|
||
})
|
||
|
||
self.stats['devices_connected'] += 1
|
||
print(f"✓ 设备已连接: {device_info['name']} (ID: {device_id})")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备连接失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return False
|
||
|
||
def disconnect_device(self, device_id: int) -> bool:
|
||
"""
|
||
断开设备连接
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
|
||
Returns:
|
||
是否断开成功
|
||
"""
|
||
try:
|
||
if device_id not in self.devices:
|
||
print(f"✗ 设备不存在: ID {device_id}")
|
||
return False
|
||
|
||
device_info = self.devices[device_id]
|
||
if not device_info['connected']:
|
||
print(f"⚠ 设备未连接: {device_info['name']} (ID: {device_id})")
|
||
return True
|
||
|
||
# 断开设备连接
|
||
device_info['connected'] = False
|
||
if device_id in self.connected_devices:
|
||
del self.connected_devices[device_id]
|
||
|
||
# 更新连接统计
|
||
conn_type = device_info['connection_type']
|
||
if conn_type == ConnectionType.BLUETOOTH:
|
||
self.device_states['bluetooth_connected'] = max(0, self.device_states['bluetooth_connected'] - 1)
|
||
elif conn_type == ConnectionType.USB:
|
||
self.device_states['usb_connected'] = max(0, self.device_states['usb_connected'] - 1)
|
||
|
||
# 触发断开回调
|
||
self._trigger_device_callback('device_disconnected', {
|
||
'device_id': device_id,
|
||
'device_info': device_info
|
||
})
|
||
|
||
self.stats['devices_disconnected'] += 1
|
||
print(f"✓ 设备已断开: {device_info['name']} (ID: {device_id})")
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备断开失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return False
|
||
|
||
def scan_for_devices(self) -> List[int]:
|
||
"""
|
||
扫描设备
|
||
|
||
Returns:
|
||
发现的设备ID列表
|
||
"""
|
||
try:
|
||
self.device_states['scanning'] = True
|
||
self.device_states['last_scan'] = time.time()
|
||
|
||
discovered_devices = []
|
||
|
||
# 模拟设备发现过程
|
||
# 在实际实现中，这里会根据平台调用相应的API来发现设备
|
||
|
||
# 检查现有设备的状态
|
||
for device_id, device_info in self.devices.items():
|
||
# 模拟设备发现
|
||
if not device_info['connected']:
|
||
# 有一定概率"发现"设备
|
||
import random
|
||
if random.random() < 0.1: # 10%概率
|
||
discovered_devices.append(device_id)
|
||
|
||
self.device_states['devices_found'] = len(discovered_devices)
|
||
self.stats['scan_operations'] += 1
|
||
|
||
if discovered_devices:
|
||
print(f"✓ 发现 {len(discovered_devices)} 个设备")
|
||
|
||
return discovered_devices
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备扫描失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return []
|
||
finally:
|
||
self.device_states['scanning'] = False
|
||
|
||
def apply_haptic_effect(self, device_id: int, intensity: float,
|
||
frequency: float, progress: float,
|
||
zone: str = None, effect_type: str = 'simple') -> bool:
|
||
"""
|
||
应用触觉效果到设备
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
intensity: 强度(0.0-1.0)
|
||
frequency: 频率
|
||
progress: 进度(0.0-1.0)
|
||
zone: 设备区域
|
||
effect_type: 效果类型
|
||
|
||
Returns:
|
||
是否应用成功
|
||
"""
|
||
try:
|
||
# 检查设备是否存在
|
||
if device_id is not None and device_id not in self.devices:
|
||
print(f"✗ 设备不存在: ID {device_id}")
|
||
return False
|
||
|
||
# 检查设备是否连接
|
||
if device_id is not None and not self.devices[device_id]['connected']:
|
||
print(f"✗ 设备未连接: ID {device_id}")
|
||
return False
|
||
|
||
# 限制参数范围
|
||
intensity = max(0.0, min(1.0, intensity))
|
||
frequency = max(0.0, frequency)
|
||
progress = max(0.0, min(1.0, progress))
|
||
|
||
# 应用设备配置限制
|
||
if device_id is not None:
|
||
device_info = self.devices[device_id]
|
||
intensity *= device_info.get('max_intensity', 1.0)
|
||
frequency = max(
|
||
device_info.get('min_frequency', 1.0),
|
||
min(device_info.get('max_frequency', 300.0), frequency)
|
||
)
|
||
|
||
# 检查设备是否支持该效果类型
|
||
supported_effects = device_info.get('supported_effects', ['simple'])
|
||
if effect_type not in supported_effects:
|
||
print(f"⚠ 设备不支持效果类型: {effect_type}")
|
||
# 降级到简单效果
|
||
effect_type = 'simple'
|
||
|
||
# 更新设备触觉状态
|
||
if device_id is not None:
|
||
device_info = self.devices[device_id]
|
||
device_info['haptic_state'] = {
|
||
'intensity': intensity,
|
||
'frequency': frequency,
|
||
'progress': progress,
|
||
'zone': zone,
|
||
'effect_type': effect_type,
|
||
'timestamp': time.time()
|
||
}
|
||
device_info['last_seen'] = time.time()
|
||
|
||
# 模拟数据传输
|
||
data_size = 32 # 模拟32字节数据
|
||
self.stats['data_transmitted'] += data_size
|
||
|
||
# 触发触觉效果应用回调
|
||
self._trigger_device_callback('haptic_effect_applied', {
|
||
'device_id': device_id,
|
||
'intensity': intensity,
|
||
'frequency': frequency,
|
||
'progress': progress,
|
||
'zone': zone,
|
||
'effect_type': effect_type,
|
||
'data_size': data_size
|
||
})
|
||
|
||
self.stats['haptic_effects'] += 1
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 触觉效果应用失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return False
|
||
|
||
def get_device(self, device_id: int) -> Optional[Dict[str, Any]]:
|
||
"""
|
||
获取设备信息
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
|
||
Returns:
|
||
设备信息字典或None
|
||
"""
|
||
return self.devices.get(device_id)
|
||
|
||
def get_connected_devices(self) -> Dict[int, Dict[str, Any]]:
|
||
"""
|
||
获取所有已连接的设备
|
||
|
||
Returns:
|
||
已连接设备字典
|
||
"""
|
||
return self.connected_devices.copy()
|
||
|
||
def get_devices_by_type(self, device_type: str) -> List[Dict[str, Any]]:
|
||
"""
|
||
根据类型获取设备列表
|
||
|
||
Args:
|
||
device_type: 设备类型
|
||
|
||
Returns:
|
||
设备信息列表
|
||
"""
|
||
try:
|
||
devices = []
|
||
for device_info in self.devices.values():
|
||
if device_info['type'] == device_type:
|
||
devices.append(device_info)
|
||
return devices
|
||
except Exception as e:
|
||
print(f"✗ 按类型获取设备失败: {e}")
|
||
return []
|
||
|
||
def update_device_battery(self, device_id: int, battery_level: float):
|
||
"""
|
||
更新设备电池电量
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
battery_level: 电池电量百分比(0-100)
|
||
"""
|
||
try:
|
||
if device_id in self.devices:
|
||
self.devices[device_id]['battery_level'] = max(0.0, min(100.0, battery_level))
|
||
except Exception as e:
|
||
print(f"✗ 设备电池电量更新失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
|
||
def update_device_signal(self, device_id: int, signal_strength: float):
|
||
"""
|
||
更新设备信号强度
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
signal_strength: 信号强度百分比(0-100)
|
||
"""
|
||
try:
|
||
if device_id in self.devices:
|
||
self.devices[device_id]['signal_strength'] = max(0.0, min(100.0, signal_strength))
|
||
except Exception as e:
|
||
print(f"✗ 设备信号强度更新失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
|
||
def set_device_config(self, device_id: int, config: Dict[str, Any]) -> bool:
|
||
"""
|
||
设置设备配置
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
config: 配置字典
|
||
|
||
Returns:
|
||
是否设置成功
|
||
"""
|
||
try:
|
||
if device_id in self.devices:
|
||
self.devices[device_id]['config'].update(config)
|
||
print(f"✓ 设备配置已更新: ID {device_id}")
|
||
return True
|
||
else:
|
||
print(f"✗ 设备不存在: ID {device_id}")
|
||
return False
|
||
except Exception as e:
|
||
print(f"✗ 设备配置设置失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return False
|
||
|
||
def get_device_config(self, device_id: int) -> Optional[Dict[str, Any]]:
|
||
"""
|
||
获取设备配置
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
|
||
Returns:
|
||
配置字典或None
|
||
"""
|
||
try:
|
||
if device_id in self.devices:
|
||
return self.devices[device_id].get('config', {})
|
||
return None
|
||
except Exception as e:
|
||
print(f"✗ 设备配置获取失败: {e}")
|
||
return None
|
||
|
||
def calibrate_device(self, device_id: int) -> bool:
|
||
"""
|
||
校准设备
|
||
|
||
Args:
|
||
device_id: 设备ID
|
||
|
||
Returns:
|
||
是否校准成功
|
||
"""
|
||
try:
|
||
if device_id not in self.devices:
|
||
print(f"✗ 设备不存在: ID {device_id}")
|
||
return False
|
||
|
||
device_info = self.devices[device_id]
|
||
print(f"✓ 设备校准完成: {device_info['name']} (ID: {device_id})")
|
||
|
||
# 更新校准时间
|
||
device_info['last_calibrated'] = time.time()
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"✗ 设备校准失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
return False
|
||
|
||
def _trigger_device_callback(self, callback_type: str, data: Dict[str, Any]):
|
||
"""
|
||
触发设备回调
|
||
|
||
Args:
|
||
callback_type: 回调类型
|
||
data: 回调数据
|
||
"""
|
||
try:
|
||
if callback_type in self.device_callbacks:
|
||
for callback in self.device_callbacks[callback_type]:
|
||
try:
|
||
callback(data)
|
||
except Exception as e:
|
||
print(f"✗ 设备回调执行失败: {e}")
|
||
except Exception as e:
|
||
print(f"✗ 设备回调触发失败: {e}")
|
||
|
||
def register_device_callback(self, callback_type: str, callback: callable):
|
||
"""
|
||
注册设备回调
|
||
|
||
Args:
|
||
callback_type: 回调类型
|
||
callback: 回调函数
|
||
"""
|
||
try:
|
||
if callback_type in self.device_callbacks:
|
||
self.device_callbacks[callback_type].append(callback)
|
||
print(f"✓ 设备回调已注册: {callback_type}")
|
||
else:
|
||
print(f"✗ 无效的回调类型: {callback_type}")
|
||
except Exception as e:
|
||
print(f"✗ 设备回调注册失败: {e}")
|
||
|
||
def unregister_device_callback(self, callback_type: str, callback: callable):
|
||
"""
|
||
注销设备回调
|
||
|
||
Args:
|
||
callback_type: 回调类型
|
||
callback: 回调函数
|
||
"""
|
||
try:
|
||
if callback_type in self.device_callbacks:
|
||
if callback in self.device_callbacks[callback_type]:
|
||
self.device_callbacks[callback_type].remove(callback)
|
||
print(f"✓ 设备回调已注销: {callback_type}")
|
||
except Exception as e:
|
||
print(f"✗ 设备回调注销失败: {e}")
|
||
|
||
def get_device_capabilities(self, device_type: str) -> List[str]:
|
||
"""
|
||
获取设备类型的功能列表
|
||
|
||
Args:
|
||
device_type: 设备类型
|
||
|
||
Returns:
|
||
功能列表
|
||
"""
|
||
return self.device_capabilities.get(device_type, [])
|
||
|
||
def get_device_zones(self, device_type: str) -> List[str]:
|
||
"""
|
||
获取设备区域列表
|
||
|
||
Args:
|
||
device_type: 设备类型
|
||
|
||
Returns:
|
||
区域列表
|
||
"""
|
||
return self.device_zones.get(device_type, [])
|
||
|
||
def get_platform_config(self) -> Dict[str, Any]:
|
||
"""
|
||
获取平台配置
|
||
|
||
Returns:
|
||
平台配置字典
|
||
"""
|
||
current_platform = platform.system()
|
||
return self.platform_config.get(current_platform, {})
|
||
|
||
def set_discovery_config(self, config: Dict[str, Any]):
|
||
"""
|
||
设置设备发现配置
|
||
|
||
Args:
|
||
config: 发现配置字典
|
||
"""
|
||
try:
|
||
self.discovery_config.update(config)
|
||
print(f"✓ 设备发现配置已更新: {self.discovery_config}")
|
||
except Exception as e:
|
||
print(f"✗ 设备发现配置设置失败: {e}")
|
||
self.stats['device_errors'] += 1
|
||
|
||
def get_discovery_config(self) -> Dict[str, Any]:
|
||
"""
|
||
获取设备发现配置
|
||
|
||
Returns:
|
||
发现配置字典
|
||
"""
|
||
return self.discovery_config.copy()
|
||
|
||
def get_device_stats(self) -> Dict[str, Any]:
|
||
"""
|
||
获取设备统计信息
|
||
|
||
Returns:
|
||
统计信息字典
|
||
"""
|
||
return self.stats.copy()
|
||
|
||
def reset_device_stats(self):
|
||
"""重置设备统计信息"""
|
||
try:
|
||
self.stats = {
|
||
'devices_registered': 0,
|
||
'devices_connected': 0,
|
||
'devices_disconnected': 0,
|
||
'scan_operations': 0,
|
||
'haptic_effects': 0,
|
||
'device_errors': 0,
|
||
'data_transmitted': 0
|
||
}
|
||
print("✓ 设备统计信息已重置")
|
||
except Exception as e:
|
||
print(f"✗ 设备统计信息重置失败: {e}")
|
||
|
||
def get_device_states(self) -> Dict[str, Any]:
|
||
"""
|
||
获取设备状态
|
||
|
||
Returns:
|
||
设备状态字典
|
||
"""
|
||
return self.device_states.copy() |