theoretically working firmware

4 files changed, 227 insertions, 9 deletions

diff --git a/src/bringup/mod.rs b/src/bringup/mod.rs
new file mode 100644
index 0000000..71c2d4b
--- /dev/null
+++ b/src/bringup/mod.rs
@@ -0,0 +1,118 @@
+use molybdos::reexport::*;
+
+use embassy_rp::{
+    adc,
+    adc::Adc,
+    gpio::{
+        Level,
+        Output,
+        Pin,
+    },
+    peripherals::{
+        SPI0,
+        SPI1,
+        USB,
+    },
+    spi,
+    spi::{
+        Async,
+        Spi,
+    },
+    watchdog::Watchdog,
+};
+use embassy_sync::{
+    blocking_mutex::raw::{
+        CriticalSectionRawMutex,
+        RawMutex,
+    },
+    mutex::Mutex,
+};
+use static_cell::StaticCell;
+use tap::Pipe;
+
+use molybdos::pal::StaticOutput;
+
+embassy_rp::bind_interrupts! {
+    struct Irqs {
+        USBCTRL_IRQ => embassy_rp::usb::InterruptHandler<USB>;
+        ADC_IRQ_FIFO => adc::InterruptHandler;
+    }
+}
+
+static BME_SPI: StaticCell<Mutex<CriticalSectionRawMutex, Spi<SPI1, Async>>> = StaticCell::new();
+static SD_SPI: StaticCell<Mutex<CriticalSectionRawMutex, Spi<SPI0, Async>>> = StaticCell::new();
+static ADC: StaticCell<Mutex<CriticalSectionRawMutex, Adc<adc::Async>>> = StaticCell::new();
+
+pub struct Split<BmeSpi, BmeSpiMutex, SdSpi, SdSpiMutex>
+where
+    SdSpiMutex: RawMutex + 'static,
+    SdSpi: 'static,
+    BmeSpiMutex: RawMutex + 'static,
+    BmeSpi: 'static,
+{
+    pub sd_spi:  &'static Mutex<SdSpiMutex, SdSpi>,
+    pub sd_cs:   StaticOutput,
+    pub bme_spi: &'static Mutex<BmeSpiMutex, BmeSpi>,
+    pub bme_cs:  StaticOutput,
+    pub wdt:     Watchdog,
+    pub usb:     molybdos::pal::UsbDriver,
+
+    pub adc: &'static Mutex<CriticalSectionRawMutex, Adc<'static, adc::Async>>,
+    // pub leds: [StaticOutput; crate::N_LED],
+}
+
+pub fn split(
+    config: embassy_rp::config::Config,
+) -> Split<crate::BMESpi, CriticalSectionRawMutex, crate::SdSpi, CriticalSectionRawMutex> {
+    let periphs = embassy_rp::init(config);
+
+    let wdt = Watchdog::new(periphs.WATCHDOG);
+
+    let bme_cs = periphs.PIN_5.degrade().pipe(|cs| Output::new(cs, Level::High));
+    let bme_spi = {
+        let sck = periphs.PIN_10;
+        let mosi = periphs.PIN_11;
+        let miso = periphs.PIN_8;
+
+        let mut conf = spi::Config::default();
+        conf.frequency = 1_000_000;
+
+        let bme_spi =
+            Spi::new(periphs.SPI1, sck, mosi, miso, periphs.DMA_CH0, periphs.DMA_CH1, conf)
+                .pipe(Mutex::<CriticalSectionRawMutex, _>::new);
+        BME_SPI.init(bme_spi)
+    };
+
+    let sd_cs = periphs.PIN_9.degrade().pipe(|cs| Output::new(cs, Level::High));
+    let sd_spi = {
+        let mosi = periphs.PIN_19;
+        let sck = periphs.PIN_18;
+        let miso = periphs.PIN_20;
+
+        let mut conf = spi::Config::default();
+        conf.frequency = 16_000_000;
+
+        let sd_spi =
+            Spi::new(periphs.SPI0, sck, mosi, miso, periphs.DMA_CH3, periphs.DMA_CH4, conf)
+                .pipe(Mutex::new);
+
+        SD_SPI.init(sd_spi)
+    };
+
+    let usb_driver = embassy_rp::usb::Driver::new(periphs.USB, Irqs);
+
+    let adc = Adc::new(periphs.ADC, Irqs, adc::Config::default());
+
+    let adc = ADC.init(Mutex::new(adc));
+
+    Split {
+        sd_spi,
+        sd_cs,
+        bme_spi,
+        bme_cs,
+        wdt,
+        usb: usb_driver,
+
+        adc,
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
index 0c9ac1a..fd70da7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1 +1,15 @@
 #![no_std]
+
+#[derive(
+    Debug, Clone, PartialEq, PartialOrd, molybdos::serde::Serialize, molybdos::serde::Deserialize,
+)]
+pub enum Uplink {
+    Ping,
+}
+
+#[derive(
+    Debug, Clone, PartialEq, PartialOrd, molybdos::serde::Serialize, molybdos::serde::Deserialize,
+)]
+pub enum Downlink {
+    Pong,
+}
diff --git a/src/main.rs b/src/main.rs
index ead8e00..3811101 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,16 +2,100 @@
 #![no_main]
 #![feature(impl_trait_in_assoc_type)]
 
-use molybdos::genlog::defmt;
-use molybdos::reexports::*;
+use molybdos::{
+    embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice,
+    embassy_rp::{
+        i2c::{
+            self,
+            I2c,
+        },
+        peripherals::{
+            I2C0,
+            SPI0,
+            SPI1,
+        },
+        spi::{
+            self,
+            Spi,
+        },
+    },
+    embassy_sync::{
+        blocking_mutex::raw::CriticalSectionRawMutex,
+        pubsub,
+    },
+    embedded_sdmmc_async::{
+        VolumeIdx,
+        VolumeManager,
+    },
+    genlog,
+    genlog::defmt,
+    pal::StaticOutput,
+};
 
-#[defmt::panic_handler]
-fn panic() -> ! {
-    panic_probe::hard_fault();
-}
+mod bringup;
+mod usb;
+
+pub type BMESpi = Spi<'static, SPI1, spi::Async>;
+pub type BMESpiDev = SpiDevice<'static, CriticalSectionRawMutex, BMESpi, StaticOutput>;
+pub type SdSpi = Spi<'static, SPI0, spi::Async>;
+pub type SdSpiDev = SpiDevice<'static, CriticalSectionRawMutex, SdSpi, StaticOutput>;
+
+pub type SensorI2c = I2c<'static, I2C0, i2c::Async>;
 
 #[embassy_executor::main]
-async fn main(_spawner: embassy_executor::Spawner) {
-    genlog::info!("hello");
-    molybdos::heap::init();
+async fn main(spawner: embassy_executor::Spawner) {
+    molybdos::pal::heap::init();
+
+    genlog::info!("boot");
+
+    let bringup::Split {
+        sd_spi,
+        sd_cs,
+        bme_spi,
+        bme_cs,
+        wdt,
+        usb,
+        ..
+    } = bringup::split(Default::default());
+
+    // spawner.must_spawn(molybdos::pal::watchdog(wdt));
+
+    let (acm,) = molybdos::lib::usb::bringup!(
+        spawn,
+        usb,
+        molybdos::pal::UsbDriver,
+        molybdos::lib::usb::config("npry", "ocularium", 0x8888, 0x0011),
+        endpoints = {
+            acm => |builder| molybdos::lib::usb::acm!(builder),
+        }
+    );
+
+    molybdos::lib::usb::start!(molybdos::pal::UsbDriver, acm, &usb::UPLINK, &usb::DOWNLINK);
+
+    molybdos::lib::util::cobs::start!(
+        ocularium::Uplink,
+        &usb::UPLINK,
+        &usb::COBS_UPLINK,
+        ocularium::Downlink,
+        &usb::DOWNLINK,
+        &usb::COBS_DOWNLINK
+    );
+
+    #[cfg(not(feature = "disable_sd"))]
+    {
+        let vm = molybdos::rt::sd::bringup!(sd_spi, SdSpi, sd_cs);
+
+        {
+            let vol = VolumeManager::open_volume(vm, VolumeIdx(0)).await.expect("opening volume");
+        }
+
+        // spawner.must_spawn(sd::run_sd(vm, pubsub::LED.sender().into()));
+    }
+
+    panic!()
+}
+
+#[defmt::panic_handler]
+fn panic() -> ! {
+    molybdos::panic_probe::hard_fault();
 }
diff --git a/src/usb.rs b/src/usb.rs
new file mode 100644
index 0000000..7ec1aae
--- /dev/null
+++ b/src/usb.rs
@@ -0,0 +1,2 @@
+molybdos::lib::usb_pipes!(pub);
+molybdos::lib::cobs_pubsub!(pub, ocularium::Uplink => COBS_UPLINK, ocularium::Downlink => COBS_DOWNLINK);