Trait Epd

pub trait Epd<HW>
where
    HW: EpdHw,
{
    type RefreshMode;
    type Command;
    type Buffer;

    // Required methods
    fn new_buffer(&self) -> Self::Buffer;
    fn width(&self) -> u32;
    fn height(&self) -> u32;
    async fn init(
        &mut self,
        spi: &mut HW::Spi,
        mode: RefreshMode,
    ) -> Result<(), HW::Error>;
    async fn set_refresh_mode(
        &mut self,
        spi: &mut HW::Spi,
        mode: Self::RefreshMode,
    ) -> Result<(), HW::Error>;
    async fn reset(&mut self) -> Result<(), HW::Error>;
    async fn sleep(&mut self, spi: &mut HW::Spi) -> Result<(), HW::Error>;
    async fn wake(&mut self, spi: &mut HW::Spi) -> Result<(), HW::Error>;
    async fn display_buffer(
        &mut self,
        spi: &mut HW::Spi,
        buffer: &Self::Buffer,
    ) -> Result<(), HW::Error>;
    async fn set_window(
        &mut self,
        spi: &mut HW::Spi,
        shape: Rectangle,
    ) -> Result<(), HW::Error>;
    async fn set_cursor(
        &mut self,
        spi: &mut HW::Spi,
        position: Point,
    ) -> Result<(), <HW as EpdHw>::Error>;
    async fn write_image(
        &mut self,
        spi: &mut HW::Spi,
        image: &[u8],
    ) -> Result<(), HW::Error>;
    async fn update_display(
        &mut self,
        spi: &mut HW::Spi,
    ) -> Result<(), HW::Error>;
    async fn send(
        &mut self,
        spi: &mut HW::Spi,
        command: Self::Command,
        data: &[u8],
    ) -> Result<(), HW::Error>;
    async fn wait_if_busy(&mut self) -> Result<(), HW::Error>;
}

Required Associated Types

type RefreshMode

type Command

type Buffer

Required Methods

fn new_buffer(&self) -> Self::Buffer

Creates a buffer for use with this display.

fn width(&self) -> u32

fn height(&self) -> u32

async fn init( &mut self, spi: &mut HW::Spi, mode: RefreshMode, ) -> Result<(), HW::Error>

Initialise the display. This must be called before any other operations.

async fn set_refresh_mode( &mut self, spi: &mut HW::Spi, mode: Self::RefreshMode, ) -> Result<(), HW::Error>

Sets the refresh mode for the display.

async fn reset(&mut self) -> Result<(), HW::Error>

Hardware reset the display. The display must be reinitialised after calling this.

async fn sleep(&mut self, spi: &mut HW::Spi) -> Result<(), HW::Error>

Puts the display to sleep.

async fn wake(&mut self, spi: &mut HW::Spi) -> Result<(), HW::Error>

Wakes and re-initialises the display if it’s asleep.

async fn display_buffer( &mut self, spi: &mut HW::Spi, buffer: &Self::Buffer, ) -> Result<(), HW::Error>

Writes the buffers data to the display and displays it.

async fn set_window( &mut self, spi: &mut HW::Spi, shape: Rectangle, ) -> Result<(), HW::Error>

Sets the window to write to during a call to [write_image]. This can enable partial writes to a subsection of the display.

async fn set_cursor( &mut self, spi: &mut HW::Spi, position: Point, ) -> Result<(), <HW as EpdHw>::Error>

Sets the cursor position for where the next byte of image data will be written.

async fn write_image( &mut self, spi: &mut HW::Spi, image: &[u8], ) -> Result<(), HW::Error>

Writes raw image data, starting at the current cursor position and auto-incrementing x then y within the current window.

async fn update_display(&mut self, spi: &mut HW::Spi) -> Result<(), HW::Error>

Updates (refreshes) the display based on the RAM. Note that this can be stateful. For example, on the Epd2in9 display, there are two RAM buffers. Calling this function swaps the active buffer. Consider this scenario:

1. [write_image] is used to turn the RAM all white.
2. [update_display] is called, which refreshes the display to be all white.
3. [write_image] is used to turn the RAM all black.
4. [update_display] is called, which refreshes the display to be all black.
5. [update_display] is called again, which refreshes the display to be all white again.

async fn send( &mut self, spi: &mut HW::Spi, command: Self::Command, data: &[u8], ) -> Result<(), HW::Error>

Send the following command and data to the display. Waits until the display is no longer busy before sending.

async fn wait_if_busy(&mut self) -> Result<(), HW::Error>

Waits for the current operation to complete if the display is busy. Note that this will wait forever if the display is asleep.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<HW> Epd<HW> for Epd2in9<HW>

where HW: EpdHw,

type Command = Command

type RefreshMode = RefreshMode

type Buffer = BinaryBuffer<{ binary_buffer_length(Size::new(DISPLAY_WIDTH as u32, DISPLAY_HEIGHT as u32)) }>