Merge pull request #4866 from xoviat/adc

adc: impl. differential channels

13 files changed, 210 insertions, 194 deletions

diff --git a/embassy-stm32/Cargo.toml b/embassy-stm32/Cargo.toml
index 0a1854dab..a722d2379 100644
--- a/embassy-stm32/Cargo.toml
+++ b/embassy-stm32/Cargo.toml
@@ -198,11 +198,11 @@ aligned = "0.4.1"
 heapless = "0.9.1"
 
 #stm32-metapac = { version = "18" }
-stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-22374e3344a2c9150b9b3d4da45c03f398fdc54e" }
+stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-b77c8d968f53b18d6bdcd052e354b5070ec2bbc2" }
 
 [build-dependencies]
 #stm32-metapac = { version = "18", default-features = false, features = ["metadata"]}
-stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-22374e3344a2c9150b9b3d4da45c03f398fdc54e", default-features = false, features = ["metadata"] }
+stm32-metapac = { git = "https://github.com/embassy-rs/stm32-data-generated", tag = "stm32-data-b77c8d968f53b18d6bdcd052e354b5070ec2bbc2", default-features = false, features = ["metadata"] }
 
 proc-macro2 = "1.0.36"
 quote = "1.0.15"
diff --git a/embassy-stm32/build.rs b/embassy-stm32/build.rs
index 09a05ce68..48da475df 100644
--- a/embassy-stm32/build.rs
+++ b/embassy-stm32/build.rs
@@ -1353,6 +1353,8 @@ fn main() {
 
     for p in METADATA.peripherals {
         if let Some(regs) = &p.registers {
+            let mut adc_pairs: BTreeMap<u8, (Option<Ident>, Option<Ident>)> = BTreeMap::new();
+
             for pin in p.pins {
                 let key = (regs.kind, pin.signal);
                 if let Some(tr) = signals.get(&key) {
@@ -1474,25 +1476,29 @@ fn main() {
                     };
 
                     // H7 has differential voltage measurements
-                    let ch: Option<u8> = if pin.signal.starts_with("INP") {
-                        Some(pin.signal.strip_prefix("INP").unwrap().parse().unwrap())
+                    let ch: Option<(u8, bool)> = if pin.signal.starts_with("INP") {
+                        Some((pin.signal.strip_prefix("INP").unwrap().parse().unwrap(), false))
                     } else if pin.signal.starts_with("INN") {
-                        // TODO handle in the future when embassy supports differential measurements
-                        None
+                        Some((pin.signal.strip_prefix("INN").unwrap().parse().unwrap(), true))
                     } else if pin.signal.starts_with("IN") && pin.signal.ends_with('b') {
                         // we number STM32L1 ADC bank 1 as 0..=31, bank 2 as 32..=63
                         let signal = pin.signal.strip_prefix("IN").unwrap().strip_suffix('b').unwrap();
-                        Some(32u8 + signal.parse::<u8>().unwrap())
+                        Some((32u8 + signal.parse::<u8>().unwrap(), false))
                     } else if pin.signal.starts_with("IN") {
-                        Some(pin.signal.strip_prefix("IN").unwrap().parse().unwrap())
+                        Some((pin.signal.strip_prefix("IN").unwrap().parse().unwrap(), false))
                     } else {
                         None
                     };
-                    if let Some(ch) = ch {
+                    if let Some((ch, false)) = ch {
+                        adc_pairs.entry(ch).or_insert((None, None)).0.replace(pin_name.clone());
+
                         g.extend(quote! {
                         impl_adc_pin!( #peri, #pin_name, #ch);
                         })
                     }
+                    if let Some((ch, true)) = ch {
+                        adc_pairs.entry(ch).or_insert((None, None)).1.replace(pin_name.clone());
+                    }
                 }
 
                 if regs.kind == "opamp" {
@@ -1531,6 +1537,23 @@ fn main() {
                     })
                 }
             }
+
+            {
+                let peri = format_ident!("{}", p.name);
+
+                for (ch, (pin, npin)) in adc_pairs {
+                    let (pin_name, npin_name) = match (pin, npin) {
+                        (Some(pin), Some(npin)) => (pin, npin),
+                        _ => {
+                            continue;
+                        }
+                    };
+
+                    g.extend(quote! {
+                    impl_adc_pair!( #peri, #pin_name, #npin_name, #ch);
+                    })
+                }
+            }
         }
     }
 
diff --git a/embassy-stm32/src/adc/c0.rs b/embassy-stm32/src/adc/c0.rs
index 1869993a5..bc97a7c4b 100644
--- a/embassy-stm32/src/adc/c0.rs
+++ b/embassy-stm32/src/adc/c0.rs
@@ -24,11 +24,11 @@ const CHSELR_SQ_SIZE: usize = 8;
 const CHSELR_SQ_MAX_CHANNEL: u8 = 14;
 const CHSELR_SQ_SEQUENCE_END_MARKER: u8 = 0b1111;
 
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 10;
 }
 
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 9;
 }
 
diff --git a/embassy-stm32/src/adc/f1.rs b/embassy-stm32/src/adc/f1.rs
index 835cc8c63..f6220de78 100644
--- a/embassy-stm32/src/adc/f1.rs
+++ b/embassy-stm32/src/adc/f1.rs
@@ -3,7 +3,7 @@ use core::marker::PhantomData;
 use core::task::Poll;
 
 use super::blocking_delay_us;
-use crate::adc::{Adc, AdcChannel, Instance, SampleTime};
+use crate::adc::{Adc, AdcChannel, Instance, SampleTime, VrefInt};
 use crate::interrupt::typelevel::Interrupt;
 use crate::interrupt::{self};
 use crate::time::Hertz;
@@ -28,11 +28,11 @@ impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandl
     }
 }
 
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<VrefInt> for T {
     const CHANNEL: u8 = 17;
 }
 
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 16;
 }
 
diff --git a/embassy-stm32/src/adc/f3.rs b/embassy-stm32/src/adc/f3.rs
index f6a4e1209..4a77f3c5b 100644
--- a/embassy-stm32/src/adc/f3.rs
+++ b/embassy-stm32/src/adc/f3.rs
@@ -3,7 +3,7 @@ use core::marker::PhantomData;
 use core::task::Poll;
 
 use super::blocking_delay_us;
-use crate::adc::{Adc, AdcChannel, Instance, SampleTime};
+use crate::adc::{Adc, AdcChannel, Instance, SampleTime, VrefInt};
 use crate::interrupt::typelevel::Interrupt;
 use crate::time::Hertz;
 use crate::{Peri, interrupt, rcc};
@@ -29,11 +29,11 @@ impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandl
     }
 }
 
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<VrefInt> for T {
     const CHANNEL: u8 = 18;
 }
 
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 16;
 }
 
diff --git a/embassy-stm32/src/adc/g4.rs b/embassy-stm32/src/adc/g4.rs
index 5d9c6ff74..6430b0243 100644
--- a/embassy-stm32/src/adc/g4.rs
+++ b/embassy-stm32/src/adc/g4.rs
@@ -140,37 +140,19 @@ impl<'d, T: Instance> Adc<'d, T> {
             );
         }
 
-        let mut s = Self { adc };
-        s.power_up();
-        s.configure_differential_inputs();
-
-        s.calibrate();
-        blocking_delay_us(1);
-
-        Self::enable();
-        s.configure();
-
-        s
-    }
-
-    fn power_up(&mut self) {
         T::regs().cr().modify(|reg| {
             reg.set_deeppwd(false);
             reg.set_advregen(true);
         });
 
         blocking_delay_us(20);
-    }
 
-    fn configure_differential_inputs(&mut self) {
         T::regs().difsel().modify(|w| {
             for n in 0..18 {
                 w.set_difsel(n, Difsel::SINGLE_ENDED);
             }
         });
-    }
 
-    fn calibrate(&mut self) {
         T::regs().cr().modify(|w| {
             w.set_adcaldif(Adcaldif::SINGLE_ENDED);
         });
@@ -190,6 +172,16 @@ impl<'d, T: Instance> Adc<'d, T> {
         while T::regs().cr().read().adcal() {}
 
         blocking_delay_us(20);
+
+        Self::enable();
+
+        // single conversion mode, software trigger
+        T::regs().cfgr().modify(|w| {
+            w.set_cont(false);
+            w.set_exten(Exten::DISABLED);
+        });
+
+        Self { adc }
     }
 
     fn enable() {
@@ -213,18 +205,10 @@ impl<'d, T: Instance> Adc<'d, T> {
         }
     }
 
-    fn configure(&mut self) {
-        // single conversion mode, software trigger
-        T::regs().cfgr().modify(|w| {
-            w.set_cont(false);
-            w.set_exten(Exten::DISABLED);
-        });
-    }
-
     /// Enable reading the voltage reference internal channel.
     pub fn enable_vrefint(&self) -> super::VrefInt
     where
-        T: super::VrefConverter,
+        T: super::SpecialConverter<super::VrefInt>,
     {
         T::common_regs().ccr().modify(|reg| {
             reg.set_vrefen(true);
@@ -236,7 +220,7 @@ impl<'d, T: Instance> Adc<'d, T> {
     /// Enable reading the temperature internal channel.
     pub fn enable_temperature(&self) -> super::Temperature
     where
-        T: super::TemperatureConverter,
+        T: super::SpecialConverter<super::Temperature>,
     {
         T::common_regs().ccr().modify(|reg| {
             reg.set_vsenseen(true);
@@ -248,7 +232,7 @@ impl<'d, T: Instance> Adc<'d, T> {
     /// Enable reading the vbat internal channel.
     pub fn enable_vbat(&self) -> super::Vbat
     where
-        T: super::VBatConverter,
+        T: super::SpecialConverter<super::Vbat>,
     {
         T::common_regs().ccr().modify(|reg| {
             reg.set_vbaten(true);
@@ -257,35 +241,6 @@ impl<'d, T: Instance> Adc<'d, T> {
         super::Vbat {}
     }
 
-    /// Enable differential channel.
-    /// Caution:
-    /// : When configuring the channel “i” in differential input mode, its negative input voltage VINN[i]
-    /// is connected to another channel. As a consequence, this channel is no longer usable in
-    /// single-ended mode or in differential mode and must never be configured to be converted.
-    /// Some channels are shared between ADC1/ADC2/ADC3/ADC4/ADC5: this can make the
-    /// channel on the other ADC unusable. The only exception is when ADC master and the slave
-    /// operate in interleaved mode.
-    #[cfg(stm32g4)]
-    fn set_differential_channel(&mut self, ch: usize, enable: bool) {
-        T::regs().cr().modify(|w| w.set_aden(false)); // disable adc
-        T::regs().difsel().modify(|w| {
-            w.set_difsel(
-                ch,
-                if enable {
-                    Difsel::DIFFERENTIAL
-                } else {
-                    Difsel::SINGLE_ENDED
-                },
-            );
-        });
-        T::regs().cr().modify(|w| w.set_aden(true));
-    }
-
-    #[cfg(stm32g4)]
-    pub fn set_differential(&mut self, channel: &mut impl AdcChannel<T>, enable: bool) {
-        self.set_differential_channel(channel.channel() as usize, enable);
-    }
-
     /// Set oversampling shift.
     #[cfg(stm32g4)]
     pub fn set_oversampling_shift(&mut self, shift: u8) {
@@ -347,7 +302,17 @@ impl<'d, T: Instance> Adc<'d, T> {
     pub fn blocking_read(&mut self, channel: &mut impl AdcChannel<T>, sample_time: SampleTime) -> u16 {
         channel.setup();
 
-        self.read_channel(channel, sample_time)
+        Self::configure_sequence([((channel.channel(), channel.is_differential()), sample_time)].into_iter());
+
+        #[cfg(stm32h7)]
+        {
+            T::regs().cfgr2().modify(|w| w.set_lshift(0));
+            T::regs()
+                .pcsel()
+                .write(|w| w.set_pcsel(channel.channel() as _, Pcsel::PRESELECTED));
+        }
+
+        self.convert()
     }
 
     /// Start regular adc conversion
@@ -420,11 +385,9 @@ impl<'d, T: Instance> Adc<'d, T> {
         Self::stop_regular_conversions();
         Self::enable();
 
-        Self::configure_sequence(sequence.map(|(channel, sample_time)| {
-            channel.setup();
-
-            (channel.channel, sample_time)
-        }));
+        Self::configure_sequence(
+            sequence.map(|(channel, sample_time)| ((channel.channel, channel.is_differential), sample_time)),
+        );
 
         // Set continuous mode with oneshot dma.
         // Clear overrun flag before starting transfer.
@@ -467,14 +430,14 @@ impl<'d, T: Instance> Adc<'d, T> {
         });
     }
 
-    pub(super) fn configure_sequence(sequence: impl ExactSizeIterator<Item = (u8, SampleTime)>) {
+    pub(super) fn configure_sequence(sequence: impl ExactSizeIterator<Item = ((u8, bool), SampleTime)>) {
         // Set sequence length
         T::regs().sqr1().modify(|w| {
             w.set_l(sequence.len() as u8 - 1);
         });
 
         // Configure channels and ranks
-        for (_i, (ch, sample_time)) in sequence.enumerate() {
+        for (_i, ((ch, is_differential), sample_time)) in sequence.enumerate() {
             let sample_time = sample_time.into();
             if ch <= 9 {
                 T::regs().smpr().modify(|reg| reg.set_smp(ch as _, sample_time));
@@ -505,6 +468,24 @@ impl<'d, T: Instance> Adc<'d, T> {
                 }
                 _ => unreachable!(),
             }
+
+            #[cfg(stm32g4)]
+            {
+                T::regs().cr().modify(|w| w.set_aden(false)); // disable adc
+
+                T::regs().difsel().modify(|w| {
+                    w.set_difsel(
+                        ch.into(),
+                        if is_differential {
+                            Difsel::DIFFERENTIAL
+                        } else {
+                            Difsel::SINGLE_ENDED
+                        },
+                    );
+                });
+
+                T::regs().cr().modify(|w| w.set_aden(true)); // enable adc
+            }
         }
     }
 
@@ -564,12 +545,9 @@ impl<'d, T: Instance> Adc<'d, T> {
         Self::enable();
 
         //adc side setup
-
-        Self::configure_sequence(sequence.map(|(mut channel, sample_time)| {
-            channel.setup();
-
-            (channel.channel, sample_time)
-        }));
+        Self::configure_sequence(
+            sequence.map(|(channel, sample_time)| ((channel.channel, channel.is_differential), sample_time)),
+        );
 
         // Clear overrun flag before starting transfer.
         T::regs().isr().modify(|reg| {
@@ -646,8 +624,17 @@ impl<'d, T: Instance> Adc<'d, T> {
 
         T::regs().jsqr().modify(|w| w.set_jl(N as u8 - 1));
 
-        for (n, (mut channel, sample_time)) in sequence.into_iter().enumerate() {
-            Self::configure_channel(&mut channel, sample_time);
+        for (n, (channel, sample_time)) in sequence.into_iter().enumerate() {
+            let sample_time = sample_time.into();
+            if channel.channel() <= 9 {
+                T::regs()
+                    .smpr()
+                    .modify(|reg| reg.set_smp(channel.channel() as _, sample_time));
+            } else {
+                T::regs()
+                    .smpr2()
+                    .modify(|reg| reg.set_smp((channel.channel() - 10) as _, sample_time));
+            }
 
             let idx = match n {
                 0..=3 => n,
@@ -749,38 +736,6 @@ impl<'d, T: Instance> Adc<'d, T> {
         T::regs().ier().modify(|r| r.set_jeosie(enable));
     }
 
-    fn configure_channel(channel: &mut impl AdcChannel<T>, sample_time: SampleTime) {
-        // Configure channel
-        Self::set_channel_sample_time(channel.channel(), sample_time);
-    }
-
-    fn read_channel(&mut self, channel: &mut impl AdcChannel<T>, sample_time: SampleTime) -> u16 {
-        Self::configure_channel(channel, sample_time);
-        #[cfg(stm32h7)]
-        {
-            T::regs().cfgr2().modify(|w| w.set_lshift(0));
-            T::regs()
-                .pcsel()
-                .write(|w| w.set_pcsel(channel.channel() as _, Pcsel::PRESELECTED));
-        }
-
-        T::regs().sqr1().write(|reg| {
-            reg.set_sq(0, channel.channel());
-            reg.set_l(0);
-        });
-
-        self.convert()
-    }
-
-    fn set_channel_sample_time(ch: u8, sample_time: SampleTime) {
-        let sample_time = sample_time.into();
-        if ch <= 9 {
-            T::regs().smpr().modify(|reg| reg.set_smp(ch as _, sample_time));
-        } else {
-            T::regs().smpr2().modify(|reg| reg.set_smp((ch - 10) as _, sample_time));
-        }
-    }
-
     // Stop regular conversions
     fn stop_regular_conversions() {
         if T::regs().cr().read().adstart() && !T::regs().cr().read().addis() {
@@ -811,47 +766,47 @@ impl<T: Instance, const N: usize> InjectedAdc<T, N> {
 
 #[cfg(stm32g4)]
 mod g4 {
-    use crate::adc::{TemperatureConverter, VBatConverter, VrefConverter};
+    use crate::adc::{SealedSpecialConverter, Temperature, Vbat, VrefInt};
 
-    impl TemperatureConverter for crate::peripherals::ADC1 {
+    impl SealedSpecialConverter<Temperature> for crate::peripherals::ADC1 {
         const CHANNEL: u8 = 16;
     }
 
-    impl VrefConverter for crate::peripherals::ADC1 {
+    impl SealedSpecialConverter<VrefInt> for crate::peripherals::ADC1 {
         const CHANNEL: u8 = 18;
     }
 
-    impl VBatConverter for crate::peripherals::ADC1 {
+    impl SealedSpecialConverter<Vbat> for crate::peripherals::ADC1 {
         const CHANNEL: u8 = 17;
     }
 
     #[cfg(peri_adc3_common)]
-    impl VrefConverter for crate::peripherals::ADC3 {
+    impl SealedSpecialConverter<VrefInt> for crate::peripherals::ADC3 {
         const CHANNEL: u8 = 18;
     }
 
     #[cfg(peri_adc3_common)]
-    impl VBatConverter for crate::peripherals::ADC3 {
+    impl SealedSpecialConverter<Vbat> for crate::peripherals::ADC3 {
         const CHANNEL: u8 = 17;
     }
 
     #[cfg(not(stm32g4x1))]
-    impl VrefConverter for crate::peripherals::ADC4 {
+    impl SealedSpecialConverter<VrefInt> for crate::peripherals::ADC4 {
         const CHANNEL: u8 = 18;
     }
 
     #[cfg(not(stm32g4x1))]
-    impl TemperatureConverter for crate::peripherals::ADC5 {
+    impl SealedSpecialConverter<Temperature> for crate::peripherals::ADC5 {
         const CHANNEL: u8 = 4;
     }
 
     #[cfg(not(stm32g4x1))]
-    impl VrefConverter for crate::peripherals::ADC5 {
+    impl SealedSpecialConverter<VrefInt> for crate::peripherals::ADC5 {
         const CHANNEL: u8 = 18;
     }
 
     #[cfg(not(stm32g4x1))]
-    impl VBatConverter for crate::peripherals::ADC5 {
+    impl SealedSpecialConverter<Vbat> for crate::peripherals::ADC5 {
         const CHANNEL: u8 = 17;
     }
 }
@@ -859,13 +814,13 @@ mod g4 {
 // TODO this should look at each ADC individually and impl the correct channels
 #[cfg(stm32h7)]
 mod h7 {
-    impl<T: Instance> TemperatureConverter for T {
+    impl<T: Instance> SealedSpecialConverter<Temperature> for T {
         const CHANNEL: u8 = 18;
     }
-    impl<T: Instance> VrefConverter for T {
+    impl<T: Instance> SealedSpecialConverter<VrefInt> for T {
         const CHANNEL: u8 = 19;
     }
-    impl<T: Instance> VBatConverter for T {
+    impl<T: Instance> SealedSpecialConverter<Vbat> for T {
         // TODO this should be 14 for H7a/b/35
         const CHANNEL: u8 = 17;
     }
diff --git a/embassy-stm32/src/adc/mod.rs b/embassy-stm32/src/adc/mod.rs
index 3bf893a35..e321c4fa1 100644
--- a/embassy-stm32/src/adc/mod.rs
+++ b/embassy-stm32/src/adc/mod.rs
@@ -80,6 +80,11 @@ pub(crate) trait SealedAdcChannel<T> {
 
     #[allow(unused)]
     fn channel(&self) -> u8;
+
+    #[allow(unused)]
+    fn is_differential(&self) -> bool {
+        false
+    }
 }
 
 /// Performs a busy-wait delay for a specified number of microseconds.
@@ -100,29 +105,28 @@ pub(crate) fn blocking_delay_us(us: u32) {
     }
 }
 
-/// Implemented for ADCs that have a Temperature channel
-pub trait TemperatureConverter {
-    const CHANNEL: u8;
-}
-/// Implemented for ADCs that have a Vref channel
-pub trait VrefConverter {
-    const CHANNEL: u8;
-}
-/// Implemented for ADCs that have a VBat channel
-pub trait VBatConverter {
+pub(self) trait SpecialChannel {}
+
+/// Implemented for ADCs that have a special channel
+trait SealedSpecialConverter<T: SpecialChannel + Sized> {
     const CHANNEL: u8;
 }
 
-// NOTE: Vrefint/Temperature/Vbat are not available on all ADCs, this currently cannot be modeled with stm32-data, so these are available from the software on all ADCs
-/// Internal voltage reference channel.
-pub struct VrefInt;
-impl<T: Instance + VrefConverter> AdcChannel<T> for VrefInt {}
-impl<T: Instance + VrefConverter> SealedAdcChannel<T> for VrefInt {
+#[allow(private_bounds)]
+pub trait SpecialConverter<T: SpecialChannel + Sized>: SealedSpecialConverter<T> {}
+
+impl<C: SpecialChannel + Sized, T: SealedSpecialConverter<C>> SpecialConverter<C> for T {}
+
+impl<C: SpecialChannel, T: Instance + SealedSpecialConverter<C>> AdcChannel<T> for C {}
+impl<C: SpecialChannel, T: Instance + SealedSpecialConverter<C>> SealedAdcChannel<T> for C {
     fn channel(&self) -> u8 {
         T::CHANNEL
     }
 }
 
+pub struct VrefInt;
+impl SpecialChannel for VrefInt {}
+
 impl VrefInt {
     #[cfg(any(adc_f3v1, adc_f3v2))]
     /// The value that vref would be if vdda was at 3300mv
@@ -133,21 +137,11 @@ impl VrefInt {
 
 /// Internal temperature channel.
 pub struct Temperature;
-impl<T: Instance + TemperatureConverter> AdcChannel<T> for Temperature {}
-impl<T: Instance + TemperatureConverter> SealedAdcChannel<T> for Temperature {
-    fn channel(&self) -> u8 {
-        T::CHANNEL
-    }
-}
+impl SpecialChannel for Temperature {}
 
 /// Internal battery voltage channel.
 pub struct Vbat;
-impl<T: Instance + VBatConverter> AdcChannel<T> for Vbat {}
-impl<T: Instance + VBatConverter> SealedAdcChannel<T> for Vbat {
-    fn channel(&self) -> u8 {
-        T::CHANNEL
-    }
-}
+impl SpecialChannel for Vbat {}
 
 /// ADC instance.
 #[cfg(not(any(
@@ -178,6 +172,7 @@ pub trait AdcChannel<T>: SealedAdcChannel<T> + Sized {
 
         AnyAdcChannel {
             channel: self.channel(),
+            is_differential: self.is_differential(),
             _phantom: PhantomData,
         }
     }
@@ -189,6 +184,7 @@ pub trait AdcChannel<T>: SealedAdcChannel<T> + Sized {
 /// storing them in an array.
 pub struct AnyAdcChannel<T> {
     channel: u8,
+    is_differential: bool,
     _phantom: PhantomData<T>,
 }
 impl_peripheral!(AnyAdcChannel<T: Instance>);
@@ -197,6 +193,10 @@ impl<T: Instance> SealedAdcChannel<T> for AnyAdcChannel<T> {
     fn channel(&self) -> u8 {
         self.channel
     }
+
+    fn is_differential(&self) -> bool {
+        self.is_differential
+    }
 }
 
 impl<T> AnyAdcChannel<T> {
@@ -315,6 +315,39 @@ macro_rules! impl_adc_pin {
     };
 }
 
+#[allow(unused_macros)]
+macro_rules! impl_adc_pair {
+    ($inst:ident, $pin:ident, $npin:ident, $ch:expr) => {
+        impl crate::adc::AdcChannel<peripherals::$inst>
+            for (
+                crate::Peri<'_, crate::peripherals::$pin>,
+                crate::Peri<'_, crate::peripherals::$npin>,
+            )
+        {
+        }
+        impl crate::adc::SealedAdcChannel<peripherals::$inst>
+            for (
+                crate::Peri<'_, crate::peripherals::$pin>,
+                crate::Peri<'_, crate::peripherals::$npin>,
+            )
+        {
+            #[cfg(any(adc_v1, adc_c0, adc_l0, adc_v2, adc_g4, adc_v4, adc_u5, adc_wba))]
+            fn setup(&mut self) {
+                <crate::peripherals::$pin as crate::gpio::SealedPin>::set_as_analog(&mut self.0);
+                <crate::peripherals::$npin as crate::gpio::SealedPin>::set_as_analog(&mut self.1);
+            }
+
+            fn channel(&self) -> u8 {
+                $ch
+            }
+
+            fn is_differential(&self) -> bool {
+                true
+            }
+        }
+    };
+}
+
 /// Get the maximum reading value for this resolution.
 ///
 /// This is `2**n - 1`.
diff --git a/embassy-stm32/src/adc/v1.rs b/embassy-stm32/src/adc/v1.rs
index 97557ee8a..58c30935f 100644
--- a/embassy-stm32/src/adc/v1.rs
+++ b/embassy-stm32/src/adc/v1.rs
@@ -43,22 +43,22 @@ impl<T: Instance> interrupt::typelevel::Handler<T::Interrupt> for InterruptHandl
 }
 
 #[cfg(not(adc_l0))]
-impl super::VBatConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::Vbat> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 18;
 }
 
 #[cfg(not(adc_l0))]
-impl super::VrefConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::VrefInt> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 17;
 }
 
 #[cfg(adc_l0)]
-impl super::VrefConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::VrefInt> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 18;
 }
 
 #[cfg(not(adc_l0))]
-impl super::TemperatureConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::Temperature> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 16;
 }
 
diff --git a/embassy-stm32/src/adc/v2.rs b/embassy-stm32/src/adc/v2.rs
index 88a8b96ed..efa1cc68c 100644
--- a/embassy-stm32/src/adc/v2.rs
+++ b/embassy-stm32/src/adc/v2.rs
@@ -22,21 +22,21 @@ pub const VREF_DEFAULT_MV: u32 = 3300;
 /// VREF voltage used for factory calibration of VREFINTCAL register.
 pub const VREF_CALIB_MV: u32 = 3300;
 
-impl super::VrefConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::VrefInt> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 17;
 }
 
 #[cfg(any(stm32f2, stm32f40x, stm32f41x))]
-impl super::TemperatureConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::Temperature> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 16;
 }
 
 #[cfg(not(any(stm32f2, stm32f40x, stm32f41x)))]
-impl super::TemperatureConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::Temperature> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 18;
 }
 
-impl super::VBatConverter for crate::peripherals::ADC1 {
+impl super::SealedSpecialConverter<super::Vbat> for crate::peripherals::ADC1 {
     const CHANNEL: u8 = 18;
 }
 
diff --git a/embassy-stm32/src/adc/v3.rs b/embassy-stm32/src/adc/v3.rs
index e816907d1..cbc217545 100644
--- a/embassy-stm32/src/adc/v3.rs
+++ b/embassy-stm32/src/adc/v3.rs
@@ -36,53 +36,53 @@ pub const VREF_CALIB_MV: u32 = 3000;
 const SAMPLE_TIMES_CAPACITY: usize = 2;
 
 #[cfg(adc_g0)]
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 13;
 }
 #[cfg(any(adc_h5, adc_h7rs))]
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 17;
 }
 #[cfg(adc_u0)]
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 12;
 }
 #[cfg(not(any(adc_g0, adc_h5, adc_h7rs, adc_u0)))]
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 0;
 }
 
 #[cfg(adc_g0)]
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 12;
 }
 #[cfg(any(adc_h5, adc_h7rs))]
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 16;
 }
 #[cfg(adc_u0)]
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 11;
 }
 #[cfg(not(any(adc_g0, adc_h5, adc_h7rs, adc_u0)))]
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 17;
 }
 
 #[cfg(adc_g0)]
-impl<T: Instance> super::VBatConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Vbat> for T {
     const CHANNEL: u8 = 14;
 }
 #[cfg(any(adc_h5, adc_h7rs))]
-impl<T: Instance> super::VBatConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Vbat> for T {
     const CHANNEL: u8 = 2;
 }
 #[cfg(adc_u0)]
-impl<T: Instance> super::VBatConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Vbat> for T {
     const CHANNEL: u8 = 13;
 }
 #[cfg(not(any(adc_g0, adc_h5, adc_h7rs, adc_u0)))]
-impl<T: Instance> super::VBatConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Vbat> for T {
     const CHANNEL: u8 = 18;
 }
 
diff --git a/embassy-stm32/src/adc/v4.rs b/embassy-stm32/src/adc/v4.rs
index 2f7baf3bf..1d5d3fb92 100644
--- a/embassy-stm32/src/adc/v4.rs
+++ b/embassy-stm32/src/adc/v4.rs
@@ -26,39 +26,39 @@ const MAX_ADC_CLK_FREQ: Hertz = Hertz::mhz(50);
 const MAX_ADC_CLK_FREQ: Hertz = Hertz::mhz(55);
 
 #[cfg(stm32g4)]
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 18;
 }
 #[cfg(stm32g4)]
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 16;
 }
 
 #[cfg(stm32h7)]
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 19;
 }
 #[cfg(stm32h7)]
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 18;
 }
 
 // TODO this should be 14 for H7a/b/35
 #[cfg(not(stm32u5))]
-impl<T: Instance> super::VBatConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Vbat> for T {
     const CHANNEL: u8 = 17;
 }
 
 #[cfg(stm32u5)]
-impl<T: Instance> super::VrefConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::VrefInt> for T {
     const CHANNEL: u8 = 0;
 }
 #[cfg(stm32u5)]
-impl<T: Instance> super::TemperatureConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Temperature> for T {
     const CHANNEL: u8 = 19;
 }
 #[cfg(stm32u5)]
-impl<T: Instance> super::VBatConverter for T {
+impl<T: Instance> super::SealedSpecialConverter<super::Vbat> for T {
     const CHANNEL: u8 = 18;
 }
 
diff --git a/examples/stm32g4/src/bin/adc.rs b/examples/stm32g4/src/bin/adc.rs
index 695f37115..94315141c 100644
--- a/examples/stm32g4/src/bin/adc.rs
+++ b/examples/stm32g4/src/bin/adc.rs
@@ -30,9 +30,14 @@ async fn main(_spawner: Spawner) {
 
     let mut adc = Adc::new(p.ADC2);
 
+    let mut adc_temp = Adc::new(p.ADC1);
+    let mut temperature = adc_temp.enable_temperature();
+
     loop {
         let measured = adc.blocking_read(&mut p.PA7, SampleTime::CYCLES24_5);
+        let temperature = adc_temp.blocking_read(&mut temperature, SampleTime::CYCLES24_5);
         info!("measured: {}", measured);
+        info!("temperature: {}", temperature);
         Timer::after_millis(500).await;
     }
 }
diff --git a/examples/stm32g4/src/bin/adc_differential.rs b/examples/stm32g4/src/bin/adc_differential.rs
index a6e2f7d33..2773723e9 100644
--- a/examples/stm32g4/src/bin/adc_differential.rs
+++ b/examples/stm32g4/src/bin/adc_differential.rs
@@ -30,16 +30,16 @@ async fn main(_spawner: Spawner) {
         config.rcc.mux.adc12sel = mux::Adcsel::SYS;
         config.rcc.sys = Sysclk::PLL1_R;
     }
-    let mut p = embassy_stm32::init(config);
+    let p = embassy_stm32::init(config);
 
     let mut adc = Adc::new(p.ADC1);
-    adc.set_differential(&mut p.PA0, true); //p:pa0,n:pa1
+    let mut differential_channel = (p.PA0, p.PA1);
 
     // can also use
     // adc.set_differential_channel(1, true);
     info!("adc initialized");
     loop {
-        let measured = adc.blocking_read(&mut p.PA0, SampleTime::CYCLES247_5);
+        let measured = adc.blocking_read(&mut differential_channel, SampleTime::CYCLES247_5);
         info!("data: {}", measured);
         Timer::after_millis(500).await;
     }