diagram.json

#![no_std]
#![no_main]

// Source code: https://github.com/georgik/esp32-spooky-maze-game

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

use display_interface_spi::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},
    // gdma::Gdma,
    i2c,
    peripherals::Peripherals,
    prelude::*,
    spi::{master::Spi, SpiMode},
    Delay,
    Rng,
    IO
};

mod app;
use app::app_loop;

mod accel_movement_controller;
mod s3box_composite_controller;
mod setup;
use setup::setup_pins;

mod types;

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();
    let clocks = ClockControl::configure(system.clock_control, CpuClock::Clock160MHz).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 (uninitialized_pins, /*configured_pins, */configured_system_pins) = setup_pins(io.pins);
    println!("SPI LED driver initialized");

    let spi = Spi::new(
        peripherals.SPI2,
        uninitialized_pins.sclk,
        uninitialized_pins.mosi,
        uninitialized_pins.miso,
        uninitialized_pins.cs,
        60u32.MHz(),
        SpiMode::Mode0,
        &clocks,
    );

    println!("SPI ready");

    let di = SPIInterfaceNoCS::new(spi, configured_system_pins.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(240 as u16, 320 as u16)
    .with_orientation(mipidsi::Orientation::Landscape(true))
    .with_color_order(mipidsi::ColorOrder::Bgr)
        .init(&mut delay, Some(configured_system_pins.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,
        uninitialized_pins.sda,
        uninitialized_pins.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, seed_buffer, icm);
    loop {}

}


main.rs

[package]
name = "spooky-esp32-c3"
version = "0.7.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" ] }
heapless = { version = "0.7.14", default-features = false }

[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 crate::accel_movement_controller::AccelMovementController;
use crate::Accelerometer;

pub fn app_loop<DISP>(
 display: &mut DISP,
 seed_buffer: [u8; 32],
 icm: impl Accelerometer // You'll need to pass your accelerometer device here
)
where
 DISP: DrawTarget<Color = Rgb565>,
{
 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 _ = display
 .draw_iter(universe.render_frame().into_iter());
 }
}

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;
 }
}

s3box_composite_controller.rs

use crate::types::{UnconfiguredPins, ConfiguredSystemPins};
use embedded_hal::digital::v2::OutputPin;
use hal::gpio::{self, Pins};

pub fn setup_pins(pins: Pins) -> (UnconfiguredPins<gpio::Unknown>, /*ConfiguredPins<impl InputPin, impl InputPin, impl InputPin, impl InputPin, impl InputPin,
 impl InputPin>, */ConfiguredSystemPins<impl OutputPin, impl OutputPin, impl OutputPin>) {
 let unconfigured_pins = UnconfiguredPins {
 sclk: pins.gpio0,
 mosi: pins.gpio6,
 miso: pins.gpio11,
 cs: pins.gpio5,
 sda: pins.gpio10,
 scl: pins.gpio8,
 };

 // let configured_pins = ConfiguredPins {
 // up_button: pins.gpio14.into_pull_up_input(),
 // down_button: pins.gpio12.into_pull_up_input(),
 // left_button: pins.gpio13.into_pull_up_input(),
 // right_button: pins.gpio15.into_pull_up_input(),
 // dynamite_button: pins.gpio26.into_pull_up_input(),
 // teleport_button: pins.gpio27.into_pull_up_input(),
 // };

 let configured_system_pins = ConfiguredSystemPins {
 dc: pins.gpio4.into_push_pull_output(),
 backlight: pins.gpio1.into_push_pull_output(),
 reset: pins.gpio3.into_push_pull_output(),
 };

 (unconfigured_pins, /*configured_pins, */configured_system_pins)
}

setup.rs

use hal::gpio;
use embedded_hal::digital::v2::OutputPin;

// Generic type for unconfigured pins
pub struct UnconfiguredPins<MODE> {
 pub sclk: gpio::Gpio0<MODE>,
 pub mosi: gpio::Gpio6<MODE>,
 pub miso: gpio::Gpio11<MODE>,
 pub cs: gpio::Gpio5<MODE>,
 pub sda: gpio::Gpio10<MODE>,
 pub scl: gpio::Gpio8<MODE>,
}

pub struct ConfiguredSystemPins<Dc: OutputPin, Bckl: OutputPin, Reset: OutputPin> {
 pub dc: Dc,
 pub backlight: Bckl,
 pub reset: Reset,
}