README.md

@@ -98,10 +98,10 @@ formatted as line-delimited JSON.
 | `report mode`                              | Show current report mode                                                      |
 | `report mode <off/on>`                     | Set report mode                                                               |
 | `pwm`                                      | Show current PWM settings                                                     |
-| `pwm <0/1> max_i_pos <amp>`                | Set maximum positive output current, clamped to [0 A, 2 A]                    |
-| `pwm <0/1> max_i_neg <amp>`                | Set maximum negative output current, clamped to [0 A, 2 A]                    |
-| `pwm <0/1> max_v <volt>`                   | Set maximum output voltage, clamped to [0 V, 4 V]                             |
-| `pwm <0/1> i_set <amp>`                    | Disengage PID, set fixed output current, clamped to [-2 A, 2 A]               |
+| `pwm <0/1> max_i_pos <amp>`                | Set maximum positive output current                                           |
+| `pwm <0/1> max_i_neg <amp>`                | Set maximum negative output current                                           |
+| `pwm <0/1> max_v <volt>`                   | Set maximum output voltage                                                    |
+| `pwm <0/1> i_set <amp>`                    | Disengage PID, set fixed output current                                       |
 | `pwm <0/1> polarity <normal/reversed>`     | Set output current polarity, with 'normal' being the front panel polarity     |
 | `pwm <0/1> pid`                            | Let output current to be controlled by the PID                                |
 | `center <0/1> <volt>`                      | Set the MAX1968 0A-centerpoint to the specified fixed voltage                 |

pytec/pytec/client.py

@@ -16,7 +16,7 @@ class Client:
         pwm_report = self.get_pwm()
         for pwm_channel in pwm_report:
             for limit in ["max_i_neg", "max_i_pos", "max_v"]:
-                if pwm_channel[limit] == 0.0:
+                if pwm_channel[limit]["value"] == 0.0:
                     logging.warning("`{}` limit is set to zero on channel {}".format(limit, pwm_channel["channel"]))
 
     def _read_line(self):
@@ -53,17 +53,17 @@ class Client:
         Example::
             [{'channel': 0,
               'center': 'vref',
-              'i_set': -0.02002179650216762,
-              'max_i_neg': 2.0,
-              'max_v': 3.988,
-              'max_i_pos': 2.0,
+              'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
+              'max_i_neg': {'max': 3.0, 'value': 3.0},
+              'max_v': {'max': 5.988, 'value': 5.988},
+              'max_i_pos': {'max': 3.0, 'value': 3.0}},
               'polarity': 'normal',
              {'channel': 1,
               'center': 'vref',
-              'i_set': -0.02002179650216762,
-              'max_i_neg': 2.0,
-              'max_v': 3.988,
-              'max_i_pos': 2.0}
+              'i_set': {'max': 2.9802790335151985, 'value': -0.02002179650216762},
+              'max_i_neg': {'max': 3.0, 'value': 3.0},
+              'max_v': {'max': 5.988, 'value': 5.988},
+              'max_i_pos': {'max': 3.0, 'value': 3.0}}
               'polarity': 'normal',
             ]
         """

src/channel_state.rs

@@ -16,7 +16,6 @@ use uom::si::{
 use crate::{
     ad7172,
     pid,
-    config::PwmLimits,
     steinhart_hart as sh,
     command_parser::{CenterPoint, Polarity},
 };
@@ -33,7 +32,6 @@ pub struct ChannelState {
     pub center: CenterPoint,
     pub dac_value: ElectricPotential,
     pub i_set: ElectricCurrent,
-    pub pwm_limits: PwmLimits,
     pub pid_engaged: bool,
     pub pid: pid::Controller,
     pub sh: sh::Parameters,
@@ -51,11 +49,6 @@ impl ChannelState {
             center: CenterPoint::Vref,
             dac_value: ElectricPotential::new::<volt>(0.0),
             i_set: ElectricCurrent::new::<ampere>(0.0),
-            pwm_limits: PwmLimits {
-                max_v: 0.0,
-                max_i_pos: 0.0,
-                max_i_neg: 0.0,
-            },
             pid_engaged: false,
             pid: pid::Controller::new(pid::Parameters::default()),
             sh: sh::Parameters::default(),

src/channels.rs

@@ -357,16 +357,52 @@ impl Channels {
         }
     }
 
-    pub fn get_max_v(&mut self, channel: usize) -> ElectricPotential {
-        ElectricPotential::new::<volt>(self.channel_state(channel).pwm_limits.max_v)
+    fn get_pwm(&self, channel: usize, pin: PwmPin) -> f64 {
+        fn get<P: hal::PwmPin<Duty=u16>>(pin: &P) -> f64 {
+            let duty = pin.get_duty();
+            let max = pin.get_max_duty();
+            duty as f64 / (max as f64)
+        }
+        match (channel, pin) {
+            (_, PwmPin::ISet) =>
+                panic!("i_set is no pwm pin"),
+            (0, PwmPin::MaxIPos) =>
+                get(&self.pwm.max_i_pos0),
+            (0, PwmPin::MaxINeg) =>
+                get(&self.pwm.max_i_neg0),
+            (0, PwmPin::MaxV) =>
+                get(&self.pwm.max_v0),
+            (1, PwmPin::MaxIPos) =>
+                get(&self.pwm.max_i_pos1),
+            (1, PwmPin::MaxINeg) =>
+                get(&self.pwm.max_i_neg1),
+            (1, PwmPin::MaxV) =>
+                get(&self.pwm.max_v1),
+            _ =>
+                unreachable!(),
+        }
     }
 
-    pub fn get_max_i_pos(&mut self, channel: usize) -> ElectricCurrent {
-        ElectricCurrent::new::<ampere>(self.channel_state(channel).pwm_limits.max_i_pos)
+    pub fn get_max_v(&mut self, channel: usize) -> (ElectricPotential, ElectricPotential) {
+        let max = 4.0 * ElectricPotential::new::<volt>(3.3);
+        let duty = self.get_pwm(channel, PwmPin::MaxV);
+        (duty * max, MAX_TEC_V)
     }
 
-    pub fn get_max_i_neg(&mut self, channel: usize) -> ElectricCurrent {
-        ElectricCurrent::new::<ampere>(self.channel_state(channel).pwm_limits.max_i_neg)
+    pub fn get_max_i_pos(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) {
+        let duty = match self.channel_state(channel).polarity {
+            Polarity::Normal => self.get_pwm(channel, PwmPin::MaxIPos),
+            Polarity::Reversed => self.get_pwm(channel, PwmPin::MaxINeg),
+        };
+        (duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, MAX_TEC_I)
+    }
+
+    pub fn get_max_i_neg(&mut self, channel: usize) -> (ElectricCurrent, ElectricCurrent) {
+        let duty = match self.channel_state(channel).polarity {
+            Polarity::Normal => self.get_pwm(channel, PwmPin::MaxINeg),
+            Polarity::Reversed => self.get_pwm(channel, PwmPin::MaxIPos),
+        };
+        (duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, MAX_TEC_I)
     }
 
     // Get current passing through TEC
@@ -412,42 +448,36 @@ impl Channels {
 
     pub fn set_max_v(&mut self, channel: usize, max_v: ElectricPotential) -> (ElectricPotential, ElectricPotential) {
         let max = 4.0 * ElectricPotential::new::<volt>(3.3);
-        let max_v = max_v.min(MAX_TEC_V).max(ElectricPotential::zero());
-        let duty = (max_v / max).get::<ratio>();
+        let duty = (max_v.min(MAX_TEC_V).max(ElectricPotential::zero()) / max).get::<ratio>();
         let duty = self.set_pwm(channel, PwmPin::MaxV, duty);
-        self.channel_state(channel).pwm_limits.max_v = max_v.get::<volt>();
         (duty * max, max)
     }
 
     pub fn set_max_i_pos(&mut self, channel: usize, max_i_pos: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) {
         let max = ElectricCurrent::new::<ampere>(3.0);
-        let max_i_pos = max_i_pos.min(MAX_TEC_I).max(ElectricCurrent::zero());
-        let duty = (max_i_pos / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
+        let duty = (max_i_pos.min(MAX_TEC_I).max(ElectricCurrent::zero()) / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
         let duty = match self.channel_state(channel).polarity {
             Polarity::Normal => self.set_pwm(channel, PwmPin::MaxIPos, duty),
             Polarity::Reversed => self.set_pwm(channel, PwmPin::MaxINeg, duty),
         };
-        self.channel_state(channel).pwm_limits.max_i_pos = max_i_pos.get::<ampere>();
         (duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, max)
     }
 
     pub fn set_max_i_neg(&mut self, channel: usize, max_i_neg: ElectricCurrent) -> (ElectricCurrent, ElectricCurrent) {
         let max = ElectricCurrent::new::<ampere>(3.0);
-        let max_i_neg = max_i_neg.min(MAX_TEC_I).max(ElectricCurrent::zero());
-        let duty = (max_i_neg / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
+        let duty = (max_i_neg.min(MAX_TEC_I).max(ElectricCurrent::zero()) / MAX_TEC_I_DUTY_TO_CURRENT_RATE).get::<ratio>();
         let duty = match self.channel_state(channel).polarity {
             Polarity::Normal => self.set_pwm(channel, PwmPin::MaxINeg, duty),
             Polarity::Reversed => self.set_pwm(channel, PwmPin::MaxIPos, duty),
         };
-        self.channel_state(channel).pwm_limits.max_i_neg = max_i_neg.get::<ampere>();
         (duty * MAX_TEC_I_DUTY_TO_CURRENT_RATE, max)
     }
 
     pub fn set_polarity(&mut self, channel: usize, polarity: Polarity) {
         if self.channel_state(channel).polarity != polarity {
             let i_set = self.channel_state(channel).i_set;
-            let max_i_pos = self.get_max_i_pos(channel);
-            let max_i_neg = self.get_max_i_neg(channel);
+            let max_i_pos = self.get_max_i_pos(channel).0;
+            let max_i_neg = self.get_max_i_neg(channel).0;
             self.channel_state(channel).polarity = polarity;
 
             self.set_i(channel, i_set);
@@ -511,10 +541,10 @@ impl Channels {
         PwmSummary {
             channel,
             center: CenterPointJson(self.channel_state(channel).center.clone()),
-            i_set: self.get_i(channel),
-            max_v: self.get_max_v(channel),
-            max_i_pos: self.get_max_i_pos(channel),
-            max_i_neg: self.get_max_i_neg(channel),
+            i_set: (self.get_i(channel), MAX_TEC_I).into(),
+            max_v: self.get_max_v(channel).into(),
+            max_i_pos: self.get_max_i_pos(channel).into(),
+            max_i_neg: self.get_max_i_neg(channel).into(),
             polarity: PolarityJson(self.channel_state(channel).polarity.clone()),
         }
     }
@@ -612,14 +642,26 @@ impl Serialize for PolarityJson {
     }
 }
 
+#[derive(Serialize)]
+pub struct PwmSummaryField<T: Serialize> {
+    value: T,
+    max: T,
+}
+
+impl<T: Serialize> From<(T, T)> for PwmSummaryField<T> {
+    fn from((value, max): (T, T)) -> Self {
+        PwmSummaryField { value, max }
+    }
+}
+
 #[derive(Serialize)]
 pub struct PwmSummary {
     channel: usize,
     center: CenterPointJson,
-    i_set: ElectricCurrent,
-    max_v: ElectricPotential,
-    max_i_pos: ElectricCurrent,
-    max_i_neg: ElectricCurrent,
+    i_set: PwmSummaryField<ElectricCurrent>,
+    max_v: PwmSummaryField<ElectricPotential>,
+    max_i_pos: PwmSummaryField<ElectricCurrent>,
+    max_i_neg: PwmSummaryField<ElectricCurrent>,
     polarity: PolarityJson,
 }
 

src/config.rs

@@ -75,17 +75,17 @@ impl ChannelConfig {
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct PwmLimits {
-    pub max_v: f64,
-    pub max_i_pos: f64,
-    pub max_i_neg: f64,
+struct PwmLimits {
+    max_v: f64,
+    max_i_pos: f64,
+    max_i_neg: f64,
 }
 
 impl PwmLimits {
     pub fn new(channels: &mut Channels, channel: usize) -> Self {
-        let max_v = channels.get_max_v(channel);
-        let max_i_pos = channels.get_max_i_pos(channel);
-        let max_i_neg = channels.get_max_i_neg(channel);
+        let (max_v, _) = channels.get_max_v(channel);
+        let (max_i_pos, _) = channels.get_max_i_pos(channel);
+        let (max_i_neg, _) = channels.get_max_i_neg(channel);
         PwmLimits {
             max_v: max_v.get::<volt>(),
             max_i_pos: max_i_pos.get::<ampere>(),