uferris-bsp 0.2.0

A Board Support Package for the uFerris Learner Board
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
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
133
134
135
136
137
138

use core::marker::PhantomData;

use embedded_hal::i2c::I2c;
#[cfg(feature = "async")]
use embedded_hal_async::i2c::I2c as AsyncI2c;

#[cfg(feature = "async")]
use crate::Async;
use crate::{Blocking, Mode};

const RTC_ADDR: u8 = 0x68;

/// The board's real time clock.
///
/// `M` selects the board mode: see [`Mode`]. Both modes expose the same two
/// methods, they just differ in whether the I2C traffic is awaited.
pub struct Rtc<I2C, M = Blocking> {
    i2c: I2C,
    _mode: PhantomData<M>,
}

impl<I2C, M: Mode> Rtc<I2C, M> {
    pub fn new(i2c: I2C) -> Self {
        Self {
            i2c,
            _mode: PhantomData,
        }
    }
}

impl<I2C: I2c> Rtc<I2C, Blocking> {
    /// Set the RTC time
    pub fn set_time(
        &mut self,
        year: u16,
        month: u8,
        day: u8,
        hour: u8,
        min: u8,
        sec: u8,
    ) -> Result<(), I2C::Error> {
        let year_u8 = (year - 2000) as u8;
        let sec_bcd = to_bcd(sec);
        let min_bcd = to_bcd(min);
        let hour_bcd = to_bcd(hour);
        let day_bcd = to_bcd(day);
        let weekday_bcd = to_bcd(5);
        let month_bcd = to_bcd(month);
        let year_bcd = to_bcd(year_u8);
        self.i2c.write(
            RTC_ADDR,
            &[
                0x00,
                sec_bcd,
                min_bcd,
                hour_bcd,
                weekday_bcd,
                day_bcd,
                month_bcd,
                year_bcd,
            ],
        )
    }

    /// Read the RTC time
    pub fn read_time(&mut self) -> Result<(u16, u8, u8, u8, u8, u8), I2C::Error> {
        // read time from RTC
        let mut buf = [0u8; 7];
        self.i2c.write_read(RTC_ADDR, &[0x00], &mut buf)?;
        let sec = from_bcd(buf[0] & 0x7F);
        let min = from_bcd(buf[1] & 0x7F);
        let hour = from_bcd(buf[2] & 0x3F);
        let day = from_bcd(buf[4] & 0x3F);
        let month = from_bcd(buf[5] & 0x1F);
        let year = from_bcd(buf[6]) as u16 + 2000;
        Ok((year, month, day, hour, min, sec))
    }
}

#[cfg(feature = "async")]
impl<I2C: AsyncI2c> Rtc<I2C, Async> {
    /// Set the RTC time
    pub async fn set_time(
        &mut self,
        year: u16,
        month: u8,
        day: u8,
        hour: u8,
        min: u8,
        sec: u8,
    ) -> Result<(), I2C::Error> {
        let year_u8 = (year - 2000) as u8;
        let sec_bcd = to_bcd(sec);
        let min_bcd = to_bcd(min);
        let hour_bcd = to_bcd(hour);
        let day_bcd = to_bcd(day);
        let weekday_bcd = to_bcd(5);
        let month_bcd = to_bcd(month);
        let year_bcd = to_bcd(year_u8);
        self.i2c
            .write(
                RTC_ADDR,
                &[
                    0x00,
                    sec_bcd,
                    min_bcd,
                    hour_bcd,
                    weekday_bcd,
                    day_bcd,
                    month_bcd,
                    year_bcd,
                ],
            )
            .await
    }

    /// Read the RTC time
    pub async fn read_time(&mut self) -> Result<(u16, u8, u8, u8, u8, u8), I2C::Error> {
        // read time from RTC
        let mut buf = [0u8; 7];
        self.i2c.write_read(RTC_ADDR, &[0x00], &mut buf).await?;
        let sec = from_bcd(buf[0] & 0x7F);
        let min = from_bcd(buf[1] & 0x7F);
        let hour = from_bcd(buf[2] & 0x3F);
        let day = from_bcd(buf[4] & 0x3F);
        let month = from_bcd(buf[5] & 0x1F);
        let year = from_bcd(buf[6]) as u16 + 2000;
        Ok((year, month, day, hour, min, sec))
    }
}

// Simple BCD helpers
fn to_bcd(val: u8) -> u8 {
    ((val / 10) << 4) | (val % 10)
}
fn from_bcd(val: u8) -> u8 {
    10 * (val >> 4) + (val & 0x0F)
}