Add lora-phy examples.

examples/stm32l0/src/bin/lora_cad.rs

@@ -0,0 +1,105 @@
+//! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
+//! It demonstrates LORA P2P CAD functionality.
+#![no_std]
+#![no_main]
+#![macro_use]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_lora::iv::Stm32l0InterfaceVariant;
+use embassy_stm32::exti::{Channel, ExtiInput};
+use embassy_stm32::gpio::{Input, Level, Output, Pin, Pull, Speed};
+use embassy_stm32::spi;
+use embassy_stm32::time::khz;
+use embassy_time::{Delay, Duration, Timer};
+use lora_phy::mod_params::*;
+use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
+use lora_phy::LoRa;
+use {defmt_rtt as _, panic_probe as _};
+
+const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI16;
+    config.rcc.enable_hsi48 = true;
+    let p = embassy_stm32::init(config);
+
+    // SPI for sx1276
+    let spi = spi::Spi::new(
+        p.SPI1,
+        p.PB3,
+        p.PA7,
+        p.PA6,
+        p.DMA1_CH3,
+        p.DMA1_CH2,
+        khz(200),
+        spi::Config::default(),
+    );
+
+    let nss = Output::new(p.PA15.degrade(), Level::High, Speed::Low);
+    let reset = Output::new(p.PC0.degrade(), Level::High, Speed::Low);
+
+    let irq_pin = Input::new(p.PB4.degrade(), Pull::Up);
+    let irq = ExtiInput::new(irq_pin, p.EXTI4.degrade());
+
+    let iv = Stm32l0InterfaceVariant::new(nss, reset, irq, None, None).unwrap();
+
+    let mut delay = Delay;
+
+    let mut lora = {
+        match LoRa::new(SX1276_7_8_9::new(BoardType::Stm32l0Sx1276, spi, iv), false, &mut delay).await {
+            Ok(l) => l,
+            Err(err) => {
+                info!("Radio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    let mut debug_indicator = Output::new(p.PB5, Level::Low, Speed::Low);
+    let mut start_indicator = Output::new(p.PB6, Level::Low, Speed::Low);
+
+    start_indicator.set_high();
+    Timer::after(Duration::from_secs(5)).await;
+    start_indicator.set_low();
+
+    let mdltn_params = {
+        match lora.create_modulation_params(
+            SpreadingFactor::_10,
+            Bandwidth::_250KHz,
+            CodingRate::_4_8,
+            LORA_FREQUENCY_IN_HZ,
+        ) {
+            Ok(mp) => mp,
+            Err(err) => {
+                info!("Radio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    match lora.prepare_for_cad(&mdltn_params, true).await {
+        Ok(()) => {}
+        Err(err) => {
+            info!("Radio error = {}", err);
+            return;
+        }
+    };
+
+    match lora.cad().await {
+        Ok(cad_activity_detected) => {
+            if cad_activity_detected {
+                info!("cad successful with activity detected")
+            } else {
+                info!("cad successful without activity detected")
+            }
+            debug_indicator.set_high();
+            Timer::after(Duration::from_secs(5)).await;
+            debug_indicator.set_low();
+        }
+        Err(err) => info!("cad unsuccessful = {}", err),
+    }
+}

examples/stm32l0/src/bin/lora_lorawan.rs

@@ -0,0 +1,88 @@
+//! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
+//! It demonstrates LoRaWAN join functionality.
+#![no_std]
+#![no_main]
+#![macro_use]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_lora::iv::Stm32l0InterfaceVariant;
+use embassy_lora::LoraTimer;
+use embassy_stm32::exti::{Channel, ExtiInput};
+use embassy_stm32::gpio::{Input, Level, Output, Pin, Pull, Speed};
+use embassy_stm32::rng::Rng;
+use embassy_stm32::spi;
+use embassy_stm32::time::khz;
+use embassy_time::Delay;
+use lora_phy::mod_params::*;
+use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
+use lora_phy::LoRa;
+use lorawan::default_crypto::DefaultFactory as Crypto;
+use lorawan_device::async_device::lora_radio::LoRaRadio;
+use lorawan_device::async_device::{region, Device, JoinMode};
+use {defmt_rtt as _, panic_probe as _};
+
+const LORAWAN_REGION: region::Region = region::Region::EU868; // warning: set this appropriately for the region
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI16;
+    config.rcc.enable_hsi48 = true;
+    let p = embassy_stm32::init(config);
+
+    // SPI for sx1276
+    let spi = spi::Spi::new(
+        p.SPI1,
+        p.PB3,
+        p.PA7,
+        p.PA6,
+        p.DMA1_CH3,
+        p.DMA1_CH2,
+        khz(200),
+        spi::Config::default(),
+    );
+
+    let nss = Output::new(p.PA15.degrade(), Level::High, Speed::Low);
+    let reset = Output::new(p.PC0.degrade(), Level::High, Speed::Low);
+
+    let irq_pin = Input::new(p.PB4.degrade(), Pull::Up);
+    let irq = ExtiInput::new(irq_pin, p.EXTI4.degrade());
+
+    let iv = Stm32l0InterfaceVariant::new(nss, reset, irq, None, None).unwrap();
+
+    let mut delay = Delay;
+
+    let lora = {
+        match LoRa::new(SX1276_7_8_9::new(BoardType::Stm32l0Sx1276, spi, iv), true, &mut delay).await {
+            Ok(l) => l,
+            Err(err) => {
+                info!("Radio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    let radio = LoRaRadio::new(lora);
+    let region: region::Configuration = region::Configuration::new(LORAWAN_REGION);
+    let mut device: Device<_, Crypto, _, _> = Device::new(region, radio, LoraTimer::new(), Rng::new(p.RNG));
+
+    defmt::info!("Joining LoRaWAN network");
+
+    // TODO: Adjust the EUI and Keys according to your network credentials
+    match device
+        .join(&JoinMode::OTAA {
+            deveui: [0, 0, 0, 0, 0, 0, 0, 0],
+            appeui: [0, 0, 0, 0, 0, 0, 0, 0],
+            appkey: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        })
+        .await
+    {
+        Ok(()) => defmt::info!("LoRaWAN network joined"),
+        Err(err) => {
+            info!("Radio error = {}", err);
+            return;
+        }
+    };
+}

examples/stm32l0/src/bin/lora_p2p_receive.rs

@@ -1,5 +1,5 @@
 //! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
-//! It demonstrates LORA P2P receive functionality.
+//! It demonstrates LORA P2P receive functionality in conjunction with the lora_p2p_send example.
 #![no_std]
 #![no_main]
 #![macro_use]
@@ -18,6 +18,8 @@ use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
 use lora_phy::LoRa;
 use {defmt_rtt as _, panic_probe as _};
 
+const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
+
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
     let mut config = embassy_stm32::Config::default();
@@ -67,7 +69,12 @@ async fn main(_spawner: Spawner) {
     let mut receiving_buffer = [00u8; 100];
 
     let mdltn_params = {
-        match lora.create_modulation_params(SpreadingFactor::_10, Bandwidth::_250KHz, CodingRate::_4_8, 903900000) {
+        match lora.create_modulation_params(
+            SpreadingFactor::_10,
+            Bandwidth::_250KHz,
+            CodingRate::_4_8,
+            LORA_FREQUENCY_IN_HZ,
+        ) {
             Ok(mp) => mp,
             Err(err) => {
                 info!("Radio error = {}", err);

examples/stm32l0/src/bin/lora_p2p_send.rs

@@ -0,0 +1,110 @@
+//! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
+//! It demonstrates LORA P2P send functionality.
+#![no_std]
+#![no_main]
+#![macro_use]
+#![feature(type_alias_impl_trait)]
+
+use defmt::*;
+use embassy_executor::Spawner;
+use embassy_lora::iv::Stm32l0InterfaceVariant;
+use embassy_stm32::exti::{Channel, ExtiInput};
+use embassy_stm32::gpio::{Input, Level, Output, Pin, Pull, Speed};
+use embassy_stm32::spi;
+use embassy_stm32::time::khz;
+use embassy_time::Delay;
+use lora_phy::mod_params::*;
+use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
+use lora_phy::LoRa;
+use {defmt_rtt as _, panic_probe as _};
+
+const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let mut config = embassy_stm32::Config::default();
+    config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI16;
+    config.rcc.enable_hsi48 = true;
+    let p = embassy_stm32::init(config);
+
+    // SPI for sx1276
+    let spi = spi::Spi::new(
+        p.SPI1,
+        p.PB3,
+        p.PA7,
+        p.PA6,
+        p.DMA1_CH3,
+        p.DMA1_CH2,
+        khz(200),
+        spi::Config::default(),
+    );
+
+    let nss = Output::new(p.PA15.degrade(), Level::High, Speed::Low);
+    let reset = Output::new(p.PC0.degrade(), Level::High, Speed::Low);
+
+    let irq_pin = Input::new(p.PB4.degrade(), Pull::Up);
+    let irq = ExtiInput::new(irq_pin, p.EXTI4.degrade());
+
+    let iv = Stm32l0InterfaceVariant::new(nss, reset, irq, None, None).unwrap();
+
+    let mut delay = Delay;
+
+    let mut lora = {
+        match LoRa::new(SX1276_7_8_9::new(BoardType::Stm32l0Sx1276, spi, iv), false, &mut delay).await {
+            Ok(l) => l,
+            Err(err) => {
+                info!("Radio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    let mdltn_params = {
+        match lora.create_modulation_params(
+            SpreadingFactor::_10,
+            Bandwidth::_250KHz,
+            CodingRate::_4_8,
+            LORA_FREQUENCY_IN_HZ,
+        ) {
+            Ok(mp) => mp,
+            Err(err) => {
+                info!("Radio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    let mut tx_pkt_params = {
+        match lora.create_tx_packet_params(4, false, true, false, &mdltn_params) {
+            Ok(pp) => pp,
+            Err(err) => {
+                info!("Radio error = {}", err);
+                return;
+            }
+        }
+    };
+
+    match lora.prepare_for_tx(&mdltn_params, 17, true).await {
+        Ok(()) => {}
+        Err(err) => {
+            info!("Radio error = {}", err);
+            return;
+        }
+    };
+
+    let buffer = [0x01u8, 0x02u8, 0x03u8];
+    match lora.tx(&mdltn_params, &mut tx_pkt_params, &buffer, 0xffffff).await {
+        Ok(()) => {
+            info!("TX DONE");
+        }
+        Err(err) => {
+            info!("Radio error = {}", err);
+            return;
+        }
+    };
+
+    match lora.sleep(&mut delay).await {
+        Ok(()) => info!("Sleep successful"),
+        Err(err) => info!("Sleep unsuccessful = {}", err),
+    }
+}

examples/stm32l0/src/bin/lorawan.rs

@@ -1,74 +0,0 @@
-//! This example runs on the STM32 LoRa Discovery board which has a builtin Semtech Sx127x radio
-#![no_std]
-#![no_main]
-#![macro_use]
-#![allow(dead_code)]
-#![feature(type_alias_impl_trait)]
-
-use embassy_executor::Spawner;
-use embassy_lora::sx127x::*;
-use embassy_lora::LoraTimer;
-use embassy_stm32::exti::ExtiInput;
-use embassy_stm32::gpio::{Input, Level, Output, Pull, Speed};
-use embassy_stm32::rng::Rng;
-use embassy_stm32::spi;
-use embassy_stm32::time::khz;
-use lorawan::default_crypto::DefaultFactory as Crypto;
-use lorawan_device::async_device::{region, Device, JoinMode};
-use {defmt_rtt as _, panic_probe as _};
-
-#[embassy_executor::main]
-async fn main(_spawner: Spawner) {
-    let mut config = embassy_stm32::Config::default();
-    config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI16;
-    config.rcc.enable_hsi48 = true;
-    let p = embassy_stm32::init(config);
-
-    // SPI for sx127x
-    let spi = spi::Spi::new(
-        p.SPI1,
-        p.PB3,
-        p.PA7,
-        p.PA6,
-        p.DMA1_CH3,
-        p.DMA1_CH2,
-        khz(200),
-        spi::Config::default(),
-    );
-
-    let cs = Output::new(p.PA15, Level::High, Speed::Low);
-    let reset = Output::new(p.PC0, Level::High, Speed::Low);
-    let _ = Input::new(p.PB1, Pull::None);
-
-    let ready = Input::new(p.PB4, Pull::Up);
-    let ready_pin = ExtiInput::new(ready, p.EXTI4);
-
-    let radio = Sx127xRadio::new(spi, cs, reset, ready_pin, DummySwitch).await.unwrap();
-
-    let region = region::Configuration::new(region::Region::EU868);
-    let mut device: Device<_, Crypto, _, _> = Device::new(region, radio, LoraTimer::new(), Rng::new(p.RNG));
-
-    defmt::info!("Joining LoRaWAN network");
-
-    // TODO: Adjust the EUI and Keys according to your network credentials
-    device
-        .join(&JoinMode::OTAA {
-            deveui: [0, 0, 0, 0, 0, 0, 0, 0],
-            appeui: [0, 0, 0, 0, 0, 0, 0, 0],
-            appkey: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        })
-        .await
-        .ok()
-        .unwrap();
-    defmt::info!("LoRaWAN network joined");
-
-    defmt::info!("Sending 'PING'");
-    device.send(b"PING", 1, false).await.ok().unwrap();
-    defmt::info!("Message sent!");
-}
-
-pub struct DummySwitch;
-impl RadioSwitch for DummySwitch {
-    fn set_rx(&mut self) {}
-    fn set_tx(&mut self) {}
-}