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

egse/tempcontrol/beaglebone/beaglebone.py

@@ -1,342 +0,0 @@
-import os
-import logging
-
-from egse.decorators import dynamic_interface
-from egse.device import DeviceInterface
-from egse.proxy import Proxy
-from egse.settings import Settings
-from egse.command import ClientServerCommand
-from egse.confman import ConfigurationManagerProxy
-from egse.zmq_ser import connect_address
-
-logger = logging.getLogger(__name__)
-
-CTRL_SETTINGS = Settings.load("BeagleBone Heater Control Server")
-DEVICE_SETTINGS = Settings.load(filename='beaglebone.yaml')
-
-LED_PINS = [69, 68, 66, 67]
-PWM_PINS = [4, 5, 7, 8]
-
-class BeagleboneCommand(ClientServerCommand):
-    def get_cmd_string(self, *args, **kwargs):
-        out = super().get_cmd_string(*args, **kwargs)
-        return out + '\n'
-
-class BeagleboneError(Exception):
-    pass
-
-class BeagleboneInterface(DeviceInterface):
-    """ BeagleBone base class."""
-
-    @dynamic_interface
-    def connect_beaglebone(self, device):
-        return NotImplemented
-
-    @dynamic_interface
-    def set_enable(self, dev_idx, chnl_idx, enable):
-        """ Enable PWM pin. """
-        return NotImplemented
-
-    @dynamic_interface
-    def set_duty_cycle(self, dev_idx, chnl_idx, duty_cycle):
-        """ Duty cycle duration in ns. """
-        return NotImplemented
-
-    @dynamic_interface
-    def set_period(self, dev_idx, chnl_idx, period):
-        """ Period duration in ns. """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_temperature(self, dev_idx):
-        """ Get board temperature. """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_voltage(self, dev_idx, chnl_idx):
-        """ Get channel voltage. """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_current(self, dev_idx, chnl_idx):
-        """ Get channel current. """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_power(self, dev_idx, chnl_idx):
-        """ Get channel power. """
-        return NotImplemented
-    
-    @dynamic_interface
-    def get_enable(self, dev_idx, chnl_idx):
-        """ Get enabled state. """
-        return NotImplemented
-
-    @dynamic_interface
-    def get_duty_cycle(self, dev_idx, chnl_idx):
-        """ Get duty cycle. """
-        return NotImplemented
-
-
-class BeagleboneSimulator(BeagleboneInterface):
-    
-    def __init__(self):
-        super().__init__()
-        self._is_connected = True
-        self.duty_cycle = [[[] for _ in range(4)] for _ in range(6)]
-        self.enabled = [[[] for _ in range(4)] for _ in range(6)]   
-        
-        for htr_idx in range(0, 6):
-            for ch_idx in range(0, 4):
-                self.duty_cycle[htr_idx][ch_idx] = 2 * ch_idx + htr_idx
-                self.enabled[htr_idx][ch_idx] = False
-
-
-    def is_connected(self):
-        return self._is_connected
-
-    def is_simulator(self):
-        return True
-
-    def connect(self):
-        self._is_connected = True
-
-    def disconnect(self):
-        self._is_connected = False
-
-    def reconnect(self):
-       if self.is_connected():
-           self.disconnect()
-       self.connect()
-
-    def set_enable(self, dev_idx, chnl_idx, enable):
-       logger.info(f"Heater {dev_idx} Channel {chnl_idx} state has been set to {enable}")
-       self.enabled[dev_idx][chnl_idx] = enable
-
-    def set_duty_cycle(self, dev_idx, chnl_idx, duty_cycle):
-       logger.info(f"Duty cycle for Heater {dev_idx} Channel {chnl_idx} set to {duty_cycle}ns")
-       self.duty_cycle[dev_idx][chnl_idx] = duty_cycle
-
-    def set_period(self, dev_idx, chnl_idx, period):
-       logger.info(f"Period for Heater {dev_idx} Channel {chnl_idx} set to {period} ns")
-
-
-    def get_temperature(self, dev_idx):
-       return 20.0
-
-    def get_voltage(self, dev_idx, chnl_idx):
-       return 1.0
-
-    def get_current(self, dev_idx, chnl_idx):
-       return 0.1
-
-    def get_power(self, dev_idx, chnl_idx):
-       return 1.0
-   
-    def get_enable(self, dev_idx, chnl_idx):
-       return self.enabled[dev_idx][chnl_idx]
-   
-    def get_duty_cycle(self, dev_idx, chnl_idx):
-       return self.duty_cycle[dev_idx][chnl_idx]
-   
-    def get_availability(self):
-       return [True] * 6
-
-
-class BeagleboneHeater:
-    
-    # Perform SRON gssw imports here to avoid issues at other THs
-    from gssw.lib.device import Device
-    
-    def __init__(self, num, config, hal):
-        self.num        = num + 1
-        
-        self.config     = config
-        self.hal        = hal
-        
-        self._is_connected     = False
-        
-        try:
-            self.connect()
-        except Exception:
-            self._is_connected = False
-        
-    @property
-    def connected(self):
-        return self._is_connected
-
-    def connect(self):
-        self.pwm  = self.Device(f'pwm_{self.num}', self.config, self.hal)
-        self.i2c  = self.Device(f'i2c_{self.num}', self.config, self.hal)
-        self.gpio = self.Device(f'gpio_{self.num}', self.config, self.hal)
-        
-        for i in range(4):
-            self.set_period(i, 10000)
-            
-        self._is_connected = True
-
-    def disconnect(self):
-        if self.pwm.socket:
-            self.pwm.socket.close()
-        if self.i2c.socket:
-            self.i2c.socket.close()
-        if self.gpio.socket:
-            self.gpio.socket.close()
-        
-        self._is_connected = False
-
-    def disconnected(self):
-        self._is_connected = False
-
-    @property
-    def temperature(self):
-        def twosComp(val, bits):
-            if (val & (1 << (bits - 1))) != 0:
-                val = val - (1 << bits)
-            return val
-        raw = self.i2c.get('TEMP')
-        val = ((raw << 8) & 0xFF00) + (raw >> 8)
-        val = val >> 4
-        return twosComp(val, 12) * (128/0x7FF)
-
-
-    
-    def set_enable(self, channel, state):
-        self.pwm.setMultiple([('PWM_NUM', PWM_PINS[channel]),
-                            ('PWM_ENABLE', state)])
-        self.gpio.setMultiple([('GPIO_PIN', LED_PINS[channel]),
-                            ('GPIO_VALUE', state)])
-
-    
-    def set_duty_cycle(self, channel, duty_cycle):
-        self.pwm.setMultiple([('PWM_NUM', PWM_PINS[channel]), 
-                            ('PWM_DUTY_CYCLE', duty_cycle)])
-
-    
-    def set_period(self, channel, period):
-        self.pwm.setMultiple([('PWM_NUM', PWM_PINS[channel]), 
-                            ('PWM_PERIOD', period)])
-    
-    def get_voltage(self, channel):
-        raw = self.i2c.get(f'V_{channel}')
-        val = ((raw << 8) & 0xFF00) + (raw >> 8)
-        val = val >> 4
-        return val * 0.025
-
-    
-    def get_current(self, channel):
-        raw = self.i2c.get(f'I_{channel}')
-        val = ((raw << 8) & 0xFF00) + (raw >> 8)
-        val = val >> 4
-        return val * 5e-4
-
-    
-    def get_power(self, channel):
-        return self.get_voltage(channel) * self.get_current(channel)
-
-    
-    def get_enable(self, channel):
-        pwm_enable = self.pwm.getSetMultiple([('PWM_NUM', PWM_PINS[channel]), 
-                                                ('PWM_ENABLE', None)])[0]
-        return bool(pwm_enable)
-    
-    def get_duty_cycle(self, channel):
-
-        pwm_duty_cycle = self.pwm.getSetMultiple([('PWM_NUM', PWM_PINS[channel]), ('PWM_DUTY_CYCLE', None)])
-        return int(pwm_duty_cycle[0])
-
-            
-    def set_timeout(self, timeout):
-        self.pwm.setTimeout(timeout)
-        self.gpio.setTimeout(timeout)
-        self.i2c.setTimeout(timeout)
-
-
-class BeagleboneHeaterController(BeagleboneInterface):
-
-    def __init__(self):
-        super().__init__()
-
-        # Perform SRON gssw imports here to avoid issues at other THs
-        from gssw.config.configclient import ConfigClient
-        from gssw.common import addLoggingLevel
-        from gssw.hal.hal import Hal
-        from gssw.hal.halclient import HalClient
-
-        logger.debug('Initalizing BeagleBone Black Heater Controller')
-
-        configClient = ConfigClient(os.getenv('GSSW_CONFIGURATION_FILE'))
-        self.config = configClient.config
-        addLoggingLevel('data', 15)
-
-        with ConfigurationManagerProxy() as cm:
-            setup = cm.get_setup()
-
-        self._availability = setup.gse.beaglebone_heater.availability
-        self._active       = [False] * len(self._availability)
-        
-        self.hal = Hal()
-        hal_client = HalClient(self.hal, self.config)
-        hal_client.requestHal()
-        
-        self.heaters = {}
-        
-        for htr, available in enumerate(self._availability):
-            if available:
-                self.heaters[htr] = BeagleboneHeater(htr, self.config, self.hal)
-
-    def is_simulator(self):
-        return False
-
-    def is_connected(self):
-        return all([heater.connected for heater in self.heaters.values()])
-
-    def connect(self):
-        for heater in self.heaters.values():
-            heater.connect()
-    
-    def disconnect(self):
-        for heater in self.heaters.values():
-            heater.disconnect()
-
-    def reconnect(self):
-        for heater in self.heaters.values():
-            heater.disconnect()
-            heater.connect()
-
-    def connect_beaglebone(self, device):
-        self.heaters[device].connect()
-
-    def set_enable(self, dev_idx, chnl_idx, enable):
-        self.heaters[dev_idx].set_enable(chnl_idx, enable)
-
-    def set_duty_cycle(self, dev_idx, chnl_idx, duty_cycle):
-        self.heaters[dev_idx].set_duty_cycle(chnl_idx, duty_cycle)
-
-    def set_period(self, dev_idx, chnl_idx, period):
-        self.heaters[dev_idx].set_period(chnl_idx, period)
-
-    def get_temperature(self, dev_idx):
-        return self.heaters[dev_idx].temperature
-
-    def get_voltage(self, dev_idx, chnl_idx):
-        return self.heaters[dev_idx].get_voltage(chnl_idx)
-
-    def get_current(self, dev_idx, chnl_idx):
-        return self.heaters[dev_idx].get_current(chnl_idx)
-
-    def get_power(self, dev_idx, chnl_idx):
-        return self.heaters[dev_idx].get_power(chnl_idx)
-    
-    def get_enable(self, dev_idx, chnl_idx):
-        return self.heaters[dev_idx].get_enable(chnl_idx)
-    
-    def get_duty_cycle(self, dev_idx, chnl_idx):
-        return self.heaters[dev_idx].get_duty_cycle(chnl_idx)
-
-
-class BeagleboneProxy(Proxy, BeagleboneInterface):
-    def __init__(self, protocol=CTRL_SETTINGS.PROTOCOL,
-                 hostname=CTRL_SETTINGS.HOSTNAME,
-                 port=CTRL_SETTINGS.COMMANDING_PORT):
-        super().__init__(connect_address(protocol, hostname, port))

egse/tempcontrol/beaglebone/beaglebone.yaml

@@ -1,110 +0,0 @@
-BaseClass:
-    egse.tempcontrol.beaglebone.BeagleboneInterface
-
-ProxyClass:
-    egse.tempcontrol.beaglebone.BeagleboneProxy
-
-ControlServerClass:
-    egse.tempcontrol.beaglebone.BeagleboneControlServer
-
-ControlServer:
-    egse.tempcontrol.beaglebone.beaglebone_cs
-
-UserInterface:
-    egse.tempcontrol.beaglebone.beaglebone_ui
-
-Commands:
-
-    # Definition of the DeviceInterface.
-
-    disconnect:
-        description: Disconnect from the PWM Controller.
-
-    connect:
-        description: Connect to the PWM Controller.
-
-    reconnect:
-        description: Reconnect to the PWM Controller.
-
-    is_simulator:
-        description: Ask if the control server is a simulator.
-        returns:     bool | True if far end is a simulator.
-
-    is_connected:
-        description: Check if PWM Controller is connected.
-
-    # Definition of the device commands.
-    set_enable:
-        description: Enable PWM pin.
-        args:
-            dev_idx:   int  | Device index.
-            chnl_idx:  int  | Channel index.
-            enable: bool | Enable PWM pin.
-        cmd:         "{dev_idx}{pin_number}{enable}"
-
-    set_duty_cycle:
-        description: Duty cycle duration in ns.
-        args:
-            dev_idx:   int | Device index.
-            chnl_idx:  int | Channel index.
-            duty_cycle: int | Duty cycle.
-        cmd:         "{dev_idx}{pin_number}{duty_cycle}"
-
-    set_period:
-        description: Period duration in ns.
-        args:
-            dev_idx:   int | Device index.
-            chnl_idx:  int | Channel index.
-            period:     int | Period.
-        cmd:         "{dev_idx}{pin_number}{period}"
-
-    get_temperature:
-        description: Get board temperature.
-        args:
-            dev_idx:  int | Device index.
-        cmd:  "{dev_idx}"
-        returns:     float | Temperature dgrC
-
-    get_voltage:
-        description: Get channel voltage.
-        args:
-            dev_idx:   int | Device index.
-            chnl_idx:  int | Channel index.
-        cmd: "{dev_idx}{chnl_idx}"
-        returns:       float | Voltage V
-
-    get_current:
-        description: Get channel current.
-        args:
-            dev_idx:   int | Device index.
-            chnl_idx:  int | Channel index.
-        cmd: "{dev_idx}{chnl_idx}"
-        returns:       float | Current A
-
-    get_power:
-        description: Get channel power.
-        args:
-            dev_idx:   int | Device index.
-            chnl_idx:  int | Channel index.
-        cmd: "{dev_idx}{chnl_idx}"
-        returns:       float | Power W
-
-    get_enable:
-        description: Get channel state
-        args:
-            dev_idx:   int | Device index.
-            chnl_idx:  int | Channel index.
-        cmd: "{dev_idx}{chnl_idx}"
-        returns:       bool | state
-
-    get_duty_cycle:
-        description: Get channel duty cycle.
-        args:
-            dev_idx:   int | Device index.
-            chnl_idx:  int | Channel index.
-        cmd: "{dev_idx}{chnl_idx}"
-        returns:       int | duty cycle in ns
-
-    connect_beaglebone:
-        description:
-        cmd: "{device}"

egse/tempcontrol/beaglebone/beaglebone_cs.py

@@ -1,117 +0,0 @@
-# Control server for the BeagleBone Black heater controller
-
-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.beaglebone.beaglebone_protocol import BeagleboneProtocol
-from egse.tempcontrol.beaglebone.beaglebone import BeagleboneProxy
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-
-logger = logging.getLogger('BeagleBone Heater')
-
-CTRL_SETTINGS = Settings.load("BeagleBone Heater Control Server")
-
-
-class BeagleBoneControlServer(ControlServer):
-
-    def __init__(self):
-        super().__init__()
-
-        self.device_protocol = BeagleboneProtocol(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)
-
-        self.set_delay(5)
-        
-        self.set_hk_delay(CTRL_SETTINGS.DELAY)
-
-
-    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 'BB_HEATERS'
-
-    def before_serve(self):
-        start_http_server(CTRL_SETTINGS.METRICS_PORT)
-        
-    # def after_serve(self):
-    #     for idx, dev in enumerate(self.device_protocol.beaglebone.beaglebone.dev_gpio_names):
-    #         self.device_protocol.beaglebone.beaglebone._dev_gpio[idx].socket.close()
-        
-    #     for idx, dev in enumerate(self.device_protocol.beaglebone.beaglebone.dev_pwm_names):
-    #         self.device_protocol.beaglebone.beaglebone._dev_pwm[idx].socket.close()
-         
-    #     for idx, dev in enumerate(self.device_protocol.beaglebone.beaglebone.dev_i2c_names):
-    #         self.device_protocol.beaglebone.beaglebone._dev_i2c[idx].socket.close()
-        
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-@click.option("--simulator", "--sim", is_flag=True, help="Start the BeagleBone Simulator as the backend.")
-def start(simulator):
-    """Start the BeagleBone Control Server."""
-
-    if simulator:
-        Settings.set_simulation_mode(True)
-    try:
-        control_server = BeagleBoneControlServer()
-        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 BeagleBone 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 BeagleboneProxy() as proxy:
-
-        sp = proxy.get_service_proxy()
-        sp.quit_server()
-
-
-if __name__ == "__main__":
-
-    sys.exit(cli())

egse/tempcontrol/beaglebone/beaglebone_protocol.py

@@ -1,135 +0,0 @@
-import logging
-import time
-
-from prometheus_client import Gauge
-
-from egse.control import ControlServer
-from egse.protocol import CommandProtocol
-from egse.settings import Settings
-from egse.tempcontrol.beaglebone.beaglebone import BeagleboneHeaterController
-from egse.tempcontrol.beaglebone.beaglebone import BeagleboneInterface
-from egse.tempcontrol.beaglebone.beaglebone import BeagleboneSimulator
-from egse.tempcontrol.beaglebone.beaglebone import BeagleboneCommand
-from egse.system import format_datetime
-from egse.zmq_ser import bind_address
-
-COMMAND_SETTINGS = Settings.load(filename='beaglebone.yaml')
-
-logger = logging.getLogger(__name__)
-
-
-class BeagleboneProtocol(CommandProtocol):
-
-    from gssw.lib.errors import GsswTimeoutError, PeerException, CommunicationError
-
-    def __init__(self, control_server:ControlServer):
-        super().__init__()
-            
-        self.control_server = control_server
-
-        if Settings.simulation_mode():
-            self.beaglebone = BeagleboneSimulator()
-            self._num_dev = 6
-        else:
-            self.beaglebone = BeagleboneHeaterController()
-            self._num_dev = len(self.beaglebone.heaters)
-
-        self.temperature_gauges = [Gauge(f'GSRON_HTR_TEMP_{device}', '') for device in range(self._num_dev)]
-        self.current_gauges     = [[Gauge(f"GSRON_HTR_I_{device}_{channel}", '') for channel in range(4)] for device in range(self._num_dev)]
-        self.voltage_gauges     = [[Gauge(f"GSRON_HTR_V_{device}_{channel}", '') for channel in range(4)] for device in range(self._num_dev)]
-        self.resistance_gauges  = [[Gauge(f"GSRON_HTR_R_{device}_{channel}", '') for channel in range(4)] for device in range(self._num_dev)]
-        self.power_gauges       = [[Gauge(f"GSRON_HTR_P_{device}_{channel}", '') for channel in range(4)] for device in range(self._num_dev)]
-        
-        self.valid_hk           = [True] * self._num_dev
-        self.valid_status       = [True] * self._num_dev
-        
-        self.load_commands(COMMAND_SETTINGS.Commands, BeagleboneCommand, BeagleboneInterface)
-
-        self.build_device_method_lookup_table(self.beaglebone)
-
-    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()
-
-        htr_connected = [False] * self._num_dev
-        htr_enabled   = [[] * 4] * self._num_dev
-        htr_cycle     = [[] * 4] * self._num_dev
-        
-        
-        for i, heater in enumerate(self.beaglebone.heaters.values()):
-            
-            enabled     = []
-            duty_cycle  = []
-            
-            if heater.connected:
-                try:
-                    for channel in range(4):
-                        enabled.append(heater.get_enable(channel))
-                        duty_cycle.append(heater.get_duty_cycle(channel))
-    
-                    htr_connected[i] = True
-                except self.CommunicationError as ex:
-                    logger.error("Could not connect to heater %s: %s", i, ex)
-                    heater.disconnected()
-                except self.PeerException as ex:
-                    logger.warning("Could not retrieve housekeeping from heater %s: %s", i, ex)      
-                    
-            if not heater.connected:
-                for channel in range(4):
-                    enabled.append(False)
-                    duty_cycle.append(0.0)       
-        
-            htr_enabled[i] = enabled
-            htr_cycle[i]   = duty_cycle
-        
-        status_info['Connected']  = htr_connected
-        status_info['Enabled']    = htr_enabled
-        status_info['duty_cycle'] = htr_cycle        
-
-        return status_info
-
-    
-    def get_housekeeping(self) -> dict:
-
-        hk_dict = {'timestamp': format_datetime()}
-
-        for i, heater in enumerate(self.beaglebone.heaters.values()):
-            if heater.connected:
-                try:
-                    hk_dict[f'GSRON_HTR_TEMP_{i}'] = heater.temperature
-                    
-                    for channel in range(4):
-                        hk_dict[f"GSRON_HTR_V_{i}_{channel}"] = heater.get_voltage(channel)
-                        hk_dict[f"GSRON_HTR_I_{i}_{channel}"] = heater.get_current(channel)
-                        
-                        hk_dict[f"GSRON_HTR_R_{i}_{channel}"] = hk_dict[f"GSRON_HTR_V_{i}_{channel}"] / hk_dict[f"GSRON_HTR_I_{i}_{channel}"] \
-                                                                    if hk_dict[f"GSRON_HTR_I_{i}_{channel}"] else 0
-                        hk_dict[f"GSRON_HTR_P_{i}_{channel}"] = hk_dict[f"GSRON_HTR_V_{i}_{channel}"] * hk_dict[f"GSRON_HTR_I_{i}_{channel}"]
-                except self.GsswTimeoutError as ex:
-                    logger.error("Could not connect with Beaglebone heater %s: %s", i, ex)
-                    heater.disconnected()
-                except self.PeerException as ex:
-                    logger.warning("Could not retrieve housekeeping from heater %s: %s", i, ex)
-                    heater.disconnected()
-                    
-            if not heater.connected:
-                hk_dict[f'GSRON_HTR_TEMP_{i}'] = 0.0
-                        
-                for channel in range(4):
-                    hk_dict[f"GSRON_HTR_V_{i}_{channel}"] = 0.0
-                    hk_dict[f"GSRON_HTR_I_{i}_{channel}"] = 0.0
-                    hk_dict[f"GSRON_HTR_R_{i}_{channel}"] = 0.0
-                    hk_dict[f"GSRON_HTR_P_{i}_{channel}"] = 0.0     
-        
-            self.temperature_gauges[i].set(hk_dict[f'GSRON_HTR_TEMP_{i}'])
-                        
-            for channel in range(4):
-                self.voltage_gauges[i][channel].set(hk_dict[f"GSRON_HTR_V_{i}_{channel}"])
-                self.current_gauges[i][channel].set(hk_dict[f"GSRON_HTR_I_{i}_{channel}"])
-                self.resistance_gauges[i][channel].set(hk_dict[f"GSRON_HTR_R_{i}_{channel}"])
-                self.power_gauges[i][channel].set(hk_dict[f"GSRON_HTR_P_{i}_{channel}"])
-
-        return hk_dict