dmx_interface/

main.rs

//! DMX interface firmware for ESP32-S2 (Lolin S2 Mini).
//!
//! Current scope: status LED on GPIO7 (LEDC PWM, own embassy task), user
//! button on GPIO5 (power-up factory-reset hold plus click actions),
//! USB-CDC with esptool auto-reset, ring-buffer logging over the CDC port,
//! panic reports persisted across resets, and a `WiFi` network stack (AP
//! with DHCP server or station mode, AP fallback).

#![no_std]
#![no_main]
// In this binary crate every module is private, so `missing_docs` only
// gates crate-level items (the `//!` header above). Module and API doc
// coverage is enforced separately by scripts/check-rust-docs.sh plus the
// warning-denied rustdoc build (`inv docs:rustdoc`).
#![deny(missing_docs)]
#![allow(dead_code)]

extern crate alloc;

// Module docs live as `//!` at the top of each module file. Do NOT also put
// `///` docs on these declarations: rustdoc then resolves the module's
// intra-doc links in this (parent) module's scope and every unqualified link
// breaks — see AGENTS.md "//!" only.
mod boards;
mod config;
mod hardware;
mod logging;
mod net;
mod panic_report;
mod storage;

use embassy_executor::Spawner;
use embassy_time::{Duration, Timer};
use esp_alloc::HeapRegion;
use esp_hal::{
    clock::CpuClock, interrupt::software::SoftwareInterruptControl, timer::timg::TimerGroup,
};

use hardware::led::LedStatus;

esp_bootloader_esp_idf::esp_app_desc!();

/// Clears the panic boot-loop counter once the firmware ran stably for 30 s.
#[embassy_executor::task]
async fn stable_marker() {
    Timer::after(Duration::from_secs(30)).await;
    panic_report::mark_stable();
}

/// Entry point.
#[esp_rtos::main]
async fn main(spawner: Spawner) -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default().with_cpu_clock(CpuClock::max()));

    // ── Heap allocator ─────────────────────────────────────────────────────
    {
        /// Heap size in bytes (internal RAM — the `WiFi` driver and smoltcp
        /// need ~100 KiB per esp-radio's examples, plus panic-report replay
        /// and NVS reads).
        const HEAP_SIZE: usize = 128 * 1024;
        /// Backing memory for the heap allocator, placed in `.dram2_uninit`
        /// (the 136 KiB region above the stack top that nothing else uses —
        /// see esp-hal's `dram2.x`), keeping the main `dram_seg` free for
        /// the `WiFi` driver's statics and the stack.
        #[unsafe(link_section = ".dram2_uninit")]
        static mut HEAP_MEM: [u8; HEAP_SIZE] = [0u8; HEAP_SIZE];
        let heap_ptr = core::ptr::addr_of_mut!(HEAP_MEM).cast::<u8>();
        // SAFETY: `heap_ptr` points to the whole `HEAP_MEM` array, which is
        // valid for `'static`, exclusively owned by the allocator afterwards,
        // handed over exactly once, and `size > 0`.
        let region = unsafe {
            HeapRegion::new(
                heap_ptr,
                HEAP_SIZE,
                esp_alloc::MemoryCapability::Internal.into(),
            )
        };
        // SAFETY: the heap region is registered exactly once at init time,
        // before anything allocates.
        unsafe {
            esp_alloc::HEAP.add_region(region);
        }
    }

    // ── Embassy scheduler ──────────────────────────────────────────────────
    let timg0 = TimerGroup::new(peripherals.TIMG0);
    let sw_int = SoftwareInterruptControl::new(peripherals.SW_INTERRUPT);
    esp_rtos::start(timg0.timer0, sw_int.software_interrupt0);

    // ── Logging + last-panic report ────────────────────────────────────────
    // Must follow esp_rtos::start (uptime timestamps need the time driver)
    // and precede the USB spawn, so a stored panic report is already in the
    // ring when the first host connects.
    logging::init();
    storage::init(peripherals.FLASH);
    // Load the persisted config and push it into every consumer (LED
    // brightness today, the network stack below).
    let config = storage::load();
    config.apply();
    panic_report::report_last_panic();

    // ── USB-CDC (esptool auto-reset + log drain) ───────────────────────────
    spawner.spawn(
        hardware::usb::task(peripherals.USB0, peripherals.GPIO20, peripherals.GPIO19)
            .expect("USB task spawn failed"),
    );
    spawner.spawn(stable_marker().expect("stable marker spawn failed"));

    // ── Status LED (LEDC PWM, own task) ─────────────────────────────────────
    hardware::led::set(LedStatus::Startup);
    spawner.spawn(
        hardware::led::task(peripherals.LEDC, peripherals.GPIO7).expect("LED task spawn failed"),
    );

    // ── User button (GPIO5): power-up factory reset, then click actions ────
    // The hold check must finish before the network starts, so a triggered
    // reset never brings the radio up just to reboot again.
    let button = hardware::button::input(peripherals.GPIO5);
    hardware::button::boot_factory_reset(&button).await;
    spawner.spawn(hardware::button::task(button).expect("button task spawn failed"));

    // ── WiFi (AP/STA bring-up + embassy-net stack) ─────────────────────────
    spawner.spawn(net::task(peripherals.WIFI, config, spawner).expect("network task spawn failed"));

    log::info!("Init complete");

    // TODO(phase 6): switch to Ok only once the network is up — the old
    // firmware waited for NETWORK_READY + 2 s before LED_MODE_NORMAL.
    // Until then, keep the Startup breathing visible for 3 s (three full
    // breaths at the 1 s period) before settling into the steady Ok state.
    Timer::after(Duration::from_secs(3)).await;
    hardware::led::set(LedStatus::Ok);

    // No main-loop duties yet — Phase 8 moves system work into tasks.
    loop {
        core::future::pending::<()>().await;
    }
}