Struct CydDisplayEsp 

pub struct CydDisplayEsp<D: SpiDevice<u8> = ExclusiveDevice<Spi<'static, Blocking>, Output<'static>, NoDelay>> { /* private fields */ }

An owned CYD-family ESP32 display component.

D is the underlying embedded-hal SPI device type; it defaults to an exclusively-owned SPI peripheral. Shared-bus backends (see CydEspOneSpi) instantiate this with an embedded_hal_bus::spi::RefCellDevice instead.

Start with the cyd module example. The display-only constructor and static-storage pattern are shown by the CydDisplayEsp::new example.

Implementations

impl CydDisplayEsp<ExclusiveDevice<Spi<'static, Blocking>, Output<'static>, NoDelay>>

pub fn new<const PIXEL_COUNT: usize>( statics: &'static CydStaticEsp<PIXEL_COUNT>, display_spi: impl Instance + 'static, display_sck_pin: impl PeripheralOutput<'static>, display_mosi_pin: impl PeripheralOutput<'static>, display_miso_pin: impl PeripheralInput<'static>, display_cs_pin: impl OutputPin + 'static, display_dc_pin: impl OutputPin + 'static, display_rst_pin: impl OutputPin + 'static, display_backlight_pin: impl OutputPin + 'static, display_spi_hz: u32, orientation: Orientation, background_color: Rgb888, foreground_color: Rgb888, font: &'static MonoFont<'static>, ) -> Result<Self, Error>

Construct a display-only CYD display component that owns its draw buffer.

Choosing the pixel buffer capacity is the most important construction decision: statics determines both static RAM use and the largest buffered region. See CydEsp::new_static for the sizing choices.

use device_envoy_esp::{Result, cyd::{CydDisplay, CydDisplayEsp, CydEsp, DEFAULT_DISPLAY_SPI_HZ, DEFAULT_FONT, Orientation}};
use embedded_graphics::{pixelcolor::Rgb888, prelude::RgbColor};
async fn construct(p: esp_hal::peripherals::Peripherals) -> Result<()> {
    static CYD_STATIC: device_envoy_esp::cyd::CydStaticEsp<0> = CydEsp::new_static();
    let display = CydDisplayEsp::new(&CYD_STATIC, p.SPI2, p.GPIO1, p.GPIO2, p.GPIO3,
        p.GPIO4, p.GPIO5, p.GPIO7, p.GPIO8, DEFAULT_DISPLAY_SPI_HZ,
        Orientation::Landscape, Rgb888::BLACK, Rgb888::WHITE, &DEFAULT_FONT)?;
    assert_eq!(display.screen_size(), Orientation::Landscape.size());
    Ok(())
}

Trait Implementations

impl<D: SpiDevice<u8>> CydDisplay for CydDisplayEsp<D>

fn screen_size(&self) -> Size

Screen size after applying the configured Orientation: 320×240 in landscape or 240×320 in portrait.

fn background_color(&self) -> Rgb888

The device default background color.

fn foreground_color(&self) -> Rgb888

The device default foreground/text color.

fn background_565(&self) -> Rgb565

The device default background color in the native Rgb565 format.

fn foreground_565(&self) -> Rgb565

The device default foreground/text color in the native Rgb565 format.

fn fill_rectangle( &mut self, rectangle: Rectangle, color: Rgb565, ) -> Result<(), Error>

Fill rectangle immediately with color in logical display coordinates.

fn fill_contiguous<I>( &mut self, rectangle: Rectangle, pixels: I, ) -> Result<(), Error>

where I: IntoIterator<Item = Rgb565>,

Fill rectangle immediately from row-major native-color pixels.

fn to_rgb565(&self, color: Rgb888) -> Rgb565

Convert an Rgb888 color to the device’s native Rgb565 format.

fn frame_mut(&mut self, rectangle: Rectangle) -> Self::Frame<'_>

Borrow a frame covering rectangle, cleared to the device background color.

fn full_frame_mut(&mut self) -> Self::Frame<'_>

Borrow a full-screen frame, cleared to the device background color.

fn fill_contiguous_full<I>(&mut self, pixels: I) -> Result<(), Self::Error>

where I: IntoIterator<Item = Rgb565>,

Fill the complete screen immediately from row-major native-color pixels.

fn draw_items<const DRAW_ITEM_CAPACITY: usize>( &mut self, bounds: Rectangle, background_color: Rgb565, items: impl IntoIterator<Item = DrawItem>, ) -> Result<(), Self::Error>

Draw items immediately inside bounds.

fn clear(&mut self) -> Result<(), Self::Error>

Clear the whole screen to the device default background color.

fn fill(&mut self, color: Rgb565) -> Result<(), Self::Error>

Fill the whole screen with an explicit color.

fn for_each_tile<'a, F>( &'a mut self, grid: TileGrid, draw: F, ) -> impl Future<Output = Result<(), Self::Error>> + 'a

where Self: Sized, F: for<'frame> FnMut(&mut Self::Frame<'frame>) + 'a,

Draw and flush each tile in grid.

impl<D: SpiDevice<u8>> Debug for CydDisplayEsp<D>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: SpiDevice<u8>> DisplayBackend for CydDisplayEsp<D>

type Error = Error

Error returned when a frame is flushed.

type Frame<'a> = CydFrameEsp<'a, D> where Self: 'a

Frame type created by this display implementation.

fn create_frame_mut(&mut self, rectangle: Rectangle) -> Self::Frame<'_>

Create a frame covering rectangle in logical display coordinates.