Struct ssd1331::Ssd1331

pub struct Ssd1331<SPI, DC> { /* fields omitted */ }

SSD1331 display interface

Examples

Draw shapes and text with embedded-graphics

This requires the graphics feature to be enabled (on by default).

use embedded_graphics::{
    geometry::Point,
    image::{Image, ImageRawLE},
    mono_font::{
        ascii::{FONT_6X10, FONT_9X18},
        MonoTextStyleBuilder,
    },
    pixelcolor::Rgb565,
    prelude::*,
    primitives::{Circle, Line, PrimitiveStyle, Rectangle, Triangle},
    text::{Baseline, Text},
};
use ssd1331::{DisplayRotation::Rotate0, Ssd1331};

// Set up SPI interface and digital pin. These are stub implementations used in examples.
let spi = Spi;
let dc = Pin;

let mut display = Ssd1331::new(spi, dc, Rotate0);
let raw = ImageRawLE::new(include_bytes!("../examples/ferris.raw"), 86);

let image: Image<ImageRawLE<Rgb565>> = Image::new(&raw, Point::zero());

// Initialise and clear the display
display.init().unwrap();
display.flush().unwrap();

Triangle::new(
    Point::new(8, 16 + 16),
    Point::new(8 + 16, 16 + 16),
    Point::new(8 + 8, 16),
)
.into_styled(PrimitiveStyle::with_stroke(Rgb565::RED, 1))
.draw(&mut display)
.unwrap();

Rectangle::with_corners(Point::new(36, 16), Point::new(36 + 16, 16 + 16))
    .into_styled(PrimitiveStyle::with_stroke(Rgb565::GREEN, 1))
    .draw(&mut display)
    .unwrap();

Circle::new(Point::new(64, 16), 16)
    .into_styled(PrimitiveStyle::with_stroke(Rgb565::BLUE, 1))
    .draw(&mut display)
    .unwrap();

image.draw(&mut display);

// Red with a small amount of green creates a deep orange colour
let rust_style = MonoTextStyleBuilder::new()
    .font(&FONT_9X18)
    .text_color(Rgb565::RED)
    .build();

Text::with_baseline("Hello Rust!", Point::new(0, 0), rust_style, Baseline::Top)
    .draw(&mut display)
    .unwrap();

// Render graphics objects to the screen
display.flush().unwrap();

Implementations

impl<SPI, DC, CommE, PinE> Ssd1331<SPI, DC> where
    SPI: Write<u8, Error = CommE>,
    DC: OutputPin<Error = PinE>, 

pub fn new(spi: SPI, dc: DC, display_rotation: DisplayRotation) -> Self

Create new display instance

Ensure display.init() is called before sending data otherwise nothing will be shown.

The driver allocates a buffer of 96px * 64px * 16bits = 12,288 bytes. This may be too large for some target hardware.

Examples

Create a display instance with no rotation

use ssd1331::{DisplayRotation::Rotate0, Ssd1331};

// Set up SPI interface and digital pin. These are stub implementations used in examples.
let spi = Spi;
let dc = Pin;

let mut display = Ssd1331::new(spi, dc, Rotate0);

// Initialise and clear the display
display.init().unwrap();
display.flush().unwrap();

pub fn release(self) -> (SPI, DC)

Release SPI and DC resources for reuse in other code

pub fn clear(&mut self)

Clear the display buffer

display.flush() must be called to update the display

pub fn reset<RST, DELAY>(
    &mut self,
    rst: &mut RST,
    delay: &mut DELAY
) -> Result<(), Error<CommE, PinE>> where
    RST: OutputPin<Error = PinE>,
    DELAY: DelayMs<u8>, 

Reset the display

This method brings the RST pin low for 1ms to reset the module, waits for another 1ms then brings RST high

pub fn flush(&mut self) -> Result<(), Error<CommE, PinE>>

Send the full framebuffer to the display

This resets the draw area the full size of the display

pub fn set_draw_area(
    &mut self,
    start: (u8, u8),
    end: (u8, u8)
) -> Result<(), Error<CommE, PinE>>

Set the top left and bottom right corners of a bounding box to draw to

pub fn set_pixel(&mut self, x: u32, y: u32, value: u16)

Set the value for an individual pixel.

pub fn init(&mut self) -> Result<(), Error<CommE, PinE>>

Initialise display, setting sensible defaults and rotation

pub fn dimensions(&self) -> (u8, u8)

Get display dimensions, taking into account the current rotation of the display

Examples

No rotation

use ssd1331::{DisplayRotation, Ssd1331};

// Set up SPI interface and digital pin. These are stub implementations used in examples.
let spi = Spi;
let dc = Pin;

let display = Ssd1331::new(spi, dc, DisplayRotation::Rotate0);

assert_eq!(display.dimensions(), (96, 64));

90 degree rotation rotation

use ssd1331::{DisplayRotation, Ssd1331};

// Set up SPI interface and digital pin. These are stub implementations used in examples.
let spi = Spi;
let dc = Pin;

let display = Ssd1331::new(spi, dc, DisplayRotation::Rotate90);

assert_eq!(display.dimensions(), (64, 96));

pub fn set_rotation(
    &mut self,
    rot: DisplayRotation
) -> Result<(), Error<CommE, PinE>>

Set the display rotation

pub fn rotation(&self) -> DisplayRotation

Get the current rotation of the display

pub fn turn_on(&mut self) -> Result<(), Error<CommE, PinE>>

Turn the display on (eg exiting sleep mode)

pub fn turn_off(&mut self) -> Result<(), Error<CommE, PinE>>

Turn the display off (enter sleep mode)

Trait Implementations

impl<SPI, DC> DrawTarget for Ssd1331<SPI, DC> where
    SPI: Write<u8>,
    DC: OutputPin, 

type Color = Rgb565

The pixel color type the targetted display supports.

type Error = Infallible

Error type to return when a drawing operation fails.

fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error> where
    I: IntoIterator<Item = Pixel<Self::Color>>, 

Draw individual pixels to the display without a defined order.

fn fill_contiguous<I>(
    &mut self,
    area: &Rectangle,
    colors: I
) -> Result<(), Self::Error> where
    I: IntoIterator<Item = Self::Color>, 

Fill a given area with an iterator providing a contiguous stream of pixel colors.

fn fill_solid(
    &mut self,
    area: &Rectangle,
    color: Self::Color
) -> Result<(), Self::Error>

Fill a given area with a solid color.

fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error>

Fill the entire display with a solid color.

impl<SPI, DC> OriginDimensions for Ssd1331<SPI, DC> where
    SPI: Write<u8>,
    DC: OutputPin, 

fn size(&self) -> Size

Returns the size of the bounding box.