diagram.json

#![no_std]
#![no_main]

#[global_allocator]
static ALLOCATOR: esp_alloc::EspHeap = esp_alloc::EspHeap::empty();

// use display_interface_spi::SPIInterfaceNoCS;
use spi_dma_displayinterface::spi_dma_displayinterface::SPIInterfaceNoCS;

use embedded_graphics::{
    mono_font::{ascii::FONT_8X13, MonoTextStyle},
    prelude::{Point, RgbColor},
    text::Text,
    Drawable,
};

use esp_println::println;

use hal::{
    clock::{ClockControl, CpuClock},
    dma::DmaPriority,
    gdma::Gdma,
    i2c,
    peripherals::Peripherals,
    prelude::*,
    spi::{
        master::{prelude::*, Spi},
        // master::Spi,
        SpiMode,
    },
    Delay,
    Rng,
    IO
};

mod app;
use app::app_loop;

mod accel_movement_controller;
mod s3box_composite_controller;

use esp_backtrace as _;

// #[cfg(any(feature = "imu_controls"))]
use icm42670::{accelerometer::Accelerometer, Address, Icm42670};
// #[cfg(any(feature = "imu_controls"))]
use shared_bus::BusManagerSimple;

#[entry]
fn main() -> ! {
    let peripherals = Peripherals::take();
    let system = peripherals.SYSTEM.split();

    // With DMA we have sufficient throughput, so we can clock down the CPU to 80MHz
    let clocks = ClockControl::configure(system.clock_control, CpuClock::Clock80MHz).freeze();

    let mut delay = Delay::new(&clocks);

    println!("About to initialize the SPI LED driver");
    let io = IO::new(peripherals.GPIO, peripherals.IO_MUX);

    let lcd_h_res = 240;
    let lcd_v_res = 320;

    let lcd_sclk = io.pins.gpio0;
    let lcd_mosi = io.pins.gpio6;
    let lcd_miso = io.pins.gpio11; // random unused pin
    let lcd_cs = io.pins.gpio5;
    let lcd_dc = io.pins.gpio4.into_push_pull_output();
    let _lcd_backlight = io.pins.gpio1.into_push_pull_output();
    let lcd_reset = io.pins.gpio3.into_push_pull_output();

    let i2c_sda = io.pins.gpio10;
    let i2c_scl = io.pins.gpio8;

    let dma = Gdma::new(peripherals.DMA);
    let dma_channel = dma.channel0;

    let mut descriptors = [0u32; 8 * 3];
    let mut rx_descriptors = [0u32; 8 * 3];


    let spi = Spi::new(
        peripherals.SPI2,
        lcd_sclk,
        lcd_mosi,
        lcd_miso,
        lcd_cs,
        60u32.MHz(),
        SpiMode::Mode0,
        &clocks,
    ).with_dma(dma_channel.configure(
        false,
        &mut descriptors,
        &mut rx_descriptors,
        DmaPriority::Priority0,
    ));

    println!("SPI ready");

    let di = SPIInterfaceNoCS::new(spi, lcd_dc);

    // ESP32-S3-BOX display initialization workaround: Wait for the display to power up.
    // If delay is 250ms, picture will be fuzzy.
    // If there is no delay, display is blank
    delay.delay_ms(500u32);

    let mut display = match mipidsi::Builder::st7789(di)
    .with_display_size(lcd_h_res as u16, lcd_v_res as u16)
    .with_orientation(mipidsi::Orientation::Landscape(true))
    .with_color_order(mipidsi::ColorOrder::Rgb)
        .init(&mut delay, Some(lcd_reset)) {
        Ok(display) => display,
        Err(_e) => {
            // Handle the error and possibly exit the application
            panic!("Display initialization failed");
        }
    };

    // configured_system_pins.backlight.set_high();

    println!("Initializing...");
        Text::new(
            "Initializing...",
            Point::new(80, 110),
            MonoTextStyle::new(&FONT_8X13, RgbColor::GREEN),
        )
        .draw(&mut display)
        .unwrap();

    println!("Initialized");
    let i2c = i2c::I2C::new(
        peripherals.I2C0,
        i2c_sda,
        i2c_scl,
        100u32.kHz(),
        &clocks,
    );
    println!("I2C ready");

    // #[cfg(any(feature = "imu_controls"))]
    let bus = BusManagerSimple::new(i2c);
    // #[cfg(any(feature = "imu_controls"))]
    let icm = Icm42670::new(bus.acquire_i2c(), Address::Primary).unwrap();

    let mut rng = Rng::new(peripherals.RNG);
    let mut seed_buffer = [0u8; 32];
    rng.read(&mut seed_buffer).unwrap();


    app_loop( &mut display, lcd_h_res-1, lcd_v_res, seed_buffer, icm);
    loop {}

}

main.rs

[package]
name = "spooky-esp32-c3"
version = "0.8.0"
authors = ["Juraj Michálek <juraj.michalek@gmail.com>"]
edition = "2021"
license = "MIT"

[dependencies]
hal = { package = "esp32c3-hal", version = "0.13.0" }
esp-backtrace = { version = "0.9.0", features = [
 "esp32c3",
 "panic-handler",
 "print-rtt",
] }
esp-println = { version = "0.7.0", default-features = false, features = [ "esp32c3", "rtt" ] }

esp-alloc = "0.3.0"
embedded-graphics = "0.8.0"
embedded-graphics-framebuf = { version = "0.3.0", git = "https://github.com/georgik/embedded-graphics-framebuf.git", branch = "feature/embedded-graphics-0.8" }
embedded-hal = "0.2"
display-interface = "0.4"
display-interface-spi = "0.4"
icm42670 = { git = "https://github.com/jessebraham/icm42670/" }
mipidsi = "0.7.1"
panic-halt = "0.2"
shared-bus = { version = "0.3.0" }
spooky-core = { git = "https://github.com/georgik/esp32-spooky-maze-game.git", package = "spooky-core", default-features = false, features = ["static_maze"]}
spooky-embedded = { git = "https://github.com/georgik/esp32-spooky-maze-game.git", package = "spooky-embedded", default-features = false, features = [ "static_maze" ] }
spi-dma-displayinterface = { git = "https://github.com/georgik/esp32-spooky-maze-game.git", package = "spi-dma-displayinterface", features = [ "esp32c3" ] }

[features]
default = [ "esp32c3_ili9341" ]
system_timer = []

button_controls = []
imu_controls = []

esp32 = []
esp32s2 = ["system_timer"]
esp32s3 = []
esp32c3 = ["system_timer"]

esp32c3_ili9341 = [ "esp32c3", "imu_controls" ]

Cargo.toml

use crate::s3box_composite_controller::S3BoxCompositeController;
use embedded_graphics::{pixelcolor::Rgb565, prelude::DrawTarget};
use spooky_core::{engine::Engine, spritebuf::SpriteBuf, universe::Universe};
use embedded_graphics_framebuf::FrameBuf;
use embedded_graphics::prelude::RgbColor;
use display_interface::WriteOnlyDataCommand;
use embedded_hal::digital::v2::OutputPin;
use mipidsi::models::Model;
use crate::accel_movement_controller::AccelMovementController;
use crate::Accelerometer;

pub fn app_loop<DI, M, RST>(
 display: &mut mipidsi::Display<DI, M, RST>,
 lcd_h_res:u16,
 lcd_v_res:u16,
 seed_buffer: [u8; 32],
 icm: impl Accelerometer
) where
 DI: WriteOnlyDataCommand,
 M: Model<ColorFormat = Rgb565>,
 RST: OutputPin,
{
 let accel_movement_controller = AccelMovementController::new(icm, 0.2);

 let demo_movement_controller = spooky_core::demo_movement_controller::DemoMovementController::new(seed_buffer);
 let movement_controller = S3BoxCompositeController::new(demo_movement_controller, accel_movement_controller);

 let mut data = [Rgb565::BLACK; 320 * 240];
 let fbuf = FrameBuf::new(&mut data, 320, 240);
 let spritebuf = SpriteBuf::new(fbuf);

 let engine = Engine::new(spritebuf, Some(seed_buffer));

 let mut universe = Universe::new_with_movement_controller(engine, movement_controller);

 universe.initialize();

 loop {
 let pixel_iterator = universe.render_frame().get_pixel_iter();
 let _ = display.set_pixels(0, 0, lcd_v_res, lcd_h_res, pixel_iterator);
 }
}

app.rs

use spooky_core::engine::Action;
use spooky_core::movement_controller::MovementController;
use icm42670::accelerometer::Accelerometer;
pub struct AccelMovementController
where
 I: Accelerometer,
{
 icm: I,
 last_action: Action,
 accel_threshold: f32,
}

impl AccelMovementController
where
 I: Accelerometer,
{
 pub fn new(icm: I, accel_threshold: f32) -> Self {
 Self {
 icm,
 last_action: Action::None,
 accel_threshold,
 }
 }
}

impl MovementController for AccelMovementController
where
 I: Accelerometer,
{
 fn set_active(&mut self, _index:usize) {
 }

 fn get_movement(&self) -> Action {
 self.last_action
 }

 fn tick(&mut self) {
 if let Ok(accel_norm) = self.icm.accel_norm() {
 if accel_norm.y > self.accel_threshold {
 self.last_action = Action::Right;
 } else if accel_norm.y < -self.accel_threshold {
 self.last_action = Action::Left;
 } else if accel_norm.x > self.accel_threshold {
 self.last_action = Action::Down;
 } else if accel_norm.x < -self.accel_threshold {
 self.last_action = Action::Up;
 } else {
 self.last_action = Action::None;
 }
 // Additional actions for Teleport and PlaceDynamite can be added here
 }
 }
}

accel_movement_controller.rs

use spooky_core::engine::Action;
use spooky_core::movement_controller::MovementController;
use spooky_core::demo_movement_controller::DemoMovementController;
use crate::accel_movement_controller::AccelMovementController;
use icm42670::accelerometer::Accelerometer;

pub struct S3BoxCompositeController
where
 I: Accelerometer,
{
 demo_controller: DemoMovementController,
 accel_controller: AccelMovementController,
 active_index: usize, // 0 for demo_controller, 1 for accel_controller
 last_action: Action,
 last_accel_action: Action,
}

impl S3BoxCompositeController
where
 I: Accelerometer,
{
 pub fn new(demo_controller: DemoMovementController, accel_controller: AccelMovementController) -> Self {
 Self {
 demo_controller,
 accel_controller,
 active_index: 0,
 last_action: Action::None,
 last_accel_action: Action::None,
 }
 }
}

impl MovementController for S3BoxCompositeController
where
 I: Accelerometer,
{
 fn tick(&mut self) {
 self.last_action = Action::None;
 match self.active_index {
 0 => {
 self.accel_controller.tick();
 let current_accel_action = self.accel_controller.get_movement();
 // Initialization state of accelerometer
 if self.last_accel_action == Action::None {
 self.last_accel_action = current_accel_action;
 } else if self.last_accel_action != current_accel_action {
 // 2nd change of state, we consider it as signal to start the game mode
 self.last_action = Action::Start;
 self.set_active(1);
 }
 self.demo_controller.tick()
 },
 1 => self.accel_controller.tick(),
 _ => {}
 }
 }

 fn get_movement(&self) -> Action {
 if self.last_action != Action::None {
 return self.last_action;
 }

 match self.active_index {
 0 => self.demo_controller.get_movement(),
 1 => self.accel_controller.get_movement(),
 _ => Action::None,
 }
 }

 fn set_active(&mut self, index: usize) {
 self.active_index = index;
 }
}