il0373 0.2.0

Driver for the IL0373 e-Paper display (EPD) controller, for use with embedded-graphics
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

use crate::command::{Command, DataInterval, DataPolarity};
use crate::config::Config;
use crate::interface::DisplayInterface;
use hal;

// Max display resolution is 160x296
/// The maximum number of rows supported by the controller
pub const MAX_GATE_OUTPUTS: u16 = 296;
/// The maximum number of cols supported by the controller
pub const MAX_SOURCE_OUTPUTS: u8 = 160;

/// Represents the dimensions of the display.
pub struct Dimensions {
    /// The number of rows the display has.
    ///
    /// Must be less than or equal to MAX_GATE_OUTPUTS.
    pub rows: u16,
    /// The number of columns the display has.
    ///
    /// Must be less than or equal to MAX_SOURCE_OUTPUTS.
    pub cols: u8,
}

/// Represents the physical rotation of the display relative to the native orientation.
///
/// For example the native orientation of the Inky pHAT display is a tall (portrait) 104x212
/// display. `Rotate270` can be used to make it the right way up when attached to a Raspberry Pi
/// Zero with the ports on the top.
#[derive(Clone, Copy)]
pub enum Rotation {
    Rotate0,
    Rotate90,
    Rotate180,
    Rotate270,
}

impl Default for Rotation {
    /// Default is no rotation (`Rotate0`).
    fn default() -> Self {
        Rotation::Rotate0
    }
}

/// A configured display with a hardware interface.
pub struct Display<I>
where
    I: DisplayInterface,
{
    interface: I,
    config: Config,
}

impl<I> Display<I>
where
    I: DisplayInterface,
{
    /// Create a new display instance from a DisplayInterface and Config.
    ///
    /// The `Config` is typically created with `config::Builder`.
    pub fn new(interface: I, config: Config) -> Self {
        Self { interface, config }
    }

    /// Perform a hardware reset
    ///
    /// This will wake a controller that has previously entered deep sleep.
    pub fn reset<D: hal::delay::DelayNs>(&mut self, delay: &mut D) -> Result<(), I::Error> {
        self.interface.reset(delay);
        self.init(delay)
    }

    /// Initialize the controller
    fn init<D: hal::delay::DelayNs>(&mut self, delay: &mut D) -> Result<(), I::Error> {
        self.config.power_setting.execute(&mut self.interface)?;
        self.config
            .booster_soft_start
            .execute(&mut self.interface)?;
        Command::PowerOn.execute(&mut self.interface)?;
        delay.delay_ms(200);
        self.config.panel_setting.execute(&mut self.interface)?;
        Command::VCOMDataIntervalSetting(0x0, DataPolarity::Both, DataInterval::V10)
            .execute(&mut self.interface)?;
        self.config.pll.execute(&mut self.interface)?;
        Command::VCMDCSetting(0xA).execute(&mut self.interface)?;
        delay.delay_ms(20);
        Command::ResolutionSetting(self.config.dimensions.cols, self.config.dimensions.rows)
            .execute(&mut self.interface)?;
        Ok(())
    }

    /// Tell the hardware to update the display
    pub fn signal_update(&mut self) -> Result<(), I::Error> {
        // Kick off the display update
        Command::DisplayRefresh.execute(&mut self.interface)
    }

    fn power_down(&mut self) -> Result<(), I::Error> {
        self.interface.busy_wait();
        Command::VCOMDataIntervalSetting(0x0, DataPolarity::BWOnly, DataInterval::V10)
            .execute(&mut self.interface)?;
        Command::VCMDCSetting(0).execute(&mut self.interface)?;
        Command::PowerOff.execute(&mut self.interface)
    }

    /// Enter deep sleep mode.
    ///
    /// This puts the display controller into a low power mode. `reset` must be called to wake it
    /// from sleep.
    pub fn deep_sleep(&mut self) -> Result<(), I::Error> {
        self.power_down()?;
        Command::DeepSleep.execute(&mut self.interface)
    }

    /// Returns the number of rows the display has.
    pub fn rows(&self) -> u16 {
        self.config.dimensions.rows
    }

    /// Returns the number of columns the display has.
    pub fn cols(&self) -> u8 {
        self.config.dimensions.cols
    }

    /// Returns the rotation the display was configured with.
    pub fn rotation(&self) -> Rotation {
        self.config.rotation
    }

    /// returns the interface
    pub fn interface(&mut self) -> &mut I {
        &mut self.interface
    }
}