src/ad5680.rs

@@ -7,15 +7,14 @@ use stm32f4xx_hal::{
     spi,
 };
 
-/// SPI Mode 1
 pub const SPI_MODE: spi::Mode = spi::Mode {
-    polarity: spi::Polarity::IdleLow,
-    phase: spi::Phase::CaptureOnSecondTransition,
+    polarity: spi::Polarity::IdleHigh,
+    phase: spi::Phase::CaptureOnFirstTransition,
 };
 /// 30 MHz
 pub const SPI_CLOCK: MegaHertz = MegaHertz(30);
 
-pub const MAX_VALUE: u32 = 0x3FFFF;
+pub const MAX_VALUE: u32 = 0x20000;
 
 /// [AD5680](https://www.analog.com/media/en/technical-documentation/data-sheets/AD5680.pdf) DAC
 pub struct Dac<SPI: Transfer<u8>, S: OutputPin> {

src/channel_state.rs

@@ -26,7 +26,7 @@ impl Default for ChannelState {
 
 impl ChannelState {
     /// Update PID state on ADC input, calculate new DAC output
-    pub fn update_pid(&mut self, now: Instant, adc_data: u32) -> u32 {
+    pub fn update_pid(&mut self, now: Instant, adc_data: u32) {
         self.adc_data = Some(adc_data);
         self.adc_time = now;
 
@@ -34,6 +34,6 @@ impl ChannelState {
         let input = (adc_data as f64) / (ad7172::MAX_VALUE as f64);
         let temperature = self.sh.get_temperature(input);
         let output = self.pid.update(temperature);
-        (output * (ad5680::MAX_VALUE as f64)) as u32
+        self.dac_value = (output * (ad5680::MAX_VALUE as f64)) as u32;
     }
 }

src/channels.rs

@@ -48,40 +48,34 @@ impl Channels {
 
             let dac_value = {
                 let state = self.channel_state(channel);
-                let pid_output = state.update_pid(instant, data);
+                state.update_pid(instant, data);
 
                 if state.pid_engaged {
-                    Some(pid_output)
+                    Some(state.dac_value)
                 } else {
                     None
                 }
             };
             if let Some(dac_value) = dac_value {
                 // Forward PID output to i_set DAC
-                self.set_dac(channel.into(), dac_value);
+                match channel {
+                    0 => {
+                        self.channel0.dac.set(dac_value).unwrap();
+                        self.channel0.shdn.set_high().unwrap();
+                    }
+                    1 => {
+                        self.channel1.dac.set(dac_value).unwrap();
+                        self.channel1.shdn.set_high().unwrap();
+                    }
+                    _ =>
+                        unreachable!(),
+                }
             }
 
             channel
         })
     }
 
-    /// i_set DAC
-    pub fn set_dac(&mut self, channel: usize, duty: u32) {
-        match channel {
-            0 => {
-                self.channel0.dac.set(duty).unwrap();
-                self.channel0.state.dac_value = duty;
-                self.channel0.shdn.set_high().unwrap();
-            }
-            1 => {
-                self.channel1.dac.set(duty).unwrap();
-                self.channel1.state.dac_value = duty;
-                self.channel1.shdn.set_high().unwrap();
-            }
-            _ => unreachable!(),
-        }
-    }
-
     pub fn read_ref_adc(&mut self, channel: usize) -> u16 {
         match channel {
             0 => self.channel0.ref_adc.convert(

src/main.rs

@@ -16,6 +16,7 @@ use cortex_m_rt::entry;
 use stm32f4xx_hal::{
     hal::{
         self,
+        digital::v2::OutputPin,
         watchdog::{WatchdogEnable, Watchdog},
     },
     rcc::RccExt,
@@ -252,7 +253,18 @@ fn main() -> ! {
                                 }
                                 Command::Pwm { channel, pin: PwmPin::ISet, duty } if duty <= ad5680::MAX_VALUE => {
                                     channels.channel_state(channel).pid_engaged = false;
-                                    channels.set_dac(channel, duty);
+                                    match channel {
+                                        0 => {
+                                            channels.channel0.dac.set(duty).unwrap();
+                                            channels.channel0.shdn.set_high().unwrap();
+                                        }
+                                        1 => {
+                                            channels.channel1.dac.set(duty).unwrap();
+                                            channels.channel1.shdn.set_high().unwrap();
+                                        }
+                                        _ => unreachable!(),
+                                    }
+                                    channels.channel_state(channel).dac_value = duty;
                                     let _ = writeln!(
                                         socket, "channel {}: PWM duty cycle manually set to {}/{}",
                                         channel, duty, ad5680::MAX_VALUE