doc: 更新 README 已完成的特性。

Reviewed-on: Ivan/ups-esp32c3-rust#6

README.md

@@ -9,7 +9,7 @@
 - [x] 以 NTP 方式校准时间；
 - [x] 以 MQTT 方式上报状态；
 - [x] 提供 UPS 电源输出的控制信号；
-- [ ] 提供 UPS 内置电池充电电路电源输入的控制信号；
+- [x] 提供 UPS 内置电池充电电路电源输入的控制信号；
 
 ## GPIO 定义
 

src/charge_controller.rs

@@ -1,189 +1,114 @@
 use std::{
-    sync::{
+    sync::{Arc, Mutex, MutexGuard},
-        Arc, Mutex, MutexGuard,
+    time::Duration,
-    },
 };
 
 use embedded_hal::digital::v2::{OutputPin, PinState};
 use embedded_svc::event_bus::{EventBus, Postbox};
-use esp_idf_hal::gpio::{Gpio6, Output};
+use esp_idf_hal::gpio::{Gpio7, Output};
 use esp_idf_svc::eventloop::{
     Background, EspBackgroundEventLoop, EspEventFetchData, EspEventLoop, EspEventPostData,
     EspSubscription, EspTypedEventDeserializer, EspTypedEventSerializer, EspTypedEventSource, User,
 };
 use esp_idf_sys::c_types;
-use log::{info, warn, debug};
+use log::warn;
 use serde_json::json;
 
-use crate::voltage_detection::{VoltageDetectionWorker, VOLTAGE_EVENTLOOP};
+use crate::{
+    time::Time,
+    voltage_detection::{VoltageDetectionWorker, VOLTAGE_EVENTLOOP},
+};
 
-const WAITING_OFF_SECONDS: u8 = 60;
+pub static mut CHARGE_STATE_EVENT_LOOP: Option<
-
-pub static mut DC_OUT_STATE_EVENT_LOOP: Option<
     EspEventLoop<esp_idf_svc::eventloop::User<Background>>,
 > = None;
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum DcOutStatus {
+pub enum ChargeStatus {
-    WaitingOn(u8),
+    Charging,
-    On,
+    Charged,
-    Off,
-    WaitingOff,
-    TurningOff(u8),
 }
 
 #[derive(Debug, Clone, Copy)]
-pub struct DcOutControllerState {
+pub struct ChargeControllerState {
-    pub status: DcOutStatus,
+    pub status: ChargeStatus,
     pub pin_state: PinState,
+    pub charge_deadline_at: Duration,
 }
 
-impl DcOutControllerState {
+impl ChargeControllerState {
     pub fn new() -> Self {
         Self {
-            status: DcOutStatus::On,
+            status: ChargeStatus::Charging,
             pin_state: PinState::Low,
+            charge_deadline_at: Duration::ZERO,
         }
     }
 
-    fn handle_adapter_down(&mut self) {
-        info!("status: {:?}", self);
-        match self.status {
-            DcOutStatus::On => {
-                self.status = DcOutStatus::WaitingOff;
-            }
-            DcOutStatus::WaitingOn(_) => {
-                self.status = DcOutStatus::Off;
-            }
-            DcOutStatus::TurningOff(seconds) => {
-                let seconds = seconds - 1;
-                if seconds > 0 {
-                    self.status = DcOutStatus::TurningOff(seconds);
-                } else {
-                    self.status = DcOutStatus::Off;
-                }
-            }
-            _ => {}
-        };
-    }
-
-    fn turn_off(&mut self) {
-        match self.status {
-            DcOutStatus::On => {
-                self.status = DcOutStatus::TurningOff(WAITING_OFF_SECONDS);
-            }
-            DcOutStatus::WaitingOff => {
-                self.status = DcOutStatus::TurningOff(WAITING_OFF_SECONDS);
-            }
-            DcOutStatus::WaitingOn(_) => {
-                self.status = DcOutStatus::Off;
-            }
-            DcOutStatus::TurningOff(seconds) => {
-                let seconds = seconds - 1;
-                if seconds > 0 {
-                    self.status = DcOutStatus::TurningOff(seconds);
-                } else {
-                    self.status = DcOutStatus::Off;
-                }
-            }
-            _ => {}
-        };
-    }
-
-    fn turn_on(&mut self) {
-        match self.status {
-            DcOutStatus::WaitingOff => {
-                self.status = DcOutStatus::On;
-            }
-            DcOutStatus::Off => {
-                self.status = DcOutStatus::WaitingOn(WAITING_OFF_SECONDS);
-            }
-            DcOutStatus::WaitingOn(seconds) => {
-                let seconds = seconds - 1;
-                if seconds > 0 {
-                    self.status = DcOutStatus::WaitingOn(seconds);
-                } else {
-                    self.status = DcOutStatus::On;
-                }
-            }
-            DcOutStatus::TurningOff(seconds) => {
-                let seconds = seconds - 1;
-                if seconds > 0 {
-                    self.status = DcOutStatus::TurningOff(seconds);
-                } else {
-                    self.status = DcOutStatus::On;
-                }
-            }
-            _ => {}
-        };
-    }
-
     pub fn to_json(&self) -> String {
         let status = match self.status {
-            DcOutStatus::WaitingOn(_) => "WaitingOn",
+            ChargeStatus::Charging => "Charging",
-            DcOutStatus::On => "On",
+            ChargeStatus::Charged => "Charged",
-            DcOutStatus::Off => "Off",
-            DcOutStatus::WaitingOff => "WaitingOff",
-            DcOutStatus::TurningOff(_) => "TurningOff",
         };
         let pin_state = match self.pin_state {
             PinState::Low => "Low",
             PinState::High => "High",
         };
-        let seconds: i16 = match self.status {
+        let now = Time::new().get_time();
-            DcOutStatus::WaitingOn(seconds) => seconds.into(),
+        let charging_count_down = if now > self.charge_deadline_at {
-            DcOutStatus::TurningOff(seconds) => seconds.into(),
+            -1i64
-            _ => -1,
+        } else {
+            (self.charge_deadline_at - now).as_secs() as i64
         };
-        json!({ "status": status, "pin_state": pin_state, "seconds": seconds }).to_string()
+        json!({ "status": status, "pin_state": pin_state, "charging_count_down": charging_count_down}).to_string()
     }
 }
 
-impl EspTypedEventSource for DcOutControllerState {
+impl EspTypedEventSource for ChargeControllerState {
     fn source() -> *const c_types::c_char {
         b"Charge\0".as_ptr() as *const _
     }
 }
 
-impl EspTypedEventSerializer<DcOutControllerState> for DcOutControllerState {
+impl EspTypedEventSerializer<ChargeControllerState> for ChargeControllerState {
     fn serialize<R>(
-        event: &DcOutControllerState,
+        event: &ChargeControllerState,
         f: impl for<'a> FnOnce(&'a EspEventPostData) -> R,
     ) -> R {
         f(&unsafe { EspEventPostData::new(Self::source(), Self::event_id(), event) })
     }
 }
 
-impl EspTypedEventDeserializer<DcOutControllerState> for DcOutControllerState {
+impl EspTypedEventDeserializer<ChargeControllerState> for ChargeControllerState {
     fn deserialize<R>(
         data: &EspEventFetchData,
-        f: &mut impl for<'a> FnMut(&'a DcOutControllerState) -> R,
+        f: &mut impl for<'a> FnMut(&'a ChargeControllerState) -> R,
     ) -> R {
         f(unsafe { data.as_payload() })
     }
 }
 
-type DcOutPin = Gpio6<Output>;
+type ChargeCtlPin = Gpio7<Output>;
 
-pub struct DcOutController {
+pub struct ChargeController {
-    pub state: DcOutControllerState,
+    pub state: ChargeControllerState,
     voltage_subscription: Option<EspSubscription<User<Background>>>,
-    pin: Arc<Mutex<DcOutPin>>,
+    pin: Arc<Mutex<ChargeCtlPin>>,
 }
 
-impl DcOutController {
+impl ChargeController {
     pub fn new() -> anyhow::Result<Self> {
-        let pin = unsafe { Gpio6::<Output>::new() }
+        let pin = unsafe { Gpio7::<Output>::new() }
             .into_output()
             .map_err(|err| anyhow::anyhow!("Make Gpio6 Into output Failed. {}", err))?;
 
         match EspBackgroundEventLoop::new(&Default::default()) {
-            Ok(eventloop) => unsafe { DC_OUT_STATE_EVENT_LOOP = Some(eventloop) },
+            Ok(eventloop) => unsafe { CHARGE_STATE_EVENT_LOOP = Some(eventloop) },
             Err(err) => anyhow::bail!("Init Event Loop failed. {:?}", err),
         }
 
         anyhow::Ok(Self {
-            state: DcOutControllerState::new(),
+            state: ChargeControllerState::new(),
             voltage_subscription: None,
             pin: Arc::new(Mutex::new(pin)),
         })
@@ -196,33 +121,46 @@ impl DcOutController {
         if let Some(event_loop) = unsafe { VOLTAGE_EVENTLOOP.as_mut() } {
             let voltage_subscription = event_loop
                 .subscribe(move |obj: &VoltageDetectionWorker| {
-                    if obj.adapter_voltage < 1000 {
+                    match state.status {
-                        if obj.battery_voltage < 1000 {
+                        ChargeStatus::Charging => {
-                            state.turn_off();
+                            if obj.battery_voltage < 12600 {
-                        } else {
+                                state.status = ChargeStatus::Charging;
-                            state.handle_adapter_down();
+                            } else {
+                                let now = Time::new().get_time();
+                                if state.charge_deadline_at == Duration::ZERO {
+                                    state.charge_deadline_at = now + Duration::from_secs(600);
+                                } else if now > state.charge_deadline_at {
+                                    state.status = ChargeStatus::Charged;
+                                } else {
+                                    state.status = ChargeStatus::Charging;
+                                }
+                            }
+                        }
+                        ChargeStatus::Charged => {
+                            if obj.battery_voltage < 10500 {
+                                state.status = ChargeStatus::Charging;
+                            } else {
+                                state.status = ChargeStatus::Charged;
+                            }
                         }
-                    } else {
-                        state.turn_on();
                     }
 
                     match pin.lock() {
                         Ok(pin) => {
-                            if let Err(err) = Self::output_ctl(state, pin) {
+                            if let Err(err) = Self::output_ctl(&mut state, pin) {
                                 warn!("Put Control Pin State Failed. {}", err);
                             }
                         }
                         Err(_) => todo!(),
                     }
 
-                    if let Some(event_loop) = unsafe { DC_OUT_STATE_EVENT_LOOP.as_mut() } {
+                    if let Some(event_loop) = unsafe { CHARGE_STATE_EVENT_LOOP.as_mut() } {
                         if let Err(err) = event_loop.post(&state, None) {
                             warn!("Post DC Out Status Failed. {}", err);
                         }
                     } else {
-                        warn!("DC_OUT_STATE_EVENT_LOOP is None");
+                        warn!("CHARGE_STATE_EVENT_LOOP is None");
                     }
-                    debug!("status: {:?}", state);
                 })
                 .map_err(|err| anyhow::anyhow!("Subscribe Voltage Failed. {}", err))?;
             self.voltage_subscription = Some(voltage_subscription);
@@ -232,14 +170,14 @@ impl DcOutController {
         anyhow::Ok(())
     }
     fn output_ctl(
-        mut state: DcOutControllerState,
+        state: &mut ChargeControllerState,
-        mut pin: MutexGuard<DcOutPin>,
+        mut pin: MutexGuard<ChargeCtlPin>,
     ) -> anyhow::Result<()> {
-        if DcOutStatus::Off == state.status && state.pin_state == PinState::Low {
+        if ChargeStatus::Charging == state.status {
             pin.set_high()
                 .map_err(|err| anyhow::anyhow!("Set DC Output Control Pin High Failed. {}", err))?;
             state.pin_state = PinState::High;
-        } else if DcOutStatus::On == state.status && state.pin_state == PinState::High {
+        } else if ChargeStatus::Charged == state.status {
             pin.set_low()
                 .map_err(|err| anyhow::anyhow!("Set DC Output Control Pin Low Failed. {}", err))?;
             state.pin_state = PinState::Low;

src/dc_out_controller.rs

@@ -1,7 +1,6 @@
 use std::{
-    sync::{
+    sync::{Arc, Mutex, MutexGuard},
-        Arc, Mutex, MutexGuard,
+    time::Duration,
-    },
 };
 
 use embedded_hal::digital::v2::{OutputPin, PinState};
@@ -12,12 +11,16 @@ use esp_idf_svc::eventloop::{
     EspSubscription, EspTypedEventDeserializer, EspTypedEventSerializer, EspTypedEventSource, User,
 };
 use esp_idf_sys::c_types;
-use log::{info, warn, debug};
+use log::warn;
 use serde_json::json;
 
-use crate::voltage_detection::{VoltageDetectionWorker, VOLTAGE_EVENTLOOP};
+use crate::{
+    time::Time,
+    voltage_detection::{VoltageDetectionWorker, VOLTAGE_EVENTLOOP},
+};
 
-const WAITING_OFF_SECONDS: u8 = 60;
+const WAITING_OFF_DURATION: u64 = 60;
+const WAITING_ON_DURATION: u64 = 60;
 
 pub static mut DC_OUT_STATE_EVENT_LOOP: Option<
     EspEventLoop<esp_idf_svc::eventloop::User<Background>>,
@@ -25,11 +28,11 @@ pub static mut DC_OUT_STATE_EVENT_LOOP: Option<
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum DcOutStatus {
-    WaitingOn(u8),
+    WaitingOn(Duration),
     On,
     Off,
     WaitingOff,
-    TurningOff(u8),
+    TurningOff(Duration),
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -47,7 +50,6 @@ impl DcOutControllerState {
     }
 
     fn handle_adapter_down(&mut self) {
-        info!("status: {:?}", self);
         match self.status {
             DcOutStatus::On => {
                 self.status = DcOutStatus::WaitingOff;
@@ -55,11 +57,9 @@ impl DcOutControllerState {
             DcOutStatus::WaitingOn(_) => {
                 self.status = DcOutStatus::Off;
             }
-            DcOutStatus::TurningOff(seconds) => {
+            DcOutStatus::TurningOff(target) => {
-                let seconds = seconds - 1;
+                let now = Time::new().get_time();
-                if seconds > 0 {
+                if now > target {
-                    self.status = DcOutStatus::TurningOff(seconds);
-                } else {
                     self.status = DcOutStatus::Off;
                 }
             }
@@ -68,21 +68,21 @@ impl DcOutControllerState {
     }
 
     fn turn_off(&mut self) {
+        let now = Time::new().get_time();
         match self.status {
             DcOutStatus::On => {
-                self.status = DcOutStatus::TurningOff(WAITING_OFF_SECONDS);
+                self.status =
+                    DcOutStatus::TurningOff(now + Duration::from_secs(WAITING_OFF_DURATION));
             }
             DcOutStatus::WaitingOff => {
-                self.status = DcOutStatus::TurningOff(WAITING_OFF_SECONDS);
+                self.status =
+                    DcOutStatus::TurningOff(now + Duration::from_secs(WAITING_OFF_DURATION));
             }
             DcOutStatus::WaitingOn(_) => {
                 self.status = DcOutStatus::Off;
             }
-            DcOutStatus::TurningOff(seconds) => {
+            DcOutStatus::TurningOff(target) => {
-                let seconds = seconds - 1;
+                if target < now {
-                if seconds > 0 {
-                    self.status = DcOutStatus::TurningOff(seconds);
-                } else {
                     self.status = DcOutStatus::Off;
                 }
             }
@@ -91,26 +91,22 @@ impl DcOutControllerState {
     }
 
     fn turn_on(&mut self) {
+        let now = Time::new().get_time();
         match self.status {
             DcOutStatus::WaitingOff => {
                 self.status = DcOutStatus::On;
             }
             DcOutStatus::Off => {
-                self.status = DcOutStatus::WaitingOn(WAITING_OFF_SECONDS);
+                self.status =
+                    DcOutStatus::WaitingOn(now + Duration::from_secs(WAITING_ON_DURATION));
             }
-            DcOutStatus::WaitingOn(seconds) => {
+            DcOutStatus::WaitingOn(target) => {
-                let seconds = seconds - 1;
+                if target <= now {
-                if seconds > 0 {
-                    self.status = DcOutStatus::WaitingOn(seconds);
-                } else {
                     self.status = DcOutStatus::On;
                 }
             }
-            DcOutStatus::TurningOff(seconds) => {
+            DcOutStatus::TurningOff(target) => {
-                let seconds = seconds - 1;
+                if target <= now {
-                if seconds > 0 {
-                    self.status = DcOutStatus::TurningOff(seconds);
-                } else {
                     self.status = DcOutStatus::On;
                 }
             }
@@ -130,11 +126,18 @@ impl DcOutControllerState {
             PinState::Low => "Low",
             PinState::High => "High",
         };
-        let seconds: i16 = match self.status {
+        let now = Time::new().get_time();
-            DcOutStatus::WaitingOn(seconds) => seconds.into(),
+        let target = match self.status {
-            DcOutStatus::TurningOff(seconds) => seconds.into(),
+            DcOutStatus::WaitingOn(target) => target,
-            _ => -1,
+            DcOutStatus::TurningOff(target) => target,
+            _ => Duration::ZERO,
         };
+        let seconds = if now < target {
+            target - now
+        } else {
+            Duration::ZERO
+        }
+        .as_secs();
         json!({ "status": status, "pin_state": pin_state, "seconds": seconds }).to_string()
     }
 }
@@ -208,7 +211,7 @@ impl DcOutController {
 
                     match pin.lock() {
                         Ok(pin) => {
-                            if let Err(err) = Self::output_ctl(state, pin) {
+                            if let Err(err) = Self::output_ctl(&mut state, pin) {
                                 warn!("Put Control Pin State Failed. {}", err);
                             }
                         }
@@ -222,7 +225,6 @@ impl DcOutController {
                     } else {
                         warn!("DC_OUT_STATE_EVENT_LOOP is None");
                     }
-                    debug!("status: {:?}", state);
                 })
                 .map_err(|err| anyhow::anyhow!("Subscribe Voltage Failed. {}", err))?;
             self.voltage_subscription = Some(voltage_subscription);
@@ -232,14 +234,14 @@ impl DcOutController {
         anyhow::Ok(())
     }
     fn output_ctl(
-        mut state: DcOutControllerState,
+        state: &mut DcOutControllerState,
         mut pin: MutexGuard<DcOutPin>,
     ) -> anyhow::Result<()> {
-        if DcOutStatus::Off == state.status && state.pin_state == PinState::Low {
+        if DcOutStatus::Off == state.status {
             pin.set_high()
                 .map_err(|err| anyhow::anyhow!("Set DC Output Control Pin High Failed. {}", err))?;
             state.pin_state = PinState::High;
-        } else if DcOutStatus::On == state.status && state.pin_state == PinState::High {
+        } else if DcOutStatus::On == state.status {
             pin.set_low()
                 .map_err(|err| anyhow::anyhow!("Set DC Output Control Pin Low Failed. {}", err))?;
             state.pin_state = PinState::Low;

src/main.rs

@@ -15,12 +15,13 @@ mod message_queue;
 mod time;
 mod voltage_detection;
 mod wifi;
+mod charge_controller;
 
 use crate::{
     beep::{ringtone, Beep},
     dc_out_controller::{DcOutController, DcOutControllerState, DC_OUT_STATE_EVENT_LOOP},
     message_queue::MqDto,
-    voltage_detection::{VoltageDetectionWorker, VOLTAGE_EVENTLOOP},
+    voltage_detection::{VoltageDetectionWorker, VOLTAGE_EVENTLOOP}, charge_controller::{CHARGE_STATE_EVENT_LOOP, ChargeControllerState, ChargeController},
 };
 use crate::{
     message_queue::MessageQueue, time::Time, voltage_detection::VoltageDetection, wifi::Internet,
@@ -56,7 +57,7 @@ fn main() {
         blink.play();
     });
 
-    let mut voltage_detection = VoltageDetection::new();
+    let voltage_detection = VoltageDetection::new();
 
     voltage_detection.unwrap()
         .watching()
@@ -77,6 +78,12 @@ fn main() {
         .watch()
         .expect("Can not watch for dc_out_controller");
 
+    let mut charge_controller = ChargeController::new().expect("Can not get ChargeController instance");
+    charge_controller
+        .watch()
+        .expect("Can not watch for charge_controller");
+
+
     sleep(Duration::from_millis(100));
 
     let mut _mq = MessageQueue::new();
@@ -91,6 +98,7 @@ fn main() {
 
     let _mq_tx_for_voltage = _mq.tx.clone();
     let _mq_tx_for_dc_out_state = _mq.tx.clone();
+    let _mq_tx_for_charge_state = _mq.tx.clone();
 
     let _voltage_subscription;
     if let Some(voltage_event_loop) = unsafe { VOLTAGE_EVENTLOOP.as_mut() } {
@@ -151,6 +159,29 @@ fn main() {
         panic!("DC_OUT_STATE_EVENT_LOOP is undefined!");
     }
 
+    let _charge_state_subscription;
+    if let Some(charge_state_event_loop) = unsafe { CHARGE_STATE_EVENT_LOOP.as_mut() } {
+        _charge_state_subscription = charge_state_event_loop
+            .subscribe(move |message: &ChargeControllerState| {
+                match _mq_tx_for_charge_state.lock() {
+                    Ok(tx) => {
+                        let result = tx.send(MqDto {
+                            topic: "charge_state".to_string(),
+                            message: message.to_json(),
+                        });
+
+                        if let Err(err) = result {
+                            warn!("send charge_state message failed. {}", err)
+                        }
+                    }
+                    Err(err) => warn!("send charge_state to mq message failed. {}", err),
+                }
+            })
+            .expect(" Listening Event Loop Failed");
+    } else {
+        panic!("CHARGE_STATE_EVENT_LOOP is undefined!");
+    }
+
     loop {
         sleep(Duration::from_millis(100));
     }

src/voltage_detection.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use embedded_hal::{adc::Channel, prelude::_embedded_hal_adc_OneShot};
-use embedded_svc::{event_bus::Postbox};
+use embedded_svc::event_bus::Postbox;
 use esp_idf_hal::{
     adc::{
         config::{self},
@@ -13,11 +13,9 @@ use esp_idf_hal::{
     },
     gpio::{Gpio1, Gpio2, Gpio3, Input},
 };
-use esp_idf_svc::{
+use esp_idf_svc::eventloop::{
-    eventloop::{
+    Background, EspBackgroundEventLoop, EspEventFetchData, EspEventLoop, EspEventPostData,
-        Background, EspBackgroundEventLoop, EspEventFetchData, EspEventLoop, EspEventPostData,
+    EspTypedEventDeserializer, EspTypedEventSerializer, EspTypedEventSource,
-        EspTypedEventDeserializer, EspTypedEventSerializer, EspTypedEventSource,
-    },
 };
 use esp_idf_sys::c_types;
 use log::{debug, warn};
@@ -75,6 +73,8 @@ impl VoltageDetection {
                         anyhow::anyhow!("Failed to set GPIO 3 as analog input. {}", err)
                     })?;
 
+                let mut adc = PoweredAdc::new(unsafe { ADC1::new() }, config::Config::new())?;
+
                 let mut worker = worker.lock().map_err(|err| {
                     anyhow::anyhow!("Lock VoltageDetection Worker Failed. {}", err)
                 })?;
@@ -83,7 +83,12 @@ impl VoltageDetection {
 
                 loop {
                     last_runing_at = Time::new().get_time();
-                    match worker.read_once(&mut adapter_pin, &mut battery_pin, &mut output_pin) {
+                    match worker.read_once(
+                        &mut adc,
+                        &mut adapter_pin,
+                        &mut battery_pin,
+                        &mut output_pin,
+                    ) {
                         Ok(_) => debug!(
                             "Adapter: {},\tBattery: {},\t Output: {}",
                             worker.adapter_voltage, worker.battery_voltage, worker.output_voltage
@@ -107,11 +112,11 @@ impl VoltageDetection {
                     }
                     let mut delta = Time::new().get_time() - last_runing_at;
 
-                    if delta >= Duration::from_millis(1000) {
+                    if delta >= Duration::from_millis(5000) {
                         delta = Duration::ZERO
                     }
 
-                    sleep(Duration::from_millis(1000) - delta);
+                    sleep(Duration::from_millis(5000) - delta);
                 }
             };
 
@@ -134,11 +139,12 @@ impl VoltageDetectionWorker {
 
     pub fn read_once(
         &mut self,
+        adc: &mut PoweredAdc<ADC1>,
         adapter_pin: &mut Gpio1<Atten6dB<ADC1>>,
         battery_pin: &mut Gpio2<Atten6dB<ADC1>>,
         output_pin: &mut Gpio3<Atten6dB<ADC1>>,
     ) -> anyhow::Result<()> {
-        match self.read_pin_once(adapter_pin) {
+        match self.read_pin_once(adc, adapter_pin) {
             Ok(voltage) => {
                 self.adapter_voltage = ((voltage as f32) * ADAPTER_OFFSET) as u16;
             }
@@ -147,7 +153,7 @@ impl VoltageDetectionWorker {
             }
         }
 
-        match self.read_pin_once(battery_pin) {
+        match self.read_pin_once(adc, battery_pin) {
             Ok(voltage) => {
                 self.battery_voltage = ((voltage as f32) * BATTERY_OFFSET) as u16;
             }
@@ -155,7 +161,7 @@ impl VoltageDetectionWorker {
                 warn!("Adapter Voltage read failed: {:?}", err);
             }
         }
-        match self.read_pin_once(output_pin) {
+        match self.read_pin_once(adc, output_pin) {
             Ok(voltage) => {
                 self.output_voltage = ((voltage as f32) * OUTPUT_OFFSET) as u16;
             }
@@ -168,16 +174,23 @@ impl VoltageDetectionWorker {
     }
     pub fn read_pin_once<AN: Analog<ADC1>, PIN: Channel<AN, ID = u8>>(
         &mut self,
+        adc: &mut PoweredAdc<ADC1>,
         pin: &mut PIN,
     ) -> anyhow::Result<u16> {
-        let mut adc = PoweredAdc::new(unsafe { ADC1::new() }, config::Config::new())?;
+        let mut avg_voltage: u16 = 0;
-        let voltage = adc.read(pin);
+        for _ in 0..10 {
-        match voltage {
+            let voltage = adc.read(pin);
-            Ok(voltage) => anyhow::Ok(voltage),
+            match voltage {
-            Err(err) => {
+                Ok(voltage) => {
-                anyhow::bail!("Adapter Voltage read failed: {:?}", err)
+                    avg_voltage += voltage;
-            }
+                }
+                Err(err) => {
+                    anyhow::bail!("Adapter Voltage read failed: {:?}", err)
+                }
+            };
+            sleep(Duration::from_millis(100));
         }
+        anyhow::Ok(avg_voltage / 10)
     }
 }