From 967d75fffa34065749b0f2f8bdb272052d2944f6 Mon Sep 17 00:00:00 2001 From: Mathias Date: Mon, 17 Jun 2024 14:51:50 +0200 Subject: [PATCH] Bump embassy-sync to 0.6 --- Cargo.toml | 2 +- examples/rpi-pico/Cargo.toml | 3 +- examples/rpi-pico/src/bin/embassy-perf.rs | 65 +++++++++------ .../rpi-pico/src/bin/embassy-smoltcp-ppp.rs | 81 ++++++++++++++----- 4 files changed, 105 insertions(+), 46 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c8b21f0..df7be4c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,7 +29,7 @@ defmt = { version = "^0.3", optional = true } embedded-hal = "1.0" embassy-time = "0.3" -embassy-sync = "0.5" +embassy-sync = "0.6" embassy-futures = "0.1" embedded-nal-async = { version = "0.7" } diff --git a/examples/rpi-pico/Cargo.toml b/examples/rpi-pico/Cargo.toml index a07f340..4a9d2a1 100644 --- a/examples/rpi-pico/Cargo.toml +++ b/examples/rpi-pico/Cargo.toml @@ -17,7 +17,7 @@ embassy-time = { version = "0.3", features = [ "defmt", "defmt-timestamp-uptime", ] } -embassy-sync = { version = "0.5" } +embassy-sync = { version = "0.6" } embassy-rp = { version = "0.1.0", features = [ "defmt", "unstable-pac", @@ -80,6 +80,7 @@ embassy-futures = { path = "../../../embassy/embassy-futures" } embassy-executor = { path = "../../../embassy/embassy-executor" } ublox-sockets = { path = "../../../ublox-sockets" } no-std-net = { path = "../../../no-std-net" } +atat = { path = "../../../atat/atat" } [profile.dev] debug = 2 diff --git a/examples/rpi-pico/src/bin/embassy-perf.rs b/examples/rpi-pico/src/bin/embassy-perf.rs index f990655..0376907 100644 --- a/examples/rpi-pico/src/bin/embassy-perf.rs +++ b/examples/rpi-pico/src/bin/embassy-perf.rs @@ -61,40 +61,57 @@ async fn main(spawner: Spawner) { let p = embassy_rp::init(Default::default()); - let rst = Output::new(p.PIN_26, Level::High); - - let (tx_pin, rx_pin, rts_pin, cts_pin, uart) = - (p.PIN_24, p.PIN_25, p.PIN_23, p.PIN_22, p.UART1); - - let tx_buf = &mut make_static!([0u8; 64])[..]; - let rx_buf = &mut make_static!([0u8; 64])[..]; - let mut config = uart::Config::default(); - config.baudrate = 115200; - let uart = uart::BufferedUart::new_with_rtscts( - uart, Irqs, tx_pin, rx_pin, rts_pin, cts_pin, tx_buf, rx_buf, config, + let rst_pin = OutputOpenDrain::new(p.PIN_26.degrade(), Level::High); + + static TX_BUF: StaticCell<[u8; 32]> = StaticCell::new(); + static RX_BUF: StaticCell<[u8; 32]> = StaticCell::new(); + let wifi_uart = uart::BufferedUart::new_with_rtscts( + p.UART1, + Irqs, + p.PIN_24, + p.PIN_25, + p.PIN_23, + p.PIN_22, + TX_BUF.init([0; 32]), + RX_BUF.init([0; 32]), + uart::Config::default(), ); - let (rx, tx) = uart.split(); - let buffers = &*make_static!(atat::Buffers::new()); - let (ingress, client) = buffers.split( - common::TxWrap(tx), - EdmDigester::default(), - atat::Config::new(), + static RESOURCES: StaticCell> = + StaticCell::new(); + + let mut runner = Runner::new( + wifi_uart.split(), + RESOURCES.init(Resources::new()), + WifiConfig { rst_pin }, ); - defmt::unwrap!(spawner.spawn(ingress_task(ingress, rx))); - let state = make_static!(State::new(client)); - let (net_device, mut control, runner) = new(state, &buffers.urc_channel, rst).await; + static PPP_STATE: StaticCell> = StaticCell::new(); + let net_device = runner.ppp_stack(PPP_STATE.init(embassy_net_ppp::State::new())); - defmt::unwrap!(spawner.spawn(wifi_task(runner))); + // Generate random seed + let seed = 0x0123_4567_89ab_cdef; // chosen by fair dice roll. guarenteed to be random. // Init network stack - let stack = &*make_static!(UbloxStack::new( + static STACK: StaticCell>> = StaticCell::new(); + static STACK_RESOURCES: StaticCell> = StaticCell::new(); + + let stack = &*STACK.init(Stack::new( net_device, - make_static!(StackResources::<4>::new()), + embassy_net::Config::default(), + STACK_RESOURCES.init(StackResources::new()), + seed, )); - defmt::unwrap!(spawner.spawn(net_task(stack))); + static CONTROL_RESOURCES: StaticCell = StaticCell::new(); + let mut control = runner.control(CONTROL_RESOURCES.init(ControlResources::new()), &stack); + + spawner.spawn(net_task(stack)).unwrap(); + spawner.spawn(ppp_task(runner, &stack)).unwrap(); + + stack.wait_config_up().await; + + Timer::after(Duration::from_secs(1)).await; loop { match control.join_wpa2(WIFI_NETWORK, WIFI_PASSWORD).await { diff --git a/examples/rpi-pico/src/bin/embassy-smoltcp-ppp.rs b/examples/rpi-pico/src/bin/embassy-smoltcp-ppp.rs index 2991638..21c9416 100644 --- a/examples/rpi-pico/src/bin/embassy-smoltcp-ppp.rs +++ b/examples/rpi-pico/src/bin/embassy-smoltcp-ppp.rs @@ -1,6 +1,7 @@ #![no_std] #![no_main] #![feature(type_alias_impl_trait)] +#![feature(impl_trait_in_assoc_type)] #[cfg(not(feature = "ppp"))] compile_error!("You must enable the `ppp` feature flag to build this example"); @@ -9,16 +10,16 @@ use defmt::*; use embassy_executor::Spawner; use embassy_net::tcp::TcpSocket; use embassy_net::{Ipv4Address, Stack, StackResources}; -use embassy_rp::gpio::{AnyPin, Level, Output, Pin}; +use embassy_rp::gpio::{AnyPin, Level, Output, OutputOpenDrain, Pin}; use embassy_rp::peripherals::UART1; -use embassy_rp::uart::{BufferedInterruptHandler, BufferedUart}; +use embassy_rp::uart::{BufferedInterruptHandler, BufferedUart, BufferedUartRx, BufferedUartTx}; use embassy_rp::{bind_interrupts, uart}; use embassy_time::{Duration, Timer}; -use embedded_tls::Aes128GcmSha256; use embedded_tls::TlsConfig; use embedded_tls::TlsConnection; use embedded_tls::TlsContext; use embedded_tls::UnsecureProvider; +use embedded_tls::{Aes128GcmSha256, MaxFragmentLength}; use rand_chacha::rand_core::SeedableRng; use rand_chacha::ChaCha8Rng; use reqwless::headers::ContentType; @@ -26,13 +27,31 @@ use reqwless::request::Request; use reqwless::request::RequestBuilder as _; use reqwless::response::Response; use static_cell::StaticCell; -use ublox_short_range::asynch::{PPPRunner, Resources}; +use ublox_short_range::asynch::control::ControlResources; +use ublox_short_range::asynch::{Resources, Runner}; use {defmt_rtt as _, panic_probe as _}; const CMD_BUF_SIZE: usize = 128; const INGRESS_BUF_SIZE: usize = 512; const URC_CAPACITY: usize = 2; +pub struct WifiConfig { + pub rst_pin: OutputOpenDrain<'static>, +} + +impl<'a> ublox_short_range::WifiConfig<'a> for WifiConfig { + type ResetPin = OutputOpenDrain<'static>; + + const PPP_CONFIG: embassy_net_ppp::Config<'a> = embassy_net_ppp::Config { + username: b"", + password: b"", + }; + + fn reset_pin(&mut self) -> Option<&mut Self::ResetPin> { + Some(&mut self.rst_pin) + } +} + #[embassy_executor::task] async fn net_task(stack: &'static Stack>) -> ! { stack.run().await @@ -40,11 +59,17 @@ async fn net_task(stack: &'static Stack>) -> ! #[embassy_executor::task] async fn ppp_task( - mut runner: PPPRunner<'static, Output<'static>, INGRESS_BUF_SIZE, URC_CAPACITY>, - interface: BufferedUart<'static, UART1>, + mut runner: Runner< + 'static, + BufferedUartRx<'static, UART1>, + BufferedUartTx<'static, UART1>, + WifiConfig, + INGRESS_BUF_SIZE, + URC_CAPACITY, + >, stack: &'static embassy_net::Stack>, ) -> ! { - runner.run(interface, stack).await + runner.run(stack).await } bind_interrupts!(struct Irqs { @@ -55,7 +80,7 @@ bind_interrupts!(struct Irqs { async fn main(spawner: Spawner) { let p = embassy_rp::init(Default::default()); - let rst = Output::new(p.PIN_26.degrade(), Level::High); + let rst_pin = OutputOpenDrain::new(p.PIN_26.degrade(), Level::High); static TX_BUF: StaticCell<[u8; 32]> = StaticCell::new(); static RX_BUF: StaticCell<[u8; 32]> = StaticCell::new(); @@ -74,15 +99,21 @@ async fn main(spawner: Spawner) { static RESOURCES: StaticCell> = StaticCell::new(); - let (net_device, mut control, runner) = - ublox_short_range::asynch::new_ppp(RESOURCES.init(Resources::new()), rst); + let mut runner = Runner::new( + wifi_uart.split(), + RESOURCES.init(Resources::new()), + WifiConfig { rst_pin }, + ); + + static PPP_STATE: StaticCell> = StaticCell::new(); + let net_device = runner.ppp_stack(PPP_STATE.init(embassy_net_ppp::State::new())); // Generate random seed let seed = 0x0123_4567_89ab_cdef; // chosen by fair dice roll. guarenteed to be random. // Init network stack static STACK: StaticCell>> = StaticCell::new(); - static STACK_RESOURCES: StaticCell> = StaticCell::new(); + static STACK_RESOURCES: StaticCell> = StaticCell::new(); let stack = &*STACK.init(Stack::new( net_device, @@ -91,19 +122,19 @@ async fn main(spawner: Spawner) { seed, )); + static CONTROL_RESOURCES: StaticCell = StaticCell::new(); + let mut control = runner.control(CONTROL_RESOURCES.init(ControlResources::new()), &stack); + spawner.spawn(net_task(stack)).unwrap(); - spawner.spawn(ppp_task(runner, wifi_uart, &stack)).unwrap(); + spawner.spawn(ppp_task(runner, &stack)).unwrap(); stack.wait_config_up().await; Timer::after(Duration::from_secs(1)).await; - control - .set_hostname("Factbird-duo-wifi-test") - .await - .unwrap(); + control.set_hostname("Ublox-wifi-test").await.ok(); - control.join_open("Test").await; + control.join_wpa2("MyAccessPoint", "12345678").await; info!("We have network!"); @@ -129,7 +160,9 @@ async fn main(spawner: Spawner) { let mut read_record_buffer = [0; 16384]; let mut write_record_buffer = [0; 16384]; - let config = TlsConfig::new().with_server_name(hostname); + let config = TlsConfig::new() + // .with_max_fragment_length(MaxFragmentLength::Bits11) + .with_server_name(hostname); let mut tls = TlsConnection::new(socket, &mut read_record_buffer, &mut write_record_buffer); tls.open(TlsContext::new( @@ -147,9 +180,17 @@ async fn main(spawner: Spawner) { .build(); request.write(&mut tls).await.unwrap(); - let mut rx_buf = [0; 4096]; + let mut rx_buf = [0; 1024]; + let mut body_buf = [0; 8192]; let response = Response::read(&mut tls, reqwless::request::Method::GET, &mut rx_buf) .await .unwrap(); - info!("{=[u8]:a}", rx_buf); + let len = response + .body() + .reader() + .read_to_end(&mut body_buf) + .await + .unwrap(); + + info!("{=[u8]:a}", &body_buf[..len]); }