Struct Controller

pub struct Controller { /* private fields */ }

The main struct used to control lights. Provides ways of accessing the light color values and rendering those values to the string.

Implementations

impl Controller

pub fn new(c_struct: ws2811_t) -> Self

Creates a new Controller

Note: This is only to be called from the Builder struct

pub fn render(&mut self) -> Result<()>

Render the colors to the string.

It doesn’t automatically do this because it is a somewhat costly operation that should be batched.

Examples found in repository

examples/basic.rs (line 30)

fn main() {
    // Construct a single channel controller. Note that the
    // Controller is initialized by default and is cleaned up on drop

    let mut controller = ControllerBuilder::new()
        .freq(800_000)
        .dma(10)
        .channel(
            0, // Channel Index
            ChannelBuilder::new()
                .pin(10) // GPIO 10 = SPI0 MOSI
                .count(64) // Number of LEDs
                .strip_type(StripType::Ws2812)
                .brightness(20) // default: 255
                .build(),
        )
        .build()
        .unwrap();

    let leds = controller.leds_mut(0);

    for led in leds {
        *led = [0, 0, 255, 0];
    }

    controller.render().unwrap();
}

pub fn wait(&mut self) -> Result<()>

Wait for a render to be completed.

pub fn channels(&self) -> Vec<usize>

Gets the channels with non-zero number of LED’s associated with them.

I know this is somewhat non-intuitive, but naming it something like active_channels(&self) seemed overly verbose.

pub fn brightness(&self, channel: usize) -> u8

Gets the brightness of the LEDs

pub fn set_brightness(&mut self, channel: usize, value: u8)

Sets the brighness of the LEDs

pub fn leds(&self, channel: usize) -> &[RawColor]

Gets a slice view to the color array to be written to the LEDs. See leds_mut for a mutable slice view to this data.

Safety

This function is moderately unsafe because we rely on the promise from the C library that it will stick to its memory layout and that the pointer is valid.

pub fn leds_mut(&mut self, channel: usize) -> &mut [RawColor]

Gets a mutable slice pointing to the color array to be written to the LEDs.

Safety

This function is moderately unsafe because we rely on the promise from the C library that it will stick to its memory layout and that the pointer is valid.

Examples found in repository

examples/basic.rs (line 24)

fn main() {
    // Construct a single channel controller. Note that the
    // Controller is initialized by default and is cleaned up on drop

    let mut controller = ControllerBuilder::new()
        .freq(800_000)
        .dma(10)
        .channel(
            0, // Channel Index
            ChannelBuilder::new()
                .pin(10) // GPIO 10 = SPI0 MOSI
                .count(64) // Number of LEDs
                .strip_type(StripType::Ws2812)
                .brightness(20) // default: 255
                .build(),
        )
        .build()
        .unwrap();

    let leds = controller.leds_mut(0);

    for led in leds {
        *led = [0, 0, 255, 0];
    }

    controller.render().unwrap();
}

Trait Implementations

impl Clone for Controller

fn clone(&self) -> Controller

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Controller

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

Formats the value using the given formatter.

impl Drop for Controller

fn drop(&mut self)

Executes the destructor for this type.