A personal rust firmware for the Badger 2040 W
drop the a. just sync
+68
-125
+64
-118
src/pcf85063a/alarm.rs
+64
-118
src/pcf85063a/alarm.rs
···
1
1
use super::{BitFlags, Control, DEVICE_ADDRESS, Error, PCF85063, Register, decode_bcd, encode_bcd};
2
-
use embedded_hal_async::i2c::I2c;
2
+
use embedded_hal_1::i2c::I2c;
3
3
use time::Time;
4
4
5
5
impl<I2C, E> PCF85063<I2C>
···
7
7
I2C: I2c<Error = E>,
8
8
{
9
9
/// Set the alarm seconds, minutes and hours, keeping the AE bit unchanged.
10
-
pub async fn set_alarm_time(&mut self, time: Time) -> Result<(), Error<E>> {
11
-
self.set_alarm_seconds(time.second()).await?;
12
-
self.set_alarm_minutes(time.minute()).await?;
13
-
self.set_alarm_hours(time.hour()).await?;
10
+
pub fn set_alarm_time(&mut self, time: Time) -> Result<(), Error<E>> {
11
+
self.set_alarm_seconds(time.second())?;
12
+
self.set_alarm_minutes(time.minute())?;
13
+
self.set_alarm_hours(time.hour())?;
14
14
Ok(())
15
15
}
16
16
···
23
23
let data: u8 = data & BitFlags::AE; // keep the AE bit as is
24
24
let setting: u8 = encode_bcd(seconds);
25
25
let data: u8 = data | setting;
26
-
self.write_register(Register::SECOND_ALARM, data).await
26
+
self.write_register(Register::SECOND_ALARM, data)
27
27
}
28
28
29
29
/// Set the alarm minutes [0-59], keeping the AE bit unchanged.
30
-
pub async fn set_alarm_minutes(&mut self, minutes: u8) -> Result<(), Error<E>> {
30
+
pub fn set_alarm_minutes(&mut self, minutes: u8) -> Result<(), Error<E>> {
31
31
if minutes > 59 {
32
32
return Err(Error::InvalidInputData);
33
33
}
34
-
let data: u8 = self.read_register(Register::MINUTE_ALARM).await?; // read current value
34
+
let data: u8 = self.read_register(Register::MINUTE_ALARM)?; // read current value
35
35
let data: u8 = data & BitFlags::AE; // keep the AE bit as is
36
36
let setting: u8 = encode_bcd(minutes);
37
37
let data: u8 = data | setting;
38
-
self.write_register(Register::MINUTE_ALARM, data).await
38
+
self.write_register(Register::MINUTE_ALARM, data)
39
39
}
40
40
41
41
/// Set the alarm hours [0-23], keeping the AE bit unchanged.
42
-
pub async fn set_alarm_hours(&mut self, hours: u8) -> Result<(), Error<E>> {
42
+
pub fn set_alarm_hours(&mut self, hours: u8) -> Result<(), Error<E>> {
43
43
if hours > 23 {
44
44
return Err(Error::InvalidInputData);
45
45
}
46
-
let data: u8 = self.read_register(Register::HOUR_ALARM).await?; // read current value
46
+
let data: u8 = self.read_register(Register::HOUR_ALARM)?; // read current value
47
47
let data: u8 = data & BitFlags::AE; // keep the AE bit as is
48
48
let setting: u8 = encode_bcd(hours);
49
49
let data: u8 = data | setting;
50
-
self.write_register(Register::HOUR_ALARM, data).await
50
+
self.write_register(Register::HOUR_ALARM, data)
51
51
}
52
52
53
53
/// Set the alarm day [1-31], keeping the AE bit unchanged.
54
-
pub async fn set_alarm_day(&mut self, day: u8) -> Result<(), Error<E>> {
54
+
pub fn set_alarm_day(&mut self, day: u8) -> Result<(), Error<E>> {
55
55
if !(1..=31).contains(&day) {
56
56
return Err(Error::InvalidInputData);
57
57
}
58
-
let data: u8 = self.read_register(Register::DAY_ALARM).await?; // read current value
58
+
let data: u8 = self.read_register(Register::DAY_ALARM)?; // read current value
59
59
let data: u8 = data & BitFlags::AE; // keep the AE bit as is
60
60
let setting: u8 = encode_bcd(day);
61
61
let data: u8 = data | setting;
62
-
self.write_register(Register::DAY_ALARM, data).await
62
+
self.write_register(Register::DAY_ALARM, data)
63
63
}
64
64
65
65
/// Set the alarm weekday [0-6], keeping the AE bit unchanged.
66
-
pub async fn set_alarm_weekday(&mut self, weekday: u8) -> Result<(), Error<E>> {
66
+
pub fn set_alarm_weekday(&mut self, weekday: u8) -> Result<(), Error<E>> {
67
67
if weekday > 6 {
68
68
return Err(Error::InvalidInputData);
69
69
}
70
-
let data: u8 = self.read_register(Register::WEEKDAY_ALARM).await?; // read current value
70
+
let data: u8 = self.read_register(Register::WEEKDAY_ALARM)?; // read current value
71
71
let data: u8 = data & BitFlags::AE; // keep the AE bit as is
72
72
let setting: u8 = encode_bcd(weekday);
73
73
let data: u8 = data | setting;
74
-
self.write_register(Register::WEEKDAY_ALARM, data).await
74
+
self.write_register(Register::WEEKDAY_ALARM, data)
75
75
}
76
76
77
77
/// Control alarm seconds (On: alarm enabled, Off: alarm disabled).
78
-
pub async fn control_alarm_seconds(&mut self, status: Control) -> Result<(), Error<E>> {
78
+
pub fn control_alarm_seconds(&mut self, status: Control) -> Result<(), Error<E>> {
79
79
match status {
80
-
Control::Off => {
81
-
self.set_register_bit_flag(Register::SECOND_ALARM, BitFlags::AE)
82
-
.await
83
-
}
84
-
Control::On => {
85
-
self.clear_register_bit_flag(Register::SECOND_ALARM, BitFlags::AE)
86
-
.await
87
-
}
80
+
Control::Off => self.set_register_bit_flag(Register::SECOND_ALARM, BitFlags::AE),
81
+
Control::On => self.clear_register_bit_flag(Register::SECOND_ALARM, BitFlags::AE),
88
82
}
89
83
}
90
84
91
85
/// Is alarm seconds enabled?
92
-
pub async fn is_alarm_seconds_enabled(&mut self) -> Result<bool, Error<E>> {
93
-
Ok(!self
94
-
.is_register_bit_flag_high(Register::SECOND_ALARM, BitFlags::AE)
95
-
.await?)
86
+
pub fn is_alarm_seconds_enabled(&mut self) -> Result<bool, Error<E>> {
87
+
Ok(!self.is_register_bit_flag_high(Register::SECOND_ALARM, BitFlags::AE)?)
96
88
}
97
89
98
90
/// Control alarm minutes (On: alarm enabled, Off: alarm disabled).
99
-
pub async fn control_alarm_minutes(&mut self, status: Control) -> Result<(), Error<E>> {
91
+
pub fn control_alarm_minutes(&mut self, status: Control) -> Result<(), Error<E>> {
100
92
match status {
101
-
Control::Off => {
102
-
self.set_register_bit_flag(Register::MINUTE_ALARM, BitFlags::AE)
103
-
.await
104
-
}
105
-
Control::On => {
106
-
self.clear_register_bit_flag(Register::MINUTE_ALARM, BitFlags::AE)
107
-
.await
108
-
}
93
+
Control::Off => self.set_register_bit_flag(Register::MINUTE_ALARM, BitFlags::AE),
94
+
Control::On => self.clear_register_bit_flag(Register::MINUTE_ALARM, BitFlags::AE),
109
95
}
110
96
}
111
97
112
98
/// Is alarm minutes enabled?
113
-
pub async fn is_alarm_minutes_enabled(&mut self) -> Result<bool, Error<E>> {
114
-
Ok(!self
115
-
.is_register_bit_flag_high(Register::MINUTE_ALARM, BitFlags::AE)
116
-
.await?)
99
+
pub fn is_alarm_minutes_enabled(&mut self) -> Result<bool, Error<E>> {
100
+
Ok(!self.is_register_bit_flag_high(Register::MINUTE_ALARM, BitFlags::AE)?)
117
101
}
118
102
119
103
/// Control alarm hours (On: alarm enabled, Off: alarm disabled).
120
-
pub async fn control_alarm_hours(&mut self, status: Control) -> Result<(), Error<E>> {
104
+
pub fn control_alarm_hours(&mut self, status: Control) -> Result<(), Error<E>> {
121
105
match status {
122
-
Control::Off => {
123
-
self.set_register_bit_flag(Register::HOUR_ALARM, BitFlags::AE)
124
-
.await
125
-
}
126
-
Control::On => {
127
-
self.clear_register_bit_flag(Register::HOUR_ALARM, BitFlags::AE)
128
-
.await
129
-
}
106
+
Control::Off => self.set_register_bit_flag(Register::HOUR_ALARM, BitFlags::AE),
107
+
Control::On => self.clear_register_bit_flag(Register::HOUR_ALARM, BitFlags::AE),
130
108
}
131
109
}
132
110
133
111
/// Is alarm hours enabled?
134
-
pub async fn is_alarm_hours_enabled(&mut self) -> Result<bool, Error<E>> {
135
-
Ok(!self
136
-
.is_register_bit_flag_high(Register::HOUR_ALARM, BitFlags::AE)
137
-
.await?)
112
+
pub fn is_alarm_hours_enabled(&mut self) -> Result<bool, Error<E>> {
113
+
Ok(!self.is_register_bit_flag_high(Register::HOUR_ALARM, BitFlags::AE)?)
138
114
}
139
115
140
116
/// Control alarm day (On: alarm enabled, Off: alarm disabled).
141
-
pub async fn control_alarm_day(&mut self, status: Control) -> Result<(), Error<E>> {
117
+
pub fn control_alarm_day(&mut self, status: Control) -> Result<(), Error<E>> {
142
118
match status {
143
-
Control::Off => {
144
-
self.set_register_bit_flag(Register::DAY_ALARM, BitFlags::AE)
145
-
.await
146
-
}
147
-
Control::On => {
148
-
self.clear_register_bit_flag(Register::DAY_ALARM, BitFlags::AE)
149
-
.await
150
-
}
119
+
Control::Off => self.set_register_bit_flag(Register::DAY_ALARM, BitFlags::AE),
120
+
Control::On => self.clear_register_bit_flag(Register::DAY_ALARM, BitFlags::AE),
151
121
}
152
122
}
153
123
154
124
/// Is alarm day enabled?
155
-
pub async fn is_alarm_day_enabled(&mut self) -> Result<bool, Error<E>> {
156
-
Ok(!self
157
-
.is_register_bit_flag_high(Register::DAY_ALARM, BitFlags::AE)
158
-
.await?)
125
+
pub fn is_alarm_day_enabled(&mut self) -> Result<bool, Error<E>> {
126
+
Ok(!self.is_register_bit_flag_high(Register::DAY_ALARM, BitFlags::AE)?)
159
127
}
160
128
161
129
/// Control alarm weekday (On: alarm enabled, Off: alarm disabled).
162
-
pub async fn control_alarm_weekday(&mut self, status: Control) -> Result<(), Error<E>> {
130
+
pub fn control_alarm_weekday(&mut self, status: Control) -> Result<(), Error<E>> {
163
131
match status {
164
-
Control::Off => {
165
-
self.set_register_bit_flag(Register::WEEKDAY_ALARM, BitFlags::AE)
166
-
.await
167
-
}
168
-
Control::On => {
169
-
self.clear_register_bit_flag(Register::WEEKDAY_ALARM, BitFlags::AE)
170
-
.await
171
-
}
132
+
Control::Off => self.set_register_bit_flag(Register::WEEKDAY_ALARM, BitFlags::AE),
133
+
Control::On => self.clear_register_bit_flag(Register::WEEKDAY_ALARM, BitFlags::AE),
172
134
}
173
135
}
174
136
175
137
/// Is alarm weekday enabled?
176
-
pub async fn is_alarm_weekday_enabled(&mut self) -> Result<bool, Error<E>> {
177
-
Ok(!self
178
-
.is_register_bit_flag_high(Register::WEEKDAY_ALARM, BitFlags::AE)
179
-
.await?)
138
+
pub fn is_alarm_weekday_enabled(&mut self) -> Result<bool, Error<E>> {
139
+
Ok(!self.is_register_bit_flag_high(Register::WEEKDAY_ALARM, BitFlags::AE)?)
180
140
}
181
141
182
142
/// Enable or disable alarm interrupt.
183
-
pub async fn control_alarm_interrupt(&mut self, status: Control) -> Result<(), Error<E>> {
143
+
pub fn control_alarm_interrupt(&mut self, status: Control) -> Result<(), Error<E>> {
184
144
match status {
185
-
Control::On => {
186
-
self.set_register_bit_flag(Register::CONTROL_2, BitFlags::AIE)
187
-
.await
188
-
}
189
-
Control::Off => {
190
-
self.clear_register_bit_flag(Register::CONTROL_2, BitFlags::AIE)
191
-
.await
192
-
}
145
+
Control::On => self.set_register_bit_flag(Register::CONTROL_2, BitFlags::AIE),
146
+
Control::Off => self.clear_register_bit_flag(Register::CONTROL_2, BitFlags::AIE),
193
147
}
194
148
}
195
149
196
-
pub async fn get_alarm_time(&mut self) -> Result<Time, Error<E>> {
150
+
pub fn get_alarm_time(&mut self) -> Result<Time, Error<E>> {
197
151
Ok(Time::from_hms(
198
-
self.get_alarm_hours().await?,
199
-
self.get_alarm_minutes().await?,
200
-
self.get_alarm_seconds().await?,
152
+
self.get_alarm_hours()?,
153
+
self.get_alarm_minutes()?,
154
+
self.get_alarm_seconds()?,
201
155
)?)
202
156
}
203
157
204
158
/// Read the alarm seconds setting.
205
-
pub async fn get_alarm_seconds(&mut self) -> Result<u8, Error<E>> {
159
+
pub fn get_alarm_seconds(&mut self) -> Result<u8, Error<E>> {
206
160
let mut data = [0];
207
161
self.i2c
208
162
.write_read(DEVICE_ADDRESS, &[Register::SECOND_ALARM], &mut data)
209
-
.await
210
163
.map_err(Error::I2C)?;
211
164
Ok(decode_bcd(data[0]))
212
165
}
213
166
214
167
/// Read the alarm minutes setting.
215
-
pub async fn get_alarm_minutes(&mut self) -> Result<u8, Error<E>> {
168
+
pub fn get_alarm_minutes(&mut self) -> Result<u8, Error<E>> {
216
169
let mut data = [0];
217
170
self.i2c
218
171
.write_read(DEVICE_ADDRESS, &[Register::MINUTE_ALARM], &mut data)
219
-
.await
220
172
.map_err(Error::I2C)?;
221
173
Ok(decode_bcd(data[0]))
222
174
}
223
175
224
176
/// Read the alarm hours setting.
225
-
pub async fn get_alarm_hours(&mut self) -> Result<u8, Error<E>> {
177
+
pub fn get_alarm_hours(&mut self) -> Result<u8, Error<E>> {
226
178
let mut data = [0];
227
179
self.i2c
228
180
.write_read(DEVICE_ADDRESS, &[Register::HOUR_ALARM], &mut data)
229
-
.await
230
181
.map_err(Error::I2C)?;
231
182
Ok(decode_bcd(data[0]))
232
183
}
233
184
234
185
/// Read the alarm day setting.
235
-
pub async fn get_alarm_day(&mut self) -> Result<u8, Error<E>> {
186
+
pub fn get_alarm_day(&mut self) -> Result<u8, Error<E>> {
236
187
let mut data = [0];
237
188
self.i2c
238
189
.write_read(DEVICE_ADDRESS, &[Register::DAY_ALARM], &mut data)
239
-
.await
240
190
.map_err(Error::I2C)?;
241
191
Ok(decode_bcd(data[0]))
242
192
}
243
193
244
194
/// Read the alarm weekday setting.
245
-
pub async fn get_alarm_weekday(&mut self) -> Result<u8, Error<E>> {
195
+
pub fn get_alarm_weekday(&mut self) -> Result<u8, Error<E>> {
246
196
let mut data = [0];
247
197
self.i2c
248
198
.write_read(DEVICE_ADDRESS, &[Register::WEEKDAY_ALARM], &mut data)
249
-
.await
250
199
.map_err(Error::I2C)?;
251
200
Ok(decode_bcd(data[0]))
252
201
}
253
202
254
203
/// Get the alarm flag (if true, alarm event happened).
255
-
pub async fn get_alarm_flag(&mut self) -> Result<bool, Error<E>> {
204
+
pub fn get_alarm_flag(&mut self) -> Result<bool, Error<E>> {
256
205
self.is_register_bit_flag_high(Register::CONTROL_2, BitFlags::AF)
257
-
.await
258
206
}
259
207
260
208
/// Clear the alarm flag.
261
-
pub async fn clear_alarm_flag(&mut self) -> Result<(), Error<E>> {
209
+
pub fn clear_alarm_flag(&mut self) -> Result<(), Error<E>> {
262
210
self.clear_register_bit_flag(Register::CONTROL_2, BitFlags::AF)
263
-
.await
264
211
}
265
212
266
213
/// Check if alarm interrupt is enabled.
267
-
pub async fn is_alarm_interrupt_enabled(&mut self) -> Result<bool, Error<E>> {
214
+
pub fn is_alarm_interrupt_enabled(&mut self) -> Result<bool, Error<E>> {
268
215
self.is_register_bit_flag_high(Register::CONTROL_2, BitFlags::AIE)
269
-
.await
270
216
}
271
217
272
218
/// Shut off the alarms at once.
273
-
pub async fn disable_all_alarms(&mut self) -> Result<(), Error<E>> {
274
-
self.control_alarm_seconds(Control::Off).await?;
275
-
self.control_alarm_minutes(Control::Off).await?;
276
-
self.control_alarm_hours(Control::Off).await?;
277
-
self.control_alarm_day(Control::Off).await?;
278
-
self.control_alarm_weekday(Control::Off).await?;
219
+
pub fn disable_all_alarms(&mut self) -> Result<(), Error<E>> {
220
+
self.control_alarm_seconds(Control::Off)?;
221
+
self.control_alarm_minutes(Control::Off)?;
222
+
self.control_alarm_hours(Control::Off)?;
223
+
self.control_alarm_day(Control::Off)?;
224
+
self.control_alarm_weekday(Control::Off)?;
279
225
Ok(())
280
226
}
281
227
}
+4
-7
src/pcf85063a/datetime.rs
+4
-7
src/pcf85063a/datetime.rs
···
7
7
//! a convenient set_time() function could be added (sets only seconds, minutes and hours)
8
8
9
9
use super::{DEVICE_ADDRESS, Error, PCF85063, Register, decode_bcd, encode_bcd};
10
-
use embedded_hal_async::i2c::I2c;
10
+
use embedded_hal_1::i2c::I2c;
11
11
use time::{Date, PrimitiveDateTime, Time};
12
12
13
13
impl<I2C, E> PCF85063<I2C>
···
15
15
I2C: I2c<Error = E>,
16
16
{
17
17
/// Read date and time all at once.
18
-
pub async fn get_datetime(&mut self) -> Result<PrimitiveDateTime, Error<E>> {
18
+
pub fn get_datetime(&mut self) -> Result<PrimitiveDateTime, Error<E>> {
19
19
let mut data = [0; 7];
20
20
self.i2c
21
21
.write_read(DEVICE_ADDRESS, &[Register::SECONDS], &mut data)
22
-
.await
23
22
.map_err(Error::I2C)?;
24
23
25
24
Ok(PrimitiveDateTime::new(
···
37
36
}
38
37
39
38
/// Set date and time all at once.
40
-
pub async fn set_datetime(&mut self, datetime: &PrimitiveDateTime) -> Result<(), Error<E>> {
39
+
pub fn set_datetime(&mut self, datetime: &PrimitiveDateTime) -> Result<(), Error<E>> {
41
40
let payload = [
42
41
Register::SECONDS, //first register
43
42
encode_bcd(datetime.second()),
···
50
49
];
51
50
self.i2c
52
51
.write(DEVICE_ADDRESS, &payload)
53
-
.await
54
52
.map_err(Error::I2C)
55
53
}
56
54
57
55
/// Set only the time, date remains unchanged.
58
56
///
59
57
/// Will return an 'Error::InvalidInputData' if any of the parameters is out of range.
60
-
pub async fn set_time(&mut self, time: &Time) -> Result<(), Error<E>> {
58
+
pub fn set_time(&mut self, time: &Time) -> Result<(), Error<E>> {
61
59
let payload = [
62
60
Register::SECONDS, //first register
63
61
encode_bcd(time.second()),
···
66
64
];
67
65
self.i2c
68
66
.write(DEVICE_ADDRESS, &payload)
69
-
.await
70
67
.map_err(Error::I2C)
71
68
}
72
69
}