cgse 2023.38.0__py3-none-any.whl → 2024.1.4__py3-none-any.whl

egse/tempcontrol/spid/spid_controller.py

@@ -1,279 +0,0 @@
-import logging
-import threading
-
-import time
-
-from egse.hk import get_housekeeping
-from egse.state import GlobalState
-from egse.tempcontrol.beaglebone.beaglebone import BeagleboneProxy
-from egse.tempcontrol.spid.spid import PidInterface, PidError
-
-logger = logging.getLogger(__name__)
-
-
-class PidController(PidInterface):
-
-    # Prefixes for prometheus metrics based on agilent device index
-    PREFIXES = ["GSRON_AG34972_0_T", "GSRON_AG34972_1_T", "GSRON_AG34970_0_T", "GSRON_AG34970_1_T"]
-
-    def __init__(self):
-
-        # Get spid setup entry
-        setup = GlobalState.setup
-
-        heaters = setup.gse.spid.configuration.heaters
-
-        self.channels = [channel for heater in heaters.values() for channel in heater]
-
-        self.update_period = setup.gse.spid.configuration.update_period
-        self.temperature_timeout = setup.gse.spid.configuration.temperature_timeout
-        self.timeout_action = setup.gse.spid.configuration.timeout_action
-
-        self._is_connected = False
-        self._pid_thread = None
-        self._beaglebone = BeagleboneProxy()
-        self._t0 = None
-
-        self.setpoints = [float(0)] * len(self.channels)
-        self.running = [False] * len(self.channels)
-        self.pids = []
-
-        # Store these values for HK
-        self.inputs         = [float(0)] * len(self.channels)
-        self.errors         = [float(0)] * len(self.channels)
-        self.outputs        = [float(0)] * len(self.channels)
-        self.temperature    = [float(0)] * len(self.channels)
-        self.timestamp      = [float(0)] * len(self.channels)
-        self.isum           = [float(0)] * len(self.channels)
-
-        for i in range(len(self.channels)):
-            self.pids.append( # initialize with parameters from setup
-                PidAlgorithm(self.channels[i][5], self.channels[i][6], 0))
-
-        self.connect()
-
-
-    def connect(self):
-
-        if self._is_connected:
-            logger.warning("Trying to connect to an already connected device")
-        else:
-            self._beaglebone.connect()
-            self._t0 = time.time()
-            self._pid_thread = threading.Thread(target=self.thread_function, daemon=True)
-            self._pid_thread.daemon = True
-            self._is_connected = True
-            self._pid_thread.start()
-
-
-    def disconnect(self):
-
-        if not self._is_connected:
-            logger.warning("Trying to disconnect to an already disconnected device")
-        else:
-            # NOTE: right now the time to stop the thread could take the entire update period
-            self._is_connected = False
-            self._pid_thread.join()
-            self._beaglebone.disconnect()
-
-
-    def reconnect(self):
-
-        if self._is_connected:
-            self.disconnect()
-        self.connect()
-
-
-    def is_connected(self):
-
-        return self._is_connected
-
-
-    def is_simulator(self):
-
-        return False
-
-    def get_pid_parameters(self, channel):
-        Kp, Ki, Kd, int_max, int_min = self.pids[channel].Kp, self.pids[channel].Ki, self.pids[channel].Kd, self.pids[channel].int_max, self.pids[channel].int_min
-        logger.info(f"Current PID parameters for channel {channel}:\n\
-                      Kp: {Kp}, Ki: {Ki}, Kd: {Kd}\n\
-                      Integral max: {int_max}\n\
-                      Integral min: {int_min}")
-        return Kp, Ki, Kd, int_max, int_min
-    
-    def set_pid_parameters(self, channel, Kp, Ki, Kd, int_max=1000, int_min=0, reset=True):
-        logger.info(f"Setting PID parameters for channel {channel}:\n\
-                      Kp: {Kp}, Ki: {Ki}, Kd: {Kd}\n\
-                      Integral max: {int_max}\n\
-                      Integral min: {int_min}\n\
-                      Reset: {reset}")
-        
-        self.pids[channel].Kp = Kp
-        self.pids[channel].Ki = Ki
-        self.pids[channel].Kd = Kd
-        self.pids[channel].int_min = int_min
-        self.pids[channel].int_max = int_max
-        if reset:
-            self.pids[channel].intergral = 0
-            self.pids[channel].prev_error = 0
-
-    def set_temperature(self, channel, setpoint):
-
-        logger.info(f'set PID {channel} to {setpoint}C')
-
-        if channel not in range(len(self.channels)):
-            raise PidError(f'channel number {channel} is not defined')
-
-        self.setpoints[channel] = setpoint
-
-
-    def get_temperature(self, channel):
-        if channel not in range(len(self.channels)):
-            raise PidError(f'channel number {channel} is not defined')
-
-        return self.setpoints[channel]
-
-
-    def enable(self, channel):
-        logger.info(f'PID {channel} has been enabled')
-
-        if channel not in range(len(self.channels)):
-            raise PidError(f'channel number {channel} is not defined')
-
-        self.running[channel] = True
-
-
-    def disable(self, channel):
-        logger.info(f'PID {channel} has been disabled')
-
-        if channel not in range(len(self.channels)):
-            raise PidError(f'channel number {channel} is not defined')
-
-        self.running[channel] = False
-        _, _, _, htr_idx, ch_idx, _, _, _ = self.channels[channel]
-        self._beaglebone.set_enable(htr_idx, ch_idx, False)
-        
-    def get_running(self, channel):
-        return self.running[channel]
-
-
-    def thread_function(self):
-
-        while self._is_connected:
-
-            for i, (_, agilent_index, agilent_channel, bb_index, bb_channel, _, _, _) \
-                    in enumerate(self.channels):
-
-                # skip uninitialized channels
-                if self.setpoints[i] is float('nan'):
-                    continue
-
-                # Don't step the PID for unenabled channels to avoid a large I sum
-                if not self.running[i]:
-                    continue
-
-                # construct prometheus metric name
-                metric_name = self.PREFIXES[agilent_index] + str(agilent_channel)
-
-                # get temperature from prometheus
-                try:
-                    self.timestamp[i], self.temperature[i] = get_housekeeping(f'{metric_name}')
-
-                except Exception as e:
-                    logger.warning(f'could not get {metric_name} for pid loop {i} ({e})')
-                    continue
-
-                # Check if the temperature is recently updated
-                age = time.time() - self.timestamp[i]
-                if age < self.temperature_timeout:
-                    # Update the pid loop
-                    self.inputs[i]  = float(self.temperature[i])
-                    self.errors[i]  = self.setpoints[i] - self.inputs[i]
-                    self.outputs[i] = self.pids[i].compute_step(self.errors[i])
-                    self.isum[i]    = self.pids[i].integral
-
-                    # logger.info(f'PID {i}: error = {self.errors[i]:.2f}, '
-                    #              f'output = {100 * self.outputs[i]:.2f}%')
-                else:
-                    logger.warning(f'pid loop {i} temperature outdated {metric_name} ({age}s)')
-
-                    if self.timeout_action == 'heater_off':
-                        self.errors[i] = None
-                        self.outputs[i] = 0
-
-                if self.outputs[i] == 0:
-                    self._beaglebone.set_enable(bb_index, bb_channel, False)
-                    # logger.info("PID output is zero")
-
-                else:
-                    self._beaglebone.set_enable(bb_index, bb_channel, True)
-
-                    # logger.info(f'Set heater {bb_index}.{bb_channel} to {int(self.outputs[i] * 100)}%')
-                    self._beaglebone.set_period(bb_index, bb_channel, 10000) # PWM period in ns
-                    self._beaglebone.set_duty_cycle(
-                        bb_index, bb_channel, int(self.outputs[i] * 10000)) # duty cycle in ns
-
-            # sleep for what is left of the update period
-            t1 = time.time()
-            dt = self.update_period - (t1 - self._t0)
-            dt = max(dt, 0)
-            time.sleep(dt)
-            self._t0 = time.time()
-
-
-class PidAlgorithm:
-
-    def __init__(self, Kp, Ki, Kd):
-
-        self.Kp = Kp
-        self.Ki = Ki
-        self.Kd = Kd
-        logger.info(f"Kp: {self.Kp}, Ki: {self.Ki}, Kd: {self.Kd}")
-        self.int_max = 1000
-        self.int_min = 0
-
-        self.out_max = 0.9
-        self.out_min = 0.0
-
-        self.prev_time = None
-        self.integral = 0.0
-        self.prev_error = 0.0
-
-
-    def compute_step(self, error):
-
-        if self.prev_time is None:
-            self.prev_time = time.time()
-
-        dt = time.time() - self.prev_time
-        self.prev_time = time.time()
-
-        self.integral += error * dt
-
-        if self.integral > self.int_max:
-            self.integral = self.int_max
-
-        if self.integral < self.int_min:
-            self.integral = self.int_min
-        
-        derivative = (error - self.prev_error) / dt
-        self.prev_error = error
-
-        output = self.Kp * error + self.Ki * self.integral + self.Kd * derivative
-
-        if output > self.out_max:
-            output = self.out_max
-
-        if output < self.out_min:
-            output = self.out_min
-
-        return output
-
-
-def main():
-    pid = PidController()
-    # pid.set_temperature(2, -40)
-
-
-if __name__ == '__main__':
-    main()

egse/tempcontrol/spid/spid_cs.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-import click
-import logging
-import sys
-
-import zmq
-from prometheus_client import start_http_server
-
-from egse.control import ControlServer
-from egse.settings import Settings
-from egse.tempcontrol.spid.spid import PidProxy
-from egse.tempcontrol.spid.spid_protocol import PidProtocol
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger('PID')
-
-CTRL_SETTINGS = Settings.load("SPID Control Server")
-
-
-class PidControlServer(ControlServer):
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = PidProtocol(self)
-
-        self.logger.debug(f'Binding ZeroMQ socket to {self.device_protocol.get_bind_address()}')
-
-        self.device_protocol.bind(self.dev_ctrl_cmd_sock)
-
-        self.poller.register(self.dev_ctrl_cmd_sock, zmq.POLLIN)
-
-    def get_communication_protocol(self):
-        return CTRL_SETTINGS.PROTOCOL
-
-    def get_commanding_port(self):
-        return CTRL_SETTINGS.COMMANDING_PORT
-
-    def get_service_port(self):
-        return CTRL_SETTINGS.SERVICE_PORT
-
-    def get_monitoring_port(self):
-        return CTRL_SETTINGS.MONITORING_PORT
-
-    def get_storage_mnemonic(self):
-        try:
-            return CTRL_SETTINGS.STORAGE_MNEMONIC
-        except:
-            return 'PID'
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the SPID Simulator as the backend.")
-def start(simulator):
-    """Start the SPID Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        control_server = PidControlServer()
-        control_server.serve()
-
-    except KeyboardInterrupt:
-        logger.info("Shutdown requested...exiting")
-
-    except SystemExit as exit_code:
-        logger.info("System Exit with code {}.".format(exit_code))
-        sys.exit(exit_code)
-
-    except Exception:
-
-        logger.exception("Cannot start the SPID Control Server")
-        # The above line does exactly the same as the traceback, but on the logger
-        # import traceback
-        # traceback.print_exc(file=sys.stdout)
-
-    return 0
-
-
-@cli.command()
-def stop():
-    """Send a 'quit_server' command to the Control Server."""
-
-    with PidProxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())
-
-
-# def parse_arguments():
-#     """ Prepare the arguments that are specific for this application. """
-#     parser = argparse.ArgumentParser()
-#     parser.add_argument('--simulator', default=False, action='store_true',
-#                         help='Connect with the PID simulator instead of the real hardware.')
-#     parser.add_argument('--profile', default=False, action='store_true',
-#                         help='Enable info logging messages with method profile information.')
-#     args = parser.parse_args()
-#     return args
-#
-# if __name__ == '__main__':
-#
-#     args = parse_arguments()
-#
-#     if args.profile:
-#         Settings.set_profiling(True)
-#
-#     if args.simulator:
-#         Settings.set_simulation_mode(True)
-#
-#     try:
-#         control_server = PidControlServer()
-#         control_server.serve()
-#
-#     except KeyboardInterrupt:
-#         logger.info('Shutdown requested...exiting')
-#     except SystemExit as exit_code:
-#         logger.info('System exit with code {}'.format(exit_code))
-#         sys.exit(exit_code)
-#     except Exception:
-#         import traceback
-#         traceback.print_exc(file=sys.stdout)
-#     sys.exit(0)

egse/tempcontrol/spid/spid_protocol.py

@@ -1,107 +0,0 @@
-from egse.control import ControlServer
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from datetime import datetime
-from prometheus_client import Gauge
-
-from egse.tempcontrol.spid.spid_controller import PidController
-from egse.tempcontrol.spid.spid import PidInterface, PidSimulator, PidCommand
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-from egse.confman import ConfigurationManagerProxy
-
-
-COMMAND_SETTINGS = Settings.load(filename='spid.yaml')
-
-
-class PidProtocol(CommandProtocol):
-
-    def __init__(self, control_server:ControlServer):
-
-        super().__init__()
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.pid = PidSimulator()
-        else:
-            self.pid = PidController()
-
-        self.load_commands(COMMAND_SETTINGS.Commands, PidCommand, PidInterface)
-
-        self.build_device_method_lookup_table(self.pid)
-
-        # Get PID channels form the setup
-        with ConfigurationManagerProxy() as cm:
-            heaters = cm.get_setup().gse.spid.configuration.heaters
-
-        # Get the list of PID channe    ls [pid_idx, agilent_idx, agilent_ch, bbb_idx, bbb_ch, P, I]
-        self.channels = [channel for heater in heaters.values() for channel in heater]
-    
-
-        self.gauges_enabled = [Gauge(f'GSRON_PID_CH{channel[0]}_ENABLED', '') for channel in self.channels]
-        self.gauges_setpoint = [Gauge(f'GSRON_PID_CH{channel[0]}_SETPOINT', '') for channel in self.channels]
-        self.gauges_input = [Gauge(f'GSRON_PID_CH{channel[0]}_INPUT', '') for channel in self.channels]
-        self.gauges_error = [Gauge(f'GSRON_PID_CH{channel[0]}_ERROR', '') for channel in self.channels]
-        self.gauges_output = [Gauge(f'GSRON_PID_CH{channel[0]}_OUTPUT', '') for channel in self.channels]
-        self.gauges_isum = [Gauge(f'GSRON_PID_CH{channel[0]}_ISUM', '') for channel in self.channels]
-
-
-    def get_bind_address(self):
-
-        return bind_address(self.control_server.get_communication_protocol(),
-                            self.control_server.get_commanding_port())
-
-
-    def get_status(self):
-
-        status_info = super().get_status()
-        now = datetime.now()
-        enabled     = {f"{ch[3]}_{ch[4]}" : self.pid.running[ch[0]] for ch in self.channels}
-        setpoint    = [self.pid.setpoints[ch[0]] for ch in self.channels]
-        temperature = [self.pid.temperature[ch[0]] for ch in self.channels]
-        timestamp   = [self.pid.timestamp[ch[0]] for ch in self.channels]
-        error       = [self.pid.errors[ch[0]] for ch in self.channels]
-        isum        = [self.pid.isum[ch[0]] for ch in self.channels]
-        t_input      = [self.pid.inputs[ch[0]] for ch in self.channels]
-        output      = [self.pid.outputs[ch[0]] for ch in self.channels]
-        pid_const   = [[self.pid.pids[ch[0]].Kp, self.pid.pids[ch[0]].Ki, self.pid.pids[ch[0]].Kd] for ch in self.channels]
-
-        
-        status_info['Enabled']      = enabled
-        status_info['Setpoint']     = setpoint
-        status_info['Temperature']  = temperature
-        status_info['Timestamp']    = timestamp
-        status_info['Error']        = error
-        status_info['Isum']         = isum
-        status_info['Input']        = t_input
-        status_info['Output']       = output
-        status_info['PidConst']     = pid_const
-        
-        return status_info
-
-
-    def get_housekeeping(self) -> dict:
-
-        hk_dict = {'timestamp': format_datetime()}
-
-        for channel in self.channels:
-
-            hk_dict[f'GSRON_PID_CH{channel[0]}_ENABLED'] = int(self.pid.running[channel[0]])
-            hk_dict[f'GSRON_PID_CH{channel[0]}_SETPOINT'] = self.pid.setpoints[channel[0]]
-            hk_dict[f'GSRON_PID_CH{channel[0]}_INPUT'] = self.pid.inputs[channel[0]]
-            hk_dict[f'GSRON_PID_CH{channel[0]}_ERROR'] = self.pid.errors[channel[0]]
-            hk_dict[f'GSRON_PID_CH{channel[0]}_OUTPUT'] = self.pid.outputs[channel[0]]
-            hk_dict[f'GSRON_PID_CH{channel[0]}_ISUM'] = self.pid.pids[channel[0]].integral
-
-            self.gauges_enabled[channel[0]].set(hk_dict[f'GSRON_PID_CH{channel[0]}_ENABLED'])
-            self.gauges_setpoint[channel[0]].set(hk_dict[f'GSRON_PID_CH{channel[0]}_SETPOINT'])
-            self.gauges_input[channel[0]].set(hk_dict[f'GSRON_PID_CH{channel[0]}_INPUT'])
-            self.gauges_error[channel[0]].set(hk_dict[f'GSRON_PID_CH{channel[0]}_ERROR'])
-            self.gauges_output[channel[0]].set(hk_dict[f'GSRON_PID_CH{channel[0]}_OUTPUT'])
-            self.gauges_isum[channel[0]].set(hk_dict[f'GSRON_PID_CH{channel[0]}_ISUM'])
-
-        return hk_dict
-    
-    def quit(self):
-        self.pid.disconnect()
-        super().quit()