adc: remove sample_time from struct

25 files changed, 66 insertions, 91 deletions

diff --git a/examples/stm32c0/src/bin/adc.rs b/examples/stm32c0/src/bin/adc.rs
index 1f54b0b18..b52c9e7f8 100644
--- a/examples/stm32c0/src/bin/adc.rs
+++ b/examples/stm32c0/src/bin/adc.rs
@@ -17,7 +17,7 @@ async fn main(_spawner: Spawner) {
     info!("ADC STM32C0 example.");
 
     // We need to set certain sample time to be able to read temp sensor.
-    let mut adc = Adc::new(p.ADC1, SampleTime::CYCLES12_5, Resolution::BITS12);
+    let mut adc = Adc::new(p.ADC1, Resolution::BITS12);
     let mut temp = adc.enable_temperature().degrade_adc();
     let mut vref = adc.enable_vrefint().degrade_adc();
     let mut pin0 = p.PA0.degrade_adc();
@@ -27,9 +27,9 @@ async fn main(_spawner: Spawner) {
 
     loop {
         info!("============================");
-        let blocking_temp = adc.blocking_read(&mut temp);
-        let blocking_vref = adc.blocking_read(&mut vref);
-        let blocing_pin0 = adc.blocking_read(&mut pin0);
+        let blocking_temp = adc.blocking_read(&mut temp, SampleTime::CYCLES12_5);
+        let blocking_vref = adc.blocking_read(&mut vref, SampleTime::CYCLES12_5);
+        let blocing_pin0 = adc.blocking_read(&mut pin0, SampleTime::CYCLES12_5);
         info!(
             "Blocking ADC read: vref = {}, temp = {}, pin0 = {}.",
             blocking_vref, blocking_temp, blocing_pin0
diff --git a/examples/stm32f0/src/bin/adc-watchdog.rs b/examples/stm32f0/src/bin/adc-watchdog.rs
index ff98aac8e..6879dd10a 100644
--- a/examples/stm32f0/src/bin/adc-watchdog.rs
+++ b/examples/stm32f0/src/bin/adc-watchdog.rs
@@ -3,7 +3,7 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::adc::{self, Adc, WatchdogChannels};
+use embassy_stm32::adc::{self, Adc, SampleTime, WatchdogChannels};
 use embassy_stm32::bind_interrupts;
 use embassy_stm32::peripherals::ADC1;
 use {defmt_rtt as _, panic_probe as _};
@@ -23,12 +23,12 @@ async fn main(_spawner: Spawner) {
     loop {
         // Wait for pin to go high
         adc.init_watchdog(WatchdogChannels::from_channel(&pin), 0, 0x07F);
-        let v_high = adc.monitor_watchdog().await;
+        let v_high = adc.monitor_watchdog(SampleTime::CYCLES13_5).await;
         info!("ADC sample is high {}", v_high);
 
         // Wait for pin to go low
         adc.init_watchdog(WatchdogChannels::from_channel(&pin), 0x01f, 0xFFF);
-        let v_low = adc.monitor_watchdog().await;
+        let v_low = adc.monitor_watchdog(SampleTime::CYCLES13_5).await;
         info!("ADC sample is low {}", v_low);
     }
 }
diff --git a/examples/stm32f0/src/bin/adc.rs b/examples/stm32f0/src/bin/adc.rs
index 8825e2687..fafeeffaf 100644
--- a/examples/stm32f0/src/bin/adc.rs
+++ b/examples/stm32f0/src/bin/adc.rs
@@ -19,11 +19,10 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let mut adc = Adc::new(p.ADC1, Irqs);
-    adc.set_sample_time(SampleTime::CYCLES71_5);
     let mut pin = p.PA1;
 
     let mut vrefint = adc.enable_vref();
-    let vrefint_sample = adc.read(&mut vrefint).await;
+    let vrefint_sample = adc.read(&mut vrefint, SampleTime::CYCLES13_5).await;
     let convert_to_millivolts = |sample| {
         // From https://www.st.com/resource/en/datasheet/stm32f031c6.pdf
         // 6.3.4 Embedded reference voltage
@@ -33,7 +32,7 @@ async fn main(_spawner: Spawner) {
     };
 
     loop {
-        let v = adc.read(&mut pin).await;
+        let v = adc.read(&mut pin, SampleTime::CYCLES13_5).await;
         info!("--> {} - {} mV", v, convert_to_millivolts(v));
         Timer::after_millis(100).await;
     }
diff --git a/examples/stm32f1/src/bin/adc.rs b/examples/stm32f1/src/bin/adc.rs
index 541ff159e..2451aee3d 100644
--- a/examples/stm32f1/src/bin/adc.rs
+++ b/examples/stm32f1/src/bin/adc.rs
@@ -3,7 +3,7 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::adc::Adc;
+use embassy_stm32::adc::{Adc, SampleTime};
 use embassy_stm32::peripherals::ADC1;
 use embassy_stm32::{adc, bind_interrupts};
 use embassy_time::Timer;
@@ -22,7 +22,7 @@ async fn main(_spawner: Spawner) {
     let mut pin = p.PB1;
 
     let mut vrefint = adc.enable_vref();
-    let vrefint_sample = adc.read(&mut vrefint).await;
+    let vrefint_sample = adc.read(&mut vrefint, SampleTime::CYCLES13_5).await;
     let convert_to_millivolts = |sample| {
         // From http://www.st.com/resource/en/datasheet/CD00161566.pdf
         // 5.3.4 Embedded reference voltage
@@ -32,7 +32,7 @@ async fn main(_spawner: Spawner) {
     };
 
     loop {
-        let v = adc.read(&mut pin).await;
+        let v = adc.read(&mut pin, SampleTime::CYCLES13_5).await;
         info!("--> {} - {} mV", v, convert_to_millivolts(v));
         Timer::after_millis(100).await;
     }
diff --git a/examples/stm32f334/src/bin/adc.rs b/examples/stm32f334/src/bin/adc.rs
index a993b00ca..a420c8876 100644
--- a/examples/stm32f334/src/bin/adc.rs
+++ b/examples/stm32f334/src/bin/adc.rs
@@ -40,21 +40,19 @@ async fn main(_spawner: Spawner) -> ! {
 
     let mut adc = Adc::new(p.ADC1, Irqs);
 
-    adc.set_sample_time(SampleTime::CYCLES601_5);
-
     info!("enable vrefint...");
 
     let mut vrefint = adc.enable_vref();
     let mut temperature = adc.enable_temperature();
 
     loop {
-        let vref = adc.read(&mut vrefint).await;
+        let vref = adc.read(&mut vrefint, SampleTime::CYCLES601_5).await;
         info!("read vref: {} (should be {})", vref, vrefint.value());
 
-        let temp = adc.read(&mut temperature).await;
+        let temp = adc.read(&mut temperature, SampleTime::CYCLES601_5).await;
         info!("read temperature: {}", temp);
 
-        let pin = adc.read(&mut p.PA0).await;
+        let pin = adc.read(&mut p.PA0, SampleTime::CYCLES601_5).await;
         info!("read pin: {}", pin);
 
         let pin_mv = (pin as u32 * vrefint.value() as u32 / vref as u32) * 3300 / 4095;
diff --git a/examples/stm32f334/src/bin/opamp.rs b/examples/stm32f334/src/bin/opamp.rs
index 3e621f2a1..ddefdd03d 100644
--- a/examples/stm32f334/src/bin/opamp.rs
+++ b/examples/stm32f334/src/bin/opamp.rs
@@ -42,8 +42,6 @@ async fn main(_spawner: Spawner) -> ! {
     let mut adc = Adc::new(p.ADC2, Irqs);
     let mut opamp = OpAmp::new(p.OPAMP2);
 
-    adc.set_sample_time(SampleTime::CYCLES601_5);
-
     info!("enable vrefint...");
 
     let mut vrefint = adc.enable_vref();
@@ -51,13 +49,13 @@ async fn main(_spawner: Spawner) -> ! {
     let mut buffer = opamp.buffer_ext(p.PA7.reborrow(), p.PA6.reborrow());
 
     loop {
-        let vref = adc.read(&mut vrefint).await;
+        let vref = adc.read(&mut vrefint, SampleTime::CYCLES601_5).await;
         info!("read vref: {} (should be {})", vref, vrefint.value());
 
-        let temp = adc.read(&mut temperature).await;
+        let temp = adc.read(&mut temperature, SampleTime::CYCLES601_5).await;
         info!("read temperature: {}", temp);
 
-        let buffer = adc.read(&mut buffer).await;
+        let buffer = adc.read(&mut buffer, SampleTime::CYCLES601_5).await;
         info!("read buffer: {}", buffer);
 
         let pin_mv = (buffer as u32 * vrefint.value() as u32 / vref as u32) * 3300 / 4095;
diff --git a/examples/stm32f4/src/bin/adc.rs b/examples/stm32f4/src/bin/adc.rs
index 423d29225..5628cb827 100644
--- a/examples/stm32f4/src/bin/adc.rs
+++ b/examples/stm32f4/src/bin/adc.rs
@@ -4,7 +4,7 @@
 use cortex_m::prelude::_embedded_hal_blocking_delay_DelayUs;
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::adc::{Adc, Temperature, VrefInt};
+use embassy_stm32::adc::{Adc, SampleTime, Temperature, VrefInt};
 use embassy_time::{Delay, Timer};
 use {defmt_rtt as _, panic_probe as _};
 
@@ -23,7 +23,7 @@ async fn main(_spawner: Spawner) {
     // Startup delay can be combined to the maximum of either
     delay.delay_us(Temperature::start_time_us().max(VrefInt::start_time_us()));
 
-    let vrefint_sample = adc.blocking_read(&mut vrefint);
+    let vrefint_sample = adc.blocking_read(&mut vrefint, SampleTime::CYCLES112);
 
     let convert_to_millivolts = |sample| {
         // From http://www.st.com/resource/en/datasheet/DM00071990.pdf
@@ -50,16 +50,16 @@ async fn main(_spawner: Spawner) {
 
     loop {
         // Read pin
-        let v = adc.blocking_read(&mut pin);
+        let v = adc.blocking_read(&mut pin, SampleTime::CYCLES112);
         info!("PC1: {} ({} mV)", v, convert_to_millivolts(v));
 
         // Read internal temperature
-        let v = adc.blocking_read(&mut temp);
+        let v = adc.blocking_read(&mut temp, SampleTime::CYCLES112);
         let celcius = convert_to_celcius(v);
         info!("Internal temp: {} ({} C)", v, celcius);
 
         // Read internal voltage reference
-        let v = adc.blocking_read(&mut vrefint);
+        let v = adc.blocking_read(&mut vrefint, SampleTime::CYCLES112);
         info!("VrefInt: {}", v);
 
         Timer::after_millis(100).await;
diff --git a/examples/stm32f4/src/bin/adc_dma.rs b/examples/stm32f4/src/bin/adc_dma.rs
index f8da91336..01b881c79 100644
--- a/examples/stm32f4/src/bin/adc_dma.rs
+++ b/examples/stm32f4/src/bin/adc_dma.rs
@@ -27,8 +27,8 @@ async fn adc_task(p: Peripherals) {
         p.DMA2_CH0,
         adc_data,
         [
-            (&mut p.PA0.degrade_adc(), SampleTime::CYCLES112),
-            (&mut p.PA2.degrade_adc(), SampleTime::CYCLES112),
+            (p.PA0.degrade_adc(), SampleTime::CYCLES112),
+            (p.PA2.degrade_adc(), SampleTime::CYCLES112),
         ]
         .into_iter(),
     );
@@ -36,8 +36,8 @@ async fn adc_task(p: Peripherals) {
         p.DMA2_CH2,
         adc_data2,
         [
-            (&mut p.PA1.degrade_adc(), SampleTime::CYCLES112),
-            (&mut p.PA3.degrade_adc(), SampleTime::CYCLES112),
+            (p.PA1.degrade_adc(), SampleTime::CYCLES112),
+            (p.PA3.degrade_adc(), SampleTime::CYCLES112),
         ]
         .into_iter(),
     );
diff --git a/examples/stm32f7/src/bin/adc.rs b/examples/stm32f7/src/bin/adc.rs
index 6689e3b5d..0f226d34e 100644
--- a/examples/stm32f7/src/bin/adc.rs
+++ b/examples/stm32f7/src/bin/adc.rs
@@ -3,7 +3,7 @@
 
 use defmt::*;
 use embassy_executor::Spawner;
-use embassy_stm32::adc::Adc;
+use embassy_stm32::adc::{Adc, SampleTime};
 use embassy_time::Timer;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -16,7 +16,7 @@ async fn main(_spawner: Spawner) {
     let mut pin = p.PA3;
 
     let mut vrefint = adc.enable_vrefint();
-    let vrefint_sample = adc.blocking_read(&mut vrefint);
+    let vrefint_sample = adc.blocking_read(&mut vrefint, SampleTime::CYCLES112);
     let convert_to_millivolts = |sample| {
         // From http://www.st.com/resource/en/datasheet/DM00273119.pdf
         // 6.3.27 Reference voltage
@@ -26,7 +26,7 @@ async fn main(_spawner: Spawner) {
     };
 
     loop {
-        let v = adc.blocking_read(&mut pin);
+        let v = adc.blocking_read(&mut pin, SampleTime::CYCLES112);
         info!("--> {} - {} mV", v, convert_to_millivolts(v));
         Timer::after_millis(100).await;
     }
diff --git a/examples/stm32g0/src/bin/adc.rs b/examples/stm32g0/src/bin/adc.rs
index 7d8653ef2..972e43b55 100644
--- a/examples/stm32g0/src/bin/adc.rs
+++ b/examples/stm32g0/src/bin/adc.rs
@@ -13,11 +13,10 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let mut adc = Adc::new_with_clock(p.ADC1, Clock::Async { div: Presc::DIV1 });
-    adc.set_sample_time(SampleTime::CYCLES79_5);
     let mut pin = p.PA1;
 
     let mut vrefint = adc.enable_vrefint();
-    let vrefint_sample = adc.blocking_read(&mut vrefint);
+    let vrefint_sample = adc.blocking_read(&mut vrefint, SampleTime::CYCLES79_5);
     let convert_to_millivolts = |sample| {
         // From https://www.st.com/resource/en/datasheet/stm32g031g8.pdf
         // 6.3.3 Embedded internal reference voltage
@@ -27,7 +26,7 @@ async fn main(_spawner: Spawner) {
     };
 
     loop {
-        let v = adc.blocking_read(&mut pin);
+        let v = adc.blocking_read(&mut pin, SampleTime::CYCLES79_5);
         info!("--> {} - {} mV", v, convert_to_millivolts(v));
         Timer::after_millis(100).await;
     }
diff --git a/examples/stm32g0/src/bin/adc_oversampling.rs b/examples/stm32g0/src/bin/adc_oversampling.rs
index 834d1cd4a..f6979889d 100644
--- a/examples/stm32g0/src/bin/adc_oversampling.rs
+++ b/examples/stm32g0/src/bin/adc_oversampling.rs
@@ -17,7 +17,6 @@ async fn main(_spawner: Spawner) {
     info!("Adc oversample test");
 
     let mut adc = Adc::new_with_clock(p.ADC1, Clock::Async { div: Presc::DIV1 });
-    adc.set_sample_time(SampleTime::CYCLES1_5);
     let mut pin = p.PA1;
 
     adc.set_oversampling_ratio(Ovsr::MUL16);
@@ -25,7 +24,7 @@ async fn main(_spawner: Spawner) {
     adc.oversampling_enable(true);
 
     loop {
-        let v = adc.blocking_read(&mut pin);
+        let v = adc.blocking_read(&mut pin, SampleTime::CYCLES1_5);
         info!("--> {} ", v); //max 65520 = 0xFFF0
         Timer::after_millis(100).await;
     }
diff --git a/examples/stm32g4/src/bin/adc.rs b/examples/stm32g4/src/bin/adc.rs
index 920142a18..695f37115 100644
--- a/examples/stm32g4/src/bin/adc.rs
+++ b/examples/stm32g4/src/bin/adc.rs
@@ -29,10 +29,9 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let mut adc = Adc::new(p.ADC2);
-    adc.set_sample_time(SampleTime::CYCLES24_5);
 
     loop {
-        let measured = adc.blocking_read(&mut p.PA7);
+        let measured = adc.blocking_read(&mut p.PA7, SampleTime::CYCLES24_5);
         info!("measured: {}", measured);
         Timer::after_millis(500).await;
     }
diff --git a/examples/stm32g4/src/bin/adc_differential.rs b/examples/stm32g4/src/bin/adc_differential.rs
index 301f0da84..a6e2f7d33 100644
--- a/examples/stm32g4/src/bin/adc_differential.rs
+++ b/examples/stm32g4/src/bin/adc_differential.rs
@@ -33,14 +33,13 @@ async fn main(_spawner: Spawner) {
     let mut p = embassy_stm32::init(config);
 
     let mut adc = Adc::new(p.ADC1);
-    adc.set_sample_time(SampleTime::CYCLES247_5);
     adc.set_differential(&mut p.PA0, true); //p:pa0,n:pa1
 
     // can also use
     // adc.set_differential_channel(1, true);
     info!("adc initialized");
     loop {
-        let measured = adc.blocking_read(&mut p.PA0);
+        let measured = adc.blocking_read(&mut p.PA0, SampleTime::CYCLES247_5);
         info!("data: {}", measured);
         Timer::after_millis(500).await;
     }
diff --git a/examples/stm32g4/src/bin/adc_oversampling.rs b/examples/stm32g4/src/bin/adc_oversampling.rs
index 1e464183a..cb99ab2a7 100644
--- a/examples/stm32g4/src/bin/adc_oversampling.rs
+++ b/examples/stm32g4/src/bin/adc_oversampling.rs
@@ -33,7 +33,6 @@ async fn main(_spawner: Spawner) {
     let mut p = embassy_stm32::init(config);
 
     let mut adc = Adc::new(p.ADC1);
-    adc.set_sample_time(SampleTime::CYCLES6_5);
     // From https://www.st.com/resource/en/reference_manual/rm0440-stm32g4-series-advanced-armbased-32bit-mcus-stmicroelectronics.pdf
     // page652 Oversampler
     // Table 172. Maximum output results vs N and M. Grayed values indicates truncation
@@ -50,7 +49,7 @@ async fn main(_spawner: Spawner) {
     adc.enable_regular_oversampling_mode(Rovsm::RESUMED, Trovs::AUTOMATIC, true);
 
     loop {
-        let measured = adc.blocking_read(&mut p.PA0);
+        let measured = adc.blocking_read(&mut p.PA0, SampleTime::CYCLES6_5);
         info!("data: 0x{:X}", measured); //max 0xFFF0 -> 65520
         Timer::after_millis(500).await;
     }
diff --git a/examples/stm32h5/src/bin/adc.rs b/examples/stm32h5/src/bin/adc.rs
index 0566320d4..c919b1a95 100644
--- a/examples/stm32h5/src/bin/adc.rs
+++ b/examples/stm32h5/src/bin/adc.rs
@@ -45,14 +45,12 @@ async fn main(_spawner: Spawner) {
 
     let mut adc = Adc::new(p.ADC1);
 
-    adc.set_sample_time(SampleTime::CYCLES24_5);
-
     let mut vrefint_channel = adc.enable_vrefint();
 
     loop {
-        let vrefint = adc.blocking_read(&mut vrefint_channel);
+        let vrefint = adc.blocking_read(&mut vrefint_channel, SampleTime::CYCLES24_5);
         info!("vrefint: {}", vrefint);
-        let measured = adc.blocking_read(&mut p.PA0);
+        let measured = adc.blocking_read(&mut p.PA0, SampleTime::CYCLES24_5);
         info!("measured: {}", measured);
         Timer::after_millis(500).await;
     }
diff --git a/examples/stm32h7/src/bin/adc.rs b/examples/stm32h7/src/bin/adc.rs
index a53c9d8d5..fc45541bf 100644
--- a/examples/stm32h7/src/bin/adc.rs
+++ b/examples/stm32h7/src/bin/adc.rs
@@ -46,14 +46,12 @@ async fn main(_spawner: Spawner) {
 
     let mut adc = Adc::new(p.ADC3);
 
-    adc.set_sample_time(SampleTime::CYCLES32_5);
-
     let mut vrefint_channel = adc.enable_vrefint();
 
     loop {
-        let vrefint = adc.blocking_read(&mut vrefint_channel);
+        let vrefint = adc.blocking_read(&mut vrefint_channel, SampleTime::CYCLES32_5);
         info!("vrefint: {}", vrefint);
-        let measured = adc.blocking_read(&mut p.PC0);
+        let measured = adc.blocking_read(&mut p.PC0, SampleTime::CYCLES32_5);
         info!("measured: {}", measured);
         Timer::after_millis(500).await;
     }
diff --git a/examples/stm32l0/src/bin/adc.rs b/examples/stm32l0/src/bin/adc.rs
index 9dd09bc45..83be74ed9 100644
--- a/examples/stm32l0/src/bin/adc.rs
+++ b/examples/stm32l0/src/bin/adc.rs
@@ -19,11 +19,10 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let mut adc = Adc::new(p.ADC1, Irqs);
-    adc.set_sample_time(SampleTime::CYCLES79_5);
     let mut pin = p.PA1;
 
     let mut vrefint = adc.enable_vref();
-    let vrefint_sample = adc.read(&mut vrefint).await;
+    let vrefint_sample = adc.read(&mut vrefint, SampleTime::CYCLES79_5).await;
     let convert_to_millivolts = |sample| {
         // From https://www.st.com/resource/en/datasheet/stm32l051c6.pdf
         // 6.3.3 Embedded internal reference voltage
@@ -33,7 +32,7 @@ async fn main(_spawner: Spawner) {
     };
 
     loop {
-        let v = adc.read(&mut pin).await;
+        let v = adc.read(&mut pin, SampleTime::CYCLES79_5).await;
         info!("--> {} - {} mV", v, convert_to_millivolts(v));
         Timer::after_millis(100).await;
     }
diff --git a/examples/stm32l4/src/bin/adc.rs b/examples/stm32l4/src/bin/adc.rs
index 40e907940..835bf5411 100644
--- a/examples/stm32l4/src/bin/adc.rs
+++ b/examples/stm32l4/src/bin/adc.rs
@@ -3,7 +3,7 @@
 
 use defmt::*;
 use embassy_stm32::Config;
-use embassy_stm32::adc::{Adc, Resolution};
+use embassy_stm32::adc::{Adc, Resolution, SampleTime};
 use {defmt_rtt as _, panic_probe as _};
 
 #[cortex_m_rt::entry]
@@ -23,7 +23,7 @@ fn main() -> ! {
     let mut channel = p.PC0;
 
     loop {
-        let v = adc.blocking_read(&mut channel);
+        let v = adc.blocking_read(&mut channel, SampleTime::from_bits(0));
         info!("--> {}", v);
     }
 }
diff --git a/examples/stm32l4/src/bin/adc_dma.rs b/examples/stm32l4/src/bin/adc_dma.rs
index 7a9200edd..ab1e9d2e9 100644
--- a/examples/stm32l4/src/bin/adc_dma.rs
+++ b/examples/stm32l4/src/bin/adc_dma.rs
@@ -21,18 +21,14 @@ async fn main(_spawner: Spawner) {
     let p = embassy_stm32::init(config);
 
     let mut adc = Adc::new(p.ADC1);
-    let mut adc_pin0 = p.PA0.degrade_adc();
-    let mut adc_pin1 = p.PA1.degrade_adc();
+    let adc_pin0 = p.PA0.degrade_adc();
+    let adc_pin1 = p.PA1.degrade_adc();
     let mut adc_dma_buf = [0u16; DMA_BUF_LEN];
     let mut measurements = [0u16; DMA_BUF_LEN / 2];
     let mut ring_buffered_adc = adc.into_ring_buffered(
         p.DMA1_CH1,
         &mut adc_dma_buf,
-        [
-            (&mut adc_pin0, SampleTime::CYCLES640_5),
-            (&mut adc_pin1, SampleTime::CYCLES640_5),
-        ]
-        .into_iter(),
+        [(adc_pin0, SampleTime::CYCLES640_5), (adc_pin1, SampleTime::CYCLES640_5)].into_iter(),
     );
 
     info!("starting measurement loop");
diff --git a/examples/stm32u0/src/bin/adc.rs b/examples/stm32u0/src/bin/adc.rs
index 32a54299d..4fbc6f17f 100644
--- a/examples/stm32u0/src/bin/adc.rs
+++ b/examples/stm32u0/src/bin/adc.rs
@@ -3,7 +3,7 @@
 
 use defmt::*;
 use embassy_stm32::Config;
-use embassy_stm32::adc::{Adc, Resolution};
+use embassy_stm32::adc::{Adc, Resolution, SampleTime};
 use embassy_time::Duration;
 use {defmt_rtt as _, panic_probe as _};
 
@@ -23,7 +23,7 @@ fn main() -> ! {
     let mut channel = p.PC0;
 
     loop {
-        let v = adc.blocking_read(&mut channel);
+        let v = adc.blocking_read(&mut channel, SampleTime::CYCLES12_5);
         info!("--> {}", v);
         embassy_time::block_for(Duration::from_millis(200));
     }
diff --git a/examples/stm32u5/src/bin/adc.rs b/examples/stm32u5/src/bin/adc.rs
index 91e33053e..99944f7c7 100644
--- a/examples/stm32u5/src/bin/adc.rs
+++ b/examples/stm32u5/src/bin/adc.rs
@@ -2,8 +2,7 @@
 #![no_main]
 
 use defmt::*;
-use embassy_stm32::adc;
-use embassy_stm32::adc::{AdcChannel, adc4};
+use embassy_stm32::adc::{self, AdcChannel, SampleTime, adc4};
 use {defmt_rtt as _, panic_probe as _};
 
 #[embassy_executor::main]
@@ -18,7 +17,6 @@ async fn main(_spawner: embassy_executor::Spawner) {
     let mut adc1_pin2 = p.PA2; // A1
     adc1.set_resolution(adc::Resolution::BITS14);
     adc1.set_averaging(adc::Averaging::Samples1024);
-    adc1.set_sample_time(adc::SampleTime::CYCLES160_5);
     let max1 = adc::resolution_to_max_count(adc::Resolution::BITS14);
 
     // **** ADC2 init ****
@@ -27,7 +25,6 @@ async fn main(_spawner: embassy_executor::Spawner) {
     let mut adc2_pin2 = p.PB0; // A3
     adc2.set_resolution(adc::Resolution::BITS14);
     adc2.set_averaging(adc::Averaging::Samples1024);
-    adc2.set_sample_time(adc::SampleTime::CYCLES160_5);
     let max2 = adc::resolution_to_max_count(adc::Resolution::BITS14);
 
     // **** ADC4 init ****
@@ -36,33 +33,32 @@ async fn main(_spawner: embassy_executor::Spawner) {
     let mut adc4_pin2 = p.PC0; // A5
     adc4.set_resolution(adc4::Resolution::BITS12);
     adc4.set_averaging(adc4::Averaging::Samples256);
-    adc4.set_sample_time(adc4::SampleTime::CYCLES1_5);
     let max4 = adc4::resolution_to_max_count(adc4::Resolution::BITS12);
 
     // **** ADC1 blocking read ****
-    let raw: u16 = adc1.blocking_read(&mut adc1_pin1);
+    let raw: u16 = adc1.blocking_read(&mut adc1_pin1, SampleTime::CYCLES160_5);
     let volt: f32 = 3.3 * raw as f32 / max1 as f32;
     info!("Read adc1 pin 1 {}", volt);
 
-    let raw: u16 = adc1.blocking_read(&mut adc1_pin2);
+    let raw: u16 = adc1.blocking_read(&mut adc1_pin2, SampleTime::CYCLES160_5);
     let volt: f32 = 3.3 * raw as f32 / max1 as f32;
     info!("Read adc1 pin 2 {}", volt);
 
     // **** ADC2 blocking read ****
-    let raw: u16 = adc2.blocking_read(&mut adc2_pin1);
+    let raw: u16 = adc2.blocking_read(&mut adc2_pin1, SampleTime::CYCLES160_5);
     let volt: f32 = 3.3 * raw as f32 / max2 as f32;
     info!("Read adc2 pin 1 {}", volt);
 
-    let raw: u16 = adc2.blocking_read(&mut adc2_pin2);
+    let raw: u16 = adc2.blocking_read(&mut adc2_pin2, SampleTime::CYCLES160_5);
     let volt: f32 = 3.3 * raw as f32 / max2 as f32;
     info!("Read adc2 pin 2 {}", volt);
 
     // **** ADC4 blocking read ****
-    let raw: u16 = adc4.blocking_read(&mut adc4_pin1);
+    let raw: u16 = adc4.blocking_read(&mut adc4_pin1, adc4::SampleTime::CYCLES1_5);
     let volt: f32 = 3.3 * raw as f32 / max4 as f32;
     info!("Read adc4 pin 1 {}", volt);
 
-    let raw: u16 = adc4.blocking_read(&mut adc4_pin2);
+    let raw: u16 = adc4.blocking_read(&mut adc4_pin2, adc4::SampleTime::CYCLES1_5);
     let volt: f32 = 3.3 * raw as f32 / max4 as f32;
     info!("Read adc4 pin 2 {}", volt);
 
diff --git a/examples/stm32wba/src/bin/adc.rs b/examples/stm32wba/src/bin/adc.rs
index 8c80470b8..177aab3f3 100644
--- a/examples/stm32wba/src/bin/adc.rs
+++ b/examples/stm32wba/src/bin/adc.rs
@@ -17,15 +17,15 @@ async fn main(_spawner: embassy_executor::Spawner) {
     let mut adc4_pin2 = p.PA1; // A5
     adc4.set_resolution(adc4::Resolution::BITS12);
     adc4.set_averaging(adc4::Averaging::Samples256);
-    adc4.set_sample_time(adc4::SampleTime::CYCLES1_5);
+
     let max4 = adc4::resolution_to_max_count(adc4::Resolution::BITS12);
 
     // **** ADC4 blocking read ****
-    let raw: u16 = adc4.blocking_read(&mut adc4_pin1);
+    let raw: u16 = adc4.blocking_read(&mut adc4_pin1, adc4::SampleTime::CYCLES1_5);
     let volt: f32 = 3.0 * raw as f32 / max4 as f32;
     info!("Read adc4 pin 1 {}", volt);
 
-    let raw: u16 = adc4.blocking_read(&mut adc4_pin2);
+    let raw: u16 = adc4.blocking_read(&mut adc4_pin2, adc4::SampleTime::CYCLES1_5);
     let volt: f32 = 3.3 * raw as f32 / max4 as f32;
     info!("Read adc4 pin 2 {}", volt);
 
diff --git a/examples/stm32wba6/src/bin/adc.rs b/examples/stm32wba6/src/bin/adc.rs
index 8c80470b8..0887e124c 100644
--- a/examples/stm32wba6/src/bin/adc.rs
+++ b/examples/stm32wba6/src/bin/adc.rs
@@ -17,15 +17,14 @@ async fn main(_spawner: embassy_executor::Spawner) {
     let mut adc4_pin2 = p.PA1; // A5
     adc4.set_resolution(adc4::Resolution::BITS12);
     adc4.set_averaging(adc4::Averaging::Samples256);
-    adc4.set_sample_time(adc4::SampleTime::CYCLES1_5);
     let max4 = adc4::resolution_to_max_count(adc4::Resolution::BITS12);
 
     // **** ADC4 blocking read ****
-    let raw: u16 = adc4.blocking_read(&mut adc4_pin1);
+    let raw: u16 = adc4.blocking_read(&mut adc4_pin1, adc4::SampleTime::CYCLES1_5);
     let volt: f32 = 3.0 * raw as f32 / max4 as f32;
     info!("Read adc4 pin 1 {}", volt);
 
-    let raw: u16 = adc4.blocking_read(&mut adc4_pin2);
+    let raw: u16 = adc4.blocking_read(&mut adc4_pin2, adc4::SampleTime::CYCLES1_5);
     let volt: f32 = 3.3 * raw as f32 / max4 as f32;
     info!("Read adc4 pin 2 {}", volt);
 
diff --git a/examples/stm32wl/src/bin/adc.rs b/examples/stm32wl/src/bin/adc.rs
index 6b21b086b..adabe0df8 100644
--- a/examples/stm32wl/src/bin/adc.rs
+++ b/examples/stm32wl/src/bin/adc.rs
@@ -18,11 +18,11 @@ async fn main(_spawner: Spawner) {
     info!("Hello World!");
 
     let mut adc = Adc::new_with_clock(p.ADC1, Clock::Sync { div: CkModePclk::DIV1 });
-    adc.set_sample_time(SampleTime::CYCLES79_5);
+
     let mut pin = p.PB2;
 
     let mut vrefint = adc.enable_vrefint();
-    let vrefint_sample = adc.blocking_read(&mut vrefint);
+    let vrefint_sample = adc.blocking_read(&mut vrefint, SampleTime::CYCLES79_5);
     let convert_to_millivolts = |sample| {
         // From https://www.st.com/resource/en/datasheet/stm32g031g8.pdf
         // 6.3.3 Embedded internal reference voltage
@@ -32,7 +32,7 @@ async fn main(_spawner: Spawner) {
     };
 
     loop {
-        let v = adc.blocking_read(&mut pin);
+        let v = adc.blocking_read(&mut pin, SampleTime::CYCLES79_5);
         info!("--> {} - {} mV", v, convert_to_millivolts(v));
         Timer::after_millis(100).await;
     }
diff --git a/examples/stm32wle5/src/bin/adc.rs b/examples/stm32wle5/src/bin/adc.rs
index 8b830a1e6..4e0574d97 100644
--- a/examples/stm32wle5/src/bin/adc.rs
+++ b/examples/stm32wle5/src/bin/adc.rs
@@ -73,11 +73,10 @@ async fn async_main(_spawner: Spawner) {
     info!("Hello World!");
 
     let mut adc = Adc::new(p.ADC1);
-    adc.set_sample_time(SampleTime::CYCLES79_5);
     let mut pin = p.PA10;
 
     let mut vrefint = adc.enable_vrefint();
-    let vrefint_sample = adc.blocking_read(&mut vrefint);
+    let vrefint_sample = adc.blocking_read(&mut vrefint, SampleTime::CYCLES79_5);
     let convert_to_millivolts = |sample| {
         // From https://www.st.com/resource/en/datasheet/stm32g031g8.pdf
         // 6.3.3 Embedded internal reference voltage
@@ -87,7 +86,7 @@ async fn async_main(_spawner: Spawner) {
     };
 
     loop {
-        let v = adc.blocking_read(&mut pin);
+        let v = adc.blocking_read(&mut pin, SampleTime::CYCLES79_5);
         info!("--> {} - {} mV", v, convert_to_millivolts(v));
         Timer::after_secs(1).await;
     }