rp2040-hal 0.8.1

A Rust Embeded-HAL impl for the rp2040 microcontroller
Documentation 
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

use super::dyn_slice::{DynSliceId, DynSliceMode};
use pac::pwm::CH;

/// # Safety
///
/// Users should only implement the [`id`] function. No default function
/// implementations should be overridden. The implementing type must also have
/// "control" over the corresponding slice ID, i.e. it must guarantee that each
/// slice ID is a singleton
pub(super) unsafe trait RegisterInterface {
    /// Provide a [`DynSliceId`] identifying the set of registers controlled by
    /// this type.
    fn id(&self) -> DynSliceId;

    #[inline]
    fn ch(&self) -> &CH {
        let num = self.id().num as usize;
        unsafe { &(*pac::PWM::ptr()).ch[num] }
    }

    #[inline]
    fn advance_phase(&mut self) {
        self.ch().csr.modify(|_, w| w.ph_adv().set_bit())
    }

    #[inline]
    fn retard_phase(&mut self) {
        self.ch().csr.modify(|_, w| w.ph_ret().set_bit())
    }

    #[inline]
    fn do_change_mode(&mut self, mode: DynSliceMode) {
        self.ch().csr.modify(|_, w| match mode {
            DynSliceMode::FreeRunning => w.divmode().div(),
            DynSliceMode::InputHighRunning => w.divmode().level(),
            DynSliceMode::CountRisingEdge => w.divmode().rise(),
            DynSliceMode::CountFallingEdge => w.divmode().fall(),
        })
    }

    #[inline]
    fn write_inv_a(&mut self, value: bool) {
        self.ch().csr.modify(|_, w| w.a_inv().bit(value));
    }

    #[inline]
    fn write_inv_b(&mut self, value: bool) {
        self.ch().csr.modify(|_, w| w.b_inv().bit(value));
    }

    #[inline]
    fn write_ph_correct(&mut self, value: bool) {
        self.ch().csr.modify(|_, w| w.ph_correct().bit(value));
    }

    #[inline]
    fn write_enable(&mut self, value: bool) {
        self.ch().csr.modify(|_, w| w.en().bit(value));
    }

    #[inline]
    fn write_div_int(&mut self, value: u8) {
        self.ch().div.modify(|_, w| unsafe { w.int().bits(value) });
    }
    #[inline]
    fn write_div_frac(&mut self, value: u8) {
        self.ch().div.modify(|_, w| unsafe { w.frac().bits(value) });
    }

    #[inline]
    fn write_ctr(&mut self, value: u16) {
        self.ch().ctr.write(|w| unsafe { w.ctr().bits(value) });
    }

    #[inline]
    fn read_ctr(&self) -> u16 {
        self.ch().ctr.read().ctr().bits()
    }
    #[inline]
    fn write_cc_a(&mut self, value: u16) {
        self.ch().cc.modify(|_, w| unsafe { w.a().bits(value) });
    }
    #[inline]
    fn read_cc_a(&self) -> u16 {
        self.ch().cc.read().a().bits()
    }

    #[inline]
    fn write_cc_b(&mut self, value: u16) {
        self.ch().cc.modify(|_, w| unsafe { w.b().bits(value) });
    }

    #[inline]
    fn read_cc_b(&self) -> u16 {
        self.ch().cc.read().b().bits()
    }
    #[inline]
    fn write_top(&mut self, value: u16) {
        self.ch().top.write(|w| unsafe { w.top().bits(value) });
    }
    #[inline]
    fn read_top(&self) -> u16 {
        self.ch().top.read().top().bits()
    }
}