Adc implementation

avr-hal-generic/src/adc.rs

@@ -0,0 +1,153 @@
+/// The division factor between the system clock frequency and the input clock to the AD converter.
+///
+/// To get 10bit precision, clock from 50kHz to 200kHz must be supplied. If you need less precision, you can supply higher clock.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ClockRateDivision {
+    Factor2,
+    Factor4,
+    Factor8,
+    Factor16,
+    Factor32,
+    Factor64,
+    Factor128,
+}
+
+impl Default for ClockRateDivision {
+    fn default() -> Self {
+        Self::Factor128
+    }
+}
+
+/// Select the voltage reference for the ADC peripheral
+///
+/// The internal voltage reference options may not be used if an external reference voltage is being applied to the AREF pin.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ReferenceVoltage {
+    /// Voltage applied to AREF pin.
+    Aref,
+    /// Default reference voltage.
+    AVcc,
+    /// Internal reference voltage
+    Internal,
+}
+
+impl Default for ReferenceVoltage {
+    fn default() -> Self {
+        Self::AVcc
+    }
+}
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AdcSettings {
+    pub clock_divider: ClockRateDivision,
+    pub ref_voltage: ReferenceVoltage,
+}
+
+#[macro_export]
+macro_rules! impl_adc {
+    (
+        pub struct $Adc:ident {
+            type ChannelID = $ID:ty;
+            peripheral: $ADC:ty,
+            pins: {$($pxi:ident: ($PXi:ident, $ChannelID:expr, $didr:ident::$didr_method:ident),)+}
+        }
+    ) => {
+
+        use $crate::void::Void;
+        use $crate::hal::adc::{Channel, OneShot};
+        use $crate::nb;
+        use $crate::port::mode::Analog;
+        pub use avr_hal::adc::*;
+
+        pub struct $Adc {
+            peripheral: $ADC,
+            reading_channel: Option<$ID>,
+        }
+
+        impl $Adc {
+            pub fn new(peripheral: $ADC, settings: AdcSettings) -> $Adc {
+                let s = Self { peripheral, reading_channel: None } ;
+                s.enable(settings);
+                s
+            }
+
+            fn enable(&self, settings: AdcSettings) {
+                self.peripheral.adcsra.write(|w| {
+                    w.aden().set_bit();
+                    match settings.clock_divider {
+                        ClockRateDivision::Factor2 => w.adps().prescaler_2(),
+                        ClockRateDivision::Factor4 => w.adps().prescaler_4(),
+                        ClockRateDivision::Factor8 => w.adps().prescaler_8(),
+                        ClockRateDivision::Factor16 => w.adps().prescaler_16(),
+                        ClockRateDivision::Factor32 => w.adps().prescaler_32(),
+                        ClockRateDivision::Factor64 => w.adps().prescaler_64(),
+                        ClockRateDivision::Factor128 => w.adps().prescaler_128(),
+                    }});
+                self.peripheral.admux.write(|w| match settings.ref_voltage {
+                    ReferenceVoltage::Aref => w.refs().aref(),
+                    ReferenceVoltage::AVcc => w.refs().avcc(),
+                    ReferenceVoltage::Internal => w.refs().internal(),
+                });
+
+            }
+
+            fn disable(&self) {
+                self.peripheral.adcsra.reset();
+            }
+
+            pub fn release(self) -> $ADC {
+                self.disable();
+                self.peripheral
+            }
+        }
+
+        impl<WORD, PIN> OneShot<$Adc, WORD, PIN> for $Adc
+        where
+            WORD: From<u16>,
+            PIN: Channel<$Adc, ID=$ID>,
+        {
+            type Error = Void;
+
+            fn read(&mut self, _pin: &mut PIN) -> nb::Result<WORD, Self::Error> {
+                match (self.reading_channel, self.peripheral.adcsra.read().adsc().bit_is_set()) {
+                    // Measurement on current pin is ongoing
+                    (Some(channel), true) if channel == PIN::channel() => Err(nb::Error::WouldBlock),
+                    // Measurement on current pin completed
+                    (Some(channel), false) if channel == PIN::channel() => {
+                        self.reading_channel = None;
+                        Ok(self.peripheral.adc.read().bits().into())
+                    },
+                    // Measurement on other pin is ongoing
+                    (Some(_), _) => {
+                        self.reading_channel = None;
+                        Err(nb::Error::WouldBlock)
+                    },
+                    // Start measurement
+                    (None, _) => {
+                        self.reading_channel = Some(PIN::channel());
+                        self.peripheral.admux.modify(|_, w| w.mux().variant(PIN::channel()));
+                        self.peripheral.adcsra.modify(|_, w| w.adsc().set_bit());
+                        Err(nb::Error::WouldBlock)
+                    },
+                }
+            }
+        }
+
+        $(
+            impl Channel<$Adc> for $PXi<Analog> {
+                type ID = $ID;
+                fn channel() -> Self::ID {
+                    $ChannelID
+                }
+            }
+
+            impl<MODE> $PXi<MODE> {
+                    /// Make this pin a analog input and set the didr register
+                    pub fn into_analog_input(self, adc: &mut $Adc) -> $PXi<Analog> {
+                        adc.peripheral.$didr.modify(|_, w| w.$didr_method().set_bit());
+                        $PXi { _mode: core::marker::PhantomData }
+                    }
+            }
+        )+
+    }
+}

avr-hal-generic/src/lib.rs

@@ -18,6 +18,7 @@ pub mod port;
 pub mod serial;
 pub mod i2c;
 pub mod spi;
+pub mod adc;
 
 /// Prelude containing all HAL traits
 pub mod prelude {

avr-hal-generic/src/port.rs

@@ -13,6 +13,7 @@ pub mod mode {
     }
     /// Pin configured as a digital output
     pub struct Output;
+    pub struct Analog;
 
     impl private::Unimplementable for Output {}
     impl<M: InputMode> private::Unimplementable for Input<M> {}
@@ -246,7 +247,7 @@ macro_rules! impl_port {
 
             $(
                 pub struct $PXi<MODE> {
-                    _mode: marker::PhantomData<MODE>,
+                    pub(crate)_mode: marker::PhantomData<MODE>,
                 }
 
                 // Mode Switch implementations ---------------------------- {{{

boards/arduino-uno/examples/uno-adc.rs

@@ -0,0 +1,46 @@
+#![no_std]
+#![no_main]
+
+extern crate panic_halt;
+use arduino_uno::prelude::*;
+
+// This example opens a serial connection to the host computer.  On most POSIX operating systems (like GNU/Linux or
+// OSX), you can interface with the program by running (assuming the device appears as ttyACM0)
+//
+// $ sudo screen /dev/ttyACM0 9600
+
+#[no_mangle]
+pub extern fn main() -> ! {
+    let dp = arduino_uno::Peripherals::take().unwrap();
+
+    let mut pins = arduino_uno::Pins::new(
+        dp.PORTB,
+        dp.PORTC,
+        dp.PORTD,
+    );
+
+    let mut serial = arduino_uno::Serial::new(
+        dp.USART0,
+        pins.d0,
+        pins.d1.into_output(&mut pins.ddr),
+        9600,
+    );
+
+
+    // create the Analog Digital Converter
+    let mut adc = arduino_uno::adc::Adc::new(dp.ADC, arduino_uno::adc::AdcSettings::default());
+
+    // Convert pin to Analog input
+    let mut a0 = pins.a0.into_analog_input(&mut adc);
+
+
+    ufmt::uwriteln!(&mut serial, "Reading Analog Input on PORT a0\r").unwrap();
+
+    loop {
+        // Read the Analog value
+        let aread: u16 = nb::block!{adc.read(&mut a0)}.unwrap();
+
+        // Write it to Serial
+        ufmt::uwriteln!(&mut serial, "read: {}\r", aread);
+    }
+}

boards/arduino-uno/src/lib.rs

@@ -8,6 +8,7 @@ pub use atmega328p_hal::atmega328p;
 pub use crate::atmega328p::Peripherals;
 pub use atmega328p_hal::prelude;
 pub use atmega328p_hal::spi;
+pub use atmega328p_hal::adc;
 pub use crate::pins::*;
 
 pub type Delay = hal::delay::Delay<hal::clock::MHz16>;

chips/atmega328p-hal/src/adc.rs

@@ -0,0 +1,20 @@
+extern crate avr_hal_generic as avr_hal;
+
+use crate::port::portc::{PC0, PC1, PC2, PC3, PC4, PC5};
+
+use crate::atmega328p::adc::admux::MUX_A;
+
+avr_hal::impl_adc! {
+    pub struct Adc {
+        type ChannelID = MUX_A;
+        peripheral: crate::atmega328p::ADC,
+        pins: {
+            pc0: (PC0, MUX_A::ADC0, didr0::adc0d),
+            pc1: (PC1, MUX_A::ADC1, didr0::adc1d),
+            pc2: (PC2, MUX_A::ADC2, didr0::adc2d),
+            pc3: (PC3, MUX_A::ADC3, didr0::adc3d),
+            pc4: (PC4, MUX_A::ADC4, didr0::adc4d),
+            pc5: (PC5, MUX_A::ADC5, didr0::adc5d),
+        }
+    }
+}

chips/atmega328p-hal/src/lib.rs

@@ -9,6 +9,8 @@ pub use avr_hal::delay;
 
 pub mod port;
 
+pub mod adc;
+
 pub mod prelude {
     pub use crate::avr_hal::prelude::*;
     pub use crate::port::PortExt as _;