Improve/fix DAC sawtooth generation (#188)

usbalbin · web-flow · commit c9c85a4451ab · 2025-05-03T21:00:45.000+02:00
* Improve/fix DAC sawtooth generation
diff --git a/examples/comp_w_dac.rs b/examples/comp_w_dac.rs
@@ -29,7 +29,7 @@ fn main() -> ! {
     // Set up DAC to output to pa4 and to internal signal Dac1IntSig1
     // which just so happens is compatible with comp1
     let dac1ch1 = dp.DAC1.constrain((gpioa.pa4, Dac1IntSig1), &mut rcc);
-    let mut dac = dac1ch1.calibrate_buffer(&mut delay).enable();
+    let mut dac = dac1ch1.calibrate_buffer(&mut delay).enable(&mut rcc);
 
     let (comp1, _comp2, ..) = dp.COMP.split(&mut rcc);
     let pa1 = gpioa.pa1.into_analog();
diff --git a/examples/dac.rs b/examples/dac.rs
@@ -31,10 +31,10 @@ fn main() -> ! {
     let (dac1ch1, dac1ch2) = dp.DAC1.constrain((gpioa.pa4, gpioa.pa5), &mut rcc);
 
     // dac_manual will have its value set manually
-    let mut dac_manual = dac1ch1.calibrate_buffer(&mut delay).enable();
+    let mut dac_manual = dac1ch1.calibrate_buffer(&mut delay).enable(&mut rcc);
 
     // dac_generator will have its value set automatically from its internal noise generator
-    let mut dac_generator = dac1ch2.enable_generator(GeneratorConfig::noise(11));
+    let mut dac_generator = dac1ch2.enable_generator(GeneratorConfig::noise(11), &mut rcc);
 
     enum Direction {
         Upcounting,
diff --git a/examples/dac_sawtooth.rs b/examples/dac_sawtooth.rs
@@ -0,0 +1,81 @@
+//! ## Origin
+//!
+//! This code has been taken from the stm32g0xx-hal project and modified to support
+//! STM32G4xx MCUs.
+
+// #![deny(warnings)]
+#![deny(unsafe_code)]
+#![no_main]
+#![no_std]
+
+use embedded_hal::delay::DelayNs;
+use hal::dac::DacExt;
+use hal::delay::SYSTDelayExt;
+use hal::gpio::GpioExt;
+use hal::rcc::RccExt;
+use stm32g4xx_hal as hal;
+use stm32g4xx_hal::dac::{CountingDirection, SawtoothConfig};
+mod utils;
+extern crate cortex_m_rt as rt;
+
+use hal::stm32;
+use rt::entry;
+
+#[entry]
+fn main() -> ! {
+    let dp = stm32::Peripherals::take().expect("cannot take peripherals");
+    let cp = cortex_m::Peripherals::take().expect("cannot take core peripherals");
+
+    let mut rcc = dp.RCC.constrain();
+    let mut delay = cp.SYST.delay(&rcc.clocks);
+
+    let gpioa = dp.GPIOA.split(&mut rcc);
+    let dac1ch1 = dp.DAC1.constrain(gpioa.pa4, &mut rcc);
+
+    // Just like the ADC, the DAC (by default) converts 12bit values between digital
+    // and analog. We will configure the dac to automatically update its output
+    // froms its internal sawtooth generator.
+    //
+    // Internally however, for the sawtooth generation the dac uses a
+    // 16 bit counter where only the 12 msb are sent to the dac output and the 4 msb
+    // are ignored by the output and only used for counting. The counter is reset to
+    // `reset_value << 4` at every `trigger_reset`, meaning the output's 12 bits
+    // will be set to `reset_value`.
+    //
+    // Every trigger_inc this 16 bit counter is incremented/decremented by the specified
+    // step size. Since the 4 msb are not mapped to the output, for example using a step
+    // size of 1 will only produce a change on the output every 2^4=16th trigger_inc.
+    //
+    // We will configure the sawtooth generator with a negative slope. This means that
+    // the generator will subtract the step_size from the counter every trigger_inc.
+    // This produces something like the following waveform.
+    //
+    // \              |\              |\              |\              |
+    //   \            |  \            |  \            |  \            |
+    //     \          |    \          |    \          |    \          |
+    //       \        |      \        |      \        |      \        |
+    //         \      |        \      |        \      |        \      |
+    //           \    |          \    |          \    |          \    |
+    //             \  |            \  |            \  |            \  |
+    //               \|              \|              \|              \|
+    let step_size = 16;
+    let reset_value = 4000;
+    let trigger_count = (reset_value << 4) / step_size;
+    let delay_us = 1;
+
+    // dac_generator will have its value set automatically from its internal sawtooth generator
+    let mut dac_generator = dac1ch1.enable_sawtooth_generator(
+        SawtoothConfig::with_slope(CountingDirection::Decrement, step_size)
+            .reset_value(reset_value),
+        &mut rcc,
+    );
+
+    loop {
+        for _ in 0..trigger_count {
+            dac_generator.trigger_inc();
+            delay.delay_us(delay_us);
+        }
+        delay.delay_us(delay_us);
+        dac_generator.trigger_reset();
+    }
+}
diff --git a/src/dac.rs b/src/dac.rs
@@ -17,10 +17,30 @@ use crate::stm32::RCC;
 use embedded_hal::delay::DelayNs;
 
 pub trait DacOut<V> {
+    fn get_value(&mut self) -> V;
+    fn set_value(&mut self, val: V);
+}
+impl<V, D: DacOutGet<V> + DacOutSet<V>> DacOut<V> for D {
+    fn get_value(&mut self) -> V {
+        DacOutGet::get_value(self)
+    }
+    fn set_value(&mut self, val: V) {
+        DacOutSet::set_value(self, val);
+    }
+}
+pub trait DacOutSet<V> {
     fn set_value(&mut self, val: V);
+}
+pub trait DacOutGet<V> {
     fn get_value(&mut self) -> V;
 }
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum CountingDirection {
+    Decrement = 0,
+    Increment = 1,
+}
+
 pub struct GeneratorConfig {
     mode: u8,
     amp: u8,
@@ -34,35 +54,102 @@ impl GeneratorConfig {
         }
     }
 
-    pub fn sawtooth(amplitude: u8) -> Self {
+    pub fn noise(seed: u8) -> Self {
         Self {
-            mode: 0b11,
-            amp: amplitude,
+            mode: 0b01,
+            amp: seed,
         }
     }
+}
 
-    pub fn noise(seed: u8) -> Self {
+/// Used as regular trigger source and sawtooth generator reset trigger source
+///
+/// # Safety
+/// This trait should only be implemented for valid trigger sources with correct
+/// bit patterns.
+pub unsafe trait TriggerSource {
+    /// See stinctrigsel in reference manual for bit patterns
+    const BITS: u8;
+}
+
+/// Used as sawtooth generator inc trigger source
+/// # Safety
+/// This trait should only be implemented for valid trigger sources with correct
+/// bit patterns.
+pub unsafe trait IncTriggerSource {
+    /// See strsttrigsel in reference manual for bit patterns
+    const BITS: u8;
+}
+
+// https://www.youtube.com/watch?v=fUQaHyaXikw&ab_channel=STMicroelectronics
+#[derive(Debug, Clone, Copy)]
+pub struct SawtoothConfig {
+    /// The sawtooth counter initial value (12 bits)
+    reset_value: u16,
+
+    dir: CountingDirection,
+    step_size: u16,
+
+    inc_trigger: u8,
+    reset_trigger: u8,
+}
+
+impl Default for SawtoothConfig {
+    fn default() -> Self {
+        Self::with_slope(CountingDirection::Decrement, 0x10)
+    }
+}
+
+impl SawtoothConfig {
+    /// NOTE: The DAC output is used from 12 MSBs of the sawtooth counter so
+    /// a step_size of 1 will only increment the output by 1 every 16th inc trigger
+    pub const fn with_slope(dir: CountingDirection, step_size: u16) -> Self {
         Self {
-            mode: 0b01,
-            amp: seed,
+            reset_value: u16::MAX,
+            dir,
+            step_size,
+            inc_trigger: 0b0000,   // SW trigger using `trigger_inc`-method
+            reset_trigger: 0b0000, // SW trigger using `trigger_reset`-method
         }
     }
+
+    /// The sawtooth counter reset value (12 bits)
+    pub const fn reset_value(mut self, reset_value: u16) -> Self {
+        self.reset_value = reset_value;
+        self
+    }
+
+    pub const fn slope(mut self, dir: CountingDirection, step_size: u16) -> Self {
+        self.dir = dir;
+        self.step_size = step_size;
+        self
+    }
+
+    pub fn inc_trigger<T: IncTriggerSource>(mut self, _inc_trigger: T) -> Self {
+        self.inc_trigger = T::BITS;
+        self
+    }
+
+    pub fn reset_trigger<T: TriggerSource>(mut self, _reset_trigger: T) -> Self {
+        self.reset_trigger = T::BITS;
+        self
+    }
 }
 
 /// Enabled DAC (type state)
 pub struct Enabled;
 // / Enabled DAC without output buffer (type state)
 //pub struct EnabledUnbuffered;
-/// Enabled DAC wave generator (type state)
+/// Enabled DAC wave generator for triangle or noise wave form (type state)
 pub struct WaveGenerator;
+/// Enabled DAC wave generator for sawtooth wave form (type state)
+pub struct SawtoothGenerator;
 /// Disabled DAC (type state)
 pub struct Disabled;
 
-pub trait ED {}
-impl ED for Enabled {}
-//impl ED for EnabledUnbuffered {}
-impl ED for WaveGenerator {}
-impl ED for Disabled {}
+pub trait Generator {}
+impl Generator for WaveGenerator {}
+impl Generator for SawtoothConfig {}
 
 pub trait Instance:
     rcc::Enable
@@ -177,7 +264,8 @@ impl_pin_for_dac!(
 impl<DAC: Instance, const CH: u8, const MODE_BITS: u8> DacCh<DAC, CH, MODE_BITS, Disabled> {
     /// TODO: The DAC does not seem to work unless `calibrate_buffer` has been callen
     /// even when only using dac output internally
-    pub fn enable(self) -> DacCh<DAC, CH, MODE_BITS, Enabled> {
+    pub fn enable(self, _rcc: &mut Rcc) -> DacCh<DAC, CH, MODE_BITS, Enabled> {
+        // We require rcc here just to ensure exclusive access to registers common to ch1 and ch2
         let dac = unsafe { &(*DAC::ptr()) };
 
         dac.mcr()
@@ -190,7 +278,9 @@ impl<DAC: Instance, const CH: u8, const MODE_BITS: u8> DacCh<DAC, CH, MODE_BITS,
     pub fn enable_generator(
         self,
         config: GeneratorConfig,
+        _rcc: &mut Rcc,
     ) -> DacCh<DAC, CH, MODE_BITS, WaveGenerator> {
+        // We require rcc here just to ensure exclusive access to registers common to ch1 and ch2
         let dac = unsafe { &(*DAC::ptr()) };
 
         dac.mcr()
@@ -204,6 +294,45 @@ impl<DAC: Instance, const CH: u8, const MODE_BITS: u8> DacCh<DAC, CH, MODE_BITS,
 
         DacCh::new()
     }
+
+    pub fn enable_sawtooth_generator(
+        self,
+        config: SawtoothConfig,
+        _rcc: &mut Rcc,
+    ) -> DacCh<DAC, CH, MODE_BITS, SawtoothGenerator> {
+        // TODO: We require rcc here just to ensure exclusive access to registers common to ch1 and ch2
+        let dac = unsafe { &(*DAC::ptr()) };
+
+        dac.mcr()
+            .modify(|_, w| unsafe { w.mode(CH).bits(MODE_BITS) });
+
+        unsafe {
+            dac.stmodr().modify(|_, w| {
+                w.stinctrigsel(CH)
+                    .bits(config.inc_trigger)
+                    .strsttrigsel(CH)
+                    .bits(config.reset_trigger)
+            });
+        }
+
+        dac.cr().modify(|_, w| unsafe { w.wave(CH).bits(0b11) });
+
+        unsafe {
+            dac.str(CH as usize).write(|w| {
+                w.stdir()
+                    .bit(config.dir == CountingDirection::Increment)
+                    .stincdata()
+                    .bits(config.step_size)
+                    .strstdata()
+                    .bits(config.reset_value)
+            });
+        }
+
+        dac.cr().modify(|_, w| w.en(CH).set_bit());
+        while dac.sr().read().dacrdy(CH).bit_is_clear() {}
+
+        DacCh::new()
+    }
 }
 
 impl<DAC: Instance, const CH: u8, const MODE_BITS: u8, ED> DacCh<DAC, CH, MODE_BITS, ED> {
@@ -252,21 +381,35 @@ impl<DAC: Instance, const CH: u8, const MODE_BITS: u8, ED> DacCh<DAC, CH, MODE_B
 
 /// DacOut implementation available in any Enabled/Disabled
 /// state
-impl<DAC: Instance, const CH: u8, const MODE_BITS: u8, ED> DacOut<u16>
-    for DacCh<DAC, CH, MODE_BITS, ED>
+impl<DAC: Instance, const CH: u8, const MODE_BITS: u8> DacOutSet<u16>
+    for DacCh<DAC, CH, MODE_BITS, Enabled>
 {
     fn set_value(&mut self, val: u16) {
         let dac = unsafe { &(*DAC::ptr()) };
         dac.dhr12r(CH as usize)
             .write(|w| unsafe { w.bits(val as u32) });
     }
+}
 
+impl<DAC: Instance, const CH: u8, const MODE_BITS: u8, ED> DacOutGet<u16>
+    for DacCh<DAC, CH, MODE_BITS, ED>
+{
     fn get_value(&mut self) -> u16 {
         let dac = unsafe { &(*DAC::ptr()) };
         dac.dor(CH as usize).read().bits() as u16
     }
 }
 
+impl<DAC: Instance, const CH: u8, const MODE_BITS: u8> DacOutSet<u16>
+    for DacCh<DAC, CH, MODE_BITS, SawtoothGenerator>
+{
+    fn set_value(&mut self, reset_value: u16) {
+        let dac = unsafe { &(*<DAC>::ptr()) };
+        dac.str(CH as usize)
+            .modify(|_r, w| unsafe { w.strstdata().bits(reset_value) });
+    }
+}
+
 /// Wave generator state implementation
 impl<DAC: Instance, const CH: u8, const MODE_BITS: u8> DacCh<DAC, CH, MODE_BITS, WaveGenerator> {
     pub fn trigger(&mut self) {
@@ -275,6 +418,26 @@ impl<DAC: Instance, const CH: u8, const MODE_BITS: u8> DacCh<DAC, CH, MODE_BITS,
     }
 }
 
+/// Sawtooth generator state implementation
+impl<DAC: Instance, const CH: u8, const MODE_BITS: u8>
+    DacCh<DAC, CH, MODE_BITS, SawtoothGenerator>
+{
+    pub fn trigger_reset(&mut self) {
+        let dac = unsafe { &(*<DAC>::ptr()) };
+        dac.swtrgr().write(|w| w.swtrig(CH).set_bit());
+    }
+
+    pub fn trigger_inc(&mut self) {
+        let dac = unsafe { &(*<DAC>::ptr()) };
+        // TODO: Update once arrayified
+        if CH == 0 {
+            dac.swtrgr().write(|w| w.swtrigb1().set_bit());
+        } else {
+            dac.swtrgr().write(|w| w.swtrigb2().set_bit());
+        }
+    }
+}
+
 pub trait DacExt: Sized {
     fn constrain<PINS>(self, pins: PINS, rcc: &mut Rcc) -> PINS::Output
     where
