use ssid

rust/Cargo.toml

@@ -85,7 +85,7 @@ embassy-executor = { version = "0.7.0", features = [
     "log",
     "task-arena-size-20480",
 ] }
-embassy-time = { version = "0.4.0", features = ["log"] }
+embassy-time = { version = "0.5.0", features = ["log"] }
 esp-hal-embassy = { version = "0.9.0", features = ["esp32c6", "log-04"] }
 esp-storage = { version = "0.7.0", features = ["esp32c6"] }
 
@@ -97,19 +97,20 @@ esp-wifi = { version = "0.15.0", features = [
     "smoltcp",
     "wifi",
 ] }
-#smoltcp = { version = "0.12.0", default-features = false, features = [
-#    "log",
-#    "medium-ethernet",
-#    "multicast",
-#    "proto-dhcpv4",
-#    "proto-dns",
-#    "proto-ipv4",
-#    "socket-dns",
-#    "socket-icmp",
-#    "socket-raw",
-#    "socket-tcp",
-#    "socket-udp",
-#] }
+smoltcp = { version = "0.12.0", default-features = false, features = [
+    "alloc",
+    "log",
+    "medium-ethernet",
+    "multicast",
+    "proto-dhcpv4",
+    "proto-dns",
+    "proto-ipv4",
+    "socket-dns",
+    "socket-icmp",
+    "socket-raw",
+    "socket-tcp",
+    "socket-udp",
+] }
 #static_cell = "2.1.1"
 embedded-hal = "1.0.0"
 heapless = { version = "0.8", features = ["serde"] }

rust/src/hal/esp.rs

@@ -6,6 +6,7 @@ use anyhow::{anyhow, bail, Context};
 use chrono::{DateTime, Utc};
 use serde::Serialize;
 
+use alloc::string::ToString;
 use alloc::{string::String, vec::Vec};
 use core::marker::PhantomData;
 use core::net::{IpAddr, Ipv4Addr};
@@ -176,9 +177,9 @@ impl Esp<'_> {
     }
 
     pub(crate) async fn wifi_ap(&mut self) -> anyhow::Result<Stack<'static>> {
-        let _ssid = match self.load_config() {
-            Ok(config) => config.network.ap_ssid.clone(),
-            Err(_) => heapless::String::from_str("PlantCtrl Emergency Mode").unwrap(),
+        let ssid = match self.load_config() {
+            Ok(config) => config.network.ap_ssid.as_str().to_string(),
+            Err(_) => "PlantCtrl Emergency Mode".to_string(),
         };
 
         let spawner = Spawner::for_current_executor().await;
@@ -205,7 +206,7 @@ impl Esp<'_> {
         let stack = mk_static!(Stack, stack);
 
         let controller = self.controller.take().unwrap();
-        spawner.spawn(connection(controller)).ok();
+        spawner.spawn(connection(controller, ssid)).ok();
         spawner.spawn(net_task(runner)).ok();
         spawner.spawn(run_dhcp(stack.clone(), gw_ip_addr_str)).ok();
 
@@ -739,7 +740,7 @@ async fn run_dhcp(stack: Stack<'static>, gw_ip_addr: &'static str) {
 }
 
 #[embassy_executor::task]
-async fn connection(mut controller: WifiController<'static>) {
+async fn connection(mut controller: WifiController<'static>, ssid: String) {
     println!("start connection task");
     println!("Device capabilities: {:?}", controller.capabilities());
     loop {
@@ -753,7 +754,7 @@ async fn connection(mut controller: WifiController<'static>) {
         }
         if !matches!(controller.is_started(), core::result::Result::Ok(true)) {
             let client_config = Configuration::AccessPoint(AccessPointConfiguration {
-                ssid: "esp-wifi".try_into().unwrap(),
+                ssid: ssid.clone(),
                 ..Default::default()
             });
             controller.set_configuration(&client_config).unwrap();

rust/src/webserver/mod.rs

@@ -394,11 +394,10 @@ pub struct NightLampCommand {
 pub async fn httpd(reboot_now: Arc<AtomicBool>, stack: Stack<'static>) {
     let mut rx_buffer = [0; 1536];
     let mut tx_buffer = [0; 1536];
-    println!("Stack {}", stack.is_config_up());
     let mut socket = TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
-    println!("Socket created");
-    //let d = embassy_time::Duration::from_millis(1000);
-    //socket.set_timeout(Some(d));
+    socket.set_keep_alive(Some(Duration::from_secs(30)));
+    socket.set_timeout(Some(Duration::from_secs(5)));
+
     loop {
         println!("Wait for connection...");
         let r = socket
@@ -443,7 +442,6 @@ pub async fn httpd(reboot_now: Arc<AtomicBool>, stack: Stack<'static>) {
                 }
             };
         }
-
         let r = socket
             .write_all(
                 b"HTTP/1.0 200 OK\r\n\r\n\
@@ -463,11 +461,9 @@ pub async fn httpd(reboot_now: Arc<AtomicBool>, stack: Stack<'static>) {
         if let Err(e) = r {
             println!("flush error: {:?}", e);
         }
-        Timer::after(Duration::from_millis(1000)).await;
-
+        Timer::after_millis(100).await;
         socket.close();
-        Timer::after(Duration::from_millis(1000)).await;
-
+        Timer::after_millis(100).await;
         socket.abort();
     }