| use crate::result::OutOfRangeError; | |
| use crate::result::TockResult; | |
| use crate::syscalls::command; | |
| use core::marker::PhantomData; | |
| const DRIVER_NUMBER: usize = 0x00002; | |
| mod command_nr { | |
| pub const COUNT: usize = 0; | |
| pub const ON: usize = 1; | |
| pub const OFF: usize = 2; | |
| pub const TOGGLE: usize = 3; | |
| } | |
| #[non_exhaustive] | |
| pub struct LedsDriverFactory; | |
| impl LedsDriverFactory { | |
| pub fn init_driver(&mut self) -> TockResult<LedsDriver> { | |
| let driver = LedsDriver { | |
| num_leds: command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?, | |
| lifetime: PhantomData, | |
| }; | |
| Ok(driver) | |
| } | |
| } | |
| pub struct LedsDriver<'a> { | |
| num_leds: usize, | |
| lifetime: PhantomData<&'a ()>, | |
| } | |
| impl<'a> LedsDriver<'a> { | |
| pub fn num_leds(&self) -> usize { | |
| self.num_leds | |
| } | |
| pub fn leds(&self) -> Leds { | |
| Leds { | |
| num_leds: self.num_leds, | |
| curr_led: 0, | |
| lifetime: PhantomData, | |
| } | |
| } | |
| /// Returns the led at 0-based index `led_num` | |
| pub fn get(&self, led_num: usize) -> Result<Led, OutOfRangeError> { | |
| if led_num < self.num_leds { | |
| Ok(Led { | |
| led_num, | |
| lifetime: PhantomData, | |
| }) | |
| } else { | |
| Err(OutOfRangeError) | |
| } | |
| } | |
| } | |
| pub struct Leds<'a> { | |
| num_leds: usize, | |
| curr_led: usize, | |
| lifetime: PhantomData<&'a ()>, | |
| } | |
| impl<'a> Iterator for Leds<'a> { | |
| type Item = Led<'a>; | |
| fn next(&mut self) -> Option<Self::Item> { | |
| if self.curr_led < self.num_leds { | |
| let item = Led { | |
| led_num: self.curr_led, | |
| lifetime: PhantomData, | |
| }; | |
| self.curr_led += 1; | |
| Some(item) | |
| } else { | |
| None | |
| } | |
| } | |
| } | |
| pub struct Led<'a> { | |
| led_num: usize, | |
| lifetime: PhantomData<&'a ()>, | |
| } | |
| impl<'a> Led<'a> { | |
| pub fn led_num(&self) -> usize { | |
| self.led_num | |
| } | |
| pub fn set(&self, state: impl Into<LedState>) -> TockResult<()> { | |
| match state.into() { | |
| LedState::On => self.on(), | |
| LedState::Off => self.off(), | |
| } | |
| } | |
| pub fn on(&self) -> TockResult<()> { | |
| command(DRIVER_NUMBER, command_nr::ON, self.led_num, 0)?; | |
| Ok(()) | |
| } | |
| pub fn off(&self) -> TockResult<()> { | |
| command(DRIVER_NUMBER, command_nr::OFF, self.led_num, 0)?; | |
| Ok(()) | |
| } | |
| pub fn toggle(&self) -> TockResult<()> { | |
| command(DRIVER_NUMBER, command_nr::TOGGLE, self.led_num, 0)?; | |
| Ok(()) | |
| } | |
| } | |
| #[derive(Copy, Clone, Debug, Eq, PartialEq)] | |
| pub enum LedState { | |
| On, | |
| Off, | |
| } | |
| impl From<bool> for LedState { | |
| fn from(from_value: bool) -> Self { | |
| if from_value { | |
| LedState::On | |
| } else { | |
| LedState::Off | |
| } | |
| } | |
| } | |
| #[cfg(test)] | |
| mod test { | |
| use super::command_nr; | |
| use super::DRIVER_NUMBER; | |
| use crate::result::TockResult; | |
| use crate::syscalls; | |
| use crate::syscalls::raw::Event; | |
| #[test] | |
| pub fn single_led_can_be_enabled() { | |
| let events = syscalls::raw::run_recording_events::<TockResult<()>, _>(|next_return| { | |
| let mut drivers = unsafe { crate::drivers::retrieve_drivers_unsafe() }; | |
| next_return.set(1); | |
| let leds_driver = drivers.leds.init_driver()?; | |
| next_return.set(0); | |
| let led = leds_driver.get(0)?; | |
| led.on()?; | |
| Ok(()) | |
| }); | |
| assert_eq!( | |
| events, | |
| vec![ | |
| Event::Command(DRIVER_NUMBER, command_nr::COUNT, 0, 0), | |
| Event::Command(DRIVER_NUMBER, command_nr::ON, 0, 0), | |
| ] | |
| ); | |
| } | |
| } |