use super::{HwSensor, HwSensorType, HwType};
#[cfg(feature = "nvidia")]
use nvml_wrapper::{enum_wrappers::device::TemperatureSensor, Nvml};
pub fn read_gpu_temperatures() -> Vec<HwSensor> {
#[allow(unused_mut)]
let mut sensors = Vec::new();
#[cfg(feature = "nvidia")]
{
sensors.extend(read_nvidia_gpu_temps());
}
sensors
}
#[cfg(feature = "nvidia")]
fn read_nvidia_gpu_temps() -> Vec<HwSensor> {
let mut sensors = Vec::new();
if let Ok(nvml) = Nvml::init() {
if let Ok(count) = nvml.device_count() {
for i in 0..count {
if let Ok(device) = nvml.device_by_index(i) {
let name = device.name().unwrap_or_else(|_| format!("GPU {}", i));
if let Ok(temp) = device.temperature(TemperatureSensor::Gpu) {
sensors.push(HwSensor {
name: format!("{} Core", name),
value: temp as f32,
min: None,
max: None,
sensor_type: HwSensorType::Temperature,
hardware_type: HwType::Gpu,
});
}
}
}
}
}
sensors
}
#[cfg(feature = "nvidia")]
pub fn read_nvidia_fan_speeds() -> Vec<HwSensor> {
let mut sensors = Vec::new();
if let Ok(nvml) = Nvml::init() {
if let Ok(count) = nvml.device_count() {
for i in 0..count {
if let Ok(device) = nvml.device_by_index(i) {
let name = device.name().unwrap_or_else(|_| format!("GPU {}", i));
if let Ok(fan_speed) = device.fan_speed(0) {
sensors.push(HwSensor {
name: format!("{} Fan", name),
value: fan_speed as f32,
min: Some(0.0),
max: Some(100.0),
sensor_type: HwSensorType::Fan,
hardware_type: HwType::Gpu,
});
}
if let Ok(num_fans) = device.num_fans() {
for fan_idx in 1..num_fans {
if let Ok(fan_speed) = device.fan_speed(fan_idx) {
sensors.push(HwSensor {
name: format!("{} Fan {}", name, fan_idx + 1),
value: fan_speed as f32,
min: Some(0.0),
max: Some(100.0),
sensor_type: HwSensorType::Fan,
hardware_type: HwType::Gpu,
});
}
}
}
}
}
}
}
sensors
}
#[cfg(feature = "nvidia")]
pub fn read_nvidia_power() -> Vec<HwSensor> {
let mut sensors = Vec::new();
if let Ok(nvml) = Nvml::init() {
if let Ok(count) = nvml.device_count() {
for i in 0..count {
if let Ok(device) = nvml.device_by_index(i) {
let name = device.name().unwrap_or_else(|_| format!("GPU {}", i));
if let Ok(power_mw) = device.power_usage() {
sensors.push(HwSensor {
name: format!("{} Power", name),
value: power_mw as f32 / 1000.0, min: None,
max: device
.power_management_limit()
.ok()
.map(|p| p as f32 / 1000.0),
sensor_type: HwSensorType::Power,
hardware_type: HwType::Gpu,
});
}
}
}
}
}
sensors
}
#[cfg(feature = "nvidia")]
pub fn read_nvidia_clocks() -> Vec<HwSensor> {
use nvml_wrapper::enum_wrappers::device::Clock;
let mut sensors = Vec::new();
if let Ok(nvml) = Nvml::init() {
if let Ok(count) = nvml.device_count() {
for i in 0..count {
if let Ok(device) = nvml.device_by_index(i) {
let name = device.name().unwrap_or_else(|_| format!("GPU {}", i));
if let Ok(clock) = device.clock_info(Clock::Graphics) {
sensors.push(HwSensor {
name: format!("{} Graphics Clock", name),
value: clock as f32,
min: None,
max: device
.max_clock_info(Clock::Graphics)
.ok()
.map(|c| c as f32),
sensor_type: HwSensorType::Clock,
hardware_type: HwType::Gpu,
});
}
if let Ok(clock) = device.clock_info(Clock::Memory) {
sensors.push(HwSensor {
name: format!("{} Memory Clock", name),
value: clock as f32,
min: None,
max: device.max_clock_info(Clock::Memory).ok().map(|c| c as f32),
sensor_type: HwSensorType::Clock,
hardware_type: HwType::Gpu,
});
}
if let Ok(clock) = device.clock_info(Clock::SM) {
sensors.push(HwSensor {
name: format!("{} SM Clock", name),
value: clock as f32,
min: None,
max: device.max_clock_info(Clock::SM).ok().map(|c| c as f32),
sensor_type: HwSensorType::Clock,
hardware_type: HwType::Gpu,
});
}
}
}
}
}
sensors
}
#[cfg(feature = "nvidia")]
pub fn read_nvidia_utilization() -> Vec<HwSensor> {
let mut sensors = Vec::new();
if let Ok(nvml) = Nvml::init() {
if let Ok(count) = nvml.device_count() {
for i in 0..count {
if let Ok(device) = nvml.device_by_index(i) {
let name = device.name().unwrap_or_else(|_| format!("GPU {}", i));
if let Ok(util) = device.utilization_rates() {
sensors.push(HwSensor {
name: format!("{} GPU Load", name),
value: util.gpu as f32,
min: Some(0.0),
max: Some(100.0),
sensor_type: HwSensorType::Load,
hardware_type: HwType::Gpu,
});
sensors.push(HwSensor {
name: format!("{} Memory Load", name),
value: util.memory as f32,
min: Some(0.0),
max: Some(100.0),
sensor_type: HwSensorType::Load,
hardware_type: HwType::Gpu,
});
}
}
}
}
}
sensors
}
#[cfg(feature = "nvidia")]
pub fn read_all_nvidia_sensors() -> Vec<HwSensor> {
let mut sensors = Vec::new();
sensors.extend(read_nvidia_gpu_temps());
sensors.extend(read_nvidia_fan_speeds());
sensors.extend(read_nvidia_power());
sensors.extend(read_nvidia_clocks());
sensors.extend(read_nvidia_utilization());
sensors
}
#[cfg(not(feature = "nvidia"))]
pub fn read_all_nvidia_sensors() -> Vec<HwSensor> {
Vec::new()
}
pub fn read_superio_sensors() -> Vec<HwSensor> {
Vec::new()
}
#[cfg(target_os = "windows")]
pub fn read_wmi_temperatures() -> Vec<HwSensor> {
use std::collections::HashMap;
use wmi::{COMLibrary, Variant, WMIConnection};
let mut sensors = Vec::new();
if let Ok(com) = COMLibrary::new() {
if let Ok(wmi) = WMIConnection::with_namespace_path("root\\WMI", com) {
let query =
"SELECT InstanceName, CurrentTemperature FROM MSAcpi_ThermalZoneTemperature";
let results: Result<Vec<HashMap<String, Variant>>, _> = wmi.raw_query(query);
if let Ok(items) = results {
for (idx, item) in items.iter().enumerate() {
if let Some(Variant::UI4(temp_tenths_kelvin)) = item.get("CurrentTemperature") {
let temp_c = (*temp_tenths_kelvin as f32 / 10.0) - 273.15;
let name = item
.get("InstanceName")
.and_then(|v| match v {
Variant::String(s) => Some(s.clone()),
_ => None,
})
.unwrap_or_else(|| format!("Thermal Zone {}", idx));
if temp_c > 0.0 && temp_c < 150.0 {
let hw_type = if name.to_lowercase().contains("cpu") {
HwType::Cpu
} else if name.to_lowercase().contains("gpu") {
HwType::Gpu
} else {
HwType::Other
};
sensors.push(HwSensor {
name,
value: temp_c,
min: None,
max: None,
sensor_type: HwSensorType::Temperature,
hardware_type: hw_type,
});
}
}
}
}
}
}
sensors
}
#[cfg(not(target_os = "windows"))]
pub fn read_wmi_temperatures() -> Vec<HwSensor> {
Vec::new()
}