ch58x-hal 0.0.2

HAL for the CH583/CH582/CH581 RISC-V BLE microcotrollers from WCH
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

//! Segment LCD controller

use pac::LCD;

use crate::pac;

pub struct Config {
    pub voltage: bool,
    pub scan_clk: u8,
    pub duty: u8,
    pub bias: bool,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            voltage: false,
            scan_clk: 0b11,
            duty: 0b10,
            bias: true,
        }
    }
}

impl Config {
    pub fn voltage3v3(mut self) -> Self {
        self.voltage = false;
        self
    }
    pub fn voltage2v7(mut self) -> Self {
        self.voltage = true;
        self
    }
    pub fn duty1_4(mut self) -> Self {
        self.duty = 0b10;
        self
    }
}

pub struct Lcd {
    //lcd: LCD,
}

impl Lcd {
    pub fn new(_lcd: LCD, config: Config) -> Self {
        let lcd = unsafe { &*pac::LCD::PTR };
        let sys = unsafe { &*pac::SYS::PTR };

        // disable digital input
        unsafe {
            sys.pin_config2.modify(|_, w| w.bits(0xfffeff3f));
        }

        // default on
        sys.slp_clk_off1.modify(|_, w| w.slp_clk_lcd().clear_bit());

        // lcd config
        lcd.cmd().write(|w| unsafe {
            w.seg_en()
                .bits(0x1ffff)
                .vlcd_sel()
                .bit(config.voltage) // 2.5V
                .scan_clk_sel()
                .bits(config.scan_clk)
                .duty()
                .bits(config.duty) // 1/4
                .bias()
                .bit(config.bias)
                .on()
                .set_bit()
                .sys_en()
                .set_bit()
        });
        lcd.ram0.reset();
        lcd.ram1.reset();
        lcd.ram2.reset();

        Self {}
    }

    // n: 0 to 10
    pub fn write_data(&self, n: u8, data: u8) {
        if n < 4 {
            let lcd = unsafe { &*pac::LCD::PTR };
            let data = (data as u32) << (n * 8);
            lcd.ram0
                .modify(|r, w| unsafe { w.bits((r.bits() & !(0xff << (n * 8))) | data) });
        } else if n < 8 {
            let lcd = unsafe { &*pac::LCD::PTR };
            let data = (data as u32) << ((n - 4) * 8);
            lcd.ram1
                .modify(|r, w| unsafe { w.bits((r.bits() & !(0xff << ((n - 4) * 8))) | data) });
            return;
        } else if n < 12 {
            let lcd = unsafe { &*pac::LCD::PTR };
            let data = (data as u32) << ((n - 8) * 8);
            lcd.ram2
                .modify(|r, w| unsafe { w.bits((r.bits() & !(0xff << ((n - 8) * 8))) | data) });
            return;
        }
    }

    pub fn write_ram0(&self, data: u32) {
        let lcd = unsafe { &*pac::LCD::PTR };
        lcd.ram0.write(|w| unsafe { w.bits(data) });
    }

    pub fn write_ram1(&self, data: u32) {
        let lcd = unsafe { &*pac::LCD::PTR };
        lcd.ram1.write(|w| unsafe { w.bits(data) });
    }

    pub fn write_ram2(&self, data: u32) {
        let lcd = unsafe { &*pac::LCD::PTR };
        lcd.ram2.write(|w| unsafe { w.bits(data & 0xffff) });
    }
}