Struct Buttons 

pub struct Buttons<I2C> {
    pub led_a: ButtonLed,
    pub led_b: ButtonLed,
    pub led_c: ButtonLed,
    /* private fields */
}

Driver for the Modulino Buttons module.

Example

use modulino::Buttons;

let mut buttons = Buttons::new(i2c)?;

// Read button states
let state = buttons.read()?;
if state.a {
    println!("Button A pressed!");
}

// Control LEDs
buttons.led_a.on();
buttons.led_b.off();
buttons.led_c.set(state.c);
buttons.update_leds()?;

Fields

led_a: ButtonLed

LED A state

led_b: ButtonLed

LED B state

led_c: ButtonLed

LED C state

Implementations

impl<I2C, E> Buttons<I2C>

where I2C: I2c<Error = E>,

pub fn new(i2c: I2C) -> Result<Self, E>

Create a new Buttons instance with the default address.

pub fn new_with_address(i2c: I2C, address: u8) -> Result<Self, E>

Create a new Buttons instance with a custom address.

pub fn address(&self) -> u8

Get the I2C address.

pub fn read(&mut self) -> Result<ButtonState, E>

Read the current button states.

Returns a ButtonState struct with the pressed state of each button.

pub fn state(&self) -> ButtonState

Get the last read button state without performing I2C communication.

pub fn button_a_pressed(&self) -> bool

Check if button A is pressed (uses cached state).

pub fn button_b_pressed(&self) -> bool

Check if button B is pressed (uses cached state).

pub fn button_c_pressed(&self) -> bool

Check if button C is pressed (uses cached state).

pub fn update_leds(&mut self) -> Result<(), E>

Update the LED states on the device.

This writes the current LED states to the hardware.

pub fn set_leds(&mut self, a: bool, b: bool, c: bool) -> Result<(), E>

Set all LED states at once and update the hardware.

pub fn all_leds_off(&mut self) -> Result<(), E>

Turn all LEDs off.

pub fn all_leds_on(&mut self) -> Result<(), E>

Turn all LEDs on.

pub fn release(self) -> I2C

Release the I2C bus.