st7565 0.6.0

Driver for ST7565 based displays.
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 display_interface::{DisplayError, WriteOnlyDataCommand};
use embedded_hal::{delay::DelayNs, digital::OutputPin};

use crate::{
    command::{Command, SendSt7565Command},
    types::StaticIndicatorMode,
    DisplaySpecs, Error,
};

use super::ST7565;

/// ---- Common functionality for all modes ----
/// ============================================
impl<DI, SPECS, MODE, const WIDTH: usize, const HEIGHT: usize, const PAGES: usize>
    ST7565<DI, SPECS, MODE, WIDTH, HEIGHT, PAGES>
where
    DI: WriteOnlyDataCommand,
    SPECS: DisplaySpecs<WIDTH, HEIGHT, PAGES>,
{
    /// Set the static indicator
    pub fn set_static_indicator(
        &mut self,
        mode: Option<StaticIndicatorMode>,
    ) -> Result<(), DisplayError> {
        self.interface
            .send_command(Command::StaticIndicatorSet { mode })
    }

    /// Sets the line offset, effectively scrolling the display through memory.
    pub fn set_line_offset(&mut self, offset: u8) -> Result<(), DisplayError> {
        self.interface
            .send_command(Command::DisplayStartLineSet { address: offset })
    }

    /// Sets whether the pixels should be inverted.
    pub fn set_inverted(&mut self, inverted: bool) -> Result<(), DisplayError> {
        self.interface
            .send_command(Command::DisplayNormalReverse { reverse: inverted })
    }

    /// Displays all points of the display
    pub fn display_all_points(&mut self, enable: bool) -> Result<(), DisplayError> {
        self.interface
            .send_command(Command::DisplayAllPoints { on: enable })
    }

    /// Enable/Disable the display output
    pub fn set_display_on(&mut self, on: bool) -> Result<(), DisplayError> {
        self.interface.send_command(Command::DisplayOnOff { on })
    }

    /// Reset the display and restore all settings
    pub fn reset<RST, DELAY, PinE>(
        &mut self,
        rst: &mut RST,
        delay: &mut DELAY,
    ) -> Result<(), Error<PinE>>
    where
        RST: OutputPin<Error = PinE>,
        DELAY: DelayNs,
    {
        // Reset display
        rst.set_low().map_err(Error::Pin)?;
        delay.delay_ms(1);
        rst.set_high().map_err(Error::Pin)?;
        delay.delay_ms(1);

        // Initialize display

        // LCD Bias
        self.interface
            .send_command(Command::LcdBiasSet {
                bias_mode_1: SPECS::BIAS_MODE_1,
            })
            .map_err(Error::Comm)?;

        // ADC Selection
        self.interface
            .send_command(Command::AdcSelect {
                reverse: SPECS::FLIP_COLUMNS,
            })
            .map_err(Error::Comm)?;

        // Common output mode selection
        self.interface
            .send_command(Command::CommonOutputModeSelect {
                reverse: SPECS::FLIP_ROWS,
            })
            .map_err(Error::Comm)?;

        // Display invertion
        self.interface
            .send_command(Command::DisplayNormalReverse {
                reverse: SPECS::INVERTED,
            })
            .map_err(Error::Comm)?;

        // Booster ratio
        self.interface
            .send_command(Command::BoosterRatioSet {
                stepup_value: SPECS::BOOSTER_RATIO,
            })
            .map_err(Error::Comm)?;

        // voltage regulator resistor ratio
        self.interface
            .send_command(Command::VoltageRegulatorInternalResistorSet {
                resistor_ratio: SPECS::VOLTAGE_REGULATOR_RESISTOR_RATIO,
            })
            .map_err(Error::Comm)?;

        // electric volume
        self.interface
            .send_command(Command::ElectronicVolumeSet {
                volume_value: SPECS::ELECTRONIC_VOLUME,
            })
            .map_err(Error::Comm)?;

        // power control
        self.interface
            .send_command(Command::PowerControlSet {
                mode: SPECS::POWER_CONTROL,
            })
            .map_err(Error::Comm)?;

        // some ICs do not reset line offset to 0, so do that here as well
        self.interface
            .send_command(Command::DisplayStartLineSet { address: 0 })
            .map_err(Error::Comm)?;

        Ok(())
    }
}