diff --git a/.cargo/config.toml b/.cargo/config.toml
index 151ab092..fb3627f2 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,19 +1,17 @@
 [target.xtensa-esp32s3-none-elf]
 runner    = "probe-rs run --preverify"
+#runner = "espflash flash -M --erase-parts=otadata --log-format=defmt -T partitions.csv -s 8mb"
 rustflags = [
   "-C", "link-arg=-nostartfiles",
   "-C", "link-arg=-Wl,-Tlinkall.x",
-  "-C", "link-arg=-Trom_functions.x",
-  "-C", "link-arg=-Tdefmt.x",
 ]
 
 [target.riscv32imac-unknown-none-elf]
 runner    = "probe-rs run --preverify"
+#runner = "espflash flash -M --erase-parts=otadata --log-format=defmt -T partitions.csv -s 8mb"
 rustflags = [
   "-C", "force-frame-pointers",
   "-C", "link-arg=-Tlinkall.x",
-  "-C", "link-arg=-Trom_functions.x",
-  "-C", "link-arg=-Tdefmt.x",
 ]
 
 [alias]
@@ -38,8 +36,8 @@ ESP_WIFI_TX_QUEUE_SIZE = "16"
 ESP_WIFI_STATIC_TX_BUF_NUM = "12"
 ESP_WIFI_DYNAMIC_TX_BUF_NUM = "16"
 
-ESP_WIFI_AMPDU_RX_ENABLE = "y"
-ESP_WIFI_AMPDU_TX_ENABLE = "y"
+ESP_WIFI_AMPDU_RX_ENABLE = "true"
+ESP_WIFI_AMPDU_TX_ENABLE = "true"
 ESP_WIFI_RX_BA_WIN = "8"
 ESP_WIFI_MAX_BURST_SIZE = "0" # 0 means no limit
 ESP_WIFI_TICK_RATE_HZ = "200"
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
index 56b0358d..60a223df 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -50,32 +50,24 @@ embassy-executor = { workspace = true, features = ["nightly"] }
 embassy-time = { version = "0.3.0" }
 
 embedded-hal-old = { package = "embedded-hal", version = "0.2.7" }
-rtt-target = { version = "0.6.0", git = "https://github.com/probe-rs/rtt-target" }
+rtt-target = { version = "0.6.0", git = "https://github.com/probe-rs/rtt-target", optional = true }
 
-esp-hal = { version = "0.21.0" }
-esp-hal-embassy = { version = "0.4.0" }
+esp-hal = { version = "0.22.0" }
+esp-hal-embassy = { version = "0.5.0" }
 esp-backtrace = { version = "0.14.2", features = [
     "panic-handler",
-    "exception-handler",
-    "defmt"
+    "exception-handler"
 ] }
-esp-alloc = "0.5.0"
-esp-wifi = { version = "0.10.1", default-features = false, features = [
-    "esp-alloc",
-    "phy-enable-usb",
-    "ps-max-modem",
-    "wifi",
-    "async",
-    "embassy-net",
-    "tcp",
-    "dns",
-    "ipv4",
-    "dhcpv4"
+esp-println = { version = "0.12.0", default-features = false, optional = true, features = [
+    "critical-section",
 ] }
+esp-alloc = "0.5.0"
+esp-wifi = { version = "0.11.0", features = ["wifi"] }
 
 display-interface = "0.5"
 display-interface-spi = "0.5"
 ssd1306 = { version = "0.9.0", features = ["async", "graphics"] }
+maybe-async-cfg = "=0.2.4"
 
 portable_atomic_enum = "0.3.1"
 config-site = { path = "config-site", default-features = false, features = [
@@ -129,16 +121,18 @@ smoltcp.workspace = true
 crc = "3.0.1"
 enumset = "1.1.3"
 
-#[patch.crates-io]
-#esp-hal = { git = "https://github.com/bugadani/esp-hal.git", rev = "7ca1b4376fd48229c887018d7133ce317742ce4e" }
-#esp-hal-embassy = { git = "https://github.com/bugadani/esp-hal.git", rev = "7ca1b4376fd48229c887018d7133ce317742ce4e" }
-#esp-wifi = { git = "https://github.com/bugadani/esp-hal.git", rev = "7ca1b4376fd48229c887018d7133ce317742ce4e" }
-#esp-backtrace = { git = "https://github.com/bugadani/esp-hal.git", rev = "7ca1b4376fd48229c887018d7133ce317742ce4e" }
-#esp-println = { git = "https://github.com/bugadani/esp-hal.git", rev = "7ca1b4376fd48229c887018d7133ce317742ce4e" }
-#esp-alloc = { git = "https://github.com/bugadani/esp-hal.git", rev = "7ca1b4376fd48229c887018d7133ce317742ce4e" }
+# [patch.crates-io]
+# esp-hal = { git = "https://github.com/jessebraham/esp-hal.git", rev = "a80385a20a85592a0466311da24f4d5ec8c7ea71" }
+# esp-hal-embassy = { git = "https://github.com/jessebraham/esp-hal.git", rev = "a80385a20a85592a0466311da24f4d5ec8c7ea71" }
+# esp-wifi = { git = "https://github.com/jessebraham/esp-hal.git", rev = "a80385a20a85592a0466311da24f4d5ec8c7ea71" }
+# esp-backtrace = { git = "https://github.com/jessebraham/esp-hal.git", rev = "a80385a20a85592a0466311da24f4d5ec8c7ea71" }
+# esp-println = { git = "https://github.com/jessebraham/esp-hal.git", rev = "a80385a20a85592a0466311da24f4d5ec8c7ea71" }
+# esp-alloc = { git = "https://github.com/jessebraham/esp-hal.git", rev = "a80385a20a85592a0466311da24f4d5ec8c7ea71" }
+# xtensa-lx-rt = { git = "https://github.com/jessebraham/esp-hal.git", rev = "a80385a20a85592a0466311da24f4d5ec8c7ea71" }
 
 [features]
-default = ["defmt"]
+default = ["defmt", "rtt"]
+#default = ["defmt", "esp-println"]
 
 battery_max17055 = ["dep:max17055"]
 
@@ -153,6 +147,7 @@ esp32s3 = [
     "esp-backtrace/esp32s3",
     "esp-wifi/esp32s3",
     "esp-hal-embassy/esp32s3",
+    "esp-println?/esp32s3",
 ]
 esp32c6 = [
     "esp-hal/esp32c6",
@@ -161,6 +156,7 @@ esp32c6 = [
     "esp-backtrace/esp32c6",
     "esp-wifi/esp32c6",
     "esp-hal-embassy/esp32c6",
+    "esp-println?/esp32c6",
 ]
 
 # Signal processing
@@ -172,6 +168,8 @@ defmt = [
     "embedded-graphics/defmt",
     "esp-wifi/defmt",
     "esp-hal/defmt",
+    "esp-backtrace/defmt",
+    "esp-println?/defmt-espflash",
 
     "logger/defmt",
     "config-site/defmt",
@@ -185,9 +183,12 @@ defmt = [
 
     "embassy-net/defmt",
     "smoltcp/defmt",
-    "rtt-target/defmt",
+    "rtt-target?/defmt",
 ]
 
+rtt = ["dep:rtt-target"]
+esp-println = ["dep:esp-println", "esp-println/jtag-serial"]
+
 [package.metadata.espflash]
 partition_table = "partitions.csv"
 format = "esp-bootloader"
diff --git a/build.rs b/build.rs
index 664ea234..6b024a54 100644
--- a/build.rs
+++ b/build.rs
@@ -86,6 +86,10 @@ fn main() {
 
     let build_config = BuildConfig { mcu, hw_version };
 
+    if cfg!(feature = "defmt") {
+        println!("cargo:rustc-link-arg=-Tdefmt.x");
+    }
+
     let pkg_version = env!("CARGO_PKG_VERSION");
     let git_hash_bytes = std::process::Command::new("git")
         .args(["rev-parse", "--short", "HEAD"])
diff --git a/src/board/drivers/bitbang_spi.rs b/src/board/drivers/bitbang_spi.rs
index 3367f479..8dc7a4da 100644
--- a/src/board/drivers/bitbang_spi.rs
+++ b/src/board/drivers/bitbang_spi.rs
@@ -53,8 +53,12 @@ where
         }
     }
 
-    pub fn change_bus_frequency(&mut self, frequency: HertzU32) {
-        self.half_bit_delay = Self::frequency_to_duration(frequency);
+    pub fn apply_config(
+        &mut self,
+        config: &esp_hal::spi::master::Config,
+    ) -> Result<(), esp_hal::spi::master::ConfigError> {
+        self.half_bit_delay = Self::frequency_to_duration(config.frequency);
+        Ok(())
     }
 }
 
diff --git a/src/board/hardware/v4.rs b/src/board/hardware/v4.rs
index f5701809..c68702ae 100644
--- a/src/board/hardware/v4.rs
+++ b/src/board/hardware/v4.rs
@@ -11,12 +11,11 @@ use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use esp_hal::{
     dma::*,
-    gpio::{Input, Io, Level, Output},
-    i2c::I2c,
+    gpio::{Input, Level, Output},
+    i2c::master::I2c,
     interrupt::software::SoftwareInterruptControl,
-    peripherals,
     rtc_cntl::Rtc,
-    spi::{master::SpiDmaBus, FullDuplexMode},
+    spi::master::SpiDmaBus,
     timer::{
         systimer::{SystemTimer, Target},
         timg::TimerGroup,
@@ -27,24 +26,14 @@ use esp_hal::{
 
 use display_interface_spi::SPIInterface;
 
-pub type DisplaySpiInstance = peripherals::SPI2;
 pub type DisplayDmaChannel = ChannelCreator<0>;
 
 pub type DisplayInterface<'a> = SPIInterface<DisplaySpi<'a>, Output<'static>>;
-pub type DisplaySpi<'d> = ExclusiveDevice<
-    SpiDmaBus<'d, DisplaySpiInstance, FullDuplexMode, Async>,
-    DummyOutputPin,
-    Delay,
->;
+pub type DisplaySpi<'d> = ExclusiveDevice<SpiDmaBus<'d, Async>, DummyOutputPin, Delay>;
 
 pub type AdcDmaChannel = ChannelCreator<1>;
-pub type AdcSpiInstance = peripherals::SPI3;
 
-pub type AdcSpi = ExclusiveDevice<
-    SpiDmaBus<'static, AdcSpiInstance, FullDuplexMode, Async>,
-    Output<'static>,
-    Delay,
->;
+pub type AdcSpi = ExclusiveDevice<SpiDmaBus<'static, Async>, Output<'static>, Delay>;
 
 pub type BatteryAdcEnablePin = Output<'static>;
 pub type VbusDetectPin = Input<'static>;
@@ -57,8 +46,7 @@ pub type PoweredEcgFrontend =
 
 pub type Display = DisplayType<Output<'static>>;
 
-pub type BatteryFgI2cInstance = peripherals::I2C0;
-pub type BatteryFgI2c = I2c<'static, BatteryFgI2cInstance, Async>;
+pub type BatteryFgI2c = I2c<'static, Async>;
 pub type BatteryFg = BatteryFgType<BatteryFgI2c, BatteryAdcEnablePin>;
 
 impl super::startup::StartupResources {
@@ -66,44 +54,45 @@ impl super::startup::StartupResources {
         let peripherals = Self::common_init();
 
         let systimer = SystemTimer::new(peripherals.SYSTIMER).split::<Target>();
-        esp_hal_embassy::init(systimer.alarm0);
-
-        let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
+        esp_hal_embassy::init([
+            AnyTimer::from(systimer.alarm0),
+            AnyTimer::from(systimer.alarm1),
+        ]);
 
         let dma = Dma::new(peripherals.DMA);
 
         let display = Self::create_display_driver(
             dma.channel0,
             peripherals.SPI2,
-            io.pins.gpio12,
-            io.pins.gpio13,
-            io.pins.gpio11,
-            io.pins.gpio14,
-            io.pins.gpio21,
+            peripherals.GPIO12,
+            peripherals.GPIO13,
+            peripherals.GPIO11,
+            peripherals.GPIO14,
+            peripherals.GPIO21,
         );
 
         let adc = Self::create_frontend_driver(
             Self::create_frontend_spi(
                 dma.channel1,
                 peripherals.SPI3,
-                io.pins.gpio6,
-                io.pins.gpio7,
-                io.pins.gpio5,
-                io.pins.gpio18,
+                peripherals.GPIO6,
+                peripherals.GPIO7,
+                peripherals.GPIO5,
+                peripherals.GPIO18,
             ),
-            io.pins.gpio4,
-            io.pins.gpio2,
-            io.pins.gpio38,
-            io.pins.gpio1,
+            peripherals.GPIO4,
+            peripherals.GPIO2,
+            peripherals.GPIO38,
+            peripherals.GPIO1,
         );
 
         let battery_monitor = Self::setup_battery_monitor_fg(
             peripherals.I2C0,
-            io.pins.gpio36,
-            io.pins.gpio35,
-            io.pins.gpio17,
-            io.pins.gpio47,
-            Output::new(io.pins.gpio8, Level::Low),
+            peripherals.GPIO36,
+            peripherals.GPIO35,
+            peripherals.GPIO17,
+            peripherals.GPIO47,
+            Output::new(peripherals.GPIO8, Level::Low),
         )
         .await;
 
diff --git a/src/board/hardware/v6c6.rs b/src/board/hardware/v6c6.rs
index 22f22d8d..002dbd88 100644
--- a/src/board/hardware/v6c6.rs
+++ b/src/board/hardware/v6c6.rs
@@ -12,13 +12,12 @@ use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use esp_hal::{
     dma::*,
-    gpio::{Input, Io, Level, Output, Pull},
-    i2c::I2c,
+    gpio::{Input, Level, Output, Pull},
+    i2c::master::I2c,
     interrupt::software::SoftwareInterruptControl,
-    peripherals,
     prelude::*,
     rtc_cntl::Rtc,
-    spi::{master::SpiDmaBus, FullDuplexMode},
+    spi::master::SpiDmaBus,
     timer::{
         systimer::{SystemTimer, Target},
         timg::TimerGroup,
@@ -29,15 +28,10 @@ use esp_hal::{
 
 pub use crate::board::drivers::bitbang_spi::BitbangSpi;
 
-pub type DisplaySpiInstance = peripherals::SPI2;
 pub type DisplayDmaChannel = ChannelCreator<0>;
 
 pub type DisplayInterface<'a> = SPIInterface<DisplaySpi<'a>, Output<'static>>;
-pub type DisplaySpi<'d> = ExclusiveDevice<
-    SpiDmaBus<'d, DisplaySpiInstance, FullDuplexMode, Async>,
-    DummyOutputPin,
-    Delay,
->;
+pub type DisplaySpi<'d> = ExclusiveDevice<SpiDmaBus<'d, Async>, DummyOutputPin, Delay>;
 
 pub type AdcSpi = ExclusiveDevice<
     BitbangSpi<Output<'static>, Input<'static>, Output<'static>>,
@@ -56,55 +50,55 @@ pub type PoweredEcgFrontend =
 
 pub type Display = DisplayType<Output<'static>>;
 
-pub type BatteryFgI2cInstance = peripherals::I2C0;
-pub type BatteryFgI2c = I2c<'static, BatteryFgI2cInstance, Async>;
+pub type BatteryFgI2c = I2c<'static, Async>;
 pub type BatteryFg = BatteryFgType<BatteryFgI2c, BatteryAdcEnablePin>;
 
 impl super::startup::StartupResources {
     pub async fn initialize() -> Self {
         let peripherals = Self::common_init();
 
-        let timg0 = TimerGroup::new(peripherals.TIMG0);
-        esp_hal_embassy::init(timg0.timer0);
-
-        let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
+        let systimer = SystemTimer::new(peripherals.SYSTIMER).split::<Target>();
+        esp_hal_embassy::init([
+            AnyTimer::from(systimer.alarm0),
+            AnyTimer::from(systimer.alarm1),
+        ]);
 
         let dma = Dma::new(peripherals.DMA);
 
         let display = Self::create_display_driver(
             dma.channel0,
             peripherals.SPI2,
-            io.pins.gpio10,
-            io.pins.gpio8,
-            io.pins.gpio11,
-            io.pins.gpio22,
-            io.pins.gpio21,
+            peripherals.GPIO10,
+            peripherals.GPIO8,
+            peripherals.GPIO11,
+            peripherals.GPIO22,
+            peripherals.GPIO21,
         );
 
         let adc = Self::create_frontend_driver(
             ExclusiveDevice::new(
                 BitbangSpi::new(
-                    Output::new(io.pins.gpio7, Level::Low),
-                    Input::new(io.pins.gpio5, Pull::None),
-                    Output::new(io.pins.gpio6, Level::Low),
+                    Output::new(peripherals.GPIO7, Level::Low),
+                    Input::new(peripherals.GPIO5, Pull::None),
+                    Output::new(peripherals.GPIO6, Level::Low),
                     1u32.MHz(),
                 ),
-                Output::new(io.pins.gpio9, Level::High),
+                Output::new(peripherals.GPIO9, Level::High),
                 Delay,
             )
             .unwrap(),
-            io.pins.gpio4,
-            io.pins.gpio15,
-            io.pins.gpio23,
-            io.pins.gpio2,
+            peripherals.GPIO4,
+            peripherals.GPIO15,
+            peripherals.GPIO23,
+            peripherals.GPIO2,
         );
 
         let battery_monitor = Self::setup_battery_monitor_fg(
             peripherals.I2C0,
-            io.pins.gpio19,
-            io.pins.gpio18,
-            io.pins.gpio3,
-            io.pins.gpio20,
+            peripherals.GPIO19,
+            peripherals.GPIO18,
+            peripherals.GPIO3,
+            peripherals.GPIO20,
             DummyOutputPin,
         )
         .await;
@@ -118,7 +112,7 @@ impl super::startup::StartupResources {
             wifi: static_cell::make_static! {
                 WifiDriver::new(
                     peripherals.WIFI,
-                    AnyTimer::from(SystemTimer::new(peripherals.SYSTIMER).split::<Target>().alarm0),
+                    AnyTimer::from(systimer.alarm2),
                     peripherals.RNG,
                     peripherals.RADIO_CLK,
                 )
diff --git a/src/board/hardware/v6s3.rs b/src/board/hardware/v6s3.rs
index e97380c8..a605e567 100644
--- a/src/board/hardware/v6s3.rs
+++ b/src/board/hardware/v6s3.rs
@@ -12,12 +12,11 @@ use embassy_time::Delay;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use esp_hal::{
     dma::*,
-    gpio::{Input, Io, Output},
-    i2c::I2c,
+    gpio::{Input, Output},
+    i2c::master::I2c,
     interrupt::software::SoftwareInterruptControl,
-    peripherals,
     rtc_cntl::Rtc,
-    spi::{master::SpiDmaBus, FullDuplexMode},
+    spi::master::SpiDmaBus,
     timer::{
         systimer::{SystemTimer, Target},
         timg::TimerGroup,
@@ -26,24 +25,14 @@ use esp_hal::{
     Async,
 };
 
-pub type DisplaySpiInstance = peripherals::SPI2;
 pub type DisplayDmaChannel = ChannelCreator<0>;
 
 pub type DisplayInterface<'a> = SPIInterface<DisplaySpi<'a>, Output<'static>>;
-pub type DisplaySpi<'d> = ExclusiveDevice<
-    SpiDmaBus<'d, DisplaySpiInstance, FullDuplexMode, Async>,
-    DummyOutputPin,
-    Delay,
->;
+pub type DisplaySpi<'d> = ExclusiveDevice<SpiDmaBus<'d, Async>, DummyOutputPin, Delay>;
 
 pub type AdcDmaChannel = ChannelCreator<1>;
-pub type AdcSpiInstance = peripherals::SPI3;
 
-pub type AdcSpi = ExclusiveDevice<
-    SpiDmaBus<'static, AdcSpiInstance, FullDuplexMode, Async>,
-    Output<'static>,
-    Delay,
->;
+pub type AdcSpi = ExclusiveDevice<SpiDmaBus<'static, Async>, Output<'static>, Delay>;
 
 pub type BatteryAdcEnablePin = DummyOutputPin;
 pub type VbusDetectPin = Input<'static>;
@@ -56,8 +45,7 @@ pub type PoweredEcgFrontend =
 
 pub type Display = DisplayType<Output<'static>>;
 
-pub type BatteryFgI2cInstance = peripherals::I2C0;
-pub type BatteryFgI2c = I2c<'static, BatteryFgI2cInstance, Async>;
+pub type BatteryFgI2c = I2c<'static, Async>;
 pub type BatteryFg = BatteryFgType<BatteryFgI2c, BatteryAdcEnablePin>;
 
 impl super::startup::StartupResources {
@@ -65,43 +53,44 @@ impl super::startup::StartupResources {
         let peripherals = Self::common_init();
 
         let systimer = SystemTimer::new(peripherals.SYSTIMER).split::<Target>();
-        esp_hal_embassy::init(systimer.alarm0);
-
-        let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
+        esp_hal_embassy::init([
+            AnyTimer::from(systimer.alarm0),
+            AnyTimer::from(systimer.alarm1),
+        ]);
 
         let dma = Dma::new(peripherals.DMA);
 
         let display = Self::create_display_driver(
             dma.channel0,
             peripherals.SPI2,
-            io.pins.gpio18,
-            io.pins.gpio17,
-            io.pins.gpio8,
-            io.pins.gpio39,
-            io.pins.gpio38,
+            peripherals.GPIO18,
+            peripherals.GPIO17,
+            peripherals.GPIO8,
+            peripherals.GPIO39,
+            peripherals.GPIO38,
         );
 
         let adc = Self::create_frontend_driver(
             Self::create_frontend_spi(
                 dma.channel1,
                 peripherals.SPI3,
-                io.pins.gpio6,
-                io.pins.gpio7,
-                io.pins.gpio5,
-                io.pins.gpio0,
+                peripherals.GPIO6,
+                peripherals.GPIO7,
+                peripherals.GPIO5,
+                peripherals.GPIO0,
             ),
-            io.pins.gpio4,
-            io.pins.gpio42,
-            io.pins.gpio40,
-            io.pins.gpio1,
+            peripherals.GPIO4,
+            peripherals.GPIO42,
+            peripherals.GPIO40,
+            peripherals.GPIO1,
         );
 
         let battery_monitor = Self::setup_battery_monitor_fg(
             peripherals.I2C0,
-            io.pins.gpio36,
-            io.pins.gpio35,
-            io.pins.gpio2,
-            io.pins.gpio37,
+            peripherals.GPIO36,
+            peripherals.GPIO35,
+            peripherals.GPIO2,
+            peripherals.GPIO37,
             DummyOutputPin,
         )
         .await;
diff --git a/src/board/startup.rs b/src/board/startup.rs
index 8b5e5ac8..b7cd12a6 100644
--- a/src/board/startup.rs
+++ b/src/board/startup.rs
@@ -7,29 +7,32 @@ use crate::board::{
     drivers::{battery_monitor::BatteryMonitor, frontend::Frontend},
     utils::DummyOutputPin,
     wifi::WifiDriver,
-    AdcSpi, ChargerStatusPin, Display, DisplayDmaChannel, DisplaySpiInstance, EcgFrontend,
-    VbusDetectPin,
+    AdcSpi, ChargerStatusPin, Display, DisplayDmaChannel, EcgFrontend, VbusDetectPin,
 };
 use esp_hal::{
     clock::CpuClock,
     dma::*,
     dma_buffers,
     gpio::{Input, InputPin, Level, Output, OutputPin, Pull},
+    i2c,
     interrupt::software::SoftwareInterrupt,
     peripheral::Peripheral,
     peripherals::Peripherals,
     rtc_cntl::Rtc,
-    spi::{master::Spi, SpiMode},
+    spi::{
+        master::{Config as SpiConfig, Spi},
+        SpiMode,
+    },
 };
 
 #[cfg(feature = "esp32s3")]
-use crate::board::{AdcDmaChannel, AdcSpiInstance};
+use crate::board::AdcDmaChannel;
 
 #[cfg(feature = "battery_max17055")]
-use esp_hal::i2c::I2c;
+use esp_hal::i2c::master::I2c;
 #[cfg(feature = "battery_max17055")]
 use {
-    crate::board::{BatteryAdcEnablePin, BatteryFg, BatteryFgI2cInstance},
+    crate::board::{BatteryAdcEnablePin, BatteryFg},
     max17055::{DesignData, Max17055},
 };
 
@@ -90,7 +93,7 @@ impl StartupResources {
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn create_display_driver(
         display_dma_channel: DisplayDmaChannel,
-        display_spi: DisplaySpiInstance,
+        display_spi: impl Peripheral<P = impl esp_hal::spi::master::Instance> + 'static,
         display_reset: impl Peripheral<P = impl OutputPin> + 'static,
         display_dc: impl Peripheral<P = impl OutputPin> + 'static,
         display_cs: impl Peripheral<P = impl OutputPin> + 'static,
@@ -100,12 +103,18 @@ impl StartupResources {
         let (rx_buffer, rx_descriptors, tx_buffer, tx_descriptors) = dma_buffers!(4092);
         let dma_tx_buf = DmaTxBuf::new(tx_descriptors, tx_buffer).unwrap();
         let dma_rx_buf = DmaRxBuf::new(rx_descriptors, rx_buffer).unwrap();
-        let display_spi = Spi::new(display_spi, 40u32.MHz(), SpiMode::Mode0)
-            .with_sck(display_sclk)
-            .with_mosi(display_mosi)
-            .with_cs(display_cs)
-            .with_dma(display_dma_channel.configure_for_async(false, DmaPriority::Priority0))
-            .with_buffers(dma_rx_buf, dma_tx_buf);
+        let display_spi = Spi::new_with_config(display_spi, {
+            let mut config = SpiConfig::default();
+            config.frequency = 40u32.MHz();
+            config.mode = SpiMode::Mode0;
+            config
+        })
+        .with_sck(display_sclk)
+        .with_mosi(display_mosi)
+        .with_cs(display_cs)
+        .with_dma(display_dma_channel.configure(false, DmaPriority::Priority0))
+        .with_buffers(dma_rx_buf, dma_tx_buf)
+        .into_async();
 
         Display::new(
             SPIInterface::new(
@@ -121,10 +130,10 @@ impl StartupResources {
     #[cfg(feature = "esp32s3")]
     pub(crate) fn create_frontend_spi(
         adc_dma_channel: AdcDmaChannel,
-        adc_spi: AdcSpiInstance,
+        adc_spi: impl Peripheral<P = impl esp_hal::spi::master::Instance> + 'static,
         adc_sclk: impl Peripheral<P = impl OutputPin> + 'static,
         adc_mosi: impl Peripheral<P = impl OutputPin> + 'static,
-        adc_miso: impl Peripheral<P = impl InputPin> + 'static,
+        adc_miso: impl Peripheral<P = impl OutputPin> + 'static,
         adc_cs: impl Peripheral<P = impl OutputPin> + 'static,
     ) -> AdcSpi {
         let (rx_buffer, rx_descriptors, tx_buffer, tx_descriptors) = dma_buffers!(4092);
@@ -132,12 +141,18 @@ impl StartupResources {
         let dma_rx_buf = DmaRxBuf::new(rx_descriptors, rx_buffer).unwrap();
 
         ExclusiveDevice::new(
-            Spi::new(adc_spi, 1u32.MHz(), SpiMode::Mode1)
-                .with_sck(adc_sclk)
-                .with_mosi(adc_mosi)
-                .with_miso(adc_miso)
-                .with_dma(adc_dma_channel.configure_for_async(false, DmaPriority::Priority1))
-                .with_buffers(dma_rx_buf, dma_tx_buf),
+            Spi::new_with_config(adc_spi, {
+                let mut config = SpiConfig::default();
+                config.frequency = 1u32.MHz();
+                config.mode = SpiMode::Mode1;
+                config
+            })
+            .with_sck(adc_sclk)
+            .with_mosi(adc_mosi)
+            .with_miso(adc_miso)
+            .with_dma(adc_dma_channel.configure(false, DmaPriority::Priority1))
+            .with_buffers(dma_rx_buf, dma_tx_buf)
+            .into_async(),
             Output::new(adc_cs, Level::High),
             Delay,
         )
@@ -170,7 +185,7 @@ impl StartupResources {
         SDA: InputPin + OutputPin,
         SCL: InputPin + OutputPin,
     >(
-        i2c: BatteryFgI2cInstance,
+        i2c: impl Peripheral<P = impl i2c::master::Instance> + 'static,
         sda: impl Peripheral<P = SDA> + 'static,
         scl: impl Peripheral<P = SCL> + 'static,
         vbus_detect: impl Peripheral<P = impl InputPin> + 'static,
@@ -198,7 +213,19 @@ impl StartupResources {
             Input::new(vbus_detect, Pull::None),
             Input::new(charger_status, Pull::Up),
             BatteryFg::new(
-                Max17055::new(I2c::new_async(i2c, sda, scl, 100u32.kHz()), design),
+                Max17055::new(
+                    I2c::new(
+                        i2c,
+                        i2c::master::Config {
+                            frequency: 100u32.kHz(),
+                            ..Default::default()
+                        },
+                    )
+                    .with_sda(sda)
+                    .with_scl(scl)
+                    .into_async(),
+                    design,
+                ),
                 fg_enable,
             ),
         )
diff --git a/src/board/wifi/ap.rs b/src/board/wifi/ap.rs
index 2e5faa99..844ffe4d 100644
--- a/src/board/wifi/ap.rs
+++ b/src/board/wifi/ap.rs
@@ -16,7 +16,7 @@ use esp_wifi::{
         AccessPointConfiguration, Configuration, WifiApDevice, WifiController, WifiDevice,
         WifiEvent,
     },
-    EspWifiInitialization,
+    EspWifiController,
 };
 use macros as cardio;
 
@@ -61,7 +61,7 @@ impl Ap {
 }
 
 pub(super) struct ApState {
-    init: EspWifiInitialization,
+    init: EspWifiController<'static>,
     connection_task_control: TaskController<(), ApTaskResources>,
     net_task_control: TaskController<!>,
     handle: Ap,
@@ -69,7 +69,7 @@ pub(super) struct ApState {
 
 impl ApState {
     pub(super) fn init(
-        init: EspWifiInitialization,
+        init: EspWifiController<'static>,
         config: Config,
         wifi: &'static mut WIFI,
         rng: Rng,
@@ -77,8 +77,11 @@ impl ApState {
     ) -> Self {
         info!("Configuring AP");
 
-        let (ap_device, controller) =
-            unwrap!(esp_wifi::wifi::new_with_mode(&init, wifi, WifiApDevice));
+        let (ap_device, controller) = unwrap!(esp_wifi::wifi::new_with_mode(
+            unsafe { core::mem::transmute(&init) },
+            wifi,
+            WifiApDevice
+        ));
 
         info!("Starting AP");
 
@@ -106,7 +109,7 @@ impl ApState {
         }
     }
 
-    pub(super) async fn stop(mut self) -> EspWifiInitialization {
+    pub(super) async fn stop(mut self) -> EspWifiController<'static> {
         info!("Stopping AP");
         let _ = join(
             self.connection_task_control.stop(),
@@ -116,7 +119,7 @@ impl ApState {
 
         let controller = &mut self.connection_task_control.resources_mut().controller;
         if matches!(controller.is_started(), Ok(true)) {
-            unwrap!(controller.stop().await);
+            unwrap!(controller.stop_async().await);
         }
 
         info!("Stopped AP");
@@ -195,7 +198,7 @@ async fn ap_task(
             ap_controller.setup(&mut resources.controller).await;
 
             info!("Starting wifi");
-            unwrap!(resources.controller.start().await);
+            unwrap!(resources.controller.start_async().await);
             info!("Wifi started!");
 
             loop {
diff --git a/src/board/wifi/ap_sta.rs b/src/board/wifi/ap_sta.rs
index 62a72b6b..a94abc86 100644
--- a/src/board/wifi/ap_sta.rs
+++ b/src/board/wifi/ap_sta.rs
@@ -18,11 +18,11 @@ use embassy_futures::{
 };
 use embassy_net::Config;
 use esp_hal::{peripherals::WIFI, rng::Rng};
-use esp_wifi::{wifi::WifiController, EspWifiInitialization};
+use esp_wifi::{wifi::WifiController, EspWifiController};
 use macros as cardio;
 
 pub(super) struct ApStaState {
-    init: EspWifiInitialization,
+    init: EspWifiController<'static>,
     connection_task_control: TaskController<(), ApStaTaskResources>,
     ap_net_task_control: TaskController<!>,
     sta_net_task_control: TaskController<!>,
@@ -32,7 +32,7 @@ pub(super) struct ApStaState {
 
 impl ApStaState {
     pub(super) fn init(
-        init: EspWifiInitialization,
+        init: EspWifiController<'static>,
         ap_config: Config,
         sta_config: Config,
         wifi: &'static mut WIFI,
@@ -41,7 +41,10 @@ impl ApStaState {
     ) -> Self {
         info!("Configuring AP-STA");
 
-        let (ap_device, sta_device, controller) = unwrap!(esp_wifi::wifi::new_ap_sta(&init, wifi));
+        let (ap_device, sta_device, controller) = unwrap!(esp_wifi::wifi::new_ap_sta(
+            unsafe { core::mem::transmute(&init) },
+            wifi
+        ));
 
         info!("Starting AP-STA");
 
@@ -100,7 +103,7 @@ impl ApStaState {
         }
     }
 
-    pub(super) async fn stop(mut self) -> EspWifiInitialization {
+    pub(super) async fn stop(mut self) -> EspWifiController<'static> {
         info!("Stopping AP-STA");
         let _ = join3(
             self.connection_task_control.stop(),
@@ -111,7 +114,7 @@ impl ApStaState {
 
         let controller = &mut self.connection_task_control.resources_mut().controller;
         if matches!(controller.is_started(), Ok(true)) {
-            unwrap!(controller.stop().await);
+            unwrap!(controller.stop_async().await);
         }
 
         info!("Stopped AP-STA");
@@ -141,7 +144,7 @@ async fn ap_sta_task(
             ap_controller.setup(&mut resources.controller).await;
 
             info!("Starting wifi");
-            unwrap!(resources.controller.start().await);
+            unwrap!(resources.controller.start_async().await);
             info!("Wifi started!");
 
             loop {
diff --git a/src/board/wifi/mod.rs b/src/board/wifi/mod.rs
index 1c963c5e..57e75c64 100644
--- a/src/board/wifi/mod.rs
+++ b/src/board/wifi/mod.rs
@@ -18,7 +18,7 @@ use esp_hal::{
 };
 use esp_wifi::{
     wifi::{WifiApDevice, WifiDevice, WifiDeviceMode, WifiStaDevice},
-    EspWifiInitFor, EspWifiInitialization,
+    EspWifiController,
 };
 use gui::widgets::{wifi_access_point::WifiAccessPointState, wifi_client::WifiClientState};
 use macros as cardio;
@@ -88,27 +88,28 @@ struct WifiInitResources {
 
 enum WifiDriverState {
     Uninitialized(WifiInitResources),
-    Initialized(EspWifiInitialization),
+    Initialized(EspWifiController<'static>),
     Ap(ApState),
     Sta(StaState),
     ApSta(ApStaState),
 }
 
 impl WifiDriverState {
-    async fn initialize(&mut self, callback: impl FnOnce(EspWifiInitialization) -> Self) {
+    async fn initialize(&mut self, callback: impl FnOnce(EspWifiController<'static>) -> Self) {
         self.uninit().await;
         replace_with::replace_with_or_abort(self, |this| {
             let token = match this {
                 Self::Uninitialized(resources) => {
                     info!("Initializing Wifi driver");
                     let token = unwrap!(esp_wifi::init(
-                        EspWifiInitFor::Wifi,
                         resources.timer,
                         resources.rng,
                         resources.radio_clk,
                     ));
                     info!("Wifi driver initialized");
-                    token
+                    // FIXME: this is not safe at all, but I can't be bothered to rearchitect
+                    // this firmware.
+                    unsafe { core::mem::transmute(token) }
                 }
                 Self::Initialized(token) => token,
                 _ => unreachable!(),
diff --git a/src/board/wifi/sta.rs b/src/board/wifi/sta.rs
index 9565ff13..af9e9762 100644
--- a/src/board/wifi/sta.rs
+++ b/src/board/wifi/sta.rs
@@ -30,7 +30,7 @@ use esp_wifi::{
         AccessPointInfo, ClientConfiguration, Configuration, WifiController, WifiDevice, WifiEvent,
         WifiStaDevice,
     },
-    EspWifiInitialization,
+    EspWifiController,
 };
 use gui::widgets::wifi_client::WifiClientState;
 use macros as cardio;
@@ -266,7 +266,7 @@ impl<'a> HttpsClientResources<'a> {
 }
 
 pub(super) struct StaState {
-    init: EspWifiInitialization,
+    init: EspWifiController<'static>,
     connection_task_control: TaskController<(), StaTaskResources>,
     net_task_control: TaskController<!>,
     handle: Sta,
@@ -274,7 +274,7 @@ pub(super) struct StaState {
 
 impl StaState {
     pub(super) fn init(
-        init: EspWifiInitialization,
+        init: EspWifiController<'static>,
         config: Config,
         wifi: &'static mut WIFI,
         rng: Rng,
@@ -282,8 +282,11 @@ impl StaState {
     ) -> Self {
         info!("Configuring STA");
 
-        let (sta_device, controller) =
-            unwrap!(esp_wifi::wifi::new_with_mode(&init, wifi, WifiStaDevice));
+        let (sta_device, controller) = unwrap!(esp_wifi::wifi::new_with_mode(
+            unsafe { core::mem::transmute(&init) },
+            wifi,
+            WifiStaDevice
+        ));
 
         info!("Starting STA");
 
@@ -328,7 +331,7 @@ impl StaState {
         }
     }
 
-    pub(super) async fn stop(mut self) -> EspWifiInitialization {
+    pub(super) async fn stop(mut self) -> EspWifiController<'static> {
         info!("Stopping STA");
 
         let _ = join(
@@ -339,7 +342,7 @@ impl StaState {
 
         let controller = &mut self.connection_task_control.resources_mut().controller;
         if matches!(controller.is_started(), Ok(true)) {
-            unwrap!(controller.stop().await);
+            unwrap!(controller.stop_async().await);
         }
 
         info!("Stopped STA");
@@ -423,7 +426,7 @@ impl StaController {
 
     async fn do_scan(&mut self, controller: &mut WifiController<'_>) {
         info!("Scanning...");
-        let mut scan_results = Box::new(controller.scan_n::<SCAN_RESULTS>().await);
+        let mut scan_results = Box::new(controller.scan_n_async::<SCAN_RESULTS>().await);
 
         match scan_results.as_mut() {
             Ok((ref mut visible_networks, network_count)) => {
@@ -515,7 +518,7 @@ impl StaController {
         controller: &mut WifiController<'_>,
     ) -> Result<(), ConnectError> {
         self.state.update(InternalConnectionState::Connecting);
-        match with_timeout(Duration::from_secs(30), controller.connect()).await {
+        match with_timeout(Duration::from_secs(30), controller.connect_async()).await {
             Ok(Ok(_)) => {
                 self.state.update(InternalConnectionState::WaitingForIp);
                 Ok(())
@@ -533,7 +536,7 @@ impl StaController {
     }
 
     async fn deprioritize_current(&self, controller: &mut WifiController<'_>) {
-        match controller.get_configuration() {
+        match controller.configuration() {
             Ok(config) => match &config {
                 Configuration::Client(config) | Configuration::Mixed(config, _) => {
                     let mut known_networks = self.known_networks.lock().await;
@@ -667,7 +670,7 @@ async fn sta_task(
     task_control
         .run_cancellable(|resources| async {
             info!("Starting wifi");
-            unwrap!(resources.controller.start().await);
+            unwrap!(resources.controller.start_async().await);
             info!("Wifi started!");
 
             loop {
diff --git a/src/main.rs b/src/main.rs
index dc60aea9..91cc5992 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,6 +12,9 @@ extern crate alloc;
 #[macro_use]
 extern crate logger;
 
+#[cfg(feature = "esp-println")]
+use esp_println as _;
+
 use alloc::{boxed::Box, rc::Rc};
 use embassy_executor::Spawner;
 use embassy_sync::{
@@ -23,9 +26,6 @@ use norfs::{medium::StorageMedium, Storage, StorageError};
 use signal_processing::compressing_buffer::CompressingBuffer;
 use static_cell::{make_static, StaticCell};
 
-#[cfg(feature = "battery_max17055")]
-pub use crate::states::menu::battery_info::battery_info_menu;
-
 use crate::{
     board::{
         config::{Config, ConfigFile},
@@ -39,10 +39,7 @@ use crate::{
         firmware_update::firmware_update,
         init::initialize,
         measure::{measure, ECG_BUFFER_SIZE},
-        menu::{
-            about::about_menu, display::display_menu, main::main_menu, storage::storage_menu,
-            wifi_ap::wifi_ap, wifi_sta::wifi_sta, AppMenu,
-        },
+        menu::{display_menu_screen, AppMenu},
         throughput::throughput,
         upload_or_store_measurement::{upload_or_store_measurement, upload_stored_measurements},
         MESSAGE_DURATION,
@@ -74,7 +71,7 @@ pub struct SerialNumber;
 
 impl SerialNumber {
     pub fn bytes() -> [u8; 6] {
-        esp_hal::efuse::Efuse::get_mac_address()
+        esp_hal::efuse::Efuse::mac_address()
     }
 }
 
@@ -192,15 +189,18 @@ where
 
 #[main]
 async fn main(_spawner: Spawner) {
-    let channels = rtt_target::rtt_init! {
-        up: {
-            0: {
-                size: 1024,
-                name: "defmt"
+    #[cfg(feature = "rtt")]
+    {
+        let channels = rtt_target::rtt_init! {
+            up: {
+                0: {
+                    size: 1024,
+                    name: "defmt"
+                }
             }
-        }
-    };
-    rtt_target::set_defmt_channel(channels.up.0);
+        };
+        rtt_target::set_defmt_channel(channels.up.0);
+    }
 
     esp_alloc::heap_allocator!((48 + 96) * 1024);
 
@@ -254,14 +254,7 @@ async fn main(_spawner: Spawner) {
             AppState::Initialize => initialize(&mut board).await,
             AppState::Charging => charging(&mut board).await,
             AppState::Measure => measure(&mut board).await,
-            AppState::Menu(AppMenu::Main) => main_menu(&mut board).await,
-            AppState::Menu(AppMenu::Display) => display_menu(&mut board).await,
-            AppState::Menu(AppMenu::Storage) => storage_menu(&mut board).await,
-            AppState::Menu(AppMenu::DeviceInfo) => about_menu(&mut board).await,
-            AppState::Menu(AppMenu::WifiAP) => wifi_ap(&mut board).await,
-            AppState::Menu(AppMenu::WifiListVisible) => wifi_sta(&mut board).await,
-            #[cfg(feature = "battery_max17055")]
-            AppState::Menu(AppMenu::BatteryInfo) => battery_info_menu(&mut board).await,
+            AppState::Menu(menu) => display_menu_screen(menu, &mut board).await,
             AppState::DisplaySerial => display_serial(&mut board).await,
             AppState::FirmwareUpdate => firmware_update(&mut board).await,
             AppState::Throughput => throughput(&mut board).await,
diff --git a/src/stack_protection.rs b/src/stack_protection.rs
index ad4f825a..3ff0dddd 100644
--- a/src/stack_protection.rs
+++ b/src/stack_protection.rs
@@ -2,7 +2,7 @@ use core::ops::Range;
 
 use esp_hal::{
     assist_debug::DebugAssist,
-    get_core, interrupt,
+    interrupt,
     peripherals::{self, ASSIST_DEBUG},
     prelude::*,
     Cpu,
@@ -46,7 +46,7 @@ impl StackMonitor {
         const CANARY_GRANULARITY: u32 = 16;
 
         // We watch writes to the last word in the stack.
-        match get_core() {
+        match Cpu::current() {
             Cpu::ProCpu => assist.enable_region0_monitor(
                 bottom as u32 + CANARY_GRANULARITY,
                 bottom as u32 + CANARY_GRANULARITY + CANARY_UNITS * CANARY_GRANULARITY,
@@ -73,7 +73,7 @@ impl StackMonitor {
 
 impl Drop for StackMonitor {
     fn drop(&mut self) {
-        match get_core() {
+        match Cpu::current() {
             Cpu::ProCpu => self.assist.disable_region0_monitor(),
             #[cfg(feature = "esp32s3")]
             Cpu::AppCpu => self.assist.disable_core1_region0_monitor(),
@@ -84,7 +84,7 @@ impl Drop for StackMonitor {
 #[handler(priority = esp_hal::interrupt::Priority::max())]
 fn interrupt_handler() {
     let mut da = conjure();
-    let cpu = get_core();
+    let cpu = Cpu::current();
 
     let pc;
     let is_overflow;
@@ -92,13 +92,13 @@ fn interrupt_handler() {
     match cpu {
         Cpu::ProCpu => {
             is_overflow = da.is_region0_monitor_interrupt_set();
-            pc = da.get_region_monitor_pc();
+            pc = da.region_monitor_pc();
             da.clear_region0_monitor_interrupt();
         }
         #[cfg(feature = "esp32s3")]
         Cpu::AppCpu => {
             is_overflow = da.is_core1_region0_monitor_interrupt_set();
-            pc = da.get_core1_region_monitor_pc();
+            pc = da.core1_region_monitor_pc();
             da.clear_core1_region0_monitor_interrupt();
         }
     }
diff --git a/src/states/measure.rs b/src/states/measure.rs
index 04f355ed..66a22924 100644
--- a/src/states/measure.rs
+++ b/src/states/measure.rs
@@ -194,10 +194,12 @@ async fn measure_impl(
 
     match frontend.set_clock_source().await {
         Ok(true) => {
-            frontend
-                .spi_mut()
-                .bus_mut()
-                .change_bus_frequency(4u32.MHz());
+            unwrap!(frontend.spi_mut().bus_mut().apply_config(&{
+                let mut config = esp_hal::spi::master::Config::default();
+                config.frequency = 4u32.MHz();
+                config.mode = esp_hal::spi::SpiMode::Mode1;
+                config
+            }));
         }
 
         Err(_e) => {
diff --git a/src/states/menu/mod.rs b/src/states/menu/mod.rs
index aaa9e42b..fc3b004b 100644
--- a/src/states/menu/mod.rs
+++ b/src/states/menu/mod.rs
@@ -13,6 +13,7 @@ use crate::{
     board::initialized::Context,
     states::{TouchInputShaper, MENU_IDLE_DURATION, MIN_FRAME_TIME},
     timeout::Timeout,
+    AppState,
 };
 
 pub mod about;
@@ -154,3 +155,23 @@ pub trait MenuScreen {
         None
     }
 }
+
+pub async fn display_menu_screen(mut menu: AppMenu, board: &mut Context) -> AppState {
+    loop {
+        let next = match menu {
+            AppMenu::Main => main::main_menu(board).await,
+            AppMenu::Display => display::display_menu(board).await,
+            AppMenu::Storage => storage::storage_menu(board).await,
+            AppMenu::DeviceInfo => about::about_menu(board).await,
+            AppMenu::WifiAP => wifi_ap::wifi_ap(board).await,
+            AppMenu::WifiListVisible => wifi_sta::wifi_sta(board).await,
+            #[cfg(feature = "battery_max17055")]
+            AppMenu::BatteryInfo => battery_info::battery_info_menu(board).await,
+        };
+
+        match next {
+            AppState::Menu(app_menu) => menu = app_menu,
+            other => return other,
+        }
+    }
+}