refactor: increase channel sizes

src/clock.rs

@@ -13,19 +13,49 @@ use sntpc_time_embassy::EmbassyTimestampGenerator;
 // NTP server (pool.ntp.org is the usual choice)
 const NTP_SERVER: &str = "pool.ntp.org";
 const NTP_PORT: u16 = 123;
+// Unix epoch is 1900-01-01 + 70 years = 2_208_988_800 seconds.
+const NTP_UNIX_OFFSET: u64 = 2_208_988_800;
+
+static NTP_BOOT_OFFSET: AtomicU64 = AtomicU64::new(0);
+
+#[allow(
+    clippy::large_stack_frames,
+    reason = "it's not unusual to allocate larger objects in service's start functions"
+)]
+pub fn start_ntp_sync(spawner: Spawner, net_stack: Stack<'static>) {
+    let service = crate::mk_static!(
+        NtpClient,
+        NtpClient {
+            net_stack,
+
+            rx_meta: [PacketMetadata::EMPTY; 16],
+            rx_buf: [0u8; 48],
+            tx_meta: [PacketMetadata::EMPTY; 16],
+            tx_buf: [0u8; 48],
+        }
+    );
+
+    spawner.spawn(handler(service).unwrap());
+}
 
 pub fn now() -> embassy_time::Instant {
     embassy_time::Instant::now() + Duration::from_secs(NTP_BOOT_OFFSET.load(Ordering::Relaxed))
 }
 
-pub fn start_ntp_sync(spawner: Spawner, net_stack: Stack<'static>) {
-    spawner.spawn(handler(net_stack).unwrap());
-}
-
 #[embassy_executor::task]
-async fn handler(net_stack: Stack<'static>) {
+async fn handler(service: &'static mut NtpClient) {
+    let address = loop {
+        match service.fetch_ntp_address(NTP_SERVER, NTP_PORT).await {
+            Ok(addr) => break addr,
+            Err(err) => {
+                defmt::error!("Failed to get the NTP server's address: {}", err);
+                Timer::after(Duration::from_secs(10)).await
+            }
+        }
+    };
+
     loop {
-        match fetch_ntp_time(net_stack).await {
+        match service.fetch_ntp_time(address).await {
             Ok(unix_secs) => {
                 NTP_BOOT_OFFSET.store(
                     unix_secs - embassy_time::Instant::now().as_secs(),
@@ -41,46 +71,50 @@ async fn handler(net_stack: Stack<'static>) {
     }
 }
 
-static NTP_BOOT_OFFSET: AtomicU64 = AtomicU64::new(0);
+struct NtpClient {
+    net_stack: Stack<'static>,
 
-pub async fn fetch_ntp_time(net_stack: Stack<'static>) -> Result<u64, &'static str> {
+    rx_meta: [PacketMetadata; 16],
+    rx_buf: [u8; 48],
+    tx_meta: [PacketMetadata; 16],
+    tx_buf: [u8; 48],
+}
+
+impl NtpClient {
+    async fn fetch_ntp_address(&self, server: &str, port: u16) -> Result<SocketAddr, &'static str> {
         // Resolve the NTP server hostname
-    let server_addr = net_stack
+        let server_addr = self
-        .dns_query(NTP_SERVER, embassy_net::dns::DnsQueryType::A)
+            .net_stack
+            .dns_query(server, embassy_net::dns::DnsQueryType::A)
             .await
             .map_err(|_| "DNS resolution failed")?
             .first()
             .copied()
             .ok_or("No DNS result")?;
 
-    let socket_addr = SocketAddr::new(server_addr.into(), NTP_PORT);
+        Ok(SocketAddr::new(server_addr.into(), port))
-
+    }
-    // Allocate UDP buffers (can be small — SNTP packets are tiny)
-    let mut rx_meta = [PacketMetadata::EMPTY; 16];
-    let mut rx_buf = [0u8; 48];
-    let mut tx_meta = [PacketMetadata::EMPTY; 16];
-    let mut tx_buf = [0u8; 48];
 
+    async fn fetch_ntp_time(&mut self, address: SocketAddr) -> Result<u64, &'static str> {
         let mut socket = UdpSocket::new(
-        net_stack,
+            self.net_stack,
-        &mut rx_meta,
+            &mut self.rx_meta,
-        &mut rx_buf,
+            &mut self.rx_buf,
-        &mut tx_meta,
+            &mut self.tx_meta,
-        &mut tx_buf,
+            &mut self.tx_buf,
         );
         socket.bind(0).map_err(|_| "bind failed")?;
 
         let wrapped = UdpSocketWrapper::from(socket);
         let ctx = NtpContext::new(EmbassyTimestampGenerator::default());
 
-    let result = get_time(socket_addr, &wrapped, ctx)
+        let result = get_time(address, &wrapped, ctx)
             .await
             .map_err(|_| "SNTP request failed")?;
 
         // result.sec is the NTP timestamp in seconds since 1900-01-01.
-    // Unix epoch is 1900-01-01 + 70 years = 2_208_988_800 seconds.
-    const NTP_UNIX_OFFSET: u64 = 2_208_988_800;
         let unix_secs = result.sec().saturating_sub(NTP_UNIX_OFFSET);
 
         Ok(unix_secs)
+    }
 }

src/config.rs

@@ -34,7 +34,7 @@ pub async fn set_wifi_creds(value: WifiCredentials) -> Result<(), ConfigError> {
     recv.await?
 }
 
-static CONFIG_CHANNEL: Channel<CriticalSectionRawMutex, ConfigOperationMessage, 1> = Channel::new();
+static CONFIG_CHANNEL: Channel<CriticalSectionRawMutex, ConfigOperationMessage, 5> = Channel::new();
 
 enum ConfigOperationMessage {
     SetWifiCreds(WifiCredentials, Sender<Result<(), ConfigError>>),
@@ -112,7 +112,7 @@ impl Key for ConfigKey {
         let val = buffer
             .get_mut(0)
             .ok_or(sequential_storage::map::SerializationError::BufferTooSmall)?;
-        *val = self.clone().into();
+        *val = (*self).into();
         Ok(1)
     }
 
@@ -120,7 +120,7 @@ impl Key for ConfigKey {
         buffer: &[u8],
     ) -> Result<(Self, usize), sequential_storage::map::SerializationError> {
         let val = *buffer
-            .get(0)
+            .first()
             .ok_or(sequential_storage::map::SerializationError::BufferTooSmall)?;
         Ok((
             val.try_into()

src/http_api.rs

@@ -14,19 +14,30 @@ impl AppBuilder for HttpApiProps {
     }
 }
 
+#[allow(
+    clippy::large_stack_frames,
+    reason = "it's not unusual to allocate larger objects in service's start functions"
+)]
 pub fn start_http_api(spawner: Spawner, net_stack: Stack<'static>) {
-    spawner.spawn(
+    let service = crate::mk_static!(
-        handler(HttpApiApp::new(
+        HttpApiApp<'static, HttpApiProps>,
+        HttpApiApp {
+            config: Default::default(),
+
             net_stack,
-            Default::default(),
+            app: HttpApiProps.build_app(),
-            Default::default(),
+
-        ))
+            tcp_rx_buffer: [0; 1024],
-        .unwrap(),
+            tcp_tx_buffer: [0; 1024],
+            http_buffer: [0; 2048],
+        }
     );
+
+    spawner.spawn(handler(service).unwrap());
 }
 
 #[embassy_executor::task]
-async fn handler(mut service: HttpApiApp<'static, HttpApiProps>) {
+async fn handler(service: &'static mut HttpApiApp<'static, HttpApiProps>) {
     service.run().await;
 }
 
@@ -56,19 +67,6 @@ pub struct HttpApiApp<'a, AB: AppBuilder> {
 }
 
 impl<'a, AB: AppBuilder> HttpApiApp<'a, AB> {
-    pub fn new(net_stack: Stack<'a>, config: HttpApiConfig, app: AB) -> Self {
-        Self {
-            config: config,
-
-            net_stack: net_stack,
-            app: app.build_app(),
-
-            tcp_rx_buffer: [0; 1024],
-            tcp_tx_buffer: [0; 1024],
-            http_buffer: [0; 2048],
-        }
-    }
-
     pub async fn run(&mut self) {
         picoserve::Server::new(
             &self.app,

src/lib.rs

@@ -7,6 +7,8 @@
 #![deny(clippy::large_stack_frames)]
 #![feature(impl_trait_in_assoc_type)]
 
+extern crate alloc;
+
 pub mod http_api;
 
 pub mod clock;

src/wifi.rs

@@ -1,3 +1,4 @@
+use alloc::boxed::Box;
 use defmt::{error, info};
 use embassy_executor::Spawner;
 use embassy_futures::select::{Either, select};
@@ -11,6 +12,10 @@ use esp_radio::wifi::sta::StationConfig;
 use esp_radio::wifi::{ControllerConfig, Interface, WifiController};
 use oneshot::{RecvError, Sender};
 
+#[allow(
+    clippy::large_stack_frames,
+    reason = "it's not unusual to allocate larger objects in service's start functions"
+)]
 pub fn start_wifi(spawner: Spawner, wifi: WIFI<'static>) -> Stack<'static> {
     let wifi_config = esp_radio::wifi::Config::Station(StationConfig::default());
 
@@ -45,7 +50,7 @@ pub fn start_wifi(spawner: Spawner, wifi: WIFI<'static>) -> Stack<'static> {
     net_stack
 }
 
-pub async fn set_station_config(config: esp_radio::wifi::Config) -> Result<(), RecvError> {
+pub async fn set_station_config(config: Box<esp_radio::wifi::Config>) -> Result<(), RecvError> {
     let (send, recv) = oneshot::channel();
     WIFI_CHANNEL
         .send(WifiOperationMessage::SetStationConfig(config, send))
@@ -53,7 +58,7 @@ pub async fn set_station_config(config: esp_radio::wifi::Config) -> Result<(), R
     recv.await
 }
 
-pub async fn set_dhcp_config(config: embassy_net::DhcpConfig) -> Result<(), RecvError> {
+pub async fn set_dhcp_config(config: Box<embassy_net::DhcpConfig>) -> Result<(), RecvError> {
     let (send, recv) = oneshot::channel();
     WIFI_CHANNEL
         .send(WifiOperationMessage::SetDhcpConfig(config, send))
@@ -61,11 +66,11 @@ pub async fn set_dhcp_config(config: embassy_net::DhcpConfig) -> Result<(), Recv
     recv.await
 }
 
-static WIFI_CHANNEL: Channel<CriticalSectionRawMutex, WifiOperationMessage, 1> = Channel::new();
+static WIFI_CHANNEL: Channel<CriticalSectionRawMutex, WifiOperationMessage, 5> = Channel::new();
 
 enum WifiOperationMessage {
-    SetStationConfig(esp_radio::wifi::Config, Sender<()>),
+    SetStationConfig(Box<esp_radio::wifi::Config>, Sender<()>),
-    SetDhcpConfig(embassy_net::DhcpConfig, Sender<()>),
+    SetDhcpConfig(Box<embassy_net::DhcpConfig>, Sender<()>),
 }
 
 #[embassy_executor::task]
@@ -73,15 +78,15 @@ async fn handler(net_stack: Stack<'static>) -> ! {
     loop {
         match WIFI_CHANNEL.receive().await {
             WifiOperationMessage::SetStationConfig(config, resp) => {
-                WIFI_HANDLER_RPC.signal(config);
+                WIFI_HANDLER_RPC.signal(*config);
-                if let Err(_) = resp.send(()) {
+                if resp.send(()).is_err() {
                     // TODO: find a way to not hard-code symbols in a string
                     error!("WifiOperationMessage::SetStationConfig failed to respond")
                 };
             }
             WifiOperationMessage::SetDhcpConfig(config, resp) => {
-                net_stack.set_config_v4(embassy_net::ConfigV4::Dhcp(config));
+                net_stack.set_config_v4(embassy_net::ConfigV4::Dhcp(*config));
-                if let Err(_) = resp.send(()) {
+                if resp.send(()).is_err() {
                     // TODO: find a way to not hard-code symbols in a string
                     error!("WifiOperationMessage::SetDhcpConfig failed to respond")
                 };
@@ -114,12 +119,11 @@ async fn connection_handler(mut controller: WifiController<'static>) -> ! {
     loop {
         if let Either::First(req) =
             select(WIFI_HANDLER_RPC.wait(), connection(&mut controller)).await
+            && let Some(err) = controller.set_config(&req).err()
         {
-            if let Some(err) = controller.set_config(&req).err() {
             error!("Wifi controller failed to set a new config: {:?}", err)
         }
     }
-    }
 }
 
 #[embassy_executor::task]