added POC for temperature logging

src/damaris/gui/DamarisGUI.py

@@ -59,6 +59,7 @@ import matplotlib.figure
 from damaris.gui import ExperimentWriter, ExperimentHandling
 from damaris.gui import ResultReader, ResultHandling
 from damaris.gui import BackendDriver
+from damaris.gui.TemperatureMonitor import TemperatureMonitor
 #from damaris.gui.gtkcodebuffer import CodeBuffer, SyntaxLoader
 #from damaris.data import Drawable # this is a base class, it should be used...
 from damaris.data import DataPool, Accumulation, ADC_Result, MeasurementResult
@@ -180,6 +181,10 @@ class DamarisGUI:
 
         #to stop queued experiments
         self.stop_experiment_flag = threading.Event()
+        
+        # Temperature monitoring
+        self.temp_monitor = None
+        self.temp_controller = None
 
         exp_script = ""
         if exp_script_filename is not None and exp_script_filename != "":
@@ -572,6 +577,10 @@ class DamarisGUI:
         self.dump_filename = ""
         if actual_config[ "data_pool_name" ] != "":
             self.dump_states( init=True )
+        
+        # Start temperature monitoring if configured
+        self.start_temperature_monitoring(actual_config)
+        
         gobject.timeout_add( 200, self.observe_running_experiment )
 
     def observe_running_experiment( self ):
@@ -974,8 +983,91 @@ class DamarisGUI:
             still_running = [_f for _f in [ self.si.exp_handling, self.si.res_handling, self.si.back_driver ] if _f]
             for r in still_running:
                 r.quit_flag.set( )
+            
+            # Stop temperature monitoring
+            self.stop_temperature_monitoring()
+            
             self.state = DamarisGUI.Stop_State
 
+    def start_temperature_monitoring(self, config):
+        """
+        Start temperature monitoring thread if configured.
+        
+        Args:
+            config: Configuration dictionary from self.config.get()
+        """
+        # Check if temperature monitoring is enabled
+        if not config.get("enable_temperature_monitoring", False):
+            return
+        
+        controller_type = config.get("temperature_controller_type", "eurotherm")
+        temp_interval = config.get("temperature_interval", 2.0)
+        
+        try:
+            # Import the factory
+            from damaris.tools.temperature import create_controller
+            
+            # Create controller based on type
+            if controller_type == "eurotherm":
+                temp_device = config.get("temperature_device", "")
+                temp_baudrate = config.get("temperature_baudrate", 19200)
+                
+                if not temp_device:
+                    print("Temperature monitoring: No device configured for Eurotherm")
+                    return
+                
+                self.temp_controller = create_controller(
+                    "eurotherm", temp_device, baudrate=temp_baudrate
+                )
+                print(f"Temperature monitoring started with Eurotherm on {temp_device} (interval: {temp_interval}s)")
+                
+            elif controller_type == "simulated":
+                # Simulated controller doesn't need device configuration
+                # Use default parameters: 290K base, 10K amplitude, 60s period, 5% noise, 10% missing
+                self.temp_controller = create_controller("simulated")
+                print(f"Temperature monitoring started with simulated controller (interval: {temp_interval}s)")
+                
+            else:
+                print(f"Temperature monitoring: Unknown controller type: {controller_type}")
+                return
+            
+            # Create and start monitor thread
+            self.temp_monitor = TemperatureMonitor(
+                controller=self.temp_controller,
+                interval=temp_interval,
+                data_pool=self.data,
+                data_key="temperature"
+            )
+            self.temp_monitor.start()
+            
+        except Exception as e:
+            print(f"Failed to start temperature monitoring: {e}")
+            import traceback
+            traceback.print_exc()
+            self.temp_controller = None
+            self.temp_monitor = None
+
+    def stop_temperature_monitoring(self):
+        """
+        Stop the temperature monitoring thread if running.
+        """
+        if self.temp_monitor is not None:
+            try:
+                self.temp_monitor.stop()
+                print("Temperature monitoring stopped")
+            except Exception as e:
+                print(f"Error stopping temperature monitoring: {e}")
+            finally:
+                self.temp_monitor = None
+        
+        if self.temp_controller is not None:
+            try:
+                self.temp_controller.close()
+            except Exception as e:
+                print(f"Error closing temperature controller: {e}")
+            finally:
+                self.temp_controller = None
+
     def documentation_init( self ):
 
         self.doc_urls = {
@@ -2059,6 +2151,73 @@ class ConfigTab:
             backend_vbox.pack_start(self.config_adc_bit_depth_hbox, False, False, 0)
             self.config_adc_bit_depth_hbox.show_all()
 
+        # Temperature monitoring settings - single line layout
+        self.config_temp_hbox = gtk.HBox(homogeneous=False, spacing=6)
+        
+        # Controller type selector
+        self.config_temp_controller_type_label = gtk.Label(label="Controller:")
+        self.config_temp_controller_type_combobox = gtk.ComboBoxText()
+        self.config_temp_controller_type_combobox.append_text("eurotherm")
+        self.config_temp_controller_type_combobox.append_text("simulated")
+        self.config_temp_controller_type_combobox.set_active(0)  # Default to eurotherm
+        self.config_temp_controller_type_combobox.set_tooltip_text("Select temperature controller type")
+        self.config_temp_controller_type_combobox.connect("changed", self.on_temp_controller_type_changed)
+        
+        self.config_temp_controller_type_hbox = gtk.HBox(homogeneous=False, spacing=0)
+        self.config_temp_controller_type_hbox.pack_start(self.config_temp_controller_type_label, False, False, 0)
+        self.config_temp_controller_type_hbox.pack_start(self.config_temp_controller_type_combobox, False, False, 0)
+        self.config_temp_hbox.pack_start(self.config_temp_controller_type_hbox, False, False, 0)
+        
+        # Enable checkbox
+        self.config_temp_monitoring_checkbutton = gtk.CheckButton(label="Temp:")
+        self.config_temp_monitoring_checkbutton.set_tooltip_text("Enable periodic temperature reading from controller")
+        self.config_temp_hbox.pack_start(self.config_temp_monitoring_checkbutton, False, False, 0)
+        
+        # Device file chooser with entry (shown for eurotherm, hidden for simulated)
+        self.config_temp_device_entry = gtk.Entry()
+        self.config_temp_device_entry.set_tooltip_text("Serial port device (e.g., /dev/serial/by-id/...)")
+        self.config_temp_device_entry.set_width_chars(30)
+        self.config_temp_device_button = gtk.Button(label="...")
+        self.config_temp_device_button.set_tooltip_text("Browse for temperature controller device")
+        self.config_temp_device_button.connect("clicked", self.on_temp_device_browse_clicked)
+        
+        self.config_temp_device_hbox = gtk.HBox(homogeneous=False, spacing=0)
+        self.config_temp_device_hbox.pack_start(self.config_temp_device_entry, True, True, 0)
+        self.config_temp_device_hbox.pack_start(self.config_temp_device_button, False, False, 0)
+        self.config_temp_hbox.pack_start(self.config_temp_device_hbox, True, True, 0)
+        
+        # Interval spinbutton
+        self.config_temp_interval_label = gtk.Label(label="Interval (s):")
+        self.config_temp_interval_spinbutton = gtk.SpinButton.new_with_range(0.1, 60, 0.1)
+        self.config_temp_interval_spinbutton.set_value(2.0)  # Default to 2 seconds
+        self.config_temp_interval_spinbutton.set_tooltip_text("Time between temperature readings in seconds")
+        
+        self.config_temp_interval_hbox = gtk.HBox(homogeneous=False, spacing=6)
+        self.config_temp_interval_hbox.pack_start(self.config_temp_interval_label, False, False, 0)
+        self.config_temp_interval_hbox.pack_start(self.config_temp_interval_spinbutton, False, False, 0)
+        self.config_temp_hbox.pack_start(self.config_temp_interval_hbox, False, False, 0)
+        
+        # Baud rate (for eurotherm)
+        self.config_temp_baudrate_combobox = gtk.ComboBoxText()
+        self.config_temp_baudrate_combobox.append_text("19200")
+        self.config_temp_baudrate_combobox.append_text("9600")
+        self.config_temp_baudrate_combobox.append_text("38400")
+        self.config_temp_baudrate_combobox.append_text("57600")
+        self.config_temp_baudrate_combobox.append_text("115200")
+        self.config_temp_baudrate_combobox.set_active(0)
+        self.config_temp_baudrate_combobox.set_tooltip_text("Serial baud rate for temperature controller")
+        self.config_temp_baudrate_hbox = gtk.HBox(homogeneous=False, spacing=6)
+        self.config_temp_baudrate_hbox.pack_start(self.config_temp_baudrate_combobox, False, False, 0)
+        self.config_temp_hbox.pack_start(self.config_temp_baudrate_hbox, False, False, 0)
+        # Note: baud rate is shown for eurotherm, hidden for simulated
+        
+        # Set initial visibility based on controller type
+        self._update_temp_widgets_visibility()
+        
+        if backend_vbox:
+            backend_vbox.pack_start(self.config_temp_hbox, False, False, 0)
+            self.config_temp_hbox.show_all()
+
         # insert version informations
         components_text = """
 operating system %(os)s
@@ -2165,10 +2324,26 @@ pygobject version %(pygobject)s
             "data_pool_complib": complib,
             "data_pool_comprate": self.config_data_pool_comprate.get_value_as_int( ),
             "script_font": self.config_script_font_button.get_font_name( ),
-            "adc_bit_depth": self.config_adc_bit_depth_spinbutton.get_value_as_int()
+            "adc_bit_depth": self.config_adc_bit_depth_spinbutton.get_value_as_int(),
+            # Temperature monitoring configuration
+            "enable_temperature_monitoring": self.config_temp_monitoring_checkbutton.get_active(),
+            "temperature_controller_type": self.config_temp_controller_type_combobox.get_active_text(),
+            "temperature_device": self.config_temp_device_entry.get_text(),
+            "temperature_baudrate": self._get_temp_baudrate(),
+            "temperature_interval": self.config_temp_interval_spinbutton.get_value()
         }
         ADC_Result.default_bit_depth = actual_config["adc_bit_depth"]
         return actual_config
+    
+    def _get_temp_baudrate(self):
+        """Get selected baud rate from combobox."""
+        active_text = self.config_temp_baudrate_combobox.get_active_text()
+        if active_text:
+            try:
+                return int(active_text)
+            except ValueError:
+                pass
+        return 19200
 
     def set( self, config ):
         if "start_backend" in config:
@@ -2200,6 +2375,29 @@ pygobject version %(pygobject)s
                 ADC_Result.default_bit_depth = int(config["adc_bit_depth"])
             except (ValueError, TypeError):
                 pass
+        
+        # Temperature monitoring configuration
+        if "enable_temperature_monitoring" in config:
+            self.config_temp_monitoring_checkbutton.set_active(config["enable_temperature_monitoring"])
+        if "temperature_controller_type" in config:
+            controller_type = config["temperature_controller_type"]
+            if controller_type in ["eurotherm", "simulated"]:
+                self.config_temp_controller_type_combobox.set_active_text(controller_type)
+                # Update widget visibility based on type
+                self._update_temp_widgets_visibility()
+        if "temperature_device" in config:
+            self.config_temp_device_entry.set_text(config["temperature_device"])
+        if "temperature_baudrate" in config:
+            baudrate = str(config["temperature_baudrate"])
+            if baudrate in ["9600", "19200", "38400", "57600", "115200"]:
+                self.config_temp_baudrate_combobox.set_active_text(baudrate)
+            else:
+                self.config_temp_baudrate_combobox.set_active(0)  # Default to 19200
+        if "temperature_interval" in config:
+            try:
+                self.config_temp_interval_spinbutton.set_value(float(config["temperature_interval"]))
+            except (ValueError, TypeError):
+                self.config_temp_interval_spinbutton.set_value(2.0)
         if "data_pool_complib" in config:
             # find combo-box entry and make it active...
             model = self.config_data_pool_complib.get_model( )
@@ -2216,6 +2414,60 @@ pygobject version %(pygobject)s
     def on_adc_bit_depth_changed(self, widget):
         ADC_Result.default_bit_depth = widget.get_value_as_int()
 
+    def on_temp_device_browse_clicked(self, widget):
+        """
+        Open file chooser dialog to select temperature controller device.
+        Defaults to /dev/serial/by-id/ which is typically used for USB serial converters.
+        """
+        dialog = gtk.FileChooserDialog(
+            title="Select Temperature Controller Device",
+            parent=None,
+            action=gtk.FileChooserAction.OPEN,
+            buttons=(
+                gtk.STOCK_CANCEL, gtk.ResponseType.CANCEL,
+                gtk.STOCK_OPEN, gtk.ResponseType.OK
+            )
+        )
+        
+        # Set default folder to /dev/serial/by-id/ if it exists
+        default_folder = "/dev/serial/by-id/"
+        if os.path.isdir(default_folder):
+            dialog.set_current_folder(default_folder)
+        else:
+            # Fallback to /dev
+            dialog.set_current_folder("/dev/")
+        
+        # Only show regular files (device files)
+        dialog.set_select_multiple(False)
+        
+        response = dialog.run()
+        if response == gtk.ResponseType.OK:
+            selected_file = dialog.get_filename()
+            self.config_temp_device_entry.set_text(selected_file)
+        
+        dialog.destroy()
+
+    def on_temp_controller_type_changed(self, widget):
+        """Update widget visibility when controller type changes."""
+        self._update_temp_widgets_visibility()
+
+    def _update_temp_widgets_visibility(self):
+        """Show/hide widgets based on selected controller type."""
+        active_type = self.config_temp_controller_type_combobox.get_active_text()
+        
+        if active_type == "eurotherm":
+            # Show device selection widgets
+            self.config_temp_device_hbox.show()
+            self.config_temp_baudrate_hbox.show()
+        elif active_type == "simulated":
+            # Hide device-specific widgets for simulated controller
+            self.config_temp_device_hbox.hide()
+            self.config_temp_baudrate_hbox.hide()
+        else:
+            # Show everything for unknown types
+            self.config_temp_device_hbox.show()
+            self.config_temp_baudrate_hbox.show()
+
     def load_config_handler( self, widget ):
         if self.system_default_filename:
             self.load_config( self.system_default_filename )