Trait Interface

pub trait Interface {
    type Word: Copy;
    type Error: Debug;

    const KIND: InterfaceKind;

    // Required methods
    fn send_command(
        &mut self,
        command: u8,
        args: &[u8],
    ) -> impl Future<Output = Result<(), Self::Error>>;
    fn send_data_slice(
        &mut self,
        data: &[Self::Word],
    ) -> impl Future<Output = Result<(), Self::Error>>;
}

Command and pixel interface

Required Associated Constants

const KIND: InterfaceKind

Kind

Required Associated Types

type Word: Copy

The native width of the interface

In most cases this will be u8, except for larger parallel interfaces such as 16 bit (currently supported) or 9 or 18 bit (currently unsupported)

type Error: Debug

Error type

Required Methods

fn send_command( &mut self, command: u8, args: &[u8], ) -> impl Future<Output = Result<(), Self::Error>>

Send a command with optional parameters

fn send_data_slice( &mut self, data: &[Self::Word], ) -> impl Future<Output = Result<(), Self::Error>>

Send a raw slice of data, typically pre-formatted pixel data. WriteMemoryStart (or equivalent) must be sent before calling this function. The data is assumed to be in the correct format for the display and interface. If Self::Word is u8, data is &u8. If Self::Word is u16, data is &u16.

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.

Implementations on Foreign Types

impl<T: Interface + ?Sized> Interface for &mut T

const KIND: InterfaceKind = T::KIND

type Word = <T as Interface>::Word

type Error = <T as Interface>::Error

async fn send_command( &mut self, command: u8, args: &[u8], ) -> Result<(), Self::Error>

async fn send_data_slice( &mut self, data: &[Self::Word], ) -> Result<(), Self::Error>

Implementors

impl<BUS, DC, WR> Interface for ParallelInterface<BUS, DC, WR>

where BUS: OutputBus, BUS::Word: From<u8> + Eq + BitXor<Output = BUS::Word>, DC: OutputPin, WR: OutputPin,

const KIND: InterfaceKind = BUS::KIND

type Word = <BUS as OutputBus>::Word

type Error = ParallelError<<BUS as OutputBus>::Error, <DC as ErrorType>::Error, <WR as ErrorType>::Error>

impl<SPI, DC> Interface for SpiInterface<SPI, DC>

where SPI: SpiDevice, DC: OutputPin,

const KIND: InterfaceKind = InterfaceKind::Serial4Line

type Word = u8

type Error = SpiError<<SPI as ErrorType>::Error, <DC as ErrorType>::Error>