92 lines
3.2 KiB
Rust
92 lines
3.2 KiB
Rust
use std::{error::Error, thread::sleep, time::Duration};
|
|
|
|
use embedded_graphics::{image::Image, pixelcolor::Rgb565, prelude::*};
|
|
use esp_idf_hal::{
|
|
gpio::{Gpio16, Gpio17, Gpio18, Gpio23, Gpio5, Output},
|
|
prelude::{Hertz, Peripherals},
|
|
spi::{self, Master, Pins, SPI3},
|
|
};
|
|
use esp_idf_sys as _;
|
|
use rand::Rng;
|
|
// If using the `binstart` feature of `esp-idf-sys`, always keep this module imported
|
|
use ssd1331::{DisplayRotation::Rotate0, Ssd1331};
|
|
use tinybmp::Bmp;
|
|
|
|
fn secondary() -> Result<(), Box<dyn Error>> {
|
|
// Temporary. Will disappear once ESP-IDF 4.4 is released, but for now it is necessary to call this function once,
|
|
// or else some patches to the runtime implemented by esp-idf-sys might not link properly.
|
|
esp_idf_sys::link_patches();
|
|
|
|
// Bind the log crate to the ESP Logging facilities
|
|
esp_idf_svc::log::EspLogger::initialize_default();
|
|
let peripherals = Peripherals::take().unwrap();
|
|
let spi3 = peripherals.spi3;
|
|
let pins = peripherals.pins;
|
|
let cs: Gpio17<Output> = pins.gpio17.into_output()?;
|
|
let dc: Gpio16<Output> = pins.gpio16.into_output()?;
|
|
let mosi: Gpio23<Output> = pins.gpio23.into_output()?;
|
|
let sclk: Gpio18<Output> = pins.gpio18.into_output()?;
|
|
let reset: Gpio5<Output> = pins.gpio5.into_output()?;
|
|
|
|
// // Set up SPI interface and digital pin. These are stub implementations used in examples.
|
|
let spiman =
|
|
spi::Master::<SPI3, Gpio18<Output>, Gpio23<Output>, Gpio5<Output>, Gpio17<Output>>::new(
|
|
spi3,
|
|
Pins {
|
|
sclk: sclk,
|
|
sdo: mosi,
|
|
sdi: Some(reset),
|
|
cs: Some(cs),
|
|
},
|
|
spi::config::Config {
|
|
baudrate: Hertz(24000000),
|
|
data_mode: embedded_hal::spi::MODE_0,
|
|
write_only: false,
|
|
dma: spi::Dma::Disabled,
|
|
},
|
|
)?;
|
|
let mut display = Ssd1331::new(spiman, dc, Rotate0);
|
|
display.init().unwrap();
|
|
display.flush().unwrap();
|
|
|
|
let (w, h) = display.dimensions();
|
|
println!("got resolution {} x {}", w.clone(), h.clone());
|
|
let mut rng = rand::thread_rng();
|
|
|
|
let eye = Bmp::from_slice(include_bytes!("./eye.bmp")).expect("Failed to load BMP image");
|
|
let eye_closed =
|
|
Bmp::from_slice(include_bytes!("./eye_closed.bmp")).expect("Failed to load BMP image");
|
|
loop {
|
|
print_image(eye, &mut display, h as u32, w as u32);
|
|
sleep(Duration::from_secs(rng.gen_range(1..10)));
|
|
print_image(eye_closed, &mut display, h as u32, w as u32);
|
|
sleep(Duration::from_millis(400))
|
|
}
|
|
}
|
|
|
|
fn print_image(
|
|
img: Bmp<Rgb565>,
|
|
display: &mut Ssd1331<
|
|
Master<SPI3, Gpio18<Output>, Gpio23<Output>, Gpio5<Output>, Gpio17<Output>>,
|
|
Gpio16<Output>,
|
|
>,
|
|
h: u32,
|
|
w: u32,
|
|
) {
|
|
let im: Image<Bmp<Rgb565>> = Image::new(&img, Point::zero());
|
|
// Position image in the center of the display
|
|
let moved = im.translate(Point::new(
|
|
(w - img.size().width) as i32 / 2,
|
|
(h - img.size().height) as i32 / 2,
|
|
));
|
|
|
|
moved.draw(display).unwrap();
|
|
|
|
display.flush().unwrap();
|
|
}
|
|
|
|
fn main() -> Result<(), Box<dyn Error>> {
|
|
sleep(Duration::from_secs(1));
|
|
Ok(secondary().unwrap())
|
|
}
|