aboutsummaryrefslogtreecommitdiff
path: root/examples/rp/src/bin
diff options
context:
space:
mode:
Diffstat (limited to 'examples/rp/src/bin')
-rw-r--r--examples/rp/src/bin/lora_lorawan.rs74
-rw-r--r--examples/rp/src/bin/lora_p2p_receive.rs108
-rw-r--r--examples/rp/src/bin/lora_p2p_send.rs96
-rw-r--r--examples/rp/src/bin/lora_p2p_send_multicore.rs133
4 files changed, 0 insertions, 411 deletions
diff --git a/examples/rp/src/bin/lora_lorawan.rs b/examples/rp/src/bin/lora_lorawan.rs
deleted file mode 100644
index e7e81863e..000000000
--- a/examples/rp/src/bin/lora_lorawan.rs
+++ /dev/null
@@ -1,74 +0,0 @@
1//! This example runs on the Raspberry Pi Pico with a Waveshare board containing a Semtech Sx1262 radio.
2//! It demonstrates LoRaWAN join functionality.
3
4#![no_std]
5#![no_main]
6#![macro_use]
7#![feature(type_alias_impl_trait)]
8
9use defmt::*;
10use embassy_executor::Spawner;
11use embassy_lora::iv::GenericSx126xInterfaceVariant;
12use embassy_lora::LoraTimer;
13use embassy_rp::gpio::{Input, Level, Output, Pin, Pull};
14use embassy_rp::spi::{Config, Spi};
15use embassy_time::Delay;
16use lora_phy::mod_params::*;
17use lora_phy::sx1261_2::SX1261_2;
18use lora_phy::LoRa;
19use lorawan::default_crypto::DefaultFactory as Crypto;
20use lorawan_device::async_device::lora_radio::LoRaRadio;
21use lorawan_device::async_device::{region, Device, JoinMode};
22use lorawan_device::{AppEui, AppKey, DevEui};
23use {defmt_rtt as _, panic_probe as _};
24
25const LORAWAN_REGION: region::Region = region::Region::EU868; // warning: set this appropriately for the region
26
27#[embassy_executor::main]
28async fn main(_spawner: Spawner) {
29 let p = embassy_rp::init(Default::default());
30
31 let miso = p.PIN_12;
32 let mosi = p.PIN_11;
33 let clk = p.PIN_10;
34 let spi = Spi::new(p.SPI1, clk, mosi, miso, p.DMA_CH0, p.DMA_CH1, Config::default());
35
36 let nss = Output::new(p.PIN_3.degrade(), Level::High);
37 let reset = Output::new(p.PIN_15.degrade(), Level::High);
38 let dio1 = Input::new(p.PIN_20.degrade(), Pull::None);
39 let busy = Input::new(p.PIN_2.degrade(), Pull::None);
40
41 let iv = GenericSx126xInterfaceVariant::new(nss, reset, dio1, busy, None, None).unwrap();
42
43 let lora = {
44 match LoRa::new(SX1261_2::new(BoardType::RpPicoWaveshareSx1262, spi, iv), true, Delay).await {
45 Ok(l) => l,
46 Err(err) => {
47 info!("Radio error = {}", err);
48 return;
49 }
50 }
51 };
52
53 let radio = LoRaRadio::new(lora);
54 let region: region::Configuration = region::Configuration::new(LORAWAN_REGION);
55 let mut device: Device<_, Crypto, _, _> = Device::new(region, radio, LoraTimer::new(), embassy_rp::clocks::RoscRng);
56
57 defmt::info!("Joining LoRaWAN network");
58
59 // TODO: Adjust the EUI and Keys according to your network credentials
60 match device
61 .join(&JoinMode::OTAA {
62 deveui: DevEui::from([0, 0, 0, 0, 0, 0, 0, 0]),
63 appeui: AppEui::from([0, 0, 0, 0, 0, 0, 0, 0]),
64 appkey: AppKey::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
65 })
66 .await
67 {
68 Ok(()) => defmt::info!("LoRaWAN network joined"),
69 Err(err) => {
70 info!("Radio error = {}", err);
71 return;
72 }
73 };
74}
diff --git a/examples/rp/src/bin/lora_p2p_receive.rs b/examples/rp/src/bin/lora_p2p_receive.rs
deleted file mode 100644
index d5843fdcd..000000000
--- a/examples/rp/src/bin/lora_p2p_receive.rs
+++ /dev/null
@@ -1,108 +0,0 @@
1//! This example runs on the Raspberry Pi Pico with a Waveshare board containing a Semtech Sx1262 radio.
2//! It demonstrates LORA P2P receive functionality in conjunction with the lora_p2p_send example.
3
4#![no_std]
5#![no_main]
6#![macro_use]
7#![feature(type_alias_impl_trait)]
8
9use defmt::*;
10use embassy_executor::Spawner;
11use embassy_lora::iv::GenericSx126xInterfaceVariant;
12use embassy_rp::gpio::{Input, Level, Output, Pin, Pull};
13use embassy_rp::spi::{Config, Spi};
14use embassy_time::{Delay, Timer};
15use lora_phy::mod_params::*;
16use lora_phy::sx1261_2::SX1261_2;
17use lora_phy::LoRa;
18use {defmt_rtt as _, panic_probe as _};
19
20const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
21
22#[embassy_executor::main]
23async fn main(_spawner: Spawner) {
24 let p = embassy_rp::init(Default::default());
25
26 let miso = p.PIN_12;
27 let mosi = p.PIN_11;
28 let clk = p.PIN_10;
29 let spi = Spi::new(p.SPI1, clk, mosi, miso, p.DMA_CH0, p.DMA_CH1, Config::default());
30
31 let nss = Output::new(p.PIN_3.degrade(), Level::High);
32 let reset = Output::new(p.PIN_15.degrade(), Level::High);
33 let dio1 = Input::new(p.PIN_20.degrade(), Pull::None);
34 let busy = Input::new(p.PIN_2.degrade(), Pull::None);
35
36 let iv = GenericSx126xInterfaceVariant::new(nss, reset, dio1, busy, None, None).unwrap();
37
38 let mut lora = {
39 match LoRa::new(SX1261_2::new(BoardType::RpPicoWaveshareSx1262, spi, iv), false, Delay).await {
40 Ok(l) => l,
41 Err(err) => {
42 info!("Radio error = {}", err);
43 return;
44 }
45 }
46 };
47
48 let mut debug_indicator = Output::new(p.PIN_25, Level::Low);
49
50 let mut receiving_buffer = [00u8; 100];
51
52 let mdltn_params = {
53 match lora.create_modulation_params(
54 SpreadingFactor::_10,
55 Bandwidth::_250KHz,
56 CodingRate::_4_8,
57 LORA_FREQUENCY_IN_HZ,
58 ) {
59 Ok(mp) => mp,
60 Err(err) => {
61 info!("Radio error = {}", err);
62 return;
63 }
64 }
65 };
66
67 let rx_pkt_params = {
68 match lora.create_rx_packet_params(4, false, receiving_buffer.len() as u8, true, false, &mdltn_params) {
69 Ok(pp) => pp,
70 Err(err) => {
71 info!("Radio error = {}", err);
72 return;
73 }
74 }
75 };
76
77 match lora
78 .prepare_for_rx(&mdltn_params, &rx_pkt_params, None, None, false)
79 .await
80 {
81 Ok(()) => {}
82 Err(err) => {
83 info!("Radio error = {}", err);
84 return;
85 }
86 };
87
88 loop {
89 receiving_buffer = [00u8; 100];
90 match lora.rx(&rx_pkt_params, &mut receiving_buffer).await {
91 Ok((received_len, _rx_pkt_status)) => {
92 if (received_len == 3)
93 && (receiving_buffer[0] == 0x01u8)
94 && (receiving_buffer[1] == 0x02u8)
95 && (receiving_buffer[2] == 0x03u8)
96 {
97 info!("rx successful");
98 debug_indicator.set_high();
99 Timer::after_secs(5).await;
100 debug_indicator.set_low();
101 } else {
102 info!("rx unknown packet");
103 }
104 }
105 Err(err) => info!("rx unsuccessful = {}", err),
106 }
107 }
108}
diff --git a/examples/rp/src/bin/lora_p2p_send.rs b/examples/rp/src/bin/lora_p2p_send.rs
deleted file mode 100644
index 94bdb4e92..000000000
--- a/examples/rp/src/bin/lora_p2p_send.rs
+++ /dev/null
@@ -1,96 +0,0 @@
1//! This example runs on the Raspberry Pi Pico with a Waveshare board containing a Semtech Sx1262 radio.
2//! It demonstrates LORA P2P send functionality.
3
4#![no_std]
5#![no_main]
6#![macro_use]
7#![feature(type_alias_impl_trait)]
8
9use defmt::*;
10use embassy_executor::Spawner;
11use embassy_lora::iv::GenericSx126xInterfaceVariant;
12use embassy_rp::gpio::{Input, Level, Output, Pin, Pull};
13use embassy_rp::spi::{Config, Spi};
14use embassy_time::Delay;
15use lora_phy::mod_params::*;
16use lora_phy::sx1261_2::SX1261_2;
17use lora_phy::LoRa;
18use {defmt_rtt as _, panic_probe as _};
19
20const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
21
22#[embassy_executor::main]
23async fn main(_spawner: Spawner) {
24 let p = embassy_rp::init(Default::default());
25
26 let miso = p.PIN_12;
27 let mosi = p.PIN_11;
28 let clk = p.PIN_10;
29 let spi = Spi::new(p.SPI1, clk, mosi, miso, p.DMA_CH0, p.DMA_CH1, Config::default());
30
31 let nss = Output::new(p.PIN_3.degrade(), Level::High);
32 let reset = Output::new(p.PIN_15.degrade(), Level::High);
33 let dio1 = Input::new(p.PIN_20.degrade(), Pull::None);
34 let busy = Input::new(p.PIN_2.degrade(), Pull::None);
35
36 let iv = GenericSx126xInterfaceVariant::new(nss, reset, dio1, busy, None, None).unwrap();
37
38 let mut lora = {
39 match LoRa::new(SX1261_2::new(BoardType::RpPicoWaveshareSx1262, spi, iv), false, Delay).await {
40 Ok(l) => l,
41 Err(err) => {
42 info!("Radio error = {}", err);
43 return;
44 }
45 }
46 };
47
48 let mdltn_params = {
49 match lora.create_modulation_params(
50 SpreadingFactor::_10,
51 Bandwidth::_250KHz,
52 CodingRate::_4_8,
53 LORA_FREQUENCY_IN_HZ,
54 ) {
55 Ok(mp) => mp,
56 Err(err) => {
57 info!("Radio error = {}", err);
58 return;
59 }
60 }
61 };
62
63 let mut tx_pkt_params = {
64 match lora.create_tx_packet_params(4, false, true, false, &mdltn_params) {
65 Ok(pp) => pp,
66 Err(err) => {
67 info!("Radio error = {}", err);
68 return;
69 }
70 }
71 };
72
73 match lora.prepare_for_tx(&mdltn_params, 20, false).await {
74 Ok(()) => {}
75 Err(err) => {
76 info!("Radio error = {}", err);
77 return;
78 }
79 };
80
81 let buffer = [0x01u8, 0x02u8, 0x03u8];
82 match lora.tx(&mdltn_params, &mut tx_pkt_params, &buffer, 0xffffff).await {
83 Ok(()) => {
84 info!("TX DONE");
85 }
86 Err(err) => {
87 info!("Radio error = {}", err);
88 return;
89 }
90 };
91
92 match lora.sleep(false).await {
93 Ok(()) => info!("Sleep successful"),
94 Err(err) => info!("Sleep unsuccessful = {}", err),
95 }
96}
diff --git a/examples/rp/src/bin/lora_p2p_send_multicore.rs b/examples/rp/src/bin/lora_p2p_send_multicore.rs
deleted file mode 100644
index ccf44987c..000000000
--- a/examples/rp/src/bin/lora_p2p_send_multicore.rs
+++ /dev/null
@@ -1,133 +0,0 @@
1//! This example runs on the Raspberry Pi Pico with a Waveshare board containing a Semtech Sx1262 radio.
2//! It demonstrates LORA P2P send functionality using the second core, with data provided by the first core.
3
4#![no_std]
5#![no_main]
6#![macro_use]
7#![feature(type_alias_impl_trait)]
8
9use defmt::*;
10use embassy_executor::Executor;
11use embassy_lora::iv::GenericSx126xInterfaceVariant;
12use embassy_rp::gpio::{AnyPin, Input, Level, Output, Pin, Pull};
13use embassy_rp::multicore::{spawn_core1, Stack};
14use embassy_rp::peripherals::SPI1;
15use embassy_rp::spi::{Async, Config, Spi};
16use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
17use embassy_sync::channel::Channel;
18use embassy_time::{Delay, Timer};
19use lora_phy::mod_params::*;
20use lora_phy::sx1261_2::SX1261_2;
21use lora_phy::LoRa;
22use static_cell::StaticCell;
23use {defmt_rtt as _, panic_probe as _};
24
25static mut CORE1_STACK: Stack<4096> = Stack::new();
26static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
27static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
28static CHANNEL: Channel<CriticalSectionRawMutex, [u8; 3], 1> = Channel::new();
29
30const LORA_FREQUENCY_IN_HZ: u32 = 903_900_000; // warning: set this appropriately for the region
31
32#[cortex_m_rt::entry]
33fn main() -> ! {
34 let p = embassy_rp::init(Default::default());
35
36 let miso = p.PIN_12;
37 let mosi = p.PIN_11;
38 let clk = p.PIN_10;
39 let spi = Spi::new(p.SPI1, clk, mosi, miso, p.DMA_CH0, p.DMA_CH1, Config::default());
40
41 let nss = Output::new(p.PIN_3.degrade(), Level::High);
42 let reset = Output::new(p.PIN_15.degrade(), Level::High);
43 let dio1 = Input::new(p.PIN_20.degrade(), Pull::None);
44 let busy = Input::new(p.PIN_2.degrade(), Pull::None);
45
46 let iv = GenericSx126xInterfaceVariant::new(nss, reset, dio1, busy, None, None).unwrap();
47
48 spawn_core1(p.CORE1, unsafe { &mut CORE1_STACK }, move || {
49 let executor1 = EXECUTOR1.init(Executor::new());
50 executor1.run(|spawner| unwrap!(spawner.spawn(core1_task(spi, iv))));
51 });
52
53 let executor0 = EXECUTOR0.init(Executor::new());
54 executor0.run(|spawner| unwrap!(spawner.spawn(core0_task())));
55}
56
57#[embassy_executor::task]
58async fn core0_task() {
59 info!("Hello from core 0");
60 loop {
61 CHANNEL.send([0x01u8, 0x02u8, 0x03u8]).await;
62 Timer::after_millis(60 * 1000).await;
63 }
64}
65
66#[embassy_executor::task]
67async fn core1_task(
68 spi: Spi<'static, SPI1, Async>,
69 iv: GenericSx126xInterfaceVariant<Output<'static, AnyPin>, Input<'static, AnyPin>>,
70) {
71 info!("Hello from core 1");
72
73 let mut lora = {
74 match LoRa::new(SX1261_2::new(BoardType::RpPicoWaveshareSx1262, spi, iv), false, Delay).await {
75 Ok(l) => l,
76 Err(err) => {
77 info!("Radio error = {}", err);
78 return;
79 }
80 }
81 };
82
83 let mdltn_params = {
84 match lora.create_modulation_params(
85 SpreadingFactor::_10,
86 Bandwidth::_250KHz,
87 CodingRate::_4_8,
88 LORA_FREQUENCY_IN_HZ,
89 ) {
90 Ok(mp) => mp,
91 Err(err) => {
92 info!("Radio error = {}", err);
93 return;
94 }
95 }
96 };
97
98 let mut tx_pkt_params = {
99 match lora.create_tx_packet_params(4, false, true, false, &mdltn_params) {
100 Ok(pp) => pp,
101 Err(err) => {
102 info!("Radio error = {}", err);
103 return;
104 }
105 }
106 };
107
108 loop {
109 let buffer: [u8; 3] = CHANNEL.receive().await;
110 match lora.prepare_for_tx(&mdltn_params, 20, false).await {
111 Ok(()) => {}
112 Err(err) => {
113 info!("Radio error = {}", err);
114 return;
115 }
116 };
117
118 match lora.tx(&mdltn_params, &mut tx_pkt_params, &buffer, 0xffffff).await {
119 Ok(()) => {
120 info!("TX DONE");
121 }
122 Err(err) => {
123 info!("Radio error = {}", err);
124 return;
125 }
126 };
127
128 match lora.sleep(false).await {
129 Ok(()) => info!("Sleep successful"),
130 Err(err) => info!("Sleep unsuccessful = {}", err),
131 }
132 }
133}
generated by cgit (git 2.34.1) at 2026-04-05 21:38:15 +0000