1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
//! Module containing the current sensors and their related functionality.
use super::*;
use crate::hwmon::sync_hwmon::Hwmon;
use crate::units::Current;
#[cfg(feature = "writeable")]
use std::path::{Path, PathBuf};
/// Helper trait that sums up all functionality of a read-only current sensor.
pub trait CurrentSensor: SyncSensor + std::fmt::Debug {
/// Reads whether or not this sensor is enabled.
/// Returns an error, if the sensor doesn't support the feature.
fn read_enable(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::Enable)?;
bool::from_raw(&raw).map_err(Error::from)
}
/// Reads the input subfunction of this sensor.
/// Returns an error, if this sensor doesn't support the subtype.
fn read_input(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Input)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads this sensor's min value.
/// Returns an error, if this sensor doesn't support the feature.
fn read_min(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Min)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads this sensor's max value.
/// Returns an error, if this sensor doesn't support the feature.
fn read_max(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Max)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads this sensor's lcrit value.
/// Returns an error, if this sensor doesn't support the feature.
fn read_lcrit(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::LowCrit)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads this sensor's crit value.
/// Returns an error, if this sensor doesn't support the feature.
fn read_crit(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Crit)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads this sensor's average value.
/// Returns an error, if this sensor doesn't support the feature.
fn read_average(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Average)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads this sensor's historically lowest input.
/// Returns an error, if this sensor doesn't support the feature.
fn read_lowest(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Lowest)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads this sensor's historically highest input.
/// Returns an error, if this sensor doesn't support the feature.
fn read_highest(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Highest)?;
Current::from_raw(&raw).map_err(Error::from)
}
/// Reads whether or not an alarm condition exists for the sensor.
/// Returns an error, if the sensor doesn't support the feature.
fn read_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::Alarm)?;
bool::from_raw(&raw).map_err(Error::from)
}
/// Reads whether or not an alarm condition exists for the min subfunction of the sensor.
/// Returns an error, if the sensor doesn't support the feature.
fn read_min_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::MinAlarm)?;
bool::from_raw(&raw).map_err(Error::from)
}
/// Reads whether or not an alarm condition exists for the max subfunction of the sensor.
/// Returns an error, if the sensor doesn't support the feature.
fn read_max_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::MaxAlarm)?;
bool::from_raw(&raw).map_err(Error::from)
}
/// Reads whether or not an alarm condition exists for the crit subfunction of the sensor.
/// Returns an error, if the sensor doesn't support the feature.
fn read_crit_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::CritAlarm)?;
bool::from_raw(&raw).map_err(Error::from)
}
/// Reads whether or not an alarm condition exists for the lcrit subfunction of the sensor.
/// Returns an error, if the sensor doesn't support the feature.
fn read_lcrit_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::LowCritAlarm)?;
bool::from_raw(&raw).map_err(Error::from)
}
/// Reads whether or not an alarm condition for the sensor also triggers beeping.
/// Returns an error, if the sensor doesn't support the feature.
fn read_beep(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::Beep)?;
bool::from_raw(&raw).map_err(Error::from)
}
}
#[derive(Debug, Clone)]
pub(crate) struct CurrentSensorStruct {
hwmon_path: PathBuf,
index: u16,
}
impl Sensor for CurrentSensorStruct {
fn static_base() -> &'static str where Self: Sized {
"curr"
}
fn base(&self) -> &'static str {
"curr"
}
fn index(&self) -> u16 {
self.index
}
fn hwmon_path(&self) -> &Path {
self.hwmon_path.as_path()
}
}
impl SyncSensor for CurrentSensorStruct {}
impl CurrentSensor for CurrentSensorStruct {}
impl SyncSensorExt for CurrentSensorStruct {
fn parse(hwmon: &Hwmon, index: u16) -> Result<Self> {
let sensor = Self {
hwmon_path: hwmon.path().to_path_buf(),
index,
};
inspect_sensor(sensor, SensorSubFunctionType::Input)
}
}
#[cfg(feature = "writeable")]
impl WriteableSensor for CurrentSensorStruct {}
#[cfg(feature = "writeable")]
/// Helper trait that sums up all functionality of a read-write current sensor.
pub trait WriteableCurrentSensor: CurrentSensor + WriteableSensor {
/// Sets this sensor's enabled state.
/// Returns an error, if the sensor doesn't support the feature.
fn write_enable(&self, enable: bool) -> Result<()> {
self.write_raw(SensorSubFunctionType::Enable, &enable.to_raw())
}
/// Writes this sensor's min value.
/// Returns an error, if the sensor doesn't support the feature.
fn write_min(&self, min: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::Min, &min.to_raw())
}
/// Writes this sensor's max value.
/// Returns an error, if the sensor doesn't support the feature.
fn write_max(&self, max: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::Max, &max.to_raw())
}
/// Writes this sensor's crit value.
/// Returns an error, if the sensor doesn't support the feature.
fn write_crit(&self, crit: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::Crit, &crit.to_raw())
}
/// Writes this sensor's lcrit value.
/// Returns an error, if the sensor doesn't support the feature.
fn write_lcrit(&self, lcrit: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::LowCrit, &lcrit.to_raw())
}
/// Sets whether or not an alarm condition for the sensor also triggers beeping.
/// Returns an error, if the sensor doesn't support the feature.
fn write_beep(&self, beep: bool) -> Result<()> {
self.write_raw(SensorSubFunctionType::Beep, &beep.to_raw())
}
}
#[cfg(feature = "writeable")]
impl WriteableCurrentSensor for CurrentSensorStruct {}