adc: Add "dynamic" Channel type

Add a type that can represent any channel for e.g. storing a list of
channels in an array.

Ref: #33

arduino-hal/src/lib.rs

@@ -49,7 +49,7 @@ pub use i2c::I2c;
 #[cfg(feature = "board-selected")]
 pub mod adc {
     pub use crate::hal::adc::{
-        channel, AdcChannel, AdcOps, AdcSettings, ClockDivider, ReferenceVoltage,
+        channel, AdcChannel, AdcOps, AdcSettings, Channel, ClockDivider, ReferenceVoltage,
     };
 
     /// Check the [`avr_hal_generic::adc::Adc`] documentation.

avr-hal-generic/src/adc.rs

@@ -99,6 +99,51 @@ pub trait AdcChannel<H, ADC: AdcOps<H>> {
     fn channel(&self) -> ADC::Channel;
 }
 
+/// Representation of any ADC Channel.
+///
+/// Typically, distinct types are used per channel, like for example `Pin<mode::Analog, PC0>`.  In
+/// some situations, however, a type is needed which can represent _any_ channel.  This is required
+/// to, for example, store multiple channels in an array.
+///
+/// `Channel` is such a type.  It can be created by calling the [`into_channel()`][into-channel]
+/// method of a distinct type:
+///
+/// ```
+/// let a0 = pins.a0.into_analog_input(&mut adc);
+/// let a1 = pins.a1.into_analog_input(&mut adc);
+///
+/// let channels: [atmega_hal::adc::Channel; 2] = [
+///     a0.into_channel(),
+///     a1.into_channel(),
+/// ];
+///
+/// for ch in channels.iter() {
+///     adc.read_blocking(ch);
+/// }
+/// ```
+///
+/// [into-channel]: crate::port::Pin::into_channel
+pub struct Channel<H, ADC: AdcOps<H>> {
+    ch: ADC::Channel,
+    _h: PhantomData<H>,
+}
+
+impl<H, ADC: AdcOps<H>> Channel<H, ADC> {
+    pub fn new<CH: AdcChannel<H, ADC>>(ch: CH) -> Self {
+        Self {
+            ch: ch.channel(),
+            _h: PhantomData,
+        }
+    }
+}
+
+impl<H, ADC: AdcOps<H>> AdcChannel<H, ADC> for Channel<H, ADC> {
+    #[inline]
+    fn channel(&self) -> ADC::Channel {
+        self.ch
+    }
+}
+
 /// Analog-to-Digital Converter
 /// ```
 /// let dp = atmega_hal::Peripherals::take().unwrap();
@@ -279,6 +324,18 @@ macro_rules! impl_adc {
                 $channel
             }
         }
+
+        /// Convert this channel into a generic "[`Channel`][adc-channel]" type.
+        ///
+        /// The generic channel type can be used to store multiple channels in an array.
+        ///
+        /// [adc-channel]: crate::adc::Channel
+        $(#[$channel_attr])*
+        impl $channel_ty {
+            pub fn into_channel(self) -> $crate::adc::Channel<$HAL, $ADC> {
+                crate::adc::Channel::new(self)
+            }
+        }
         )*)?
     };
 }

avr-hal-generic/src/port.rs

@@ -304,6 +304,19 @@ impl<PIN: PinOps> Pin<mode::Analog, PIN> {
     {
         adc.read_blocking(self)
     }
+
+    /// Convert this pin into a generic [`Channel`][adc-channel] type.
+    ///
+    /// The generic channel type can be used to store multiple channels in an array.
+    ///
+    /// [adc-channel]: crate::adc::Channel
+    pub fn into_channel<H, ADC>(self) -> crate::adc::Channel<H, ADC>
+    where
+        Pin<mode::Analog, PIN>: crate::adc::AdcChannel<H, ADC>,
+        ADC: crate::adc::AdcOps<H>,
+    {
+        crate::adc::Channel::new(self)
+    }
 }
 
 #[macro_export]

mcu/atmega-hal/src/adc.rs

@@ -6,6 +6,9 @@ pub use avr_hal_generic::adc::{AdcChannel, AdcOps, AdcSettings, ClockDivider, Re
 /// Check the [`avr_hal_generic::adc::Adc`] documentation.
 pub type Adc<CLOCK> = avr_hal_generic::adc::Adc<crate::Atmega, crate::pac::ADC, CLOCK>;
 
+/// Check the [`avr_hal_generic::adc::Channel`] documentation.
+pub type Channel = avr_hal_generic::adc::Channel<crate::Atmega, crate::pac::ADC>;
+
 /// Additional channels
 ///
 /// Some channels are not directly connected to pins.  This module provides types which can be used