tdfischer/renderbug-bike
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tasks: wifi: tweak the hardware config for more reliability where possible

Browse Source
This commit is contained in:
Victoria Fischer
2026-03-09 10:24:15 +01:00
parent 9ecfd11982
commit 74d753e0b3
2 changed files with 48 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/bin/main.rs
View File

@@ -155,7 +155,16 @@ async fn main(spawner: Spawner) {
let ble = esp_radio::ble::controller::BleConnector::new(wifi_init, peripherals.BT, esp_radio::ble::Config::default()).unwrap();
let (wifi, interfaces) = esp_radio::wifi::new(wifi_init, peripherals.WIFI, esp_radio::wifi::Config::default())
let wifi_config = esp_radio::wifi::Config::default()
.with_rx_queue_size(64)
.with_tx_queue_size(256)
.with_static_rx_buf_num(32)
.with_static_tx_buf_num(32)
.with_dynamic_rx_buf_num(128)
.with_dynamic_tx_buf_num(128)
.with_rx_ba_win(7)
.with_power_save_mode(esp_radio::wifi::PowerSaveMode::Minimum);
let (wifi, interfaces) = esp_radio::wifi::new(wifi_init, peripherals.WIFI, wifi_config)
.expect("Failed to initialize WIFI!");
(wifi, interfaces.sta, ble)
@@ -198,16 +207,16 @@ async fn main(spawner: Spawner) {
let seed = Rng::new().random() as i32;
let (stack, runner) = embassy_net::new(network_device, config, RESOURCES.take(), seed as u64);
info!("Launching network services");
//spawner.must_spawn(renderbug_embassy::tasks::wifi::net_task(runner));
spawner.must_spawn(renderbug_bike::tasks::wifi::net_task(runner));
info!("Starting connectivity task");
//spawner.must_spawn(renderbug_embassy::tasks::wifi::wifi_connect_task(wifi, stack, motion_bus.dyn_sender()));
spawner.must_spawn(renderbug_bike::tasks::wifi::wifi_connect_task(wifi, motion_bus.dyn_sender()));
info!("Launching HTTP telemetry");
spawner.must_spawn(renderbug_bike::tasks::wifi::http_telemetry_task(predictions.dyn_subscriber().unwrap(), stack, motion_bus.dyn_sender()));
info!("Starting BLE services");
spawner.must_spawn(renderbug_embassy::tasks::ble::ble_task(ble, predictions.dyn_subscriber().unwrap(), spawner));
spawner.must_spawn(renderbug_bike::tasks::ble::ble_task(ble, predictions.dyn_subscriber().unwrap(), spawner));
}
#[cfg(feature="dual-core")]

66
src/tasks/wifi.rs
View File

@@ -1,7 +1,7 @@
use alloc::string::ToString;
use alloc::string::{String, ToString};
use embassy_sync::channel::DynamicSender;
use embassy_sync::pubsub::DynSubscriber;
use embassy_time::{Duration, Instant, WithTimeout};
use embassy_time::{Duration, Instant, Timer, WithTimeout};
use esp_hal::rng::Rng;
use esp_radio::wifi::{ClientConfig, ScanConfig, WifiController, WifiDevice, WifiEvent};
use log::*;
@@ -23,52 +23,46 @@ pub async fn net_task(mut runner: embassy_net::Runner<'static, WifiDevice<'stati
runner.run().await
}
#[embassy_executor::task]
pub async fn wifi_connect_task(mut wifi: WifiController<'static>, stack: Stack<'static>, motion: DynamicSender<'static, Measurement>) {
wifi.set_config(&esp_radio::wifi::ModeConfig::Client(
ClientConfig::default()
.with_ssid("The Frequency".to_string())
.with_auth_method(esp_radio::wifi::AuthMethod::Wpa2Personal)
.with_password("thepasswordkenneth".to_string())
)).unwrap();
wifi.set_mode(esp_radio::wifi::WifiMode::Sta).unwrap();
wifi.set_power_saving(esp_radio::wifi::PowerSaveMode::Maximum).unwrap();
pub fn config_for_network(name: &str) -> Option<ClientConfig> {
Some(match name {
"The Frequency" => Some(ClientConfig::default().with_password("thepasswordkenneth".to_string())),
"The Frozen Throne" => Some(ClientConfig::default().with_password("IronEmpress420".to_string())),
_ => None
}?.with_ssid(name.to_string()))
}
#[embassy_executor::task]
pub async fn wifi_connect_task(mut wifi: WifiController<'static>, motion: DynamicSender<'static, Measurement>) {
wifi.set_mode(esp_radio::wifi::WifiMode::Sta).unwrap();
wifi.start_async().with_timeout(Duration::from_secs(30)).await.unwrap().unwrap();
Timer::after_secs(2).await;
// TODO: need a way to stop wifi after, say, 30 seconds of being unable to connect, or the system goes to sleep
loop {
Backoff::from_secs(3).forever().attempt(async || {
info!("Connecting to wifi...");
wifi.start_async().await.unwrap();
motion.send(Measurement::SensorHardwareStatus(SensorSource::Wifi, crate::events::SensorState::AcquiringFix)).await;
let networks = wifi.scan_with_config_async(ScanConfig::default().with_show_hidden(true)).await.unwrap();
let networks = wifi.scan_with_config_async(ScanConfig::default()).await.unwrap();
for network in networks {
info!("wifi: {} @ {}db", network.ssid, network.signal_strength);
if let Some(cfg) = config_for_network(&network.ssid) {
wifi.set_config(&esp_radio::wifi::ModeConfig::Client(cfg)).unwrap();
if wifi.connect_async().await.is_err() {
error!("Unable to connect to wifi {network:?}");
}
match wifi.connect_async().await {
Ok(_) => Ok(()),
Err(e) => {
error!("Unable to connect to wifi: {e:?}");
wifi.stop_async().await.unwrap();
Err(())
break;
}
}
}).await.unwrap();
info!("Waiting for DHCP...");
motion.send(Measurement::SensorHardwareStatus(SensorSource::Wifi, SensorState::Degraded)).await;
if stack.wait_config_up().with_timeout(Duration::from_secs(5)).await.is_ok() {
info!("Online!");
motion.send(Measurement::SensorHardwareStatus(SensorSource::Wifi, SensorState::Online)).await;
let ip_cfg = stack.config_v4().unwrap();
info!("ip={ip_cfg:?}");
wifi.wait_for_event(WifiEvent::ApStaDisconnected).await;
info!("Wifi disconnected!");
if wifi.is_connected().unwrap() {
info!("Wifi is online!");
motion.send(Measurement::SensorHardwareStatus(SensorSource::Wifi, crate::events::SensorState::Online)).await;
wifi.wait_for_event(WifiEvent::StaDisconnected).await;
error!("Wifi disconnected");
} else {
warn!("DHCP timed out after 5 seconds. Disconnecting wifi");
wifi.disconnect_async().await.unwrap();
info!("Wifi is offline.");
motion.send(Measurement::SensorHardwareStatus(SensorSource::Wifi, crate::events::SensorState::Offline)).await;
Timer::after_secs(30).await;
}
warn!("Stopping wifi device");
wifi.stop_async().await.unwrap();
motion.send(Measurement::SensorHardwareStatus(SensorSource::Wifi, SensorState::Offline)).await;
}
}