modularise pins

Author: odrusso

src/bin/rx.rs

@@ -8,13 +8,44 @@ use embassy_executor::Spawner;
 use embassy_time::Timer;
 use esp_backtrace as _;
 use esp_hal::{
-    gpio::{Input, Level, Output, Pin, Pull},
-    peripherals::Peripherals,
+    gpio::{AnyPin, Input, Level, Output, Pin, Pull},
+    peripherals::{Peripherals, DMA, SPI2, TIMG0},
     timer::timg::TimerGroup,
 };
 
 use stack_ripper::{lora, spi, state};
 
+struct RxPins {
+    
+    lora_rst: AnyPin,
+    lora_irq: AnyPin,
+
+    lora_nss: AnyPin,
+    lora_mosi: AnyPin,
+    lora_miso: AnyPin,
+    lora_clk: AnyPin,
+
+    timg: TIMG0,
+    dma: DMA,
+    spi: SPI2,
+}
+
+fn get_rx_pins_v001(p: Peripherals) -> RxPins {
+    RxPins {
+        lora_rst: p.GPIO6.degrade(),
+        lora_irq: p.GPIO5.degrade(),
+
+        lora_nss: p.GPIO1.degrade(),
+        lora_clk: p.GPIO4.degrade(),
+        lora_miso: p.GPIO3.degrade(),
+        lora_mosi: p.GPIO2.degrade(),
+
+        timg: p.TIMG0,
+        dma: p.DMA,
+        spi: p.SPI2,
+    }
+}
+
 #[embassy_executor::task]
 async fn print_state() -> ! {
     loop {
@@ -28,31 +59,30 @@ async fn main(spawner: Spawner) {
     info!("Initializing");
 
     let peripherals: Peripherals = esp_hal::init(esp_hal::Config::default());
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
+
+    let pins = get_rx_pins_v001(peripherals);
+
+    let timg0 = TimerGroup::new(pins.timg);
 
     esp_hal_embassy::init(timg0.timer0);
 
     info!("Initializing compete");
 
-    // Set SPI bus
-    let spi_clock = peripherals.GPIO4.degrade();
-    let spi_miso = peripherals.GPIO3.degrade();
-    let spi_mosi = peripherals.GPIO2.degrade();
-
+    // Setup SPI bus
     let spi_bus = spi::init(
-        peripherals.DMA,
-        peripherals.SPI2,
-        spi_clock,
-        spi_mosi,
-        spi_miso,
+        pins.dma,
+        pins.spi,
+        pins.lora_clk,
+        pins.lora_mosi,
+        pins.lora_miso,
     );
 
-    let lora_spi_csb = Output::new(peripherals.GPIO1.degrade(), Level::High);
+    let lora_spi_csb = Output::new(pins.lora_nss, Level::High);
 
     let lora_spi = SpiDevice::new(spi_bus, lora_spi_csb);
 
-    let lora_rst = Output::new(peripherals.GPIO6.degrade(), Level::High);
-    let lora_irq = Input::new(peripherals.GPIO5.degrade(), Pull::Up);
+    let lora_rst = Output::new(pins.lora_rst, Level::High);
+    let lora_irq = Input::new(pins.lora_irq.degrade(), Pull::Up);
 
     spawner
         .spawn(lora::receive(lora_spi, lora_irq, lora_rst))

src/bin/tx.rs

@@ -6,8 +6,8 @@ use embassy_embedded_hal::shared_bus::asynch::spi::SpiDevice;
 use embassy_executor::Spawner;
 
 use esp_hal::{
-    gpio::{Input, Level, Output, Pull},
-    peripherals::Peripherals,
+    gpio::{AnyPin, Input, Level, Output, Pull},
+    peripherals::{Peripherals, DMA, SPI2, TIMG0, UART0},
     prelude::*,
     timer::timg::TimerGroup,
     uart::{Config, Uart},
@@ -18,23 +18,61 @@ use esp_backtrace as _;
 
 use stack_ripper::{gps, lora, spi};
 
+struct TxPins {
+    uart_rx: AnyPin,
+    uart_tx: AnyPin,
+    
+    lora_rst: AnyPin,
+    lora_irq: AnyPin,
+
+    lora_nss: AnyPin,
+    lora_mosi: AnyPin,
+    lora_miso: AnyPin,
+    lora_clk: AnyPin,
+
+    timg: TIMG0,
+    uart: UART0,
+    dma: DMA,
+    spi: SPI2,
+}
+
+fn get_tx_pins_v003(p: Peripherals) -> TxPins {
+    TxPins {
+        uart_rx: p.GPIO4.degrade(),
+        uart_tx: p.GPIO5.degrade(),
+
+        lora_rst: p.GPIO6.degrade(),
+        lora_irq: p.GPIO7.degrade(),
+
+        lora_nss: p.GPIO8.degrade(),
+        lora_clk: p.GPIO21.degrade(),
+        lora_miso: p.GPIO20.degrade(),
+        lora_mosi: p.GPIO10.degrade(),
+
+        timg: p.TIMG0,
+        uart: p.UART0,
+        dma: p.DMA,
+        spi: p.SPI2,
+    }
+}
+
 #[main]
 async fn main(_spawner: Spawner) -> () {
     info!("Initializing");
 
     let peripherals: Peripherals = esp_hal::init(esp_hal::Config::default());
-    let timg0 = TimerGroup::new(peripherals.TIMG0);
+
+    let pins = get_tx_pins_v003(peripherals);
+
+    let timg0 = TimerGroup::new(pins.timg);
 
     esp_hal_embassy::init(timg0.timer0);
 
     info!("Initializing compete");
 
     // Setup UART for GPS
-    let rx_pin = peripherals.GPIO8.degrade();
-    let tx_pin = peripherals.GPIO7.degrade();
-
     let uart_config = Config::default().baudrate(9600);
-    let uart = Uart::new_with_config(peripherals.UART0, uart_config, rx_pin, tx_pin)
+    let uart = Uart::new_with_config(pins.uart, uart_config, pins.uart_rx, pins.uart_tx)
         .unwrap()
         .into_async();
 
@@ -45,23 +83,20 @@ async fn main(_spawner: Spawner) -> () {
     _spawner.spawn(gps::sample_uart(rx)).unwrap();
 
     // Setup SPI bus
-    let spi_clock = peripherals.GPIO20.degrade();
-    let spi_miso = peripherals.GPIO21.degrade();
-    let spi_mosi = peripherals.GPIO1.degrade();
 
     let spi_bus = spi::init(
-        peripherals.DMA,
-        peripherals.SPI2,
-        spi_clock,
-        spi_mosi,
-        spi_miso,
+        pins.dma,
+        pins.spi,
+        pins.lora_clk,
+        pins.lora_mosi,
+        pins.lora_miso,
     );
 
-    let lora_spi_csb = Output::new(peripherals.GPIO0.degrade(), Level::High);
+    let lora_spi_csb = Output::new(pins.lora_nss, Level::High);
     let lora_spi = SpiDevice::new(spi_bus, lora_spi_csb);
 
-    let lora_rst = Output::new(peripherals.GPIO10.degrade(), Level::High);
-    let lora_irq = Input::new(peripherals.GPIO2.degrade(), Pull::Up);
+    let lora_rst = Output::new(pins.lora_rst, Level::High);
+    let lora_irq = Input::new(pins.lora_irq, Pull::Up);
 
     _spawner
         .spawn(lora::transmit(lora_spi, lora_irq, lora_rst))