flake.lock: Update

Flake lock file updates:

• Updated input 'flake-parts':
    'github:hercules-ci/flake-parts/f7c1a2d347e4c52d5fb8d10cb4d94b5884e546fb?narHash=sha256-m1Yf0wZ8j1OHjTc2UwHwyQRSnNeSgLJOd7q5Y45hzi4%3D' (2026-05-13)
  → 'github:hercules-ci/flake-parts/024633cd702b10285db5cb19b40ad48d2399ba60?narHash=sha256-zTwuwezD0w3hpga6a6P8emidzAZFyWqlNeRBlpWOOl8%3D' (2026-10-01)
• Updated input 'flake-parts/nixpkgs-lib':
    'github:nix-community/nixpkgs.lib/f5901329dade4a6ea039af1433fb087bd9c1fe14?narHash=sha256-GOkGPcboWE9BmGCRMLX3worL4EMnsnG8MyKmXNeYuhQ%3D' (2026-04-26)
  → 'github:nix-community/nixpkgs.lib/f7cd230690d9fc982d06129f9189b101fddcfa3b?narHash=sha256-oujbxmVKDhci2E4EM3KyAbRUgp5/IsCoiA/LfEF7OOk%3D' (2026-09-27)
• Updated input 'nixpkgs':
    'github:nixos/nixpkgs/a799d3e3886da994fa307f817a6bc705ae538eeb?narHash=sha256-3av0pIjlOWQ6rDbNOmpUSvbNnJkGORQKKjb4LtCZsIY%3D' (2026-06-06)
  → 'github:nixos/nixpkgs/151fa4e8ddfdd8dd25d945ad94ed54a13de9f6e4?narHash=sha256-Miqqk/ammqnTUxaoCyvtwoPeLbI1ksFyLxi/CazZpWY%3D' (2026-10-06)
• Updated input 'project-templates':
    'git+https://git.krantz.one/reed/project-templates?ref=refs/heads/master&rev=0d1a37eef3e3954cc698b577edbc37eaa736b859' (2026-06-08)
  → 'git+https://git.krantz.one/reed/project-templates?ref=refs/heads/master&rev=6c8058a5fd71c88ee64c56583d3d93b256b746bb' (2026-10-06)
• Updated input 'project-templates/crane':
    'github:ipetkov/crane/5e0fb2f64edff2822249f21293b8304dedaaf676?narHash=sha256-bEg5xoAxAwsyfnGhkEX7RJViTIBIYPd8ISg4O1c0HFc%3D' (2026-04-28)
  → 'github:ipetkov/crane/47b6b27ed9a3a9181415e4367d0c30ab2a0e0250?narHash=sha256-THGtz65UGJU%2BsonZidRboyCMk%2B9DclpMF7pwL4uDV4M%3D' (2026-10-02)
• Updated input 'project-templates/rust-overlay':
    'github:oxalica/rust-overlay/21632e942d89bf1cce4e5a63d7e58a215a0cbfcc?narHash=sha256-FVCr2Ij/jKf59a4LW481eeOF6rJRreOBrVgW/aUBTrw%3D' (2026-05-31)
  → 'github:oxalica/rust-overlay/b962e5d0c8cd97196c6a882d659fe451b52ad989?narHash=sha256-iwqAmHTX1IgzTumJR3JayNAQAo5xEmmOuGzB6b2pT/Q%3D' (2026-10-06)
• Updated input 'project-templates/treefmt-nix':
    'github:numtide/treefmt-nix/790751ff7fd3801feeaf96d7dc416a8d581265ba?narHash=sha256-pc20NRoMdiar8oPQceQT47UUZMBTiMdUuWrYu2obUP0%3D' (2026-04-08)
  → 'github:numtide/treefmt-nix/03d8ee1bcbc8f9638907bb79edb9673151d0e22b?narHash=sha256-vuzVwvjeucSnwKwMBpyP8r5IzdrMKCHEdwTrRFwUN7I%3D' (2026-10-05)

flake.lock

@@ -238,11 +238,11 @@
         "treefmt-nix": "treefmt-nix"
       },
       "locked": {
-        "lastModified": 1791419199,
-        "narHash": "sha256-eQx167Svp11qqWgwFrvV+tELtWZ+Wu2+zgKsAl8fx0M=",
+        "lastModified": 1791325749,
+        "narHash": "sha256-fFU7I8Lg+cXIwRRzuZr6pD2JqbIEFX7xsFqsPk0N4wQ=",
         "ref": "refs/heads/master",
-        "rev": "00ab3b0148e915f22ef6815a9fe24de5d8dde295",
-        "revCount": 51,
+        "rev": "6c8058a5fd71c88ee64c56583d3d93b256b746bb",
+        "revCount": 50,
         "type": "git",
         "url": "https://git.krantz.one/reed/project-templates"
       },

src/clock.rs

@@ -13,49 +13,19 @@ 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))
 }
 
-#[embassy_executor::task]
-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
+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>) {
     loop {
-        match service.fetch_ntp_time(address).await {
+        match fetch_ntp_time(net_stack).await {
             Ok(unix_secs) => {
                 NTP_BOOT_OFFSET.store(
                     unix_secs - embassy_time::Instant::now().as_secs(),
@@ -71,50 +41,46 @@ async fn handler(service: &'static mut NtpClient) {
     }
 }
 
-struct NtpClient {
-    net_stack: Stack<'static>,
+static NTP_BOOT_OFFSET: AtomicU64 = AtomicU64::new(0);
 
-    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> {
+pub async fn fetch_ntp_time(net_stack: Stack<'static>) -> Result<u64, &'static str> {
     // Resolve the NTP server hostname
-        let server_addr = self
-            .net_stack
-            .dns_query(server, embassy_net::dns::DnsQueryType::A)
+    let server_addr = net_stack
+        .dns_query(NTP_SERVER, embassy_net::dns::DnsQueryType::A)
         .await
         .map_err(|_| "DNS resolution failed")?
         .first()
         .copied()
         .ok_or("No DNS result")?;
 
-        Ok(SocketAddr::new(server_addr.into(), port))
-    }
+    let socket_addr = SocketAddr::new(server_addr.into(), NTP_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(
-            self.net_stack,
-            &mut self.rx_meta,
-            &mut self.rx_buf,
-            &mut self.tx_meta,
-            &mut self.tx_buf,
+        net_stack,
+        &mut rx_meta,
+        &mut rx_buf,
+        &mut tx_meta,
+        &mut tx_buf,
     );
     socket.bind(0).map_err(|_| "bind failed")?;
 
     let wrapped = UdpSocketWrapper::from(socket);
     let ctx = NtpContext::new(EmbassyTimestampGenerator::default());
 
-        let result = get_time(address, &wrapped, ctx)
+    let result = get_time(socket_addr, &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, 5> = Channel::new();
+static CONFIG_CHANNEL: Channel<CriticalSectionRawMutex, ConfigOperationMessage, 1> = Channel::new();
 
 enum ConfigOperationMessage {
     SetWifiCreds(WifiCredentials, Sender<Result<(), ConfigError>>),
@@ -63,6 +63,11 @@ async fn handler(
         Cache<Uncached, Uncached, Uncached, ConfigKey>,
     >,
 ) -> ! {
+    let resp_fail = |_| {
+        // TODO: make tracing work so if this code is reached you know where the error originated
+        error!("failed to respond");
+    };
+
     let mut data_buffer = [0u8; 256];
 
     loop {
@@ -70,25 +75,26 @@ async fn handler(
 
         match operation {
             ConfigOperationMessage::SetWifiCreds(value, resp) => {
-                let mut f = async || {
                 let mut buf = [0u8; 256];
-                    to_slice(&value, &mut buf)?;
+                if let Err(err) = to_slice(&value, &mut buf) {
+                    let _ = resp.send(Err(err.into())).map_err(resp_fail);
+                    continue;
+                };
 
-                    storage
+                if let Err(err) = storage
                     .store_item(&mut data_buffer, &ConfigKey::Wifi, &buf)
-                        .await?;
+                    .await
+                {
+                    let _ = resp.send(Err(err.into())).map_err(resp_fail);
+                    continue;
+                };
 
                 // TODO: send the change to the wifi service
                 // WIFI_SERVICE
                 //     .call(|s| s.set_station_config(esp_radio::wifi::Config::Station(value.into())))
                 //     .await;
 
-                    Ok(())
-                };
-                if resp.send(f().await).is_err() {
-                    // TODO: find a way to not hard-code symbols in a string
-                    error!("ConfigOperationMessage::SetWifiCreds failed to respond")
-                };
+                let _ = resp.send(Ok(())).map_err(resp_fail);
             }
         }
     }
@@ -112,7 +118,7 @@ impl Key for ConfigKey {
         let val = buffer
             .get_mut(0)
             .ok_or(sequential_storage::map::SerializationError::BufferTooSmall)?;
-        *val = (*self).into();
+        *val = self.clone().into();
         Ok(1)
     }
 
@@ -120,7 +126,7 @@ impl Key for ConfigKey {
         buffer: &[u8],
     ) -> Result<(Self, usize), sequential_storage::map::SerializationError> {
         let val = *buffer
-            .first()
+            .get(0)
             .ok_or(sequential_storage::map::SerializationError::BufferTooSmall)?;
         Ok((
             val.try_into()

src/http_api.rs

@@ -14,30 +14,19 @@ 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>) {
-    let service = crate::mk_static!(
-        HttpApiApp<'static, HttpApiProps>,
-        HttpApiApp {
-            config: Default::default(),
-
+    spawner.spawn(
+        handler(HttpApiApp::new(
             net_stack,
-            app: HttpApiProps.build_app(),
-
-            tcp_rx_buffer: [0; 1024],
-            tcp_tx_buffer: [0; 1024],
-            http_buffer: [0; 2048],
-        }
+            Default::default(),
+            Default::default(),
+        ))
+        .unwrap(),
     );
-
-    spawner.spawn(handler(service).unwrap());
 }
 
 #[embassy_executor::task]
-async fn handler(service: &'static mut HttpApiApp<'static, HttpApiProps>) {
+async fn handler(mut service: HttpApiApp<'static, HttpApiProps>) {
     service.run().await;
 }
 
@@ -67,6 +56,19 @@ 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,8 +7,6 @@
 #![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,4 +1,3 @@
-use alloc::boxed::Box;
 use defmt::{error, info};
 use embassy_executor::Spawner;
 use embassy_futures::select::{Either, select};
@@ -12,10 +11,6 @@ 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());
 
@@ -50,7 +45,7 @@ pub fn start_wifi(spawner: Spawner, wifi: WIFI<'static>) -> Stack<'static> {
     net_stack
 }
 
-pub async fn set_station_config(config: Box<esp_radio::wifi::Config>) -> Result<(), RecvError> {
+pub async fn set_station_config(config: esp_radio::wifi::Config) -> Result<(), RecvError> {
     let (send, recv) = oneshot::channel();
     WIFI_CHANNEL
         .send(WifiOperationMessage::SetStationConfig(config, send))
@@ -58,7 +53,7 @@ pub async fn set_station_config(config: Box<esp_radio::wifi::Config>) -> Result<
     recv.await
 }
 
-pub async fn set_dhcp_config(config: Box<embassy_net::DhcpConfig>) -> Result<(), RecvError> {
+pub async fn set_dhcp_config(config: embassy_net::DhcpConfig) -> Result<(), RecvError> {
     let (send, recv) = oneshot::channel();
     WIFI_CHANNEL
         .send(WifiOperationMessage::SetDhcpConfig(config, send))
@@ -66,11 +61,11 @@ pub async fn set_dhcp_config(config: Box<embassy_net::DhcpConfig>) -> Result<(),
     recv.await
 }
 
-static WIFI_CHANNEL: Channel<CriticalSectionRawMutex, WifiOperationMessage, 5> = Channel::new();
+static WIFI_CHANNEL: Channel<CriticalSectionRawMutex, WifiOperationMessage, 1> = Channel::new();
 
 enum WifiOperationMessage {
-    SetStationConfig(Box<esp_radio::wifi::Config>, Sender<()>),
-    SetDhcpConfig(Box<embassy_net::DhcpConfig>, Sender<()>),
+    SetStationConfig(esp_radio::wifi::Config, Sender<()>),
+    SetDhcpConfig(embassy_net::DhcpConfig, Sender<()>),
 }
 
 #[embassy_executor::task]
@@ -78,15 +73,15 @@ async fn handler(net_stack: Stack<'static>) -> ! {
     loop {
         match WIFI_CHANNEL.receive().await {
             WifiOperationMessage::SetStationConfig(config, resp) => {
-                WIFI_HANDLER_RPC.signal(*config);
-                if resp.send(()).is_err() {
+                WIFI_HANDLER_RPC.signal(config);
+                if let Err(_) = resp.send(()) {
                     // 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));
-                if resp.send(()).is_err() {
+                net_stack.set_config_v4(embassy_net::ConfigV4::Dhcp(config));
+                if let Err(_) = resp.send(()) {
                     // TODO: find a way to not hard-code symbols in a string
                     error!("WifiOperationMessage::SetDhcpConfig failed to respond")
                 };
@@ -119,12 +114,13 @@ 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]
 async fn ip_logger(net_stack: Stack<'static>) -> ! {