convert app to tick servicing

ch32v-insert-coin/src/app.rs

@@ -1,4 +1,4 @@
-#[derive(Default)]
+#[derive(Default, Clone, Copy)]
 pub enum State {
     // system is asleep, waiting for wake from coin insertion
     DeepSleep,
@@ -10,9 +10,12 @@ pub enum State {
 }
 
 mod settings {
+
+    #[derive(Default, Clone, Copy)]
     pub enum Level {
         Off,
         Low,
+        #[default]
         Medium,
         High,
         Maximum,
@@ -30,6 +33,7 @@ mod settings {
         }
     }
 
+    #[derive(Clone, Copy)]
     pub struct Settings {
         pub brightness: Level,
         pub volume: Level,
@@ -47,20 +51,180 @@ mod settings {
     }
 }
 
+use crate::insert_coin::{TickService, TickServiceData, TickTimerService};
 pub use settings::Settings;
 
+#[cfg(feature = "enable_print")]
+use ch32_hal::println;
+
+pub struct TimerConfig {
+    pub sp_timer_ms: usize,
+    pub lp_timer_ms: usize,
+    pub batt_adc_timer_ms: usize,
+    pub usb_adc_timer_ms: usize,
+    pub led0_timer_ms: usize,
+    pub led1_timer_ms: usize,
+    pub led2_timer_ms: usize,
+}
+
+pub struct Timers {
+    sp_timer: TickTimerService,
+    lp_timer: TickTimerService,
+    batt_adc_timer: TickTimerService,
+    usb_adc_timer: TickTimerService,
+    led0_timer: TickTimerService,
+    led1_timer: TickTimerService,
+    led2_timer: TickTimerService,
+}
+
+impl Timers {
+    pub fn new(config: TimerConfig, system_tick_rate_hz: usize) -> Self {
+        Self {
+            sp_timer: TickTimerService::new(
+                TickServiceData::new(config.sp_timer_ms * system_tick_rate_hz / 1000),
+                false,
+            ),
+            lp_timer: TickTimerService::new(
+                TickServiceData::new(config.lp_timer_ms * system_tick_rate_hz / 1000),
+                false,
+            ),
+            batt_adc_timer: TickTimerService::new(
+                TickServiceData::new(config.batt_adc_timer_ms * system_tick_rate_hz / 1000),
+                false,
+            ),
+            usb_adc_timer: TickTimerService::new(
+                TickServiceData::new(config.usb_adc_timer_ms * system_tick_rate_hz / 1000),
+                false,
+            ),
+            led0_timer: TickTimerService::new(
+                TickServiceData::new(config.led0_timer_ms * system_tick_rate_hz / 1000),
+                true,
+            ),
+            led1_timer: TickTimerService::new(
+                TickServiceData::new(config.led1_timer_ms * system_tick_rate_hz / 1000),
+                true,
+            ),
+            led2_timer: TickTimerService::new(
+                TickServiceData::new(config.led2_timer_ms * system_tick_rate_hz / 1000),
+                true,
+            ),
+        }
+    }
+    pub fn tick(&mut self) {
+        self.sp_timer.tick();
+        self.lp_timer.tick();
+        self.batt_adc_timer.tick();
+        self.usb_adc_timer.tick();
+        self.led0_timer.tick();
+        self.led1_timer.tick();
+        self.led2_timer.tick();
+    }
+    pub fn need_service(&self) -> bool {
+        self.sp_timer.need_service()
+            | self.lp_timer.need_service()
+            | self.batt_adc_timer.need_service()
+            | self.usb_adc_timer.need_service()
+            | self.led0_timer.need_service()
+            | self.led1_timer.need_service()
+            | self.led2_timer.need_service()
+    }
+    pub fn init(&mut self) {
+        self.led0_timer.reset();
+        self.led0_timer.enable(true);
+    }
+}
+
+pub struct Config {
+    pub system_tick_rate_hz: usize,
+    pub timers: TimerConfig,
+}
+
 pub struct App {
     state: State,
     pub settings: Settings,
+    timers: Timers,
     // TODO: make this the "sound module" or whatever.
     // synthesizers: AppSynthesizers,
 }
 
-impl Default for App {
-    fn default() -> Self {
+impl App {
+    pub fn new(config: Config) -> Self {
         Self {
             state: State::default(),
             settings: Settings::default(),
+            timers: Timers::new(config.timers, config.system_tick_rate_hz),
+        }
+    }
+
+    pub fn init(&mut self) {
+        // self.timers.init();
+        self.timers.batt_adc_timer.reset();
+        self.timers.batt_adc_timer.enable(true);
+
+        self.timers.usb_adc_timer.reset();
+        self.timers.usb_adc_timer.enable(true);
+
+        self.timers.led0_timer.reset();
+        self.timers.led0_timer.enable(true);
+
+        self.timers.led1_timer.reset();
+        self.timers.led1_timer.enable(true);
+
+        self.timers.led2_timer.reset();
+        self.timers.led2_timer.enable(true);
+    }
+
+    pub fn set_state(&mut self, state: State) {
+        self.state = state
+    }
+
+    pub fn state(&self) -> State {
+        self.state
+    }
+
+    pub fn settings(&self) -> Settings {
+        self.settings
+    }
+
+    pub fn tick(&mut self) {
+        self.timers.tick();
+    }
+
+    pub fn service(&mut self) {
+        if self.timers.sp_timer.need_service() {
+            self.timers.batt_adc_timer.service();
+            #[cfg(feature = "enable_print")]
+            println!("sp service");
+        }
+        if self.timers.lp_timer.need_service() {
+            self.timers.batt_adc_timer.service();
+            #[cfg(feature = "enable_print")]
+            println!("lp service");
+        }
+        if self.timers.batt_adc_timer.need_service() {
+            self.timers.batt_adc_timer.service();
+            #[cfg(feature = "enable_print")]
+            println!("batt adc service");
+        }
+        if self.timers.usb_adc_timer.need_service() {
+            self.timers.usb_adc_timer.service();
+            #[cfg(feature = "enable_print")]
+            println!("usb adc service");
+        }
+        if self.timers.led0_timer.need_service() {
+            self.timers.led0_timer.service();
+            #[cfg(feature = "enable_print")]
+            println!("led0 service");
+        }
+        if self.timers.led1_timer.need_service() {
+            self.timers.led1_timer.service();
+            #[cfg(feature = "enable_print")]
+            println!("led1 service");
+        }
+        if self.timers.led2_timer.need_service() {
+            self.timers.led2_timer.service();
+            #[cfg(feature = "enable_print")]
+            println!("led2 service");
         }
     }
 }