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
201
202
203
204
205
206
207
208
209
210
//! Module containing the current sensors and their related functionality.
use super::*;
use crate::hwmon::async_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.
#[async_trait]
pub trait AsyncCurrentSensor: AsyncSensor + std::fmt::Debug {
/// Reads whether or not this sensor is enabled.
/// Returns an error, if the sensor doesn't support the feature.
async fn read_enable(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::Enable).await?;
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.
async fn read_input(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Input).await?;
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.
async fn read_min(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Min).await?;
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.
async fn read_max(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Max).await?;
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.
async fn read_lcrit(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::LowCrit).await?;
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.
async fn read_crit(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Crit).await?;
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.
async fn read_average(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Average).await?;
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.
async fn read_lowest(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Lowest).await?;
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.
async fn read_highest(&self) -> Result<Current> {
let raw = self.read_raw(SensorSubFunctionType::Highest).await?;
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.
async fn read_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::Alarm).await?;
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.
async fn read_min_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::MinAlarm).await?;
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.
async fn read_max_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::MaxAlarm).await?;
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.
async fn read_crit_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::CritAlarm).await?;
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.
async fn read_lcrit_alarm(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::LowCritAlarm).await?;
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.
async fn read_beep(&self) -> Result<bool> {
let raw = self.read_raw(SensorSubFunctionType::Beep).await?;
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 AsyncSensor for CurrentSensorStruct {}
#[async_trait]
impl AsyncSensorExt for CurrentSensorStruct {
async fn parse(hwmon: &Hwmon, index: u16) -> Result<Self> {
let sensor = Self {
hwmon_path: hwmon.path().to_path_buf(),
index,
};
inspect_sensor(sensor, SensorSubFunctionType::Input).await
}
}
impl AsyncCurrentSensor for CurrentSensorStruct {}
#[cfg(feature = "writeable")]
impl AsyncWriteableSensor for CurrentSensorStruct {}
#[cfg(feature = "writeable")]
#[async_trait]
/// Helper trait that sums up all functionality of a read-write current sensor.
pub trait AsyncWriteableCurrentSensor: AsyncCurrentSensor + AsyncWriteableSensor {
/// Sets this sensor's enabled state.
/// Returns an error, if the sensor doesn't support the feature.
async fn write_enable(&self, enable: bool) -> Result<()> {
self.write_raw(SensorSubFunctionType::Enable, &enable.to_raw())
.await
}
/// Writes this sensor's min value.
/// Returns an error, if the sensor doesn't support the feature.
async fn write_min(&self, min: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::Min, &min.to_raw())
.await
}
/// Writes this sensor's max value.
/// Returns an error, if the sensor doesn't support the feature.
async fn write_max(&self, max: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::Max, &max.to_raw())
.await
}
/// Writes this sensor's crit value.
/// Returns an error, if the sensor doesn't support the feature.
async fn write_crit(&self, crit: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::Crit, &crit.to_raw())
.await
}
/// Writes this sensor's lcrit value.
/// Returns an error, if the sensor doesn't support the feature.
async fn write_lcrit(&self, lcrit: Current) -> Result<()> {
self.write_raw(SensorSubFunctionType::LowCrit, &lcrit.to_raw())
.await
}
/// Sets whether or not an alarm condition for the sensor also triggers beeping.
/// Returns an error, if the sensor doesn't support the feature.
async fn write_beep(&self, beep: bool) -> Result<()> {
self.write_raw(SensorSubFunctionType::Beep, &beep.to_raw())
.await
}
}
#[cfg(feature = "writeable")]
impl AsyncWriteableCurrentSensor for CurrentSensorStruct {}