chore: update esp-hal version

Author: filipton

Cargo.lock

@@ -5,27 +5,27 @@ authors = ["filipton <filipton12@gmail.com>"]
 edition = "2024"
 
 [dependencies]
-esp-backtrace = { version = "0.17.0", features = [ "exception-handler", "panic-handler", "println", "custom-pre-backtrace", "custom-halt", "esp32c3" ] }
-esp-hal = { version = "1.0.0-rc.0", features = [ "esp32c3" ] }
-esp-println = { version = "0.15.0", features = ["log-04", "esp32c3"] }
+esp-backtrace = { version = "0.18.0", features = [ "panic-handler", "println", "custom-pre-backtrace", "custom-halt", "esp32c3" ] }
+esp-hal = { version = "1.0.0-rc.1", features = [ "esp32c3" ] }
+esp-println = { version = "0.16.0", features = ["log-04", "esp32c3"] }
 log = { version = "0.4.28" }
-esp-wifi = { version = "0.15.0", features = ["coex", "esp32c3"] }
-esp-hal-embassy = { version = "0.9.0", features = ["esp32c3"] }
-embassy-executor = { version = "0.7.0", features = ["arch-riscv32", "nightly"] }
+esp-radio = { version = "0.16.0", features = ["coex", "esp32c3"] }
+esp-rtos = { version = "0.1.0", features = ["esp32c3", "embassy", "esp-radio"] }
+embassy-executor = { version = "0.9.1", features = ["arch-riscv32", "nightly"] }
 embassy-net = { version = "0.7.1", features = ["tcp", "udp", "multicast", "dhcpv4", "medium-ethernet", "proto-ipv4", "dns"] }
 embassy-time = { version = "0.5.0" }
-esp-storage = { version = "0.7.0", features = ["esp32c3"] }
+esp-storage = { version = "0.8.0", features = ["esp32c3"] }
 embedded-storage = "0.3.1"
 static_cell = { version = "2.1.1", features = ["nightly"] }
-heapless = { version = "0.8.0", default-features = false }
-esp-alloc = "0.8.0"
-esp-hal-wifimanager = { version = "0.1.2", default-features = false, features = ["ap", "ble", "esp32c3"] }
+heapless = { version = "0.9.1", default-features = false }
+esp-alloc = "0.9.0"
+esp-hal-wifimanager = { version = "0.2.0", default-features = false, features = ["ap", "ble", "esp32c3"] }
 serde = { version = "1.0.228", features = ["alloc", "derive"], default-features = false }
 serde_json = { version = "1.0.145", default-features = false, features = ["alloc"] }
 adv-shift-registers = "0.2.5"
 embedded-hal = "1.0.0"
-esp-hal-mdns = "0.1.2"
-embedded-io-async = "0.6.1"
+esp-hal-mdns = "0.1.3"
+embedded-io-async = "0.7.0"
 macros = { path = "./macros" }
 nb = "1.1.0"
 embassy-futures = "0.1.2"
@@ -37,20 +37,20 @@ critical-section = "1.2.0"
 getrandom = { version = "=0.2.15", features = ["custom"] }
 uuid = { version = "=1.12.1", default-features = false, features = ["v4"] }
 dyn-smooth = "0.2.0"
-esp-hal-ota = { version = "0.4.4", features = ["esp32c3"] }
-esp32c3 = { version = "0.30.0" }
+esp-hal-ota = { version = "0.4.5", features = ["esp32c3"] }
+esp32c3 = { version = "0.31.0" }
 anyhow = { version = "1.0.100", default-features = false }
 embedded-hal-bus = { version = "0.3.0", features = ["async"] }
 embedded-tls = { git = "https://github.com/drogue-iot/embedded-tls.git", rev="fbd486c4ee0c1f14bbc762976896afc9e2d708c8", default-features = false, features = ["alloc", "embedded-io-adapters", "log"] }
 rand_core = { version = "0.6.4", features = ["getrandom"] }
 ag-lcd-async = { git = "https://github.com/filipton/ag-lcd-async", features = [] }
 esp-hal-mfrc522 = { version = "0.3.2", features = ["embassy-time"] }
-esp-bootloader-esp-idf = { version = "0.2.0", features = ["log-04", "esp32c3"] }
-trouble-host = { version = "0.2.4", features = ["scan"] }
+esp-bootloader-esp-idf = { version = "0.3.0", features = ["log-04", "esp32c3"] }
+trouble-host = { version = "0.4.0", features = ["scan"] }
 
 [features]
 default = ["sleep"]
-esp_now = ["esp-wifi/esp-now"]
+esp_now = ["esp-radio/esp-now"]
 gen_version = []
 bat_dev_lcd = []
 release_build = ["sleep"]

Cargo.toml

@@ -1,15 +1,19 @@
 use core::cell::RefCell;
 use embassy_futures::join::join;
 use embassy_time::{Duration, Timer};
-use esp_wifi::{EspWifiController, ble::controller::BleConnector};
+use esp_radio::{Controller as RadioController, ble::controller::BleConnector};
 use trouble_host::prelude::*;
 
 #[embassy_executor::task]
 pub async fn bluetooth_timer_task(
-    init: &'static EspWifiController<'static>,
+    init: &'static RadioController<'static>,
     bt: esp_hal::peripherals::BT<'static>,
 ) {
-    let connector = BleConnector::new(init, bt);
+    let Ok(connector) = BleConnector::new(init, bt, esp_radio::ble::Config::default()) else {
+        log::error!("Cannot init ble connector");
+        return;
+    };
+
     let controller: ExternalController<_, 20> = ExternalController::new(connector);
 
     let address: Address = Address::random(esp_hal::efuse::Efuse::mac_address());

src/bluetooth.rs

@@ -3,7 +3,9 @@ use adv_shift_registers::wrappers::ShifterValueRange;
 use anyhow::Result;
 use esp_hal::{
     gpio::{AnyPin, Input, InputConfig, Level, Output, Pin, Pull},
-    peripherals::{ADC1, AES, BT, Peripherals, SPI2, TIMG0, TIMG1, UART1, WIFI},
+    peripherals::{
+        ADC1, AES, BT, FLASH, Peripherals, SPI2, SW_INTERRUPT, TIMG0, TIMG1, UART1, WIFI,
+    },
     rng::Rng,
     timer::timg::TimerGroup,
 };
@@ -21,6 +23,8 @@ pub struct Board {
     pub bt: BT<'static>,
     pub spi_dma: esp_hal::peripherals::DMA_CH0<'static>,
     pub aes: AES<'static>,
+    pub flash: FLASH<'static>,
+    pub sw_interrupt: SW_INTERRUPT<'static>,
 
     // spi
     pub miso: AnyPin<'static>,
@@ -48,14 +52,16 @@ impl Board {
 
         let timg0 = TimerGroup::new(peripherals.TIMG0);
         let timg1 = TimerGroup::new(peripherals.TIMG1);
-        let rng = Rng::new(peripherals.RNG);
+        let rng = Rng::new();
         let uart1 = peripherals.UART1;
         let spi2 = peripherals.SPI2;
         let spi_dma = peripherals.DMA_CH0;
         let adc1 = peripherals.ADC1;
         let wifi = peripherals.WIFI;
         let bt = peripherals.BT;
         let aes = peripherals.AES;
+        let flash = peripherals.FLASH;
+        let sw_interrupt = peripherals.SW_INTERRUPT;
 
         let sck = peripherals.GPIO4.degrade();
         let miso = peripherals.GPIO5.degrade();
@@ -105,6 +111,8 @@ impl Board {
             wifi,
             bt,
             aes,
+            flash,
+            sw_interrupt,
 
             miso,
             mosi,

src/board.rs

@@ -36,6 +36,11 @@ pub async fn buttons_task(
         ButtonTrigger::HoldOnce(1000),
         inspection_hold_stop(),
     );
+    handler.add_handler(
+        Button::First,
+        ButtonTrigger::HoldOnce(15000),
+        connect_bluetooth_display(),
+    );
 
     handler.add_handler(Button::Fourth, ButtonTrigger::Down, room_right());
     handler.add_handler(Button::Fourth, ButtonTrigger::HoldOnce(1000), dnf_button());
@@ -244,6 +249,16 @@ async fn inspection_hold_stop(
     Ok(false)
 }
 
+#[macros::button_handler]
+async fn connect_bluetooth_display(
+    _triggered: &ButtonTrigger,
+    _hold_time: u64,
+    state: &GlobalState,
+) -> Result<bool, ()> {
+    _ = state;
+    Ok(false)
+}
+
 #[macros::button_handler]
 async fn dnf_button(
     _triggered: &ButtonTrigger,

src/buttons.rs

@@ -12,6 +12,7 @@ use embassy_executor::Spawner;
 use embassy_sync::signal::Signal;
 use embassy_time::{Instant, Timer};
 use esp_backtrace as _;
+use esp_hal::interrupt::software::SoftwareInterruptControl;
 use esp_hal_wifimanager::{Nvs, WIFI_NVS_KEY};
 use esp_storage::FlashStorage;
 use state::{GlobalState, GlobalStateInner, SavedGlobalState, Scene, ota_state, sleep_state};
@@ -20,7 +21,7 @@ use utils::{logger::FkmLogger, set_brownout_detection};
 use ws_framer::{WsUrl, WsUrlOwned};
 
 #[cfg(feature = "esp_now")]
-use esp_wifi::esp_now::{EspNowManager, EspNowSender};
+use esp_radio::esp_now::{EspNowManager, EspNowSender};
 
 mod battery;
 mod bluetooth;
@@ -70,7 +71,7 @@ macro_rules! mk_static {
 
 esp_bootloader_esp_idf::esp_app_desc!();
 
-#[esp_hal_embassy::main]
+#[esp_rtos::main]
 async fn main(spawner: Spawner) {
     let peripherals = esp_hal::init({
         let mut config = esp_hal::Config::default();
@@ -99,7 +100,8 @@ async fn main(spawner: Spawner) {
 
     set_brownout_detection(false);
     let board = Board::init(peripherals).expect("Board init error");
-    esp_hal_embassy::init(board.timg1.timer0);
+    let software_interrupt = SoftwareInterruptControl::new(board.sw_interrupt);
+    esp_rtos::start(board.timg1.timer0, software_interrupt.software_interrupt0);
     FkmLogger::set_logger();
 
     log::info!("Version: {}", version::VERSION);
@@ -112,7 +114,8 @@ async fn main(spawner: Spawner) {
     #[cfg(feature = "qa")]
     log::info!("This firmware is in QA mode!");
 
-    let nvs = Nvs::new_from_part_table().expect("Wrong partition configuration!");
+    let nvs = Nvs::new_from_part_table(unsafe { board.flash.clone_unchecked() })
+        .expect("Wrong partition configuration!");
     let global_state = Rc::new(GlobalStateInner::new(&nvs, board.aes));
     let wifi_setup_sig = Rc::new(Signal::new());
 
@@ -171,7 +174,9 @@ async fn main(spawner: Spawner) {
 
     // mark ota as valid
     {
-        if let Ok(mut ota) = esp_hal_ota::Ota::new(FlashStorage::new()) {
+        if let Ok(mut ota) =
+            esp_hal_ota::Ota::new(FlashStorage::new(unsafe { board.flash.clone_unchecked() }))
+        {
             let res = ota.ota_mark_app_valid();
             if let Err(e) = res {
                 log::error!("Ota mark app valid failed: {e:?}");
@@ -226,7 +231,6 @@ async fn main(spawner: Spawner) {
             #[cfg(not(feature = "qa"))]
             Some(&nvs),
             board.rng,
-            board.timg0.timer0,
             board.wifi,
             unsafe { board.bt.clone_unchecked() },
             Some(wifi_setup_sig),

src/main.rs

@@ -4,8 +4,10 @@ const MAX_BACKTRACE_ADDRESSES: usize = 10;
 const RA_OFFSET: usize = 4;
 
 pub async fn read_saved_backtrace() {
-    if let Some(nvs_part) = esp_hal_wifimanager::Nvs::read_nvs_partition_offset() {
-        let mut flash = FlashStorage::new();
+    if let Some(nvs_part) = esp_hal_wifimanager::Nvs::read_nvs_partition_offset(unsafe {
+        esp_hal::peripherals::FLASH::steal()
+    }) {
+        let mut flash = FlashStorage::new(unsafe { esp_hal::peripherals::FLASH::steal() });
 
         let mut buf = [0; 1024];
         let res = embedded_storage::ReadStorage::read(
@@ -124,8 +126,10 @@ pub extern "Rust" fn custom_pre_backtrace() {
         tmp.push_str(&alloc::format!("0x{:x}\n", addr - RA_OFFSET));
     }
 
-    if let Some(nvs_part) = esp_hal_wifimanager::Nvs::read_nvs_partition_offset() {
-        let mut flash = FlashStorage::new();
+    if let Some(nvs_part) = esp_hal_wifimanager::Nvs::read_nvs_partition_offset(unsafe {
+        esp_hal::peripherals::FLASH::steal()
+    }) {
+        let mut flash = FlashStorage::new(unsafe { esp_hal::peripherals::FLASH::steal() });
         _ = embedded_storage::Storage::write(
             &mut flash,
             (nvs_part.0 + nvs_part.1 - 2) as u32,

src/utils/backtrace_store.rs

@@ -84,5 +84,5 @@ fn esp32c3_rtc_apb_freq_update() {
 
     rtc_cntl
         .store5()
-        .modify(|_, w| unsafe { w.scratch5().bits(value) });
+        .modify(|_, w| unsafe { w.data().bits(value) });
 }

src/utils/mod.rs

@@ -11,7 +11,6 @@ use embassy_sync::{
     signal::Signal,
 };
 use embassy_time::{Duration, Instant, Timer, WithTimeout};
-use embedded_io_async::Write;
 use embedded_tls::{Aes128GcmSha256, NoVerify, TlsConfig, TlsConnection, TlsContext};
 use esp_hal_ota::Ota;
 use esp_storage::FlashStorage;
@@ -208,11 +207,11 @@ async fn ws_loop(
             let mut block = [0; 16];
             block.copy_from_slice(&random_signed.to_be_bytes());
 
-            global_state.aes.lock().await.process(
-                &mut block,
-                esp_hal::aes::Mode::Decryption128,
-                esp_hal::aes::Key::Key16(key),
-            );
+            global_state
+                .aes
+                .lock()
+                .await
+                .decrypt(&mut block, esp_hal::aes::Key::Key128(key));
 
             let recv_random = u64::from_be_bytes(block[..8].try_into().expect(""));
             let fkm_token = i32::from_be_bytes(block[8..12].try_into().expect(""));
@@ -291,7 +290,10 @@ async fn ws_rw(
     global_state: GlobalState,
     socket: &mut WsSocket<'_, '_>,
 ) -> Result<(), WsRwError> {
-    let mut ota = Ota::new(FlashStorage::new()).map_err(WsRwError::OtaError)?;
+    let mut ota = Ota::new(FlashStorage::new(unsafe {
+        esp_hal::peripherals::FLASH::steal()
+    }))
+    .map_err(WsRwError::OtaError)?;
     let tagged_publisher = TAGGED_RETURN
         .publisher()
         .map_err(|_| WsRwError::TaggedPublisherError)?;
@@ -610,17 +612,25 @@ impl WsSocket<'_, '_> {
     }
 
     pub async fn write_all(&mut self, buf: &[u8]) -> Result<(), ()> {
-        match self {
+        let mut written = 0;
+        while written < buf.len() {
+            written += self.write(&buf[written..]).await?;
+        }
+
+        Ok(())
+    }
+
+    pub async fn write(&mut self, buf: &[u8]) -> Result<usize, ()> {
+        let n = match self {
             WsSocket::Tls(tls_connection) => {
-                tls_connection.write_all(buf).await.map_err(|_| ())?;
+                let n = tls_connection.write(buf).await.map_err(|_| ())?;
                 tls_connection.flush().await.map_err(|_| ())?;
+                n
             }
-            WsSocket::Raw(tcp_socket) => {
-                tcp_socket.write_all(buf).await.map_err(|_| ())?;
-            }
-        }
+            WsSocket::Raw(tcp_socket) => tcp_socket.write(buf).await.map_err(|_| ())?,
+        };
 
-        Ok(())
+        Ok(n)
     }
 }