1use embassy_time::{Duration, Instant, Timer};
27
28use crate::driver::pps::{ADDRESS, PpsBank, PpsDriver};
29pub use crate::driver::pps::{PpsError, PpsRunningMode};
30use crate::io::pps_plan::{Held, Planner, Transaction};
31use crate::io::pps_plan::{PPS_MIN_GAP_MS, next_slot_start, slot_at};
32pub use crate::io::pps_plan::{PPS_SLOT_MS, PPS_TICK_MS, PpsSetpoint, SCHEDULE, Slot};
33use crate::io::shared_i2c::SharedI2cBus;
34
35pub struct PpsReadings {
37 pub voltage: f32,
38 pub current: f32,
39 pub temperature: f32,
40 pub input_voltage: f32,
41 pub running_mode: PpsRunningMode,
42 pub enabled: bool,
44 pub voltage_set: f32,
45 pub current_set: f32,
46 pub delivered: bool,
49 pub fresh: bool,
52 pub rejected: u32,
54}
55
56pub struct PpsResources {
57 pub i2c: &'static SharedI2cBus,
58 pub on_usb_power: Option<fn(Option<bool>)>,
62}
63
64const PROBE_PERIOD: Duration = Duration::from_secs(1);
66const EPISODE_REPORT: Duration = Duration::from_secs(1);
68const SUMMARY_PERIOD: Duration = Duration::from_secs(60);
71
72struct Link {
75 errors: u32,
76 since: Instant,
77 reported: Instant,
78 done: u32,
80 failed: u32,
81 window: Instant,
82}
83
84impl Link {
85 fn new() -> Self {
86 Self {
87 errors: 0,
88 since: Instant::now(),
89 reported: Instant::now(),
90 done: 0,
91 failed: 0,
92 window: Instant::now(),
93 }
94 }
95
96 fn summarize(&mut self) {
97 let span = self.window.elapsed();
98 if span >= SUMMARY_PERIOD {
99 info!(
100 "PPS link: {} transactions, {} failed in {} s",
101 self.done,
102 self.failed,
103 span.as_secs()
104 );
105 self.done = 0;
106 self.failed = 0;
107 self.window = Instant::now();
108 }
109 }
110
111 fn ok(&mut self) {
112 self.done += 1;
113 if self.errors > 0 {
114 warn!(
115 "PPS link recovered: {} errors over {} ms",
116 self.errors,
117 self.since.elapsed().as_millis()
118 );
119 self.errors = 0;
120 }
121 }
122
123 fn failed(&mut self, op: &str, err: &PpsError) {
124 self.done += 1;
125 self.failed += 1;
126 let now = Instant::now();
127 if self.errors == 0 {
128 warn!("PPS link: {} failed: {}", op, err);
129 self.since = now;
130 self.reported = now;
131 } else if now - self.reported >= EPISODE_REPORT {
132 warn!(
133 "PPS link failing: {} errors in {} ms, last {}: {}",
134 self.errors + 1,
135 (now - self.since).as_millis(),
136 op,
137 err
138 );
139 self.reported = now;
140 }
141 self.errors += 1;
142 }
143}
144
145struct Mirror {
148 planner: Planner,
149 bank: Option<PpsBank>,
150 rejected: u32,
151}
152
153impl Mirror {
154 const fn new() -> Self {
155 Self {
156 planner: Planner::new(),
157 bank: None,
158 rejected: 0,
159 }
160 }
161
162 async fn run(
165 &mut self,
166 pps: &mut PpsDriver,
167 t: Transaction,
168 on_read: fn(&PpsReadings),
169 ) -> Result<(), PpsError> {
170 match t {
171 Transaction::Setpoints { voltage, current } => {
172 pps.write_setpoints(voltage, current).await?;
173 self.planner.wrote(voltage, current);
174 }
175 Transaction::Enable(on) => pps.write_enable(on).await?,
176 Transaction::Read => match pps.read_bank().await {
177 Ok(b) => {
178 let held = Held {
179 enabled: b.enabled,
180 voltage_set: b.voltage_set,
181 current_set: b.current_set,
182 };
183 on_read(&PpsReadings {
184 voltage: b.voltage,
185 current: b.current,
186 temperature: b.temperature,
187 input_voltage: b.input_voltage,
188 running_mode: b.running_mode,
189 enabled: b.enabled,
190 voltage_set: b.voltage_set,
191 current_set: b.current_set,
192 delivered: self.planner.holds(&held),
193 fresh: self.bank.is_none_or(|prev| prev.flag != b.flag),
194 rejected: self.rejected,
195 });
196 self.planner.read(held);
197 self.bank = Some(b);
198 }
199 Err(e) if e.is_transient() => {
200 self.rejected = self.rejected.saturating_add(1);
201 warn!("PPS reading rejected ({} total): {}", self.rejected, e);
202 }
203 Err(e) => return Err(e),
204 },
205 }
206 Ok(())
207 }
208}
209
210pub async fn pps_loop(
211 resources: PpsResources,
212 on_read: fn(&PpsReadings),
213 get_setpoint: fn() -> PpsSetpoint,
214) -> ! {
215 let mut pps = PpsDriver::new(resources.i2c, ADDRESS);
216 let mut link = Link::new();
217
218 loop {
219 match pps.probe().await {
220 Ok(id) => {
221 info!("PPS module id {:#06x} at address {:#04x}", id, ADDRESS);
222 break;
223 }
224 Err(e) => link.failed("probe", &e),
225 }
226 if let Some(report) = resources.on_usb_power {
229 Timer::after(Duration::from_millis(PPS_MIN_GAP_MS)).await;
230 report(crate::board::usb_powered(resources.i2c).await.ok());
231 }
232 Timer::after(PROBE_PERIOD).await;
233 }
234 link.ok();
235
236 let mut mirror = Mirror::new();
237 let mut start = Instant::now();
238 let (mut tick, mut next) = (0u32, 0usize);
239 loop {
240 let slot = slot_at(tick, next, resources.on_usb_power.is_some());
241 next = (next + 1) % SCHEDULE.len();
242 if next == 0 {
243 tick = tick.wrapping_add(1);
244 }
245 if slot == Slot::Aux {
246 if let Some(report) = resources.on_usb_power {
247 report(crate::board::usb_powered(resources.i2c).await.ok());
248 }
249 } else if let Some(t) = mirror.planner.plan(slot, &get_setpoint()) {
250 match mirror.run(&mut pps, t, on_read).await {
252 Ok(()) => link.ok(),
253 Err(e) => link.failed(t.name(), &e),
254 }
255 }
256 link.summarize();
257 start = Instant::from_micros(next_slot_start(
258 start.as_micros(),
259 Instant::now().as_micros(),
260 ));
261 Timer::at(start).await;
262 }
263}