add swap status to the report

Signed-off-by: Egor Savkin <es@m-labs.hk>

README.md

@@ -130,6 +130,7 @@ formatted as line-delimited JSON.
 | `fcurve <a> <b> <c>`             | Set fan controller curve coefficients (see *Fan control* section)             |
 | `fcurve default`                 | Set fan controller curve coefficients to defaults (see *Fan control* section) |
 | `hwrev`                          | Show hardware revision, and settings related to it                            |
+| `swap [0/1]`                     | Swap TEC polarities for channel all/0/1 (For use with Zotino)                 |
 
 
 ## USB
@@ -180,9 +181,11 @@ postfilter rate can be tuned with the `postfilter` command.
 
 ## Thermo-Electric Cooling (TEC)
 
-- Connect TEC module device 0 to TEC0- and TEC0+.
-- Connect TEC module device 1 to TEC1- and TEC1+.
-- The GND pin is for shielding not for sinking TEC module currents.
+- Connect TEC module device 0 to TEC0-/T0- and TEC0+/T0+.
+- Connect TEC module device 1 to TEC1-/T1- and TEC1+/T1+.
+- The GND pin is for shielding, not for sinking TEC module currents.
+
+For Zotino temperature regulation, connect an IDC cable to the internal Zotino header labeled TEC1/TEC2. For pre 3.0 Thermostats, use the `swap` command for those channels.
 
 When using a TEC module with the Thermostat, the Thermostat expects the thermal load (where the thermistor is located) to cool down with a positive software current set point, and heat up with a negative current set point.
 

src/channel_state.rs

@@ -35,6 +35,7 @@ pub struct ChannelState {
     pub pid_engaged: bool,
     pub pid: pid::Controller,
     pub sh: sh::Parameters,
+    pub swap_tec_polarity: bool,
 }
 
 impl ChannelState {
@@ -51,6 +52,7 @@ impl ChannelState {
             pid_engaged: false,
             pid: pid::Controller::new(pid::Parameters::default()),
             sh: sh::Parameters::default(),
+            swap_tec_polarity: false,
         }
     }
 

src/channels.rs

@@ -18,13 +18,17 @@ use crate::{
     channel_state::ChannelState,
     command_parser::{CenterPoint, PwmPin},
     command_handler::JsonBuffer,
-    pins,
+    pins::{self, Channel0VRef, Channel1VRef},
     steinhart_hart,
     hw_rev,
 };
 
 pub const CHANNELS: usize = 2;
 pub const R_SENSE: f64 = 0.05;
+
+// as stated in the MAX1968 datasheet
+pub const MAX_TEC_I: f64 = 3.0;
+
 // DAC chip outputs 0-5v, which is then passed through a resistor dividor to provide 0-3v range
 const DAC_OUT_V_MAX: f64 = 3.0;
 
@@ -114,7 +118,11 @@ impl<'a> Channels<'a> {
 
     pub fn get_i(&mut self, channel: usize) -> ElectricCurrent {
         let i_set = self.channel_state(channel).i_set;
-        i_set
+        if self.channel_state(channel).swap_tec_polarity {
+            -i_set
+        } else {
+            i_set
+        }
     }
 
     /// i_set DAC
@@ -130,11 +138,19 @@ impl<'a> Channels<'a> {
     }
 
     pub fn set_i(&mut self, channel: usize, i_set: ElectricCurrent) -> ElectricCurrent {
+        // Silently clamp i_set
+        let i_ceiling = ElectricCurrent::new::<ampere>(MAX_TEC_I);
+        let i_floor = ElectricCurrent::new::<ampere>(-MAX_TEC_I);
+        let mut i_set = i_set.min(i_ceiling).max(i_floor);
+
         let vref_meas = match channel.into() {
             0 => self.channel0.vref_meas,
             1 => self.channel1.vref_meas,
             _ => unreachable!(),
         };
+        if self.channel_state(channel).swap_tec_polarity {
+            i_set = -i_set;
+        }
         let center_point = vref_meas;
         let r_sense = ElectricalResistance::new::<ohm>(R_SENSE);
         let voltage = i_set * 10.0 * r_sense + center_point;
@@ -203,20 +219,30 @@ impl<'a> Channels<'a> {
     pub fn read_vref(&mut self, channel: usize) -> ElectricPotential {
         match channel {
             0 => {
-                let sample = self.pins_adc.convert(
-                    &self.channel0.vref_pin,
-                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
-                );
-                let mv = self.pins_adc.sample_to_millivolts(sample);
-                ElectricPotential::new::<millivolt>(mv as f64)
+                match &self.channel0.vref_pin {
+                    Channel0VRef::Analog(vref_pin) => {
+                        let sample = self.pins_adc.convert(
+                            vref_pin,
+                            stm32f4xx_hal::adc::config::SampleTime::Cycles_480
+                        );
+                        let mv = self.pins_adc.sample_to_millivolts(sample);
+                        ElectricPotential::new::<millivolt>(mv as f64)
+                    },
+                    Channel0VRef::Disabled(_) => ElectricPotential::new::<volt>(1.5)
+                }
             }
             1 => {
-                let sample = self.pins_adc.convert(
-                    &self.channel1.vref_pin,
-                    stm32f4xx_hal::adc::config::SampleTime::Cycles_480
-                );
-                let mv = self.pins_adc.sample_to_millivolts(sample);
-                ElectricPotential::new::<millivolt>(mv as f64)
+                match &self.channel1.vref_pin {
+                    Channel1VRef::Analog(vref_pin) => {
+                        let sample = self.pins_adc.convert(
+                            vref_pin,
+                            stm32f4xx_hal::adc::config::SampleTime::Cycles_480
+                        );
+                        let mv = self.pins_adc.sample_to_millivolts(sample);
+                        ElectricPotential::new::<millivolt>(mv as f64)
+                    },
+                    Channel1VRef::Disabled(_) => ElectricPotential::new::<volt>(1.5)
+                }
             }
             _ => unreachable!(),
         }
@@ -371,7 +397,12 @@ impl<'a> Channels<'a> {
 
     // Get current passing through TEC
     pub fn get_tec_i(&mut self, channel: usize) -> ElectricCurrent {
-        (self.read_itec(channel) - self.read_vref(channel)) / ElectricalResistance::new::<ohm>(0.4)
+        let tec_i = (self.read_itec(channel) - self.read_vref(channel)) / ElectricalResistance::new::<ohm>(0.4);
+        if self.channel_state(channel).swap_tec_polarity {
+            -tec_i
+        } else {
+            tec_i
+        }
     }
 
     // Get voltage across TEC
@@ -443,6 +474,7 @@ impl<'a> Channels<'a> {
             temperature: state.get_temperature()
                 .map(|temperature| temperature.get::<degree_celsius>()),
             pid_engaged: state.pid_engaged,
+            current_swapped: state.swap_tec_polarity,
             i_set,
             dac_value,
             dac_feedback: self.read_dac_feedback(channel),
@@ -540,6 +572,7 @@ pub struct Report {
     sens: Option<ElectricalResistance>,
     temperature: Option<f64>,
     pid_engaged: bool,
+    current_swapped: bool,
     i_set: ElectricCurrent,
     dac_value: ElectricPotential,
     dac_feedback: ElectricPotential,

src/command_handler.rs

@@ -412,6 +412,16 @@ impl Handler {
         }
     }
 
+    fn swap_tec_polarity (socket: &mut TcpSocket, channels: &mut Channels, channel: Option<usize>) -> Result<Handler, Error> {
+        for c in 0..CHANNELS {
+            if channel.is_none() || channel == Some(c) {
+                channels.channel_state(c).swap_tec_polarity = !channels.channel_state(c).swap_tec_polarity;
+            }
+        }
+        send_line(socket, b"{}");
+        Ok(Handler::Handled)
+    }
+
     pub fn handle_command(command: Command, socket: &mut TcpSocket, channels: &mut Channels, session: &Session, store: &mut FlashStore, ipv4_config: &mut Ipv4Config, fan_ctrl: &mut FanCtrl, hwrev: HWRev) -> Result<Self, Error> {
         match command {
             Command::Quit => Ok(Handler::CloseSocket),
@@ -441,6 +451,7 @@ impl Handler {
             Command::FanCurve { k_a, k_b, k_c } => Handler::fan_curve(socket, fan_ctrl, k_a, k_b, k_c),
             Command::FanCurveDefaults => Handler::fan_defaults(socket, fan_ctrl),
             Command::ShowHWRev => Handler::show_hwrev(socket, hwrev),
+            Command::SwapTECPolarity { channel } => Handler::swap_tec_polarity(socket, channels, channel),
         }
     }
 }

src/command_parser.rs

@@ -191,6 +191,9 @@ pub enum Command {
     },
     FanCurveDefaults,
     ShowHWRev,
+    SwapTECPolarity {
+        channel: Option<usize>,
+    },
 }
 
 fn end(input: &[u8]) -> IResult<&[u8], ()> {
@@ -584,6 +587,22 @@ fn fan_curve(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
     ))(input)
 }
 
+fn swap(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
+    let (input, _) = tag("swap")(input)?;
+    let (input, channel) = alt((
+        |input| {
+            let (input, _) = whitespace(input)?;
+            let (input, channel) = channel(input)?;
+            let (input, _) = end(input)?;
+            Ok((input, Some(channel)))
+        },
+        value(None, end)
+    ))(input)?;
+
+    let result = Ok(Command::SwapTECPolarity { channel });
+    Ok((input, result))
+}
+
 fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
     alt((value(Ok(Command::Quit), tag("quit")),
          load,
@@ -600,6 +619,7 @@ fn command(input: &[u8]) -> IResult<&[u8], Result<Command, Error>> {
          fan,
          fan_curve,
          value(Ok(Command::ShowHWRev), tag("hwrev")),
+         swap,
     ))(input)
 }
 

src/config.rs

@@ -22,6 +22,7 @@ pub struct ChannelConfig {
     pwm: PwmLimits,
     /// uses variant `PostFilter::Invalid` instead of `None` to save space
     adc_postfilter: PostFilter,
+    swap_tec_polarity: bool,
 }
 
 impl ChannelConfig {
@@ -41,6 +42,7 @@ impl ChannelConfig {
             sh: state.sh.clone(),
             pwm,
             adc_postfilter,
+            swap_tec_polarity: state.swap_tec_polarity,
         }
     }
 
@@ -51,6 +53,7 @@ impl ChannelConfig {
         state.pid.target = self.pid_target.into();
         state.pid_engaged = self.pid_engaged;
         state.sh = self.sh.clone();
+        state.swap_tec_polarity = self.swap_tec_polarity;
 
         self.pwm.apply(channels, channel);
 

src/fan_ctrl.rs

@@ -11,13 +11,11 @@ use uom::si::{
 use crate::{
     hw_rev::HWSettings,
     command_handler::JsonBuffer,
+    channels::MAX_TEC_I,
 };
 
 pub type FanPin = PwmChannels<TIM8, pwm::C4>;
 
-// as stated in the schematics
-const MAX_TEC_I: f32 = 3.0;
-
 const MAX_USER_FAN_PWM: f32 = 100.0;
 const MIN_USER_FAN_PWM: f32 = 1.0;
 
@@ -56,7 +54,7 @@ impl FanCtrl {
     pub fn cycle(&mut self, abs_max_tec_i: ElectricCurrent) {
         self.abs_max_tec_i = abs_max_tec_i.get::<ampere>() as f32;
         if self.fan_auto && self.hw_settings.fan_available {
-            let scaled_current = self.abs_max_tec_i / MAX_TEC_I;
+            let scaled_current = self.abs_max_tec_i / MAX_TEC_I as f32;
             // do not limit upper bound, as it will be limited in the set_pwm()
             let pwm = (MAX_USER_FAN_PWM * (scaled_current * (scaled_current * self.k_a + self.k_b) + self.k_c)) as u32;
             self.set_pwm(pwm);

src/pins.rs

@@ -66,21 +66,31 @@ pub trait ChannelPins {
     type TecUMeasPin;
 }
 
+pub enum Channel0VRef {
+    Analog(PA0<Analog>),
+    Disabled(PA0<Input<Floating>>),
+}
+
 impl ChannelPins for Channel0 {
     type DacSpi = Dac0Spi;
     type DacSync = PE4<Output<PushPull>>;
     type Shdn = PE10<Output<PushPull>>;
-    type VRefPin = PA0<Analog>;
+    type VRefPin = Channel0VRef;
     type ItecPin = PA6<Analog>;
     type DacFeedbackPin = PA4<Analog>;
     type TecUMeasPin = PC2<Analog>;
 }
 
+pub enum Channel1VRef {
+    Analog(PA3<Analog>),
+    Disabled(PA3<Input<Floating>>),
+}
+
 impl ChannelPins for Channel1 {
     type DacSpi = Dac1Spi;
     type DacSync = PF6<Output<PushPull>>;
     type Shdn = PE15<Output<PushPull>>;
-    type VRefPin = PA3<Analog>;
+    type VRefPin = Channel1VRef;
     type ItecPin = PB0<Analog>;
     type DacFeedbackPin = PA5<Analog>;
     type TecUMeasPin = PC3<Analog>;
@@ -150,13 +160,17 @@ impl Pins {
             gpioe.pe13, gpioe.pe14
         );
 
+        let hwrev = HWRev::detect_hw_rev(&HWRevPins {hwrev0: gpiod.pd0, hwrev1: gpiod.pd1,
+            hwrev2: gpiod.pd2, hwrev3: gpiod.pd3});
+        let hw_settings = hwrev.settings();
+
         let (dac0_spi, dac0_sync) = Self::setup_dac0(
             clocks, spi4,
             gpioe.pe2, gpioe.pe4, gpioe.pe6
         );
         let mut shdn0 = gpioe.pe10.into_push_pull_output();
         let _ = shdn0.set_low();
-        let vref0_pin = gpioa.pa0.into_analog();
+        let vref0_pin = if hwrev.major > 2 {Channel0VRef::Analog(gpioa.pa0.into_analog())} else {Channel0VRef::Disabled(gpioa.pa0)};
         let itec0_pin = gpioa.pa6.into_analog();
         let dac_feedback0_pin = gpioa.pa4.into_analog();
         let tec_u_meas0_pin = gpioc.pc2.into_analog();
@@ -176,7 +190,7 @@ impl Pins {
         );
         let mut shdn1 = gpioe.pe15.into_push_pull_output();
         let _ = shdn1.set_low();
-        let vref1_pin = gpioa.pa3.into_analog();
+        let vref1_pin = if hwrev.major > 2 {Channel1VRef::Analog(gpioa.pa3.into_analog())} else {Channel1VRef::Disabled(gpioa.pa3)};
         let itec1_pin = gpiob.pb0.into_analog();
         let dac_feedback1_pin = gpioa.pa5.into_analog();
         let tec_u_meas1_pin = gpioc.pc3.into_analog();
@@ -198,10 +212,6 @@ impl Pins {
             channel1,
         };
 
-        let hwrev = HWRev::detect_hw_rev(&HWRevPins {hwrev0: gpiod.pd0, hwrev1: gpiod.pd1,
-            hwrev2: gpiod.pd2, hwrev3: gpiod.pd3});
-        let hw_settings = hwrev.settings();
-
         let leds = Leds::new(gpiod.pd9, gpiod.pd10.into_push_pull_output(), gpiod.pd11.into_push_pull_output());
 
         let eeprom_scl = gpiob.pb8.into_alternate().set_open_drain();