Struct Pcf8574 

pub struct Pcf8574 { /* private fields */ }

Represents an LCD display attached via PCF8574 I2C expander. Use the traits in the lcd crate to interact with it.

Implementations

impl Pcf8574

pub fn new(bus: u8, address: u16) -> Result<Self, LinuxI2CError>

Create a new instance, using the Linux I2C interface for communication. bus is the number of /dev/i2c-<bus> to use, and address is the I2C address of the device.

After opening the device, defaults to ignoring all I/O errors; see Self::on_error and ErrorHandling for how to change this behavior.

Examples found in repository

examples/hello_world.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = args().skip(1);
    let bus = args.next()
        .map(|s| u8::from_str_radix(&s, 10))
        .unwrap_or_else(|| usage())
        .unwrap_or_else(|e| {
            eprintln!("invalid bus number: {}", e);
            usage();
        });
    let addr = args.next()
        .map_or_else(|| Ok(0x27), |s| {
            if let Some(hex) = s.strip_prefix("0x") {
                u16::from_str_radix(hex, 16)
            } else {
                u16::from_str_radix(&s, 10)
            }
        })
        .unwrap_or_else(|e| {
            eprintln!("invalid i2c address: {}", e);
            usage();
        });

    let mut dev = Pcf8574::new(bus, addr)?;
    dev.on_error(ErrorHandling::Panic);

    let mut display = lcd::Display::new(dev);
    display.init(lcd::FunctionLine::Line2, lcd::FunctionDots::Dots5x8);
    display.display(
        lcd::DisplayMode::DisplayOn,
        lcd::DisplayCursor::CursorOff,
        lcd::DisplayBlink::BlinkOff);

    display.clear();
    display.home();
    display.print("Hello, World!");
    display.position(2, 1);
    display.print("This is line two");
    display.position(2, 2);
    display.print("... and line three");
    display.position(0, 3);
    display.print("Good bye!");

    Ok(())
}

pub fn on_error(&mut self, on_err: ErrorHandling)

Change the I/O error handling strategy.

lcd::Hardware doesn’t have any way to return errors to the caller, so error handling has to be done here, internally.

Examples found in repository

examples/hello_world.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = args().skip(1);
    let bus = args.next()
        .map(|s| u8::from_str_radix(&s, 10))
        .unwrap_or_else(|| usage())
        .unwrap_or_else(|e| {
            eprintln!("invalid bus number: {}", e);
            usage();
        });
    let addr = args.next()
        .map_or_else(|| Ok(0x27), |s| {
            if let Some(hex) = s.strip_prefix("0x") {
                u16::from_str_radix(hex, 16)
            } else {
                u16::from_str_radix(&s, 10)
            }
        })
        .unwrap_or_else(|e| {
            eprintln!("invalid i2c address: {}", e);
            usage();
        });

    let mut dev = Pcf8574::new(bus, addr)?;
    dev.on_error(ErrorHandling::Panic);

    let mut display = lcd::Display::new(dev);
    display.init(lcd::FunctionLine::Line2, lcd::FunctionDots::Dots5x8);
    display.display(
        lcd::DisplayMode::DisplayOn,
        lcd::DisplayCursor::CursorOff,
        lcd::DisplayBlink::BlinkOff);

    display.clear();
    display.home();
    display.print("Hello, World!");
    display.position(2, 1);
    display.print("This is line two");
    display.position(2, 2);
    display.print("... and line three");
    display.position(0, 3);
    display.print("Good bye!");

    Ok(())
}

pub fn backlight(&mut self, on: bool)

Set the display’s backlight on or off.

Trait Implementations

impl Delay for Pcf8574

fn delay_us(&mut self, delay_usec: u32)

Delay for given amount of time (in microseconds).

impl Hardware for Pcf8574

fn rs(&mut self, bit: bool)

fn enable(&mut self, bit: bool)

fn data(&mut self, bits: u8)

fn apply(&mut self)

Send data to the device.

fn wait_address(&mut self)

Address set up time is 40ns minimum (tAS) This function should be overridden in case processor is too fast for 40ns to pass.

fn mode(&self) -> FunctionMode

Override to pick 8-bit mode (4-bit mode by default)

fn can_read(&self) -> bool

If this implementation can read from the data port. Default is false. If true is returned, both rw and read_data need to be implemented.

fn rw(&mut self, _bit: bool)

Set R/W flag.

fn read_data(&mut self) -> u8

Read data from the data pins of the LCD (D0-D7 in 8-bit mode and D4-D7 in 4-bit mode)