ssd1315_driver/

command.rs

use crate::config::PumpLevel;
use display_interface::{DataFormat::U8, DisplayError, WriteOnlyDataCommand};

#[cfg(feature = "async")]
use display_interface::AsyncWriteOnlyDataCommand;

/// Commands that are used to initialize OLED screen.
#[maybe_async_cfg::maybe(
    sync(keep_self),
    async(
        feature = "async",
        idents(WriteOnlyDataCommand(async = "AsyncWriteOnlyDataCommand"),)
    )
)]
pub enum Command {
    /* Scrolling Command Table */
    HScrollSetup(HScrollDir, Page, Page, NFrames), // 0x26: Horizontal Scroll Setup
    VHScrollSetup(VHScrollDir, Page, Page, NFrames, u8), // 0x29: Vertical and Horizontal Scroll Setup
    ContentScroll(CScrollDir, Page, Page),               // 0x2C/2D: Content to be scrolled
    EnableScroll(bool),                                  // 0x2E/2F: Deactivate/Activate Scroll
    VScrollArea(u8, u8),                                 // 0xA3: Set Vertical Scroll Area

    /* Fundamental Command Table */
    LowerColStart(u8), // 0x00-0x0F: Set Lower Column Start Address for Page Addressing Mode
    UpperColStart(u8), // 0x10-0x1F: Set Higher Column Start Address for Page Addressing Mode
    AddressMode(AddrMode), // 0x20: Set Memory Addressing Mode
    ColumnAddress(u8, u8), // 0x21: Set Column Address (start, end)
    PageAddress(Page, Page), // 0x22: Set Page Address (start, end)
    StartLine(u8),     // 0x40-0x7F: Set Display Start Line
    Contrast(u8),      // 0x81: Set Contrast Control
    ChargePump(PumpLevel), // 0x8D: Set Charge Pump
    AllOn(bool),       // 0xA4/A5: Entire Display ON (A4=resume, A5=all on)
    Invert(bool),      // 0xA6/A7: Set Normal/Inverse Display (A6=normal, A7=inverse)
    Multiplex(u8),     // 0xA8: Set Multiplex Ratio
    InternalIref(bool, bool), // 0xAD: Internal IREF Setting
    DisplayOn(bool),   // 0xAE/AF: Set Display ON/OFF (AE=off, AF=on)
    SegmentRemap(bool), // 0xA0/A1: Set Segment Remap (A0=normal, A1=reverse)
    PageStart(Page),   // 0xB0-0xB7: Set Page Start Address for Page Addressing Mode
    ReverseComDir(bool), // 0xC0/C8: Set COM Output Scan Direction (C0=normal, C8=remapped)
    DisplayOffset(u8), // 0xD3: Set Display Offset
    DisplayClockDiv(u8, u8), // 0xD5: Set Display Clock Divide Ratio/Oscillator Frequency
    PreChargePeriod(u8, u8), // 0xD9: Set Pre-charge Period
    ComPinConfig(bool, bool), // 0xDA: Set COM Pins Hardware Configuration (A4, A5)
    VcomhDeselect(u8), // 0xDB: Set VCOMH Deselect Level
    Noop,              // 0xE3: No operation
}

#[maybe_async_cfg::maybe(
    sync(keep_self),
    async(
        feature = "async",
        idents(WriteOnlyDataCommand(async = "AsyncWriteOnlyDataCommand"),)
    )
)]
impl Command {
    pub async fn send<DI: WriteOnlyDataCommand>(self, iface: &mut DI) -> Result<(), DisplayError> {
        let commands: &[u8] = match self {
            Command::HScrollSetup(dir, start, end, nframes) => &[
                0x26 | (dir as u8),
                0,
                start as u8,
                nframes as u8,
                end as u8,
                0,
                0x7F,
            ],
            Command::VHScrollSetup(dir, start, end, nframes, offset) => &[
                0x28 | (dir as u8),
                0,
                start as u8,
                nframes as u8,
                end as u8,
                offset,
                0,
                0x7F,
            ],
            Command::ContentScroll(dir, start, end) => {
                &[0x2C | (dir as u8), 0, start as u8, 1, end as u8, 0, 0x7F]
            }
            Command::EnableScroll(en) => &[0x2E | (en as u8)],
            Command::VScrollArea(above, lines) => &[0xA3, above, lines],
            Command::LowerColStart(addr) => &[0x0F & addr],
            Command::UpperColStart(addr) => &[0x10 | (0x07 & addr)],
            Command::StartLine(line) => &[0x40 | (0x3F & line)],
            Command::AddressMode(mode) => &[0x20, mode as u8],
            Command::ColumnAddress(start, end) => &[0x21, start, end],
            Command::PageAddress(start, end) => &[0x22, start as u8, end as u8],
            Command::PageStart(page) => &[0xB0 | (page as u8)],
            Command::Contrast(val) => &[0x81, val],
            Command::AllOn(on) => &[0xA4 | (on as u8)],
            Command::Invert(inv) => &[0xA6 | (inv as u8)],
            Command::DisplayOn(on) => &[0xAE | (on as u8)],
            Command::SegmentRemap(remap) => &[0xA0 | (remap as u8)],
            Command::DisplayOffset(offset) => &[0xD3, offset],
            Command::Multiplex(ratio) => &[0xA8, ratio],
            Command::ReverseComDir(rev) => &[0xC0 | ((rev as u8) << 3)],
            Command::ComPinConfig(alt, lr) => &[0xDA, 0x2 | ((alt as u8) << 4) | ((lr as u8) << 5)],
            Command::DisplayClockDiv(fosc, div) => &[0xD5, ((0xF & fosc) << 4) | (0xF & div)],
            Command::PreChargePeriod(phase1, phase2) => {
                &[0xD9, ((0xF & phase2) << 4) | (0xF & phase1)]
            }
            Command::VcomhDeselect(level) => &[0xDB, level as u8],
            Command::ChargePump(level) => &[0x8D, level as u8],
            Command::InternalIref(en, current) => {
                &[0xAD, ((current as u8) << 5) | ((en as u8) << 4)]
            }
            Command::Noop => &[0xE3],
        };

        iface.send_commands(U8(commands)).await
    }
}

/// Horizontal Scroll Direction
pub enum HScrollDir {
    /// Left to right
    LeftToRight = 0,
    /// Right to left
    RightToLeft = 1,
}

/// Content Scroll Direction
pub enum CScrollDir {
    /// Left to right
    LeftToRight = 0,
    /// Right to left
    RightToLeft = 1,
}

/// Vertical and horizontal scroll dir
pub enum VHScrollDir {
    /// Vertical and right horizontal
    VerticalRight = 0b01,
    /// Vertical and left horizontal
    VerticalLeft = 0b10,
}

/// Display page
#[derive(Debug, Clone, Copy)]
pub enum Page {
    Page0 = 0b000,
    Page1 = 0b001,
    Page2 = 0b010,
    Page3 = 0b011,
    Page4 = 0b100,
    Page5 = 0b101,
    Page6 = 0b110,
    Page7 = 0b111,
}

/// Frow the row to Page
/// 0..7  => Page0
/// 8..15 => Page1
/// ...
impl From<u8> for Page {
    fn from(val: u8) -> Page {
        match val / 8 {
            0 => Page::Page0,
            1 => Page::Page1,
            2 => Page::Page2,
            3 => Page::Page3,
            4 => Page::Page4,
            5 => Page::Page5,
            6 => Page::Page6,
            7 => Page::Page7,
            _ => panic!("Page too high"),
        }
    }
}

/// Frame interval
pub enum NFrames {
    /// 2 Frames
    F2 = 0b111,
    /// 3 Frames
    F3 = 0b100,
    /// 4 Frames
    F4 = 0b101,
    /// 5 Frames
    F5 = 0b110,
    /// 6 Frames
    F6 = 0b000,
    /// 32 Frames
    F32 = 0b001,
    /// 64 Frames
    F64 = 0b010,
    /// 128 Frames
    F128 = 0b011,
}

/// Addressing modes
pub enum AddrMode {
    Horizontal = 0b00, // Horizontal mode
    Vertical = 0b01,   // Vertical mode
    Page = 0b10,       // Page mode (default)
}