reorder device functions alphabetically and new view temp feature

Author: samuelnguyen999

src/devices/thermal_control.py

@@ -29,62 +29,47 @@ def __init__(self, titrator):
         self._amplitude = 0.0
         self._period_in_seconds = 0
 
-    def get_heat(self, default):
-        """
-        Get the heat setting from EEPROM
-        """
-        if self._heat is None:
-            return default
-        return self._heat
-
-    def set_heat(self, value):
+    def get_amplitude(self):
         """
-        Set the heat setting in EEPROM
+        Get the amplitude for the pH function.
         """
-        self._heat = value
+        return self._amplitude
 
     def get_base_thermal_target(self):
         """
         Get the base thermal target
         """
         return self._base_thermal_target
 
-    def set_base_thermal_target(self, value):
-        """
-        Set the base thermal target
-        """
-        self._base_thermal_target = value
-
     def get_current_thermal_target(self):
         """
         Get the current thermal target
         """
         return self._current_thermal_target
 
-    def set_current_thermal_target(self, value):
+    def get_heat(self, default):
         """
-        Set the current thermal target
+        Get the heat setting from EEPROM
         """
-        self._current_thermal_target = value
+        if self._heat is None:
+            return default
+        return self._heat
 
-    def get_thermal_function_type(self):
+    def get_period_in_seconds(self):
         """
-        Get the current thermal function type.
+        Get the period in seconds for the pH function.
         """
-        return self._thermal_function_type
+        return self._period_in_seconds
 
-    def set_thermal_function_type(self, function_type):
+    def get_ramp_time_end(self):
         """
-        Set the current thermal function type.
+        Get the ramp time end in seconds.
         """
-        if function_type in (
-            ThermalControl.FLAT_TYPE,
-            ThermalControl.RAMP_TYPE,
-            ThermalControl.SINE_TYPE,
-        ):
-            self._thermal_function_type = function_type
-        else:
-            raise ValueError("Invalid thermal function type")
+        return (
+            self._ramp_time_end_seconds
+            if self._thermal_function_type != ThermalControl.FLAT_TYPE
+            else 0
+        )
 
     def get_ramp_time_start(self):
         """
@@ -96,15 +81,35 @@ def get_ramp_time_start(self):
             else 0
         )
 
-    def get_ramp_time_end(self):
+    def get_thermal_function_type(self):
         """
-        Get the ramp time end in seconds.
+        Get the current thermal function type.
         """
-        return (
-            self._ramp_time_end_seconds
-            if self._thermal_function_type != ThermalControl.FLAT_TYPE
-            else 0
-        )
+        return self._thermal_function_type
+
+    def set_amplitude(self, amplitude):
+        """
+        Set the amplitude for the pH function.
+        """
+        self._amplitude = amplitude
+
+    def set_base_thermal_target(self, value):
+        """
+        Set the base thermal target
+        """
+        self._base_thermal_target = value
+
+    def set_current_thermal_target(self, value):
+        """
+        Set the current thermal target
+        """
+        self._current_thermal_target = value
+
+    def set_heat(self, value):
+        """
+        Set the heat setting in EEPROM
+        """
+        self._heat = value
 
     def set_ramp_duration_hours(self, new_ph_ramp_duration):
         """
@@ -133,24 +138,6 @@ def set_ramp_duration_hours(self, new_ph_ramp_duration):
             self._thermal_function_type = ThermalControl.FLAT_TYPE
             print("Set ramp time to 0")
 
-    def get_amplitude(self):
-        """
-        Get the amplitude for the pH function.
-        """
-        return self._amplitude
-
-    def set_amplitude(self, amplitude):
-        """
-        Set the amplitude for the pH function.
-        """
-        self._amplitude = amplitude
-
-    def get_period_in_seconds(self):
-        """
-        Get the period in seconds for the pH function.
-        """
-        return self._period_in_seconds
-
     def set_sine_amplitude_and_hours(self, amplitude, period_in_hours):
         """
         Set the amplitude and period (in hours) for the sine wave pH function.
@@ -161,3 +148,16 @@ def set_sine_amplitude_and_hours(self, amplitude, period_in_hours):
             self._thermal_function_type = ThermalControl.SINE_TYPE
         else:
             raise ValueError("Amp and period !> than 0.")
+
+    def set_thermal_function_type(self, function_type):
+        """
+        Set the current thermal function type.
+        """
+        if function_type in (
+            ThermalControl.FLAT_TYPE,
+            ThermalControl.RAMP_TYPE,
+            ThermalControl.SINE_TYPE,
+        ):
+            self._thermal_function_type = function_type
+        else:
+            raise ValueError("Invalid thermal function type")

src/devices/thermal_probe.py

@@ -25,29 +25,42 @@ def __init__(self, eeprom):
         self.first_time = True
         self.last_time = 0
 
-    def get_thermal_correction(self):
-        """
-        Get the thermal correction value from EEPROM
-        """
-        return float(self._correction)
-
     def clear_thermal_correction(self):
         """
         Clear the thermal correction value in EEPROM
         """
         self._correction = 0
 
-    def set_thermal_correction(self, value):
+    def get_raw_temperature(self):
         """
-        Set the thermal correction value in EEPROM
+        Simulate reading the raw temperature from a sensor.
+        In a real implementation, this method would interface with hardware.
         """
-        self._correction = value
+        # Placeholder for actual sensor reading logic
+        return 25.0  # return thermo.temperature(RTDnominal, refResistor);
+
+    def get_running_average(self):
+        """
+        Return the corrected running average within the range of 00.00-99.99
+        """
+        temperature = self.get_uncorrected_running_average() + self._correction
+        if temperature < 0.0:
+            temperature = 0.0
+        elif temperature > 99.99:
+            temperature = 99.99
+        return temperature
+
+    def get_thermal_correction(self):
+        """
+        Get the thermal correction value from EEPROM
+        """
+        return float(self._correction)
 
     def get_uncorrected_running_average(self):
         """
         Calculate the uncorrected running average of temperature readings.
         """
-        current_time = time.time()  # Get current time in seconds
+        current_time = time.time()
         if (
             self.first_time or self.last_time + 1 <= current_time
         ):  # Check if 1 second has passed
@@ -66,21 +79,8 @@ def get_uncorrected_running_average(self):
         valid_readings = self.history[: self.history_index + 1]
         return sum(valid_readings) / len(valid_readings)
 
-    def get_running_average(self):
-        """
-        Return the corrected running average within the range of 00.00-99.99
-        """
-        temperature = self.get_uncorrected_running_average() + self._correction
-        if temperature < 0.0:
-            temperature = 0.0
-        elif temperature > 99.99:
-            temperature = 99.99
-        return temperature
-
-    def get_raw_temperature(self):
+    def set_thermal_correction(self, value):
         """
-        Simulate reading the raw temperature from a sensor.
-        In a real implementation, this method would interface with hardware.
+        Set the thermal correction value in EEPROM
         """
-        # Placeholder for actual sensor reading logic
-        return 25.0  # return thermo.temperature(RTDnominal, refResistor);
+        self._correction = value

src/ui_state/main_menu.py

@@ -33,6 +33,7 @@
 from src.ui_state.view_menu.view_ph_calibration import ViewPHCalibration
 from src.ui_state.view_menu.view_pid_constants import ViewPIDConstants
 from src.ui_state.view_menu.view_tank_id import ViewTankID
+from src.ui_state.view_menu.view_thermal import ViewThermal
 from src.ui_state.view_menu.view_thermal_correction import (
     ViewThermalCorrection,
 )
@@ -61,6 +62,7 @@ def __init__(self, titrator):
             "View pH slope",
             "View PID",
             "View tank ID",
+            "View temp",
             "View temp cal",
             "View time",
             "View version",
@@ -95,6 +97,7 @@ def __init__(self, titrator):
             ViewPHCalibration,  # View pH slope
             ViewPIDConstants,  # View PID constants
             ViewTankID,  # View Tank ID
+            ViewThermal,  # View Temperature
             ViewThermalCorrection,  # View Thermal Correction
             ViewTime,  # View Time
             ViewVersion,  # View Version

src/ui_state/view_menu/view_thermal.py

@@ -0,0 +1,37 @@
+"""
+The file to hold the View Thermal class
+"""
+
+from src.devices.library import Keypad
+from src.ui_state.ui_state import UIState
+
+
+class ViewThermal(UIState):
+    """
+    This is a class for the ViewThermal state of the Tank Controller
+    """
+
+    def __init__(self, titrator, previous_state=None):
+        """
+        The constructor for the ViewThermal class
+        """
+        super().__init__(titrator)
+        self.previous_state = previous_state
+
+    def loop(self):
+        """
+        The loop function for the ViewThermal class
+        """
+        self.titrator.lcd.print("Avg    Raw", line=1)
+        average = self.titrator.thermal_probe.get_running_average()
+        raw = self.titrator.thermal_probe.get_raw_temperature()
+        self.titrator.lcd.print(
+            f"{average}   {raw}", line=2
+        )
+
+    def handle_key(self, key):
+        """
+        The handle_key function for the ViewThermal class
+        """
+        if key in [Keypad.KEY_4, Keypad.KEY_D]:
+            self._set_next_state(self.previous_state, True)

tests/ui_state/view_menu/view_thermal_test.py

@@ -0,0 +1,61 @@
+"""
+The file to test the View Thermal class
+"""
+
+from unittest import mock
+
+from src.devices.library import LiquidCrystal
+from src.titrator import Titrator
+from src.ui_state.main_menu import MainMenu
+from src.ui_state.ui_state import UIState
+from src.ui_state.view_menu.view_thermal import ViewThermal
+
+
+class MockPreviousState(UIState):
+    """
+    A mock previous state for testing purposes
+    """
+
+    def __init__(self, titrator):
+        super().__init__(titrator)
+
+
+@mock.patch.object(LiquidCrystal, "print")
+def test_view_thermal_loop(print_mock):
+    """
+    The function to test ViewThermal's loop function
+    """
+    titrator = Titrator()
+    titrator.thermal_probe.get_running_average = mock.Mock(return_value="25.5")
+    titrator.thermal_probe.get_raw_temperature = mock.Mock(return_value="26.0")
+
+    state = ViewThermal(titrator, MainMenu(titrator))
+
+    state.loop()
+
+    print_mock.assert_any_call("Avg    Raw", line=1)
+    print_mock.assert_any_call("25.5   26.0", line=2)
+
+
+def test_handle_key_4():
+    """
+    The function to test the back handle key
+    """
+    titrator = Titrator()
+
+    titrator.state = ViewThermal(titrator, MockPreviousState(titrator))
+
+    titrator.state.handle_key("4")
+    assert isinstance(titrator.state, MockPreviousState)
+
+
+def test_handle_key_d():
+    """
+    The function to test the reset handle keys
+    """
+    titrator = Titrator()
+
+    titrator.state = ViewThermal(titrator, MockPreviousState(titrator))
+
+    titrator.state.handle_key("D")
+    assert isinstance(titrator.state, MockPreviousState)