Struct hd44780_ntb::GpioDriver

pub struct GpioDriver<RS, EN, DP, D> where
    RS: OutputPin,
    EN: OutputPin,
    DP: OutputPin,
    D: DelayUs<u16>,  { /* fields omitted */ }

This is the driver used for direct GPIO pin connected HD44780 displays.

The HD44780 display normally has a 16 inline connector. The only pins of concern in this driver are the RS, E, and the data bus pins D0 through D7. When the display is going to be used with a 4 bit (pin) data bus make sure the data output pins are connected to D4 through D7 and NOT to the lower data pins D0 through D4.

Remarks

This driver assumes that the RW input on the display is pulled to GND forcing the display into Write mode at all times.

The driver can be switched between 4 and 8 bit (pin) interface by just changing the number of pins given in data parameter to the new() function when creating a new instance.

Implementations

impl<RS, EN, DP, D> GpioDriver<RS, EN, DP, D> where
    RS: OutputPin,
    EN: OutputPin,
    DP: OutputPin,
    D: DelayUs<u16>, 

pub fn new(rs: RS, e: EN, data: Vec<DP>, delay: D) -> GpioDriver<RS, EN, DP, D>

Create a new instance of driver.

The HD44780 display normally has a 16 inline connector.

Arguments

• rs - An already setup output GPIO pin that is connected to the register select input on display.
• e - An already setup output GPIO pin that is connected to the enable input on display.
• data - An already setup array or Vec of GPIO output pins that are connected to the data inputs of the display. Only 4 or 8 pins should be used.

Examples

For examples of using the driver in both 4 and 8 bit modes have look at the Raspberry Pi 4 bit and Raspberry Pi 8 bit examples.

Trait Implementations

impl<RS: Debug, EN: Debug, DP: Debug, D: Debug> Debug for GpioDriver<RS, EN, DP, D> where
    RS: OutputPin,
    EN: OutputPin,
    DP: OutputPin,
    D: DelayUs<u16>, 

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

Formats the value using the given formatter.

impl<RS, EN, DP, D> HD44780 for GpioDriver<RS, EN, DP, D> where
    RS: OutputPin,
    EN: OutputPin,
    DP: OutputPin,
    D: DelayUs<u16>, 

const COMMAND_DELAY: u16

Delay time constant used to ensure HD44780 can finish processing command.

fn command(&mut self, byte: u8, delay: u16) -> Result

Provides an interface to send commands through the HD44780 driver.

fn init<FSM, DCM, EMSM>(
    &mut self,
    fs_mode: FSM,
    dc_mode: DCM,
    ems_mode: EMSM
) -> Result where
    FSM: Into<Option<FunctionMode>>,
    DCM: Into<Option<DisplayMode>>,
    EMSM: Into<Option<EntryMode>>, 

Used to initialize the display into a know state.

fn clear_display(&mut self) -> Result

Clear the display.

fn cursor_shift(&mut self, mode: ShiftMode) -> Result

Used to shift the display or the cursor to the left or right.

fn display_control(&mut self, mode: DisplayMode) -> Result

Set display on/off controls.

fn entry_mode_set(&mut self, mode: EntryMode) -> Result

Sets data cursor direction and display shifting.

fn function_set(&mut self, mode: FunctionMode) -> Result

Used to initialize the interface size (4, 8 bit), display line count, and font.

fn return_home(&mut self) -> Result

Reset the cursor to home position.

fn set_cg_ram_addr(&mut self, address: u8) -> Result

Set CG RAM(Custom Char) address.

fn set_dd_ram_addr(&mut self, address: u8) -> Result

Set DD RAM(Display) address.

const CLEAR_DISPLAY: u8

const CURSOR_SHIFT: u8

const DISPLAY_CONTROL: u8

const ENTRY_MODE_SET: u8

const FUNCTION_SET: u8

const RETURN_HOME: u8

const SET_CG_RAM_ADDR: u8

const SET_DD_RAM_ADDR: u8

impl<RS, EN, DP, D> Write for GpioDriver<RS, EN, DP, D> where
    RS: OutputPin,
    EN: OutputPin,
    DP: OutputPin,
    D: DelayUs<u16>, 

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writeer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.