use serde::{Deserialize, Serialize};
use std::fmt;
pub trait MotherboardDevice: Send + Sync {
fn name(&self) -> &str;
fn device_path(&self) -> Option<String>;
fn temperature_sensors(&self) -> Result<Vec<TemperatureSensor>, Error>;
fn voltage_rails(&self) -> Result<Vec<VoltageRail>, Error>;
fn fans(&self) -> Result<Vec<FanInfo>, Error>;
fn set_fan_speed(&self, fan_index: usize, speed: FanControl) -> Result<(), Error> {
let _ = (fan_index, speed);
Err(Error::NotSupported("Fan control not supported".into()))
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TemperatureSensor {
pub label: String,
pub temperature: Option<f32>,
pub max: Option<f32>,
pub critical: Option<f32>,
pub sensor_type: SensorType,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VoltageRail {
pub label: String,
pub voltage: Option<f32>,
pub min: Option<f32>,
pub max: Option<f32>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FanInfo {
pub label: String,
pub rpm: Option<u32>,
pub pwm: Option<u8>,
pub min_rpm: Option<u32>,
pub max_rpm: Option<u32>,
pub controllable: Option<bool>,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum FanControl {
Manual(u8),
Automatic,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SensorType {
Cpu,
Gpu,
Chipset,
Vrm,
Ambient,
M2Slot,
Pch,
Storage,
Other,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SensorReading {
pub label: String,
pub value: Option<f32>,
pub unit: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemInfo {
pub os_name: Option<String>,
pub os_version: Option<String>,
pub kernel_version: Option<String>,
pub architecture: Option<String>,
pub hostname: Option<String>,
pub bios: BiosInfo,
pub manufacturer: Option<String>, pub product_name: Option<String>, pub serial_number: Option<String>,
pub uuid: Option<String>,
pub board_vendor: Option<String>,
pub board_name: Option<String>,
pub board_version: Option<String>,
pub cpu_name: Option<String>,
pub cpu_cores: Option<u32>,
pub cpu_threads: Option<u32>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BiosInfo {
pub vendor: Option<String>, pub version: Option<String>, pub release_date: Option<String>, pub revision: Option<String>, pub firmware_type: FirmwareType, pub secure_boot: Option<bool>, }
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum FirmwareType {
Bios,
Uefi,
Unknown,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PcieDeviceInfo {
pub name: String,
pub device_id: Option<String>,
pub vendor: Option<String>,
pub pcie_version: Option<String>, pub link_width: Option<u8>, pub link_speed: Option<String>, pub slot: Option<String>,
pub device_class: Option<String>, }
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SataDeviceInfo {
pub name: String,
pub model: Option<String>,
pub serial: Option<String>,
pub firmware: Option<String>,
pub capacity_gb: Option<f64>,
pub interface_speed: Option<String>, pub port: Option<u8>,
pub temperature: Option<f32>, pub media_type: SataMediaType,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SataMediaType {
Hdd,
Ssd,
Unknown,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemTemperatures {
pub cpu: Option<f32>,
pub gpu: Option<f32>,
pub motherboard: Option<f32>,
pub storage: Vec<(String, f32)>, pub network: Vec<(String, f32)>, }
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UsbDeviceInfo {
pub name: String,
pub device_id: Option<String>,
pub vendor: Option<String>,
pub product_id: Option<String>,
pub vendor_id: Option<String>,
pub usb_version: UsbVersion,
pub device_class: Option<String>,
pub status: Option<String>,
pub hub_port: Option<u8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum UsbVersion {
Usb1_1,
Usb2_0,
Usb3_0,
Usb3_1,
Usb3_2,
Usb4,
Unknown,
}
impl std::fmt::Display for UsbVersion {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
UsbVersion::Usb1_1 => write!(f, "USB 1.1"),
UsbVersion::Usb2_0 => write!(f, "USB 2.0"),
UsbVersion::Usb3_0 => write!(f, "USB 3.0"),
UsbVersion::Usb3_1 => write!(f, "USB 3.1"),
UsbVersion::Usb3_2 => write!(f, "USB 3.2"),
UsbVersion::Usb4 => write!(f, "USB4"),
UsbVersion::Unknown => write!(f, "Unknown"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DisplayOutputInfo {
pub name: String,
pub output_type: DisplayOutputType,
pub connected: bool,
pub resolution: Option<String>,
pub refresh_rate: Option<u32>,
pub adapter: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum DisplayOutputType {
Hdmi,
DisplayPort,
Dvi,
Vga,
Thunderbolt,
UsbC,
Internal,
Unknown,
}
impl std::fmt::Display for DisplayOutputType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
DisplayOutputType::Hdmi => write!(f, "HDMI"),
DisplayOutputType::DisplayPort => write!(f, "DisplayPort"),
DisplayOutputType::Dvi => write!(f, "DVI"),
DisplayOutputType::Vga => write!(f, "VGA"),
DisplayOutputType::Thunderbolt => write!(f, "Thunderbolt"),
DisplayOutputType::UsbC => write!(f, "USB-C"),
DisplayOutputType::Internal => write!(f, "Internal"),
DisplayOutputType::Unknown => write!(f, "Unknown"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AudioDeviceInfo {
pub name: String,
pub device_type: Option<AudioDeviceType>,
pub manufacturer: Option<String>,
pub status: Option<String>,
pub is_default: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum AudioDeviceType {
Output, Input, OutputInput, Unknown,
}
impl std::fmt::Display for AudioDeviceType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
AudioDeviceType::Output => write!(f, "Output"),
AudioDeviceType::Input => write!(f, "Input"),
AudioDeviceType::OutputInput => write!(f, "Input/Output"),
AudioDeviceType::Unknown => write!(f, "Unknown"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BluetoothDeviceInfo {
pub name: String,
pub address: Option<String>,
pub device_type: Option<String>,
pub connected: bool,
pub paired: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NetworkPortInfo {
pub name: String,
pub port_type: NetworkPortType,
pub speed: Option<String>,
pub mac_address: Option<String>,
pub connected: Option<bool>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum NetworkPortType {
Ethernet,
WiFi,
Bluetooth,
Thunderbolt,
Other,
}
impl std::fmt::Display for NetworkPortType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
NetworkPortType::Ethernet => write!(f, "Ethernet"),
NetworkPortType::WiFi => write!(f, "Wi-Fi"),
NetworkPortType::Bluetooth => write!(f, "Bluetooth"),
NetworkPortType::Thunderbolt => write!(f, "Thunderbolt"),
NetworkPortType::Other => write!(f, "Other"),
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PeripheralsInfo {
pub usb_devices: Vec<UsbDeviceInfo>,
pub display_outputs: Vec<DisplayOutputInfo>,
pub audio_devices: Vec<AudioDeviceInfo>,
pub bluetooth_devices: Vec<BluetoothDeviceInfo>,
pub network_ports: Vec<NetworkPortInfo>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DriverInfo {
pub name: String,
pub version: Option<String>,
pub driver_type: DriverType,
pub description: Option<String>,
pub vendor: Option<String>,
pub date: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum DriverType {
Gpu,
Chipset,
Storage,
Network,
Audio,
Usb,
Other,
}
impl fmt::Display for DriverType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DriverType::Gpu => write!(f, "GPU"),
DriverType::Chipset => write!(f, "Chipset"),
DriverType::Storage => write!(f, "Storage"),
DriverType::Network => write!(f, "Network"),
DriverType::Audio => write!(f, "Audio"),
DriverType::Usb => write!(f, "USB"),
DriverType::Other => write!(f, "Other"),
}
}
}
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("Operation not supported: {0}")]
NotSupported(String),
#[error("No sensors found")]
NoSensorsFound,
#[error("Initialization failed: {0}")]
InitializationFailed(String),
#[error("Query failed: {0}")]
QueryFailed(String),
#[error("Permission denied: {0}")]
PermissionDenied(String),
#[error("I/O error: {0}")]
IoError(#[from] std::io::Error),
#[error("Parse error: {0}")]
ParseError(String),
#[error("Fan control error: {0}")]
FanControlError(String),
#[error("Unknown error: {0}")]
Unknown(String),
}