LailaTheElf/RTS10_verslagen
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

finis exersise 8.3

Browse Source
This commit is contained in:
Laila van Reenen
2025-10-30 16:30:40 +01:00
parent 1410897f8f
commit a8d37effb2
4 changed files with 631 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
report-3/rts10_rust/src/leds.rs
View File

@@ -52,37 +52,44 @@ impl<'a, T: OutputPin> Toggle<T> for ToggleLed<'a, T> {
pub struct Leds<'a,
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> {
pub red: &'a mut RT,
pub green: &'a mut GT,
pub orange: &'a mut OT,
pub blue: &'a mut BT,
// phantom data to convince rustc the generics RP, GP and BP are used.
_r: PhantomData<RP>,
_g: PhantomData<GP>,
_o: PhantomData<OP>,
_b: PhantomData<BP>,
}
impl<'a,
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> Leds<'a, RP, RT, GP, GT, BP, BT> {
pub fn new(red: &'a mut RT, green: &'a mut GT, blue: &'a mut BT) -> Self {
> Leds<'a, RP, RT, GP, GT, OP, OT, BP, BT> {
pub fn new(red: &'a mut RT, green: &'a mut GT, orange: &'a mut OT, blue: &'a mut BT) -> Self {
Self {
red,
green,
orange,
blue,
_r: PhantomData,
_g: PhantomData,
_o: PhantomData,
_b: PhantomData,
}
}
pub fn set_all(&mut self, red: PinState, green: PinState, blue: PinState) {
pub fn set_all(&mut self, red: PinState, green: PinState, orange: PinState, blue: PinState) {
let _ = self.red.set(red);
let _ = self.blue.set(blue);
let _ = self.orange.set(orange);
let _ = self.green.set(green);
let _ = self.blue.set(blue);
}
}

21
report-3/rts10_rust/src/main.rs
View File

@@ -3,6 +3,7 @@
#![no_main]
#![no_std]
use embedded_hal::digital::PinState;
// Halt on panic
use panic_halt as _; // panic handler
@@ -27,11 +28,16 @@ fn main() -> ! {
//led pinnen uphalen
let mut green_pin = &mut gpiod.pd12.into_push_pull_output();
let mut red_pin = &mut gpiod.pd14.into_push_pull_output();
let mut orange_pin = &mut gpiod.pd13.into_push_pull_output();
let mut blue_pin = &mut gpiod.pd15.into_push_pull_output();
let mut green = ToggleLed::new(&mut green_pin).expect("faild to set green led");
let mut red = ToggleLed::new(&mut red_pin).expect("faild to set red led");
let mut orange = ToggleLed::new(&mut orange_pin).expect("faild to set orange led");
let mut blue = ToggleLed::new(&mut blue_pin).expect("faild to set blue led");
let mut leds = Leds::new(&mut red, &mut green, &mut blue);
let mut leds = Leds::new(&mut red, &mut green, &mut orange, &mut blue);
//user knop
let gpioa = dp.GPIOA.split();
let button = &mut gpioa.pa0.into_floating_input();
//leds struct en state machine maken
let mut state_machine = StateMachine::new(&mut leds);
@@ -41,9 +47,20 @@ fn main() -> ! {
// Create a delay abstraction based on SysTick
let mut delay = cp.SYST.delay(&clocks);
let mut button_high = button.is_high();
loop {
let _ = state_machine.second_passed();
delay.delay_ms(1000_u32);
for _ in 0..99 {
if button_high != button.is_high() {
button_high = button.is_high();
if button_high {
state_machine.button_press();
} else {
state_machine.button_release();
}
}
delay.delay_ms(10_u32);
}
}
}

146
report-3/rts10_rust/src/state_machine.rs
View File

@@ -4,44 +4,67 @@ use crate::leds::{Leds, Toggle};
enum States {
Red(StateRed),
Blue(StateBlue),
Orange(StateOrange),
Green(StateGreen),
BridgeOpen(StateBridgeOpen)
}
trait State<
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> {
fn new(leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> Self;
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> States;
fn new(leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> Self;
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States;
fn button_press(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States;
fn button_release(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States;
}
pub struct StateMachine<'a,
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> {
state: States,
leds: &'a mut Leds<'a, RP, RT, GP, GT, BP, BT>,
leds: &'a mut Leds<'a, RP, RT, GP, GT, OP, OT, BP, BT>
}
impl<'a,
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> StateMachine<'a, RP, RT, GP, GT, BP, BT>
> StateMachine<'a, RP, RT, GP, GT, OP, OT, BP, BT>
{
pub fn new(leds: &'a mut Leds<'a, RP, RT, GP, GT, BP, BT>) -> Self {
pub fn new(leds: &'a mut Leds<'a, RP, RT, GP, GT, OP, OT, BP, BT>) -> Self {
Self {
state: States::Red(StateRed::new(leds)),
leds,
leds
}
}
pub fn second_passed(&mut self) {
self.state = match &self.state {
States::Red(state) => state.second_passed(self.leds),
States::Blue(state) => state.second_passed(self.leds),
States::Orange(state) => state.second_passed(self.leds),
States::Green(state) => state.second_passed(self.leds),
States::BridgeOpen(state) => state.second_passed(self.leds),
}
}
pub fn button_press(&mut self) {
self.state = match &self.state {
States::Red(state) => state.button_press(self.leds),
States::Orange(state) => state.button_press(self.leds),
States::Green(state) => state.button_press(self.leds),
States::BridgeOpen(state) => state.button_press(self.leds),
}
}
pub fn button_release(&mut self) {
self.state = match &self.state {
States::Red(state) => state.button_release(self.leds),
States::Orange(state) => state.button_release(self.leds),
States::Green(state) => state.button_release(self.leds),
States::BridgeOpen(state) => state.button_release(self.leds),
}
}
}
@@ -56,15 +79,16 @@ struct StateRed {
impl<
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> State<RP, RT, GP, GT, BP, BT> for StateRed {
fn new(leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> Self {
leds.set_all(PinState::High, PinState::Low, PinState::Low);
> State<RP, RT, GP, GT, OP, OT, BP, BT> for StateRed {
fn new(leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> Self {
leds.set_all(PinState::High, PinState::Low, PinState::Low, PinState::Low);
Self {
time_passed: 0
}
}
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> States {
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
if self.time_passed + 1 >= 4 {
States::Green(StateGreen::new(leds))
} else {
@@ -73,6 +97,15 @@ impl<
})
}
}
fn button_press(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::BridgeOpen(StateBridgeOpen::new(leds))
}
fn button_release(&self, _leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::Red(Self {
time_passed: self.time_passed
})
}
}
// ####################################################
@@ -85,40 +118,107 @@ struct StateGreen {
impl<
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> State<RP, RT, GP, GT, BP, BT> for StateGreen {
fn new(leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> Self {
leds.set_all(PinState::Low, PinState::High, PinState::Low);
> State<RP, RT, GP, GT, OP, OT, BP, BT> for StateGreen {
fn new(leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> Self {
leds.set_all(PinState::Low, PinState::High, PinState::Low, PinState::Low);
Self {
time_passed: 0
}
}
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> States {
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
if self.time_passed + 1 >= 3 {
States::Blue(StateBlue::new(leds))
States::Orange(StateOrange::new(leds))
} else {
States::Green(Self {
time_passed: self.time_passed + 1
})
}
}
fn button_press(&self, _leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::Green(Self {
time_passed: self.time_passed
})
}
fn button_release(&self, _leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::Green(Self {
time_passed: self.time_passed
})
}
}
// ####################################################
// ## BLUE ############################################
// ## ORANGE ############################################
// ####################################################
struct StateBlue {}
struct StateOrange {}
impl<
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> State<RP, RT, GP, GT, BP, BT> for StateBlue {
fn new(leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> Self {
leds.set_all(PinState::Low, PinState::Low, PinState::High);
> State<RP, RT, GP, GT, OP, OT, BP, BT> for StateOrange {
fn new(leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> Self {
leds.set_all(PinState::Low, PinState::Low, PinState::High, PinState::Low);
Self {}
}
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, BP, BT>) -> States {
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::Red(StateRed::new(leds))
}
fn button_press(&self, _leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::Orange(Self {})
}
fn button_release(&self, _leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::Orange(Self {})
}
}
// ####################################################
// ## BRIDGE_OPEN #####################################
// ####################################################
struct StateBridgeOpen {
time_passed: u32
}
impl<
RP: OutputPin, RT: Toggle<RP>,
GP: OutputPin, GT: Toggle<GP>,
OP: OutputPin, OT: Toggle<OP>,
BP: OutputPin, BT: Toggle<BP>
> State<RP, RT, GP, GT, OP, OT, BP, BT> for StateBridgeOpen {
fn new(leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> Self {
leds.set_all(PinState::Low, PinState::Low, PinState::Low, PinState::High);
Self {
time_passed: 0
}
}
fn second_passed(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
if self.time_passed + 1 == 2 {
let _ = leds.blue.low();
States::BridgeOpen(Self {
time_passed: self.time_passed + 1
})
} else if self.time_passed + 1 >= 3 {
let _ = leds.blue.high();
States::BridgeOpen(Self {
time_passed: 0
})
} else {
States::BridgeOpen(Self {
time_passed: self.time_passed + 1
})
}
}
fn button_press(&self, _leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::BridgeOpen(Self {
time_passed: self.time_passed
})
}
fn button_release(&self, leds: &mut Leds<RP, RT, GP, GT, OP, OT, BP, BT>) -> States {
States::Red(StateRed::new(leds))
}
}