atsamd_hal/
delay.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
//! Delays

use atsamd_hal_macros::hal_cfg;
use cortex_m::peripheral::syst::SystClkSource;
use cortex_m::peripheral::SYST;

use crate::clock::GenericClockController;
use crate::ehal::delay::DelayNs;
use crate::ehal_02;
use crate::time::Hertz;

#[hal_cfg("rtc-d5x")]
use crate::typelevel::Increment;

#[hal_cfg("rtc-d5x")]
use crate::clock::v2::{gclk::Gclk0Id, Source};

/// System timer (SysTick) as a delay provider
pub struct Delay {
    sysclock: Hertz,
    syst: SYST,
}

impl Delay {
    /// Configures the system timer (SysTick) as a delay provider
    pub fn new(mut syst: SYST, clocks: &mut GenericClockController) -> Self {
        syst.set_clock_source(SystClkSource::Core);

        Delay {
            syst,
            sysclock: clocks.gclk0().into(),
        }
    }

    #[hal_cfg("rtc-d5x")]
    /// Configures the system timer (SysTick) as a delay provide, compatible
    /// with the V2 clocking API
    pub fn new_with_source<S>(mut syst: SYST, gclk0: S) -> (Self, S::Inc)
    where
        S: Source<Id = Gclk0Id> + Increment,
    {
        syst.set_clock_source(SystClkSource::Core);
        (
            Delay {
                syst,
                sysclock: gclk0.freq(),
            },
            gclk0.inc(),
        )
    }

    /// Releases the system timer (SysTick) resource
    pub fn free(self) -> SYST {
        self.syst
    }
}

impl DelayNs for Delay {
    // The default method is delay_ns. If we don't provide implementations for
    // delay_us and delay_ms, the trait impl will use delay_ns to implement the
    // other two methods. As the delay implementation is actually defined in terms
    // of microseconds, we need to provide implementations for all three methods.
    fn delay_ns(&mut self, ns: u32) {
        self.delay_us(ns / 1000);
    }

    fn delay_us(&mut self, us: u32) {
        // The SysTick Reload Value register supports values between 1 and 0x00FFFFFF.
        const MAX_RVR: u32 = 0x00FF_FFFF;

        let mut total_rvr = us * (self.sysclock.to_Hz() / 1_000_000);

        while total_rvr != 0 {
            let current_rvr = if total_rvr <= MAX_RVR {
                total_rvr
            } else {
                MAX_RVR
            };

            self.syst.set_reload(current_rvr);
            self.syst.clear_current();
            self.syst.enable_counter();

            // Update the tracking variable while we are waiting...
            total_rvr -= current_rvr;

            while !self.syst.has_wrapped() {}

            self.syst.disable_counter();
        }
    }

    fn delay_ms(&mut self, ms: u32) {
        self.delay_us(ms * 1000);
    }
}

impl ehal_02::blocking::delay::DelayMs<u32> for Delay {
    fn delay_ms(&mut self, ms: u32) {
        <Self as DelayNs>::delay_us(self, ms * 1_000);
    }
}

impl ehal_02::blocking::delay::DelayMs<u16> for Delay {
    fn delay_ms(&mut self, ms: u16) {
        <Self as ehal_02::blocking::delay::DelayMs<u32>>::delay_ms(self, ms as u32);
    }
}

impl ehal_02::blocking::delay::DelayMs<u8> for Delay {
    fn delay_ms(&mut self, ms: u8) {
        <Self as ehal_02::blocking::delay::DelayMs<u32>>::delay_ms(self, ms as u32);
    }
}

impl ehal_02::blocking::delay::DelayUs<u32> for Delay {
    fn delay_us(&mut self, us: u32) {
        <Self as DelayNs>::delay_us(self, us);
    }
}

impl ehal_02::blocking::delay::DelayUs<u16> for Delay {
    fn delay_us(&mut self, us: u16) {
        <Self as ehal_02::blocking::delay::DelayUs<u32>>::delay_us(self, us as u32);
    }
}

impl ehal_02::blocking::delay::DelayUs<u8> for Delay {
    fn delay_us(&mut self, us: u8) {
        <Self as ehal_02::blocking::delay::DelayUs<u32>>::delay_us(self, us as u32);
    }
}