Add Wi-Fi scan details display and MQTT publish

- HTML: Add Wi-Fi scan results container to network.html
- Rust: Implement `wifi_scan_details()` with RSSI, channel, auth method
- API & UI: Fetch and display scan results in table format
- MQTT: Publish top 10 networks sorted by RSSI to `/wifi_scan`

Software/MainBoard/rust/src/hal/esp.rs

@@ -7,15 +7,16 @@ use chrono::{DateTime, Utc};
 
 use crate::fat_error::{FatError, FatResult};
 use crate::hal::shared_flash::MutexFlashStorage;
-use alloc::string::ToString;
+use alloc::string::{String, ToString};
 use alloc::sync::Arc;
-use alloc::{string::String, vec, vec::Vec};
+use alloc::{format, vec, vec::Vec};
 use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
 use embassy_sync::mutex::Mutex;
 use embedded_storage::nor_flash::{check_erase, NorFlash, ReadNorFlash, RmwNorFlashStorage};
 use esp_bootloader_esp_idf::ota::OtaImageState::Valid;
 use esp_bootloader_esp_idf::ota::{Ota, OtaImageState};
 use esp_bootloader_esp_idf::partitions::{AppPartitionSubType, FlashRegion};
+use serde::{Deserialize, Serialize};
 use esp_hal::gpio::{Input, RtcPinWithResistors};
 use esp_hal::rng::Rng;
 use esp_hal::rtc_cntl::{
@@ -30,6 +31,24 @@ use esp_radio::wifi::scan::{ScanConfig, ScanTypeConfig};
 use esp_radio::wifi::{Interface, WifiController};
 use log::{error, info};
 
+/// Detailed Wi-Fi scan information including signal strength
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct WifiScanDetails {
+    pub ssid: String,
+    pub bssid: String,
+    pub rssi: i32,
+    pub channel: u8,
+    pub auth_method: String,
+}
+
+// Helper function to format BSSID as MAC address string
+fn format_bssid(bssid: &[u8; 6]) -> String {
+    alloc::format!(
+        "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
+        bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]
+    )
+}
+
 
 #[esp_hal::ram(unstable(rtc_fast), unstable(persistent))]
 static mut LAST_WATERING_TIMESTAMP: [i64; PLANT_COUNT] = [0; PLANT_COUNT];
@@ -192,6 +211,25 @@ impl Esp<'_> {
         Ok(rv)
     }
 
+    /// Return detailed Wi-Fi scan information including signal strength
+    pub(crate) async fn wifi_scan_details(&mut self) -> FatResult<Vec<WifiScanDetails>> {
+        let ap_infos = self.wifi_scan().await?;
+        
+        // Convert AccessPointInfo to WifiScanDetails
+        let details: Vec<WifiScanDetails> = ap_infos
+            .iter()
+            .map(|ap| WifiScanDetails {
+                ssid: ap.ssid.as_str().to_string(),
+                bssid: format_bssid(&ap.bssid),
+                rssi: ap.signal_strength as i32,
+                channel: ap.channel as u8,
+                auth_method: format!("{:?}",ap.auth_method),
+            })
+            .collect();
+        
+        Ok(details)
+    }
+
     pub(crate) fn last_pump_time(&self, plant: usize) -> Option<DateTime<Utc>> {
         let ts = unsafe { LAST_WATERING_TIMESTAMP }[plant];
         DateTime::from_timestamp_millis(ts)

Software/MainBoard/rust/src/main.rs

@@ -280,6 +280,7 @@ async fn safe_main(spawner: Spawner) -> FatResult<()> {
             error!("Error publishing battery state {e}");
         });
         let _ = mqtt::publish_mppt_state(&mut board).await;
+        let _ = mqtt::publish_wifi_scan(&mut board).await;
     }
 
     log(

Software/MainBoard/rust/src/mqtt.rs

@@ -6,8 +6,9 @@ use crate::log::{log, LogMessage};
 use crate::plant_state::PlantState;
 use crate::tank::TankState;
 use crate::{bail, VersionInfo};
-use alloc::string::String;
-use alloc::{format, string::ToString};
+use alloc::format;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
 use chrono::DateTime;
 use chrono_tz::Tz;
 use core::sync::atomic::Ordering;
@@ -349,6 +350,16 @@ pub async fn pump_info(
     };
 }
 
+/// Wi-Fi scan result details for MQTT
+#[derive(Serialize, Debug, PartialEq)]
+pub struct WifiScanResult {
+    pub ssid: String,
+    pub bssid: String,
+    pub rssi: i32,
+    pub channel: u8,
+    pub auth_method: String,
+}
+
 #[derive(Serialize, Debug, PartialEq)]
 pub struct Solar {
     pub current_ma: u32,
@@ -407,3 +418,30 @@ pub async fn publish_battery_state(
     publish("/battery", &json).await;
     Ok(())
 }
+
+/// Publish Wi-Fi scan details to MQTT
+pub async fn publish_wifi_scan(
+    board: &mut MutexGuard<'_, CriticalSectionRawMutex, HAL<'static>>,
+) -> FatResult<()> {
+    let mut wifi_details = board.board_hal.get_esp().wifi_scan_details().await?;
+    
+    // Sort by RSSI in descending order (strongest first)
+    wifi_details.sort_by(|a, b| b.rssi.cmp(&a.rssi));
+    
+    // Take only the strongest 10 results
+    let wifi_results: Vec<WifiScanResult> = wifi_details
+        .iter()
+        .take(10)
+        .map(|d| WifiScanResult {
+            ssid: d.ssid.clone(),
+            bssid: d.bssid.clone(),
+            rssi: d.rssi,
+            channel: d.channel,
+            auth_method: d.auth_method.clone(),
+        })
+        .collect();
+
+    let json = serde_json::to_string(&wifi_results)?;
+    publish("/wifi_scan", &json).await;
+    Ok(())
+}

Software/MainBoard/rust/src/webserver/get_json.rs

@@ -214,3 +214,12 @@ pub(crate) async fn get_log_localization_config<T, const N: usize>(
         &LogMessage::log_localisation_config(),
     )?))
 }
+
+/// Return Wi-Fi scan details including signal strength (RSSI)
+pub(crate) async fn get_wifi_details<T, const N: usize>(
+    _request: &mut Connection<'_, T, N>,
+) -> FatResult<Option<String>> {
+    let mut board = BOARD_ACCESS.get().await.lock().await;
+    let wifi_details = board.board_hal.get_esp().wifi_scan_details().await?;
+    Ok(Some(serde_json::to_string(&wifi_details)?))
+}

Software/MainBoard/rust/src/webserver/mod.rs

@@ -12,6 +12,7 @@ use crate::webserver::backup_manager::{backup_config, backup_info, get_backup_co
 use crate::webserver::get_json::{
     delete_save, get_battery_state, get_config, get_live_moisture, get_log_localization_config,
     get_firmware_info_web, get_solar_state, get_time, get_timezones, list_saves, tank_info,
+    get_wifi_details,
 };
 use crate::webserver::get_log::{get_live_log, get_log};
 use crate::webserver::get_static::{serve_bundle, serve_favicon, serve_index};
@@ -83,6 +84,7 @@ impl Handler for HTTPRequestRouter {
                             "/timezones" => Some(get_timezones().await),
                             "/moisture" => Some(get_live_moisture(conn).await),
                             "/list_saves" => Some(list_saves(conn).await),
+                            "/wifi_details" => Some(get_wifi_details(conn).await),
                             // /live_log accepts an optional ?after=N query parameter
                             p if p == "/live_log" || p.starts_with("/live_log?") => {
                                 let after: Option<u64> = p