feat(adc): differential sampling support

boards/feather_m0/examples/adc.rs

@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Adc, Prescaler, Resolution, SingleEndedInput},
     clock::GenericClockController,
 };
 
@@ -44,10 +44,11 @@ fn main() -> ! {
         .enable(peripherals.adc, &mut peripherals.pm, &adc_clock)
         .unwrap();
     let mut adc_pin = pins.a0.into_alternate();
+    let mut adc_input = SingleEndedInput::from_pin(&mut adc_pin);
 
     loop {
-        let res = adc.read(&mut adc_pin);
+        let res = adc.read(&mut adc_input);
         #[cfg(feature = "use_semihosting")]
-        cortex_m_semihosting::hprintln!("ADC value: {}", read).unwrap();
+        cortex_m_semihosting::hprintln!("ADC value: {}", res).unwrap();
     }
 }

boards/feather_m0/examples/async_adc.rs

@@ -16,7 +16,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Adc0, Prescaler, Resolution},
+    adc::{Accumulation, Adc, Adc0, Prescaler, Resolution, SingleEndedInput},
     clock::GenericClockController,
 };
 
@@ -49,9 +49,10 @@ async fn main(_s: embassy_executor::Spawner) -> ! {
         .into_future(Irqs);
 
     let mut adc_pin = pins.a0.into_alternate();
+    let mut adc_input = SingleEndedInput::from_pin(&mut adc_pin);
 
     loop {
-        let res = adc.read(&mut adc_pin).await;
+        let res = adc.read(&mut adc_input).await;
         #[cfg(feature = "use_semihosting")]
         cortex_m_semihosting::hprintln!("ADC Result: {}", res).unwrap();
     }

boards/feather_m4/examples/adc.rs

@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Adc, Prescaler, Resolution, SingleEndedInput},
     clock::v2::{clock_system_at_reset, pclk::Pclk},
 };
 
@@ -50,9 +50,10 @@ fn main() -> ! {
         .enable(peripherals.adc0, apb_adc0, &pclk_adc0)
         .unwrap();
     let mut adc_pin = pins.a0.into_alternate();
+    let mut adc_input = SingleEndedInput::from_pin(&mut adc_pin);
 
     loop {
-        let res = adc.read(&mut adc_pin);
+        let res = adc.read(&mut adc_input);
         #[cfg(feature = "use_semihosting")]
         cortex_m_semihosting::hprintln!("ADC value: {}", res);
     }

boards/metro_m4/examples/adc.rs

@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Adc, Prescaler, Resolution, SingleEndedInput},
     clock::v2::{clock_system_at_reset, pclk::Pclk},
 };
 
@@ -49,9 +49,10 @@ fn main() -> ! {
         .enable(peripherals.adc0, apb_adc0, &pclk_adc0)
         .unwrap();
     let mut adc_pin = pins.a0.into_alternate();
+    let mut adc_input = SingleEndedInput::from_pin(&mut adc_pin);
 
     loop {
-        let res = adc.read(&mut adc_pin);
+        let res = adc.read(&mut adc_input);
         #[cfg(feature = "use_semihosting")]
         cortex_m_semihosting::hprintln!("ADC Result: {}", res).unwrap();
     }

boards/metro_m4/examples/async_adc.rs

@@ -16,7 +16,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Adc0, Prescaler, Resolution},
+    adc::{Accumulation, Adc, Adc0, Prescaler, Resolution, SingleEndedInput},
     clock::v2::{clock_system_at_reset, pclk::Pclk},
 };
 
@@ -54,9 +54,10 @@ async fn main(_s: embassy_executor::Spawner) -> ! {
         .into_future(Irqs);
 
     let mut adc_pin = pins.a0.into_alternate();
+    let mut adc_input = SingleEndedInput::from_pin(&mut adc_pin);
 
     loop {
-        let res = adc.read(&mut adc_pin).await;
+        let res = adc.read(&mut adc_input).await;
         #[cfg(feature = "use_semihosting")]
         cortex_m_semihosting::hprintln!("ADC Result: {}", res).unwrap();
     }

boards/pygamer/src/pins.rs

@@ -934,8 +934,8 @@ impl JoystickReader {
         // unnecessary? note adafruit recenters around zero.. Im not doing that
         // either atm.
 
-        let y_data: u16 = adc.read(&mut self.joy_y);
-        let x_data: u16 = adc.read(&mut self.joy_x);
+        let y_data: u16 = adc.read(&mut hal::adc::SingleEndedInput::from_pin(&mut self.joy_y));
+        let x_data: u16 = adc.read(&mut hal::adc::SingleEndedInput::from_pin(&mut self.joy_x));
 
         (x_data, y_data)
     }
@@ -969,7 +969,7 @@ pub struct BatteryReader {
 impl BatteryReader {
     /// Returns a float for voltage of battery
     pub fn read(&mut self, adc: &mut hal::adc::Adc<hal::adc::Adc0>) -> f32 {
-        let data: u16 = adc.read(&mut self.battery);
+        let data: u16 = adc.read(&mut hal::adc::SingleEndedInput::from_pin(&mut self.battery));
         let result: f32 = (data as f32 / 4095.0) * 2.0 * 3.3;
         result
     }

boards/samd11_bare/examples/adc.rs

@@ -17,7 +17,7 @@ use bsp::Pins;
 use pac::{CorePeripherals, Peripherals};
 
 use hal::{
-    adc::{Accumulation, Adc, Prescaler, Resolution},
+    adc::{Accumulation, Adc, Prescaler, Resolution, SingleEndedInput},
     clock::GenericClockController,
 };
 
@@ -45,9 +45,10 @@ fn main() -> ! {
         .unwrap();
 
     let mut adc_pin = pins.d1.into_alternate();
+    let mut adc_input = SingleEndedInput::from_pin(&mut adc_pin);
 
     loop {
-        let res = adc.read(&mut adc_pin);
+        let res = adc.read(&mut adc_input);
         #[cfg(feature = "use_semihosting")]
         cortex_m_semihosting::hprintln!("ADC Result: {}", res);
     }

hal/src/peripherals/adc/builder.rs

@@ -152,6 +152,10 @@ pub struct AdcBuilder {
     pub sample_clock_cycles: Option<u8>,
     pub accumulation: Accumulation,
     pub vref: Option<Reference>,
+    pub offset_compensation: Option<bool>,
+    pub reference_compensation: Option<bool>,
+    pub auto_left_adjust: Option<bool>,
+    pub auto_rail_to_rail: Option<bool>,
 }
 
 /// Version of [AdcBuilder] without any optional settings.
@@ -162,6 +166,10 @@ pub(crate) struct AdcSettings {
     pub sample_clock_cycles: u8,
     pub accumulation: Accumulation,
     pub vref: Reference,
+    pub offset_compensation: bool,
+    pub reference_compensation: bool,
+    pub auto_left_adjust: bool,
+    pub auto_rail_to_rail: bool,
 }
 
 impl AdcBuilder {
@@ -172,6 +180,10 @@ impl AdcBuilder {
             sample_clock_cycles: None,
             accumulation: accumulation_method,
             vref: None,
+            offset_compensation: None,
+            reference_compensation: None,
+            auto_left_adjust: None,
+            auto_rail_to_rail: None,
         }
     }
 
@@ -190,6 +202,10 @@ impl AdcBuilder {
             sample_clock_cycles: self.sample_clock_cycles.unwrap(),
             accumulation: self.accumulation,
             vref: self.vref.unwrap(),
+            offset_compensation: self.offset_compensation.unwrap_or(false),
+            reference_compensation: self.reference_compensation.unwrap_or(false),
+            auto_left_adjust: self.auto_left_adjust.unwrap_or(false),
+            auto_rail_to_rail: self.auto_rail_to_rail.unwrap_or(false),
         })
     }
 
@@ -244,6 +260,47 @@ impl AdcBuilder {
         Ok(adc_clk_freq / clocks_per_sample)
     }
 
+    /// Configure the ADC offset compensation
+    ///
+    /// ## Important
+    /// * (D5x) Enabling offset compesation forces the clock cycles per sample
+    ///   to be 4 GCLK cycles, any change to the cycles per sample via
+    ///   [`Self::with_clock_cycles_per_sample()`] will be ignored.
+    /// * (D11/D21) Not supported.
+    pub fn enable_offset_compensation(mut self, enable: bool) -> Self {
+        self.offset_compensation = Some(enable);
+        self
+    }
+
+    /// Configure the ADC reference compensation
+    pub fn enable_reference_compensation(mut self, enable: bool) -> Self {
+        self.reference_compensation = Some(enable);
+        self
+    }
+
+    /// Enables automatic left-adjustment when measuring differential inputs.
+    /// This allows use of the ADC summation or averaging hardware with
+    /// negative result values. Results are automatically right-shifted back
+    /// appropriately.
+    pub fn enable_auto_left_adjust(mut self, enable: bool) -> Self {
+        self.auto_left_adjust = Some(enable);
+        self
+    }
+
+    /// Automatically enables rail-to-rail operation when measuring a
+    /// differential input. This relaxes common-mode input requirements on
+    /// differential inputs and allows measurments closer to supply rails.
+    ///
+    /// ## Important
+    /// * (D5x) Enabling auto rail-to-rail incurs a slight runtime performance
+    ///   hit as the CTRLA.R2R bit is enable-protected, meaning the ADC must be
+    ///   shut down and re-enabled to enable/disable rail-to-rail mode.
+    /// * (D11/D21) Not supported.
+    pub fn enable_auto_rail_to_rail(mut self, enable: bool) -> Self {
+        self.auto_rail_to_rail = Some(enable);
+        self
+    }
+
     /// Turn the builder into an ADC
     #[hal_cfg("adc-d5x")]
     #[inline]

hal/src/peripherals/adc/d11/channel.rs

@@ -0,0 +1,100 @@
+use core::marker::PhantomData;
+use atsamd_hal_macros::hal_cfg;
+use crate::{
+    adc::*,
+    pac::adc::inputctrl::{Muxposselect, Muxnegselect},
+    typelevel::Sealed,
+};
+
+macro_rules! channel {
+    (
+        $(
+            $CH:ident: ($($PMUX:path)?, $($NMUX:path)?) $(+ $MARKER:ident)*
+        ),+
+        $(,)?
+    ) => {
+        crate::paste::paste!{
+            $(
+                pub struct $CH<I: AdcInstance> {
+                    adc: PhantomData<I>,
+                }
+
+                impl<I: AdcInstance> Sealed for $CH<I> {}
+
+                $(
+                    impl<I: AdcInstance> PosChannel<I> for $CH<I> {
+                        const MUXVAL: Muxposselect = $PMUX;
+                    }
+                )?
+                $(
+                    impl<I: AdcInstance> NegChannel<I> for $CH<I> {
+                        const MUXVAL: Muxnegselect = $NMUX;
+                    }
+                )?
+                $(
+                    impl<I: AdcInstance> $MARKER<I> for $CH<I> {}
+                )*
+
+                impl<I: AdcInstance> $CH<I> {
+                    pub fn get_channel() -> Self {
+                        Self {
+                            adc: PhantomData
+                        }
+                    }
+                }
+            )+
+        }
+    };
+}
+
+#[hal_cfg("adc-d21")]
+channel! {
+    AIN0: (Muxposselect::Pin0, Muxnegselect::Pin0),
+    AIN1: (Muxposselect::Pin1, Muxnegselect::Pin1),
+    AIN2: (Muxposselect::Pin2, Muxnegselect::Pin2),
+    AIN3: (Muxposselect::Pin3, Muxnegselect::Pin3),
+    AIN4: (Muxposselect::Pin4, Muxnegselect::Pin4),
+    AIN5: (Muxposselect::Pin5, Muxnegselect::Pin5),
+    AIN6: (Muxposselect::Pin6, Muxnegselect::Pin6),
+    AIN7: (Muxposselect::Pin7, Muxnegselect::Pin7),
+    AIN8: (Muxposselect::Pin8, ),
+    AIN9: (Muxposselect::Pin9, ),
+    AIN10: (Muxposselect::Pin10, ),
+    AIN11: (Muxposselect::Pin11, ),
+    AIN12: (Muxposselect::Pin12, ),
+    AIN13: (Muxposselect::Pin13, ),
+    AIN14: (Muxposselect::Pin14, ),
+    AIN15: (Muxposselect::Pin15, ),
+    AIN16: (Muxposselect::Pin15, ),
+    AIN17: (Muxposselect::Pin15, ),
+    AIN18: (Muxposselect::Pin15, ),
+    AIN19: (Muxposselect::Pin15, ),
+    TEMP: (Muxposselect::Temp, ),
+    SCALEDCOREVCC: (Muxposselect::Scaledcorevcc, ) + CpuVoltageSource,
+    SCALEDIOVCC: (Muxposselect::Scalediovcc, ) + CpuVoltageSource,
+    BANDGAP: (Muxposselect::Bandgap, ) + CpuVoltageSource,
+    DAC: (Muxposselect::Dac, ),
+    GND: (, Muxnegselect::Gnd),
+    IOGND: (, Muxnegselect::Iognd),
+}
+
+#[hal_cfg("adc-d11")]
+channel! {
+    AIN0: (Muxposselect::Pin0, Muxnegselect::Pin0),
+    AIN1: (Muxposselect::Pin1, Muxnegselect::Pin1),
+    AIN2: (Muxposselect::Pin2, Muxnegselect::Pin2),
+    AIN3: (Muxposselect::Pin3, Muxnegselect::Pin3),
+    AIN4: (Muxposselect::Pin4, Muxnegselect::Pin4),
+    AIN5: (Muxposselect::Pin5, Muxnegselect::Pin5),
+    AIN6: (Muxposselect::Pin6, Muxnegselect::Pin6),
+    AIN7: (Muxposselect::Pin7, Muxnegselect::Pin7),
+    AIN8: (Muxposselect::Pin8, ),
+    AIN9: (Muxposselect::Pin9, ),
+    TEMP: (Muxposselect::Temp, ),
+    SCALEDCOREVCC: (Muxposselect::Scaledcorevcc, ) + CpuVoltageSource,
+    SCALEDIOVCC: (Muxposselect::Scalediovcc, ) + CpuVoltageSource,
+    BANDGAP: (Muxposselect::Bandgap, ) + CpuVoltageSource,
+    DAC: (Muxposselect::Dac, ),
+    GND: (, Muxnegselect::Gnd),
+    IOGND: (, Muxnegselect::Iognd),
+}