jerryboard-two/src/main.rs

#![no_std]
#![no_main]

mod backlight;
mod display;
mod framebuffer;
mod led;

use embedded_graphics::pixelcolor::Rgb565;
use embedded_graphics::prelude::*;
use embedded_graphics::primitives::{PrimitiveStyle, Triangle};
use embassy_executor::Spawner;
use embassy_time::Timer;
use esp_backtrace as _;
use esp_bootloader_esp_idf::esp_app_desc;
use esp_hal::gpio::Output;
use esp_hal::timer::timg::TimerGroup;
use esp_hal::{init, rmt::Rmt, time::Rate, Config};
use esp_println::println;
use smart_leds::hsv::{hsv2rgb, Hsv};

const SAT: u8 = 255;
const VAL: u8 = 255;

esp_app_desc!();

#[embassy_executor::task]
async fn led_task(mut led: led::RgbLed) {
    let mut frame = 0u32;
    loop {
        let hue = (frame % 256) as u8;
        let lit = hsv2rgb(Hsv {
            hue,
            sat: SAT,
            val: VAL,
        });
        led.set_rgb(lit).unwrap();
        Timer::after_millis(30).await;
        frame = frame.wrapping_add(1);
    }
}

#[embassy_executor::task]
async fn display_task(
    mut spi: display::SpiDmaBus,
    mut dc: Output<'static>,
    mut cs: Output<'static>,
    mut fb: framebuffer::Framebuffer,
    timer: esp_hal::ledc::timer::Timer<'static, esp_hal::ledc::LowSpeed>,
    bl_pin: esp_hal::peripherals::GPIO22<'static>,
) {
    let mut backlight =
        backlight::LcdBacklight::new(&timer, bl_pin).expect("Failed to init backlight");
    backlight.set_level(0.5).unwrap();
    println!("backlight set to 0.5");

    let mut pts = [
        Point::new(86, 20),
        Point::new(61, 50),
        Point::new(111, 50),
    ];
    let mut vx: i32 = 3;
    let mut vy: i32 = 2;
    let mut frame = 0u32;

    loop {
        let hue = (frame % 256) as u8;
        let lit = hsv2rgb(Hsv {
            hue,
            sat: SAT,
            val: VAL,
        });
        let accent = Rgb565::new(lit.r/8, lit.g/4, lit.b/8);

        for p in &mut pts {
            p.x += vx;
            p.y += vy;
        }

        let min_x = pts.iter().map(|p| p.x).min().unwrap();
        let max_x = pts.iter().map(|p| p.x).max().unwrap();
        let min_y = pts.iter().map(|p| p.y).min().unwrap();
        let max_y = pts.iter().map(|p| p.y).max().unwrap();

        if min_x <= 0 || max_x >= display::WIDTH as i32 {
            vx = -vx;
        }
        if min_y <= 0 || max_y >= display::HEIGHT as i32 {
            vy = -vy;
        }

        fb.clear();
        Triangle::new(pts[0], pts[1], pts[2])
            .into_styled(PrimitiveStyle::with_fill(accent))
            .draw(&mut fb)
            .unwrap();

        display::send_framebuffer(&mut spi, &mut dc, &mut cs, fb.as_bytes())
            .await
            .unwrap();

        if frame % 32 == 0 {
            println!(
                "frame {frame}: apex=({}, {}), v=({}, {}), hue={hue}",
                pts[0].x, pts[0].y, vx, vy
            );
        }

        frame = frame.wrapping_add(1);
    }
}

#[esp_rtos::main]
async fn main(spawner: Spawner) -> ! {
    let peripherals = init(Config::default());
    let timg0 = TimerGroup::new(peripherals.TIMG0);
    esp_rtos::start(timg0.timer0, peripherals.FROM_CPU_INTR0);

    let led = {
        let rmt = Rmt::new(peripherals.RMT, Rate::from_mhz(80)).expect("Failed to init RMT");
        led::RgbLed::new(rmt.channel0, peripherals.GPIO8).expect("Failed to init RGB LED")
    };

    let (_ledc, timer) =
        backlight::setup_timer(peripherals.LEDC).expect("Failed to init backlight timer");

    let mut buffer = [0u8; 4096];
    let lcd = display::init(
        display::LcdPins {
            spi2: peripherals.SPI2,
            sck: peripherals.GPIO7,
            mosi: peripherals.GPIO6,
            dc: peripherals.GPIO15,
            cs: peripherals.GPIO14,
            rst: peripherals.GPIO21,
            dma_ch: peripherals.DMA_CH0,
        },
        &mut buffer,
    );

    let (interface, _model, _rst) = lcd.release();
    let (device, dc) = interface.release();
    let (spi, cs) = device.into_inner();

    println!("LCD {}x{} initialized", display::WIDTH, display::HEIGHT);

    spawner.spawn(led_task(led).unwrap());
    spawner.spawn(display_task(
        spi,
        dc,
        cs,
        framebuffer::Framebuffer,
        timer,
        peripherals.GPIO22,
    ).unwrap());

    loop {
        Timer::after_millis(1000).await;
    }
}