aboutsummaryrefslogtreecommitdiff
path: root/examples/stm32l0/src/bin
diff options
context:
space:
mode:
authorDario Nieuwenhuis <[email protected]>2023-11-29 16:26:31 +0100
committerDario Nieuwenhuis <[email protected]>2023-11-29 16:26:31 +0100
commit1b9925e3da0ec42b770f736cd22325203c97cb47 (patch)
tree2b03eb826cd9a9fce945921cff9c04a7e59f98f1 /examples/stm32l0/src/bin
parentb4bc9ac028568dfb3896dfb00cbd1e181863fd64 (diff)
Move embassy-lora, lora examples to lora-phy repo.
Diffstat (limited to 'examples/stm32l0/src/bin')
-rw-r--r--examples/stm32l0/src/bin/lora_cad.rs97
-rw-r--r--examples/stm32l0/src/bin/lora_lorawan.rs85
-rw-r--r--examples/stm32l0/src/bin/lora_p2p_receive.rs119
-rw-r--r--examples/stm32l0/src/bin/lora_p2p_send.rs102
4 files changed, 0 insertions, 403 deletions
diff --git a/examples/stm32l0/src/bin/lora_cad.rs b/examples/stm32l0/src/bin/lora_cad.rs
deleted file mode 100644
index 8ca9e8b22..000000000
--- a/examples/stm32l0/src/bin/lora_cad.rs
+++ /dev/null
@@ -1,97 +0,0 @@
1//! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
2//! It demonstrates LORA P2P CAD functionality.
3#![no_std]
4#![no_main]
5#![macro_use]
6#![feature(type_alias_impl_trait)]
7
8use defmt::*;
9use embassy_executor::Spawner;
10use embassy_lora::iv::Stm32l0InterfaceVariant;
11use embassy_stm32::exti::{Channel, ExtiInput};
12use embassy_stm32::gpio::{Input, Level, Output, Pin, Pull, Speed};
13use embassy_stm32::spi;
14use embassy_stm32::time::khz;
15use embassy_time::{Delay, Timer};
16use lora_phy::mod_params::*;
17use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
18use lora_phy::LoRa;
19use {defmt_rtt as _, panic_probe as _};
20
21const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
22
23#[embassy_executor::main]
24async fn main(_spawner: Spawner) {
25 let mut config = embassy_stm32::Config::default();
26 config.rcc.hsi = true;
27 config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI;
28 let p = embassy_stm32::init(config);
29
30 let mut spi_config = spi::Config::default();
31 spi_config.frequency = khz(200);
32
33 // SPI for sx1276
34 let spi = spi::Spi::new(p.SPI1, p.PB3, p.PA7, p.PA6, p.DMA1_CH3, p.DMA1_CH2, spi_config);
35
36 let nss = Output::new(p.PA15.degrade(), Level::High, Speed::Low);
37 let reset = Output::new(p.PC0.degrade(), Level::High, Speed::Low);
38
39 let irq_pin = Input::new(p.PB4.degrade(), Pull::Up);
40 let irq = ExtiInput::new(irq_pin, p.EXTI4.degrade());
41
42 let iv = Stm32l0InterfaceVariant::new(nss, reset, irq, None, None).unwrap();
43
44 let mut lora = {
45 match LoRa::new(SX1276_7_8_9::new(BoardType::Stm32l0Sx1276, spi, iv), false, Delay).await {
46 Ok(l) => l,
47 Err(err) => {
48 info!("Radio error = {}", err);
49 return;
50 }
51 }
52 };
53
54 let mut debug_indicator = Output::new(p.PB5, Level::Low, Speed::Low);
55 let mut start_indicator = Output::new(p.PB6, Level::Low, Speed::Low);
56
57 start_indicator.set_high();
58 Timer::after_secs(5).await;
59 start_indicator.set_low();
60
61 let mdltn_params = {
62 match lora.create_modulation_params(
63 SpreadingFactor::_10,
64 Bandwidth::_250KHz,
65 CodingRate::_4_8,
66 LORA_FREQUENCY_IN_HZ,
67 ) {
68 Ok(mp) => mp,
69 Err(err) => {
70 info!("Radio error = {}", err);
71 return;
72 }
73 }
74 };
75
76 match lora.prepare_for_cad(&mdltn_params, true).await {
77 Ok(()) => {}
78 Err(err) => {
79 info!("Radio error = {}", err);
80 return;
81 }
82 };
83
84 match lora.cad().await {
85 Ok(cad_activity_detected) => {
86 if cad_activity_detected {
87 info!("cad successful with activity detected")
88 } else {
89 info!("cad successful without activity detected")
90 }
91 debug_indicator.set_high();
92 Timer::after_secs(5).await;
93 debug_indicator.set_low();
94 }
95 Err(err) => info!("cad unsuccessful = {}", err),
96 }
97}
diff --git a/examples/stm32l0/src/bin/lora_lorawan.rs b/examples/stm32l0/src/bin/lora_lorawan.rs
deleted file mode 100644
index 4365c4cf6..000000000
--- a/examples/stm32l0/src/bin/lora_lorawan.rs
+++ /dev/null
@@ -1,85 +0,0 @@
1//! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
2//! It demonstrates LoRaWAN join functionality.
3#![no_std]
4#![no_main]
5#![macro_use]
6#![feature(type_alias_impl_trait)]
7
8use defmt::*;
9use embassy_executor::Spawner;
10use embassy_lora::iv::Stm32l0InterfaceVariant;
11use embassy_lora::LoraTimer;
12use embassy_stm32::exti::{Channel, ExtiInput};
13use embassy_stm32::gpio::{Input, Level, Output, Pin, Pull, Speed};
14use embassy_stm32::rng::Rng;
15use embassy_stm32::time::khz;
16use embassy_stm32::{bind_interrupts, peripherals, rng, spi};
17use embassy_time::Delay;
18use lora_phy::mod_params::*;
19use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
20use lora_phy::LoRa;
21use lorawan::default_crypto::DefaultFactory as Crypto;
22use lorawan_device::async_device::lora_radio::LoRaRadio;
23use lorawan_device::async_device::{region, Device, JoinMode};
24use lorawan_device::{AppEui, AppKey, DevEui};
25use {defmt_rtt as _, panic_probe as _};
26
27bind_interrupts!(struct Irqs {
28 RNG_LPUART1 => rng::InterruptHandler<peripherals::RNG>;
29});
30
31const LORAWAN_REGION: region::Region = region::Region::EU868; // warning: set this appropriately for the region
32
33#[embassy_executor::main]
34async fn main(_spawner: Spawner) {
35 let mut config = embassy_stm32::Config::default();
36 config.rcc.hsi = true;
37 config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI;
38 let p = embassy_stm32::init(config);
39
40 let mut spi_config = spi::Config::default();
41 spi_config.frequency = khz(200);
42
43 // SPI for sx1276
44 let spi = spi::Spi::new(p.SPI1, p.PB3, p.PA7, p.PA6, p.DMA1_CH3, p.DMA1_CH2, spi_config);
45
46 let nss = Output::new(p.PA15.degrade(), Level::High, Speed::Low);
47 let reset = Output::new(p.PC0.degrade(), Level::High, Speed::Low);
48
49 let irq_pin = Input::new(p.PB4.degrade(), Pull::Up);
50 let irq = ExtiInput::new(irq_pin, p.EXTI4.degrade());
51
52 let iv = Stm32l0InterfaceVariant::new(nss, reset, irq, None, None).unwrap();
53
54 let lora = {
55 match LoRa::new(SX1276_7_8_9::new(BoardType::Stm32l0Sx1276, spi, iv), true, Delay).await {
56 Ok(l) => l,
57 Err(err) => {
58 info!("Radio error = {}", err);
59 return;
60 }
61 }
62 };
63
64 let radio = LoRaRadio::new(lora);
65 let region: region::Configuration = region::Configuration::new(LORAWAN_REGION);
66 let mut device: Device<_, Crypto, _, _> = Device::new(region, radio, LoraTimer::new(), Rng::new(p.RNG, Irqs));
67
68 defmt::info!("Joining LoRaWAN network");
69
70 // TODO: Adjust the EUI and Keys according to your network credentials
71 match device
72 .join(&JoinMode::OTAA {
73 deveui: DevEui::from([0, 0, 0, 0, 0, 0, 0, 0]),
74 appeui: AppEui::from([0, 0, 0, 0, 0, 0, 0, 0]),
75 appkey: AppKey::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
76 })
77 .await
78 {
79 Ok(()) => defmt::info!("LoRaWAN network joined"),
80 Err(err) => {
81 info!("Radio error = {}", err);
82 return;
83 }
84 };
85}
diff --git a/examples/stm32l0/src/bin/lora_p2p_receive.rs b/examples/stm32l0/src/bin/lora_p2p_receive.rs
deleted file mode 100644
index 0627ac087..000000000
--- a/examples/stm32l0/src/bin/lora_p2p_receive.rs
+++ /dev/null
@@ -1,119 +0,0 @@
1//! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
2//! It demonstrates LORA P2P receive functionality in conjunction with the lora_p2p_send example.
3#![no_std]
4#![no_main]
5#![macro_use]
6#![feature(type_alias_impl_trait)]
7
8use defmt::*;
9use embassy_executor::Spawner;
10use embassy_lora::iv::Stm32l0InterfaceVariant;
11use embassy_stm32::exti::{Channel, ExtiInput};
12use embassy_stm32::gpio::{Input, Level, Output, Pin, Pull, Speed};
13use embassy_stm32::spi;
14use embassy_stm32::time::khz;
15use embassy_time::{Delay, Timer};
16use lora_phy::mod_params::*;
17use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
18use lora_phy::LoRa;
19use {defmt_rtt as _, panic_probe as _};
20
21const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
22
23#[embassy_executor::main]
24async fn main(_spawner: Spawner) {
25 let mut config = embassy_stm32::Config::default();
26 config.rcc.hsi = true;
27 config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI;
28 let p = embassy_stm32::init(config);
29
30 let mut spi_config = spi::Config::default();
31 spi_config.frequency = khz(200);
32
33 // SPI for sx1276
34 let spi = spi::Spi::new(p.SPI1, p.PB3, p.PA7, p.PA6, p.DMA1_CH3, p.DMA1_CH2, spi_config);
35
36 let nss = Output::new(p.PA15.degrade(), Level::High, Speed::Low);
37 let reset = Output::new(p.PC0.degrade(), Level::High, Speed::Low);
38
39 let irq_pin = Input::new(p.PB4.degrade(), Pull::Up);
40 let irq = ExtiInput::new(irq_pin, p.EXTI4.degrade());
41
42 let iv = Stm32l0InterfaceVariant::new(nss, reset, irq, None, None).unwrap();
43
44 let mut lora = {
45 match LoRa::new(SX1276_7_8_9::new(BoardType::Stm32l0Sx1276, spi, iv), false, Delay).await {
46 Ok(l) => l,
47 Err(err) => {
48 info!("Radio error = {}", err);
49 return;
50 }
51 }
52 };
53
54 let mut debug_indicator = Output::new(p.PB5, Level::Low, Speed::Low);
55 let mut start_indicator = Output::new(p.PB6, Level::Low, Speed::Low);
56
57 start_indicator.set_high();
58 Timer::after_secs(5).await;
59 start_indicator.set_low();
60
61 let mut receiving_buffer = [00u8; 100];
62
63 let mdltn_params = {
64 match lora.create_modulation_params(
65 SpreadingFactor::_10,
66 Bandwidth::_250KHz,
67 CodingRate::_4_8,
68 LORA_FREQUENCY_IN_HZ,
69 ) {
70 Ok(mp) => mp,
71 Err(err) => {
72 info!("Radio error = {}", err);
73 return;
74 }
75 }
76 };
77
78 let rx_pkt_params = {
79 match lora.create_rx_packet_params(4, false, receiving_buffer.len() as u8, true, false, &mdltn_params) {
80 Ok(pp) => pp,
81 Err(err) => {
82 info!("Radio error = {}", err);
83 return;
84 }
85 }
86 };
87
88 match lora
89 .prepare_for_rx(&mdltn_params, &rx_pkt_params, None, None, false)
90 .await
91 {
92 Ok(()) => {}
93 Err(err) => {
94 info!("Radio error = {}", err);
95 return;
96 }
97 };
98
99 loop {
100 receiving_buffer = [00u8; 100];
101 match lora.rx(&rx_pkt_params, &mut receiving_buffer).await {
102 Ok((received_len, _rx_pkt_status)) => {
103 if (received_len == 3)
104 && (receiving_buffer[0] == 0x01u8)
105 && (receiving_buffer[1] == 0x02u8)
106 && (receiving_buffer[2] == 0x03u8)
107 {
108 info!("rx successful");
109 debug_indicator.set_high();
110 Timer::after_secs(5).await;
111 debug_indicator.set_low();
112 } else {
113 info!("rx unknown packet");
114 }
115 }
116 Err(err) => info!("rx unsuccessful = {}", err),
117 }
118 }
119}
diff --git a/examples/stm32l0/src/bin/lora_p2p_send.rs b/examples/stm32l0/src/bin/lora_p2p_send.rs
deleted file mode 100644
index 4f12cadc8..000000000
--- a/examples/stm32l0/src/bin/lora_p2p_send.rs
+++ /dev/null
@@ -1,102 +0,0 @@
1//! This example runs on the STM32 LoRa Discovery board, which has a builtin Semtech Sx1276 radio.
2//! It demonstrates LORA P2P send functionality.
3#![no_std]
4#![no_main]
5#![macro_use]
6#![feature(type_alias_impl_trait)]
7
8use defmt::*;
9use embassy_executor::Spawner;
10use embassy_lora::iv::Stm32l0InterfaceVariant;
11use embassy_stm32::exti::{Channel, ExtiInput};
12use embassy_stm32::gpio::{Input, Level, Output, Pin, Pull, Speed};
13use embassy_stm32::spi;
14use embassy_stm32::time::khz;
15use embassy_time::Delay;
16use lora_phy::mod_params::*;
17use lora_phy::sx1276_7_8_9::SX1276_7_8_9;
18use lora_phy::LoRa;
19use {defmt_rtt as _, panic_probe as _};
20
21const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
22
23#[embassy_executor::main]
24async fn main(_spawner: Spawner) {
25 let mut config = embassy_stm32::Config::default();
26 config.rcc.hsi = true;
27 config.rcc.mux = embassy_stm32::rcc::ClockSrc::HSI;
28 let p = embassy_stm32::init(config);
29
30 let mut spi_config = spi::Config::default();
31 spi_config.frequency = khz(200);
32
33 // SPI for sx1276
34 let spi = spi::Spi::new(p.SPI1, p.PB3, p.PA7, p.PA6, p.DMA1_CH3, p.DMA1_CH2, spi_config);
35
36 let nss = Output::new(p.PA15.degrade(), Level::High, Speed::Low);
37 let reset = Output::new(p.PC0.degrade(), Level::High, Speed::Low);
38
39 let irq_pin = Input::new(p.PB4.degrade(), Pull::Up);
40 let irq = ExtiInput::new(irq_pin, p.EXTI4.degrade());
41
42 let iv = Stm32l0InterfaceVariant::new(nss, reset, irq, None, None).unwrap();
43
44 let mut lora = {
45 match LoRa::new(SX1276_7_8_9::new(BoardType::Stm32l0Sx1276, spi, iv), false, Delay).await {
46 Ok(l) => l,
47 Err(err) => {
48 info!("Radio error = {}", err);
49 return;
50 }
51 }
52 };
53
54 let mdltn_params = {
55 match lora.create_modulation_params(
56 SpreadingFactor::_10,
57 Bandwidth::_250KHz,
58 CodingRate::_4_8,
59 LORA_FREQUENCY_IN_HZ,
60 ) {
61 Ok(mp) => mp,
62 Err(err) => {
63 info!("Radio error = {}", err);
64 return;
65 }
66 }
67 };
68
69 let mut tx_pkt_params = {
70 match lora.create_tx_packet_params(4, false, true, false, &mdltn_params) {
71 Ok(pp) => pp,
72 Err(err) => {
73 info!("Radio error = {}", err);
74 return;
75 }
76 }
77 };
78
79 match lora.prepare_for_tx(&mdltn_params, 17, true).await {
80 Ok(()) => {}
81 Err(err) => {
82 info!("Radio error = {}", err);
83 return;
84 }
85 };
86
87 let buffer = [0x01u8, 0x02u8, 0x03u8];
88 match lora.tx(&mdltn_params, &mut tx_pkt_params, &buffer, 0xffffff).await {
89 Ok(()) => {
90 info!("TX DONE");
91 }
92 Err(err) => {
93 info!("Radio error = {}", err);
94 return;
95 }
96 };
97
98 match lora.sleep(false).await {
99 Ok(()) => info!("Sleep successful"),
100 Err(err) => info!("Sleep unsuccessful = {}", err),
101 }
102}
generated by cgit (git 2.34.1) at 2026-04-05 23:37:36 +0000