BurnIn_Worker.py

import sys, os
from PyQt5 import QtWidgets, QtCore, QtGui
from PyQt5.QtCore import QObject, pyqtSlot, pyqtSignal
import time
from datetime import datetime,timedelta
import subprocess
from __Constant import *
import json
import math

def computeTempFromTargetRH(dewPoint: float, targetRH: float = 0.10) -> float:
    """
    Calculates the temperature required to achieve a specific target relative humidity 
    for a given dew point using the Magnus-Tetens formula.
    
    :param dewPoint: The current dew point temperature in Celsius.
    :param targetRH: The desired relative humidity percentage (e.g., 10.0 for 10%).
    :return: The calculated temperature in Celsius.
    """
    # Safeguard against mathematically invalid relative humidity inputs
    if targetRH <= 0 or targetRH > 100:
        raise ValueError("Target relative humidity must be between 0% (exclusive) and 100% (inclusive).")
        
    # Magnus-Tetens constants for water vapor
    a = 17.625
    b = 243.04
    
    # Saturated vapor pressure parameter at the dew point
    alpha_dp = (a * dewPoint) / (b + dewPoint)
    
    # Rearranged equation variable
    K = alpha_dp - math.log(targetRH)
    
    # Solve for the target temperature
    targetTemp = (K * b) / (a - K)
    
    return targetTemp

## Class implementation for the Worker module of the GUI controller.
#
#  The worker is a inheriting from pyQt library in order to create assign slots and signals
class BurnIn_Worker(QObject):

    Request_msg = pyqtSignal(str,str)
    Request_confirm_sig = pyqtSignal(str)
    Request_input_dsb = pyqtSignal(str,float,float,float)
    BI_terminated = pyqtSignal()
    
    BI_Update_GUI_sig = pyqtSignal(dict)
    BI_CheckID_isOK_sig = pyqtSignal(int,int)
    BI_Clear_Monitor_sig = pyqtSignal()
    BI_Update_PowerStatus_sig = pyqtSignal(int,bool,str)

    ## Init function.
    def __init__(self,configDict,logger, SharedDict, Julabo, FNALBox, CAENController, DB_interface):

    
        super(BurnIn_Worker,self).__init__();
        self.configDict=configDict
        self.logger = logger
        self.Julabo = Julabo
        self.FNALBox = FNALBox
        self.DB_interface = DB_interface
        self.CAENController = CAENController
        self.SharedDict = SharedDict
        
        self.BIcwd = configDict.get(("BITest","cwd"),"NOKEY")
        if self.BIcwd == "NOKEY":
            self.BIcwd = "/home/thermal/BurnIn_moduleTest"
            self.logger.warning("cwd directory parameter not found. Using default")
            
        self.Ph2_ACF_version = configDict.get(("BITest","version"),"NOKEY")
        if self.Ph2_ACF_version == "NOKEY":
            self.Ph2_ACF_version = "latest"
            self.logger.warning("Ph2_ACF_version parameter not found. Using latest")
            
        self.IV_scanType = configDict.get(("IVScan","scanType"),"NOKEY")
        if self.IV_scanType == "NOKEY":
            self.IV_scanType = "before_encapsulation"
            self.logger.warning("IV_scanType parameter not found. Using before_encapsulation")
            
        self.IV_delay = configDict.get(("IVScan","delay"),"NOKEY")
        if self.IV_delay == "NOKEY":
            self.IV_delay = "5.0"
            self.logger.warning("IV_delay parameter not found. Using 5.0")
            
        self.IV_settlingTime = configDict.get(("IVScan","settlingTime"),"NOKEY")
        if self.IV_settlingTime == "NOKEY":
            self.IV_settlingTime = "0.5"
            self.logger.warning("IV_settlingTime parameter not found. Using 0.5")
            
        
        self.logger.info("Worker class initialized")
        self.last_op_ok= True
        
        
    #################################################################
    ## Basic functions. directly called from "Test Operation tab"
    #################################################################
    
    ## Function to send a cmd string to the Julabo interface
    # implemented as a is a Pyqt slot
    # NOT executed if:
    # - TCP socket is not connected and connection attempt fails
    # Control on cmd execution: none
    @pyqtSlot(str)
    def SendJulaboCmd(self,cmd):
        self.Julabo.lock.acquire()
        self.logger.info("Sending Julabo cmd "+cmd)
        if not self.Julabo.is_connected :
            self.Julabo.connect()
        if self.Julabo.is_connected :
            self.Julabo.sendTCP(cmd)
            self.logger.info(self.Julabo.receive())
        else:    
            self.last_op_ok= False    
        self.Julabo.lock.release()
        
    ## Function to send a cmd string to the CAEN controller interface
    # implemented as a is a Pyqt slot
    # NOT executed if:
    # - TCP socket is not connected and connection attempt fails    
    # Control on cmd execution: none
    @pyqtSlot(str)
    def SendCAENControllerCmd(self,cmd):
        self.CAENController.lock.acquire()
        self.logger.info("Sending CAENController cmd "+cmd)
        if not self.CAENController.is_connected :
            self.CAENController.connect()
        if self.CAENController.is_connected :
            self.CAENController.sendTCP(cmd)
            time.sleep(CAEN_SLEEP_AFTER_TCP)
            self.logger.info(self.CAENController.receive())
            self.CAENController.close()
        else:    
            self.last_op_ok= False    
        self.CAENController.lock.release()
    

    ## Function to send a cmd string to the Julabo interface
    # implemented as a is a Pyqt slot
    # NOT executed if:
    # - TCP socket is not connected and connection attempt fails    
    # Control on cmd execution: none
    @pyqtSlot(str)
    def SendFNALBoxCmd(self,cmd):
        self.logger.info("WORKER: Requesting lock on FNALBox")
        self.FNALBox.lock.acquire()
        self.logger.info("Sending FNALBox cmd "+cmd)
        if not self.FNALBox.is_connected :
            self.FNALBox.connect()
        if self.FNALBox.is_connected :
            self.FNALBox.sendTCP(cmd)
            time.sleep(FNAL_SLEEP_AFTER_TCP)
            self.logger.info(self.FNALBox.receive())
        else:    
            self.last_op_ok= False    
        self.FNALBox.lock.release()
        self.logger.info("WORKER: lock on FNALBox released")
        
    ## Function to start a test
    # implemented as a is a Pyqt slot
    @pyqtSlot(str)
    def SendModuleTestCmd(self,cmd):
        self.logger.info("Starting custom shell command...")
        cmdSplit = cmd.split()
        
        try:
            proc = subprocess.Popen(cmdSplit, cwd=self.BIcwd,stdout=subprocess.PIPE, stderr=subprocess.STDOUT)                        
                    
            while(proc.returncode==None):
            
                try:
                    outs, errs = proc.communicate(timeout=TEST_PROCESS_SLEEP)
                    self.logger.info("Custom command output: "+outs.decode())
                    #self.logger.error("BI TEST SUBPROCESS: "+errs.decode())
                    break
                except subprocess.TimeoutExpired:
                    self.logger.info("WORKER: Waiting command completion....")
                    
                if proc.returncode ==0:
                    self.logger.info("Command executed with return code "+str(proc.returncode))
                elif proc.returncode==None:
                    self.logger.info("Command executed with return code NONE")
                else:
                    self.logger.error("Command failed with return code "+str(proc.returncode))
                        
        except Exception as e:
            self.logger.error("Erro while executing custom command")
            self.logger.error(e)
                            
        
        
    ###########################################################################
    ## Safe operation functions. Directly called from "Manual Operation tab"
    ###########################################################################
    
    ## Function to select the SetPoint of the Julabo
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - JULABO and FNAL info are not updated    
    # - JULABO is ON and the selected setpoint has a target temperature below the DewPoint
    # - TCP socket is not connected and connection attempt fails    
    # Control on cmd execution: read back from instrument
    @pyqtSlot(int)    
    def Ctrl_SelSp_Cmd(self,Sp_id, PopUp=True):
        self.last_op_ok= True
        self.logger.info("WORKER: Selecting JULABO Sp"+str(Sp_id+1))
        if not (self.SharedDict["Julabo_updated"] and self.SharedDict["FNALBox_updated"]):
            Warning_str = "Operation can't be performed"
            Reason_str = "Julabo and/or FNAL box info are not updated"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return
            
        if (self.SharedDict["Ctrl_StatusJulabo"].text().find("START") != -1):
            targetT = -100.0
            if Sp_id == 0 :
                targetT = float(self.SharedDict["Ctrl_Sp1"].text())

            if targetT  < float(self.SharedDict["Ctrl_IntDewPoint"].text()):
                Warning_str = "Operation can't be performed"
                Reason_str = "Set point is configured with a temperature below internal dew point"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
        self.Julabo.lock.acquire()
        self.logger.debug("WORKER: Sending Julabo cmd" )
        if not self.Julabo.is_connected :
            self.Julabo.connect()
        if self.Julabo.is_connected :
            try:
                self.Julabo.sendTCP("out_mode_01 "+str(Sp_id))
                self.logger.info("WORKER: JULABO cmd sent")
                self.Julabo.sendTCP("in_mode_01")
                reply = self.Julabo.receive()
                if (reply != "None" and reply != "TCP error"):
                    Sp = str(int(reply.replace(" ", ""))+1)
                    self.SharedDict["Ctrl_TSp"].setText(Sp)
                if self.SharedDict["Ctrl_TSp"].text()[:1]=="1":
                    self.SharedDict["Ctrl_TargetTemp"].setText(self.SharedDict["Ctrl_Sp1"].text())

            except Exception as e:
                self.logger.error(e)
                self.last_op_ok= False
        else:
                Warning_str = "Operation can't be performed"
                Reason_str = "Can't connect to JULABO"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
        
        self.Julabo.lock.release()
            
    ## Function to select the target temperature of a JULABO SetPoint
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - JULABO and FNAL info are not updated    
    # - JULABO is ON and the selected setpoint has a target temperature below the DewPoint
    # - TCP socket is not connected and connection attempt fails    
    # Control on cmd execution: read back from instrument    
    @pyqtSlot(int,float)    
    def Ctrl_SetSp_Cmd(self,Sp_id,value, PopUp=True):
        self.last_op_ok= True
        self.logger.info("WORKER: Setting JULABO Sp"+str(Sp_id+1)+ " to " +str(value))
        if not (self.SharedDict["Julabo_updated"] and self.SharedDict["FNALBox_updated"]):
            Warning_str = "Operation can't be performed"
            Reason_str = "Julabo and/or FNAL box info are not updated"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return    
        if (self.SharedDict["Ctrl_StatusJulabo"].text().find("START") != -1):
            Sp_actual = int(self.SharedDict["Ctrl_TSp"].text())-1
            if Sp_actual==Sp_id and  value  < float(self.SharedDict["Ctrl_IntDewPoint"].text()):
                Warning_str = "Operation can't be performed"
                Reason_str = "Attempting to set target temperature of the active set point below internal dew point"
                self.logger.warning(Warning_str)
                self.logger.warning(Reason_str)
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
        self.Julabo.lock.acquire()
        self.logger.debug("WORKER: Sending Julabo cmd" )
        if not self.Julabo.is_connected :
            self.Julabo.connect()
        if self.Julabo.is_connected :
            try:
                self.Julabo.sendTCP("out_sp_0"+str(Sp_id)+" "+str(value))
                self.logger.info("WORKER: JULABO cmd sent")                    
                self.Julabo.sendTCP("in_sp_0"+str(Sp_id))
                reply = self.Julabo.receive()
                if (reply != "None" and reply != "TCP error"):
                    self.SharedDict["Ctrl_Sp"+str(Sp_id+1)].setText(reply.replace(" ", ""))
                if self.SharedDict["Ctrl_TSp"].text()[:1]=="1":
                    self.SharedDict["Ctrl_TargetTemp"].setText(self.SharedDict["Ctrl_Sp1"].text())

            except Exception as e:
                self.logger.error(e)
                self.last_op_ok= False    
        else:
            
                Warning_str = "Operation can't be performed"
                Reason_str = "Can't connect to JULABO"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
        self.Julabo.lock.release()

    ## Function to power ON/OFF the JULABO
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - POWERING ON with JULABO and FNAL info are not updated    
    # - POWERING ON with target temp below DewPoint    
    # - POWERING ON with door not locked    
    # - POWERING ON with door not closed
    # - POWERING OFF with LV ON    
    # - TCP socket is not connected and connection attempt fails
    # Control on cmd execution: read back from instrument            
    @pyqtSlot(bool)    
    def Ctrl_PowerJulabo_Cmd(self,switch, PopUp=True):
        self.last_op_ok= True
        
        if not switch:  # power off
            self.logger.info("WORKER: Powering Julabo OFF")
            if self.SharedDict["LV_on"]:
                Warning_str = "Operation can't be performed"
                Reason_str = "At least one LV channel status is ON"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
                
            self.Julabo.lock.acquire()
            self.logger.debug("WORKER: Sending Julabo cmd" )
            if not self.Julabo.is_connected :
                self.Julabo.connect()
            if self.Julabo.is_connected :
                try:
                    self.Julabo.sendTCP("out_mode_05 0")
                    self.logger.info("WORKER: JULABO cmd sent")
                    self.Julabo.sendTCP("status")
                    reply = self.Julabo.receive()
                    if (reply != "None" and reply != "TCP error"):
                        self.SharedDict["Ctrl_StatusJulabo"].setText(reply)
                    if self.SharedDict["Ctrl_StatusJulabo"].text().find("START")!=-1:
                        self.SharedDict["Ctrl_StatusJulabo"].setStyleSheet("color: rgb(0, 170, 0);font: 9pt ");
                    else:
                        self.SharedDict["Ctrl_StatusJulabo"].setStyleSheet("color: rgb(255, 0, 0);font: 9pt ");
                except Exception as e:
                    self.logger.error(e)
                    self.last_op_ok= False    
                        
            self.Julabo.lock.release()
        else:    
            self.logger.info("WORKER: Powering Julabo ON")
            if not (self.SharedDict["Julabo_updated"] and self.SharedDict["FNALBox_updated"]):
                Warning_str = "Operation can't be performed"
                Reason_str = "Julabo and/or FNAL box info are not updated"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
            if float(self.SharedDict["Ctrl_TargetTemp"].text())< float(self.SharedDict["Ctrl_IntDewPoint"].text()):
                Warning_str = "Operation can't be performed"
                Reason_str = "Attempting to start unit with target temperature below internal dew point"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
            if self.SharedDict["Ctrl_StatusLock"].text() != "LOCKED":
                Warning_str = "Operation can't be performed"
                Reason_str = "Attempting to start unit with door magnet not locked"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
            if not (self.SharedDict["Ctrl_StatusDoor"].text() == "CLOSED"):
                Warning_str = "Operation can't be performed"
                Reason_str = "BurnIn door is NOT CLOSED"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
                
            self.Julabo.lock.acquire()
            self.logger.debug("WORKER: Sending Julabo cmd" )
            if not self.Julabo.is_connected :
                self.Julabo.connect()
            if self.Julabo.is_connected :
                try:
                    self.Julabo.sendTCP("out_mode_05 1")
                    self.logger.info("WORKER: JULABO cmd sent")
                    self.Julabo.sendTCP("status")
                    reply = self.Julabo.receive()
                    if (reply != "None" and reply != "TCP error"):
                        self.SharedDict["Ctrl_StatusJulabo"].setText(reply)
                    if self.SharedDict["Ctrl_StatusJulabo"].text().find("START")!=-1:
                        self.SharedDict["Ctrl_StatusJulabo"].setStyleSheet("color: rgb(0, 170, 0);font: 9pt ");
                    else:
                        self.SharedDict["Ctrl_StatusJulabo"].setStyleSheet("color: rgb(255, 0, 0);font: 9pt ");
                except Exception as e:
                    self.logger.error(e)
                    self.last_op_ok= False    
            
            else:
            
                Warning_str = "Operation can't be performed"
                Reason_str = "Can't connect to JULABO"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
            self.Julabo.lock.release()
                    
                    

                    
    ## Function to lock/unlock the door (magnet)
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - UNLOCK with JULABO/FNAL/M5 info not updated    
    # - UNLOCK with minimal internal temp below EXTERNAL DewPoint
    # - UNLOCK with JULABO ON and taget temp below external dewpoint
    # - status of at least one defined HV channels is ON or UNKNOWN
    # - TCP socket is not connected and connection attempt fails    
    # Control on cmd execution: reply check from FNAL Box    
    @pyqtSlot(bool)    
    def Ctrl_SetLock_Cmd(self,switch, PopUp=True):
        self.last_op_ok= True
        
        lock = "LOCKED" if switch else "UNLOCK"
        cmd = "[5011]" if switch else "[5010]"

        self.logger.info("WORKER: Setting door magnet to: "+lock)
        if (not switch):
            
            if not (self.SharedDict["Julabo_updated"] and self.SharedDict["FNALBox_updated"] and self.SharedDict["M5_updated"]):
                Warning_str = "Operation can't be performed"
                Reason_str = "Julabo, FNAL box or M5 infos are not updated"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
            if (self.SharedDict["Ctrl_StatusJulabo"].text().find("START")!=-1) and (float(self.SharedDict["Ctrl_TargetTemp"].text()) < float(self.SharedDict["Ctrl_ExtDewPoint"].text())):
                Warning_str = "Operation can't be performed"
                Reason_str = "JULABO is ON with target temp below external dew point"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
            if self.SharedDict["Ctrl_LowerTemp"] < float(self.SharedDict["Ctrl_ExtDewPoint"].text()):
                Warning_str = "Operation can't be performed"
                Reason_str = "Internal minimum temperature below external dew point. Retry later"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
            if self.SharedDict["HV_on"]:
                Warning_str = "Operation can't be performed"
                Reason_str = "At least one HV channel status is ON"
                if PopUp:
                    self.Request_msg.emit(Warning_str,Reason_str)
                self.last_op_ok= False
                return
                
        self.FNALBox.lock.acquire()
        self.logger.debug("WORKER: Sending FNAL Box cmd" )
        if not self.FNALBox.is_connected :
            self.FNALBox.connect()
        if self.FNALBox.is_connected :
            try:
                self.FNALBox.sendTCP(cmd)
                self.logger.info("WORKER: FNAL Box cmd sent: " + cmd)
                time.sleep(FNAL_SLEEP_AFTER_TCP)
                reply = self.FNALBox.receive()
                if reply[-3:]=="[*]":
                    self.SharedDict["Ctrl_StatusLock"].setText(lock)
                    self.logger.info("WORKER: Done")
                else:
                    self.SharedDict["Ctrl_StatusLock"].setText("?")
                    self.logger.error("WORKER: uncorrect reply from FNAL Box: "+reply)
                    self.last_op_ok= False

            except Exception as e:
                self.logger.error(e)
                self.SharedDict["Ctrl_StatusLock"].setText("?")    
                self.last_op_ok= False
        
        else:
            Warning_str = "Operation can't be performed"
            Reason_str = "Can't connect to FNAL box"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False            
        self.FNALBox.lock.release()
        
    ## Function to select LOW/HIGH dry air flow
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - TCP socket is not connected and connection attempt fails    
    # Control on cmd execution: reply check from FNAL Box        
    @pyqtSlot(bool)    
    def Ctrl_SetHighFlow_Cmd(self,switch, PopUp=True):
        self.last_op_ok= True
        
        flow = "HIGH" if switch else "LOW"
        cmd = "[5021]" if switch else "[5020]"

        self.logger.info("WORKER: Switching dry air flow to "+flow)
        self.FNALBox.lock.acquire()
        self.logger.debug("WORKER: Sending FNAL Box cmd" )
        if not self.FNALBox.is_connected :
            self.FNALBox.connect()
        if self.FNALBox.is_connected :
            try:
                self.FNALBox.sendTCP(cmd)
                self.logger.info("WORKER: FNAL Box cmd sent: " + cmd)
                time.sleep(FNAL_SLEEP_AFTER_TCP)
                reply = self.FNALBox.receive()
                if reply[-3:]=="[*]":
                    self.SharedDict["Ctrl_StatusFlow"].setText(flow)
                    self.logger.info("WORKER: Done")
                else:
                    self.SharedDict["Ctrl_StatusFlow"].setText("?")
                    self.logger.error("WORKER: uncorrect reply from FNAL Box: "+reply)
                    self.last_op_ok= False

            except Exception as e:
                self.logger.error(e)
                self.SharedDict["Ctrl_StatusFlow"].setText("?")
                self.last_op_ok= False

        else:    
            Warning_str = "Operation can't be performed"
            Reason_str = "Can't connect to FNAL box"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False                
                    
        self.FNALBox.lock.release()
        
    ## Function to power ON/OFF individual LV channels
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - CAEN INFO are not updated
    # - POWER ON with JULABO OFF
    # - one of the slots selected by the user does not have a defined LV channel
    # - trying to switch off a slot with HV ON
    # - trying to switch off a slot with HV OFF but unknown/too high voltage
    # Control on cmd execution: none
    @pyqtSlot(bool)    
    def Ctrl_PowerLV_Cmd(self,switch,Channel_list=[], PopUp=True):
        self.last_op_ok= True
        if PopUp:
            Channel_list.clear()
        power = "On" if switch else "Off"
        if not (self.SharedDict["CAEN_updated"]):
            Warning_str = "Operation can't be performed"
            Reason_str = "CAEN infos are not updated"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return
        if switch and self.SharedDict["Ctrl_StatusJulabo"].text().find("START")==-1:
            Warning_str = "Operation can't be performed"
            Reason_str = "JULABO is not ON"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return    
        if len(Channel_list)==0:
            for row in range(NUM_BI_SLOTS):
                if self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_NAME_COL).isSelected():
                    ch_name = self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_NAME_COL).text()
                    if (ch_name == "?"):
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't turn OFF LV for slot "+str(row+1)+ " beacause LV ch. name is UNKNOWN"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    HV_defined = True if self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_NAME_COL).text() != "?" else False    
                    if (not switch) and  HV_defined and (self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text() != "OFF"):  # attempt to power down LV with HV not off
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't turn OFF LV for slot "+str(row+1)+ " beacause HV is ON or UNKNOWN"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    try:
                        HV_value = float(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_VREAD_COL).text())
                    except Exception as e:
                        self.logger.error(e)
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't turn OFF LV for slot "+str(row+1)+ " beacause HV value is invalid"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    if (not switch) and  HV_defined and (self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text() != "OFF"):  # attempt to power down LV with HV not off
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't turn OFF LV for slot "+str(row+1)+ " beacause HV is ON or UNKNOWN"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    if (not switch) and  HV_value > HV_ON_THR :  # attempt to power down LV with HV not zero (i.e. still ramping down)
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't turn OFF LV for slot "+str(row+1)+ " beacause HV value still too high"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    Channel_list.append(ch_name)
                    self.BI_Update_PowerStatus_sig.emit(row,True,power)#isLV=True means LV
                    print("Updating", row, power)
                
        self.logger.info("WORKER: Setting LV "+power+ " for ch " +str(Channel_list))
        for channel in Channel_list:
            self.SendCAENControllerCmd("Turn"+power+",PowerSupplyId:caen,ChannelId:"+channel)    
            
    ## Function to power ON/OFF individual HV channels
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - CAEN INFO are not updated
    # - POWER ON with door not CLOSED
    # - one of the slots selected by the user does not have a defined HV channel
    # - trying to switch on a slot with LV OFF
    # Control on cmd execution: none
    @pyqtSlot(bool)    
    def Ctrl_PowerHV_Cmd(self,switch,Channel_list=[],PopUp=True):
        self.last_op_ok= True
        if PopUp:
            Channel_list.clear()
        power = "On" if switch else "Off"
        if not (self.SharedDict["CAEN_updated"] and self.SharedDict["FNALBox_updated"]):
            Warning_str = "Operation can't be performed"
            Reason_str = "CAEN and/or FNAL infos are not updated"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return
        if switch and (not (self.SharedDict["Ctrl_StatusDoor"].text() == "CLOSED")):
            Warning_str = "Operation can't be performed"
            Reason_str = "BurnIn door is NOT CLOSED"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return
        
        if len(Channel_list)==0:
            for row in range(NUM_BI_SLOTS):
                if self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_NAME_COL).isSelected():
                    ch_name = self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_NAME_COL).text() 
                    if (ch_name == "?"):
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't turn OFF HV for slot "+str(row+1)+ " beacause HV ch. name is UNKNOWN"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    if (switch) and (self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_STAT_COL).text() != "ON"):  # attempt to power up HV with LV not on
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't turn OFF HV for slot "+str(row+1)+ " beacause LV is OFF or UNKNOWN"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    Channel_list.append(ch_name)
                    self.BI_Update_PowerStatus_sig.emit(row,False,power)#isLV=False means HV
                
        self.logger.info("WORKER: Setting HV "+power+ " for ch " +str(Channel_list))
        for channel in Channel_list:
            self.SendCAENControllerCmd("Turn"+power+",PowerSupplyId:caen,ChannelId:"+channel)
    
    ## Function to set indicidual LV/HV channels
    # implemented as a is a Pyqt slot
    # NOT Executed if:
    # - CAEN INFO are not updated
    # - POWER ON with door not CLOSED
    # - one of the slots selected by the user does not have a defined LV/HV setpoint
    # Control on cmd execution: none
    @pyqtSlot(str)    
    def Ctrl_VSet_Cmd(self,VType,Channel_list=[],NewValue_list=[], PopUp=True):
        self.last_op_ok= True
        if PopUp:
            Channel_list.clear()
            NewValue_list.clear()
    
        if VType != "LV" and VType != "HV":
            self.logger.error("WORKER: Received unknow Voltage type string ")
            return
            
        ColOffset = CTRLTABLE_LV_NAME_COL if VType=="LV" else CTRLTABLE_HV_NAME_COL;
        if not (self.SharedDict["CAEN_updated"]):
            Warning_str = "Operation can't be performed"
            Reason_str = "CAEN infos are not updated"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return
        if len(Channel_list) != len(NewValue_list):
            Warning_str = "Operation can't be performed"
            Reason_str = "Provided ch list and value list doesn not match in length"
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            self.last_op_ok= False
            return
            
        if len(Channel_list)==0:
            for row in range(NUM_BI_SLOTS):
                if self.SharedDict["CAEN_table"].item(row,ColOffset).isSelected():
                    ch_name = self.SharedDict["CAEN_table"].item(row,ColOffset).text() 
                    if (ch_name == "?"):
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't set LV for  slot "+str(row+1)+ " beacause LV ch. name is UNKNOWN"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    if (self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_VSET_COL+ColOffset).text() == "?"): 
                        Warning_str = "Operation can't be performed"
                        Reason_str = "Can't set LV/HV for  slot "+str(row+1)+ " beacause current setpoint is UNKNOWN"
                        if PopUp:
                            self.Request_msg.emit(Warning_str,Reason_str)
                        self.last_op_ok= False
                        return
                    self.SharedDict["WaitInput"]=True
                    Request_str="New " +VType+ " Slot "+str(row+1)
                    ValueNow = 0.0
                    try :
                        ValueNow = float(self.SharedDict["CAEN_table"].item(row,2+ColOffset).text())
                    except Exception as e:
                        self.logger.error(e)
                        
                    if VType == "LV":
                        self.Request_input_dsb.emit(Request_str,ValueNow,MIN_LV,MAX_HV)
                    else:
                        self.Request_input_dsb.emit(Request_str,ValueNow,MIN_HV,MAX_HV)
                        
                    while self.SharedDict["WaitInput"]:
                        time.sleep(0.1)
                    if self.SharedDict["Input"]!=-1:
                        NewValue_list.append(self.SharedDict["Input"])
                        Channel_list.append(ch_name)
        
        self.logger.info("WORKER: Setting LV for ch " +str(Channel_list))
        self.logger.info("WORKER: New values: " +str(NewValue_list))
        for idx,channel in enumerate(Channel_list):
            self.SendCAENControllerCmd("SetVoltage,PowerSupplyId:caen,ChannelId:"+channel+",Voltage:"+str(NewValue_list[idx]))





    ###########################################################################
    ## BI main function and related
    ###########################################################################
    
    #Check IDs failure
    def BI_CheckIDs_failed_terminate(self, Reason_str):
        self.logger.error("WORKER: Check IDs procedure failed. "+Reason_str)
        self.SharedDict["BI_Status"].setText("Failed CheckIDs")
        self.SharedDict["BI_Action"].setText("None")
        self.BI_terminated.emit()
        return False
        
    ## CheckIDs function
    # implemented as a Pyqt slot
    @pyqtSlot()            
    def BI_CheckIDs_Cmd(self):
    
        self.SharedDict["BI_Status"].setText("CheckIDs Setup")
        self.SharedDict["BI_Action"].setText("Setup")
        
        session_dict={}
        
        session_dict["ActiveSlots"]         = self.SharedDict["BI_ActiveSlots"]
        session_dict["ModuleIDs"]           = self.SharedDict["BI_ModuleIDs"]
        session_dict["fc7ID"]               = "fc7ot2"
        session_dict["Current_ModuleID"]    = "unknown"
        session_dict["fc7Slot"]             = "0"
        session_dict["TestType"]            = "readOnlyID"
        
        #checking sub-system information
            
        if not (self.SharedDict["CAEN_updated"] and self.SharedDict["FNALBox_updated"] and self.SharedDict["Julabo_updated"]):
            return self.BI_CheckIDs_failed_terminate("JULABO/CAEN/FNAL info are not updated.")
        if not (self.SharedDict["Ctrl_StatusDoor"].text() == "CLOSED"):
            return self.BI_CheckIDs_failed_terminate("Door is not closed.")
        self.logger.info("BurnIn CheckIDs started...")
        
        #selecting slots under test : LV/HV names defined && slot marked as active in BI tab
        
        LV_Channel_list=[]
        HV_Channel_list=[]
        Slot_list=[]
        
        for row in range(NUM_BI_SLOTS):
            LV_ch_name = self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_NAME_COL).text()
            HV_ch_name = self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_NAME_COL).text() 
            if (LV_ch_name != "?" and HV_ch_name != "?" and session_dict["ActiveSlots"][row]):
                LV_Channel_list.append(LV_ch_name)
                HV_Channel_list.append(HV_ch_name)
                Slot_list.append(row)
        
        if len(Slot_list)==0:
            return self.BI_CheckIDs_failed_terminate("Please enable at least one slot.")
        
        self.logger.info("BurnIn CheckIDs active slots: "+str(Slot_list))
        self.logger.info("BurnIn CheckIDs HV names: "+str(HV_Channel_list))
        self.logger.info("BurnIn CheckIDs LV names: "+str(LV_Channel_list))               
        
        PopUp=False
        
        #lock magnet
        self.Ctrl_SetLock_Cmd(True,PopUp)
        if not self.last_op_ok:
            return self.BI_CheckIDs_failed_terminate("Failed to lock door.")
            
        #sel SP
        self.Ctrl_SelSp_Cmd(0,PopUp)
        if not self.last_op_ok:
            return self.BI_CheckIDs_failed_terminate("Can't select Julabo SP.")
        
        #put JULABO to 20 degree    
        self.Ctrl_SetSp_Cmd(0,20.,PopUp)
        if not self.last_op_ok:
            return self.BI_CheckIDs_failed_terminate("Can't set Julabo temperature.")
                
        #start JULABO    
        self.Ctrl_PowerJulabo_Cmd(True,PopUp)
        if not self.last_op_ok:
            return self.BI_CheckIDs_failed_terminate("Can't power ON Julabo.")
        
        ##start LV
        self.SharedDict["BI_Action"].setText("Start LVs")
        self.BI_Update_PowerStatus_sig.emit(-2,True,"ON_dummy")#isLV=True means LV,slot=-2 means all, but command only started
        self.Ctrl_PowerLV_Cmd(True,LV_Channel_list,PopUp)
        if not self.last_op_ok:
            return self.BI_CheckIDs_failed_terminate("Can't start LVs.")

        #wait a bit then check all LVs are ON
        time.sleep(BI_SLEEP_AFTER_LVSET)
        for row in Slot_list:
            if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_STAT_COL).text()!="ON"):
                return self.BI_CheckIDs_failed_terminate("LVs check failed.")
        self.BI_Update_PowerStatus_sig.emit(-1,True,"ON_dummy")#isLV=True means LV,slot=-1 means all, update GUI-side  

        #Do *not* turn on HVs
        
        ##checking IDS
        self.SharedDict["BI_Status"].setText("CheckingIDs")
        self.SharedDict["BI_Action"].setText("Testing")
        for slot in Slot_list:
            self.SharedDict["BI_SUT"].setText(str(slot+1))
            session_dict["fc7ID"]=self.SharedDict["BI_fc7IDs"][slot]
            session_dict["fc7Slot"]=self.SharedDict["BI_fc7Slots"][slot]
            session_dict["Current_ModuleID"]    = self.SharedDict["BI_ModuleIDs"][slot]
            self.logger.info("BI: Checking ID for BI slot "+str(slot)+": module name "+session_dict["Current_ModuleID"]+", fc7 slot "+session_dict["fc7Slot"]+",board "+session_dict["fc7ID"])
            self.BI_CheckID_isOK_sig.emit(slot,0)#0 means we just started testing
            self.BI_StartTest_Cmd(session_dict)
            if not self.last_op_ok:
                self.SharedDict["BI_Status"].setText("Failed CheckIDs")
                #let's comment these for now and continue testing even if the label is wrong
                #self.SharedDict["BI_Action"].setText("None")
                #self.SharedDict["BI_SUT"].setText("None")
                self.logger.error("WORKER: Check IDs procedure failed. Error returned while checking slot "+str(slot+1))
                self.BI_CheckID_isOK_sig.emit(slot,2)#2 means failure
                #self.BI_terminated.emit()
                #return
            else:
                self.BI_CheckID_isOK_sig.emit(slot,1)#1 means success
        
        self.SharedDict["BI_SUT"].setText("None")
        self.SharedDict["BI_Status"].setText("CheckIDs stopping")
        
        #verify that HVs are off before turning off LVs
        found_HV_ON = False
        for row in Slot_list:
            if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text()!="OFF"):
                found_HV_ON = True
                self.logger.info("WORKER: Slot " + " HV is on after CheckID for some reason. Turning off.")
        if found_HV_ON:
            self.BI_Update_PowerStatus_sig.emit(-2,False,"OFF_dummy")#isLV=False means HV,slot=-2 means all, but command only started   
            self.SharedDict["BI_Action"].setText("Stop HVs")
            self.Ctrl_PowerHV_Cmd(False,HV_Channel_list,PopUp)
            if not self.last_op_ok:
                 return self.BI_CheckIDs_failed_terminate("Can't stop HVs.")
            time.sleep(BI_SLEEP_AFTER_HVSET)
            #check HV stop
            for row in Slot_list:
                if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text()!="OFF"):
                    return self.BI_CheckIDs_failed_terminate("Found HVs ON after CheckID and failed to turn them off.")
            self.BI_Update_PowerStatus_sig.emit(-1,False,"OFF_dummy")#isLV=False means HV,slot=-1 means all, but command only started   
                
        #stop LV
        self.SharedDict["BI_Action"].setText("Stop LVs")
        self.BI_Update_PowerStatus_sig.emit(-2,True,"OFF_dummy")#isLV=True means LV,slot=-2 means all, but command only started
        self.Ctrl_PowerLV_Cmd(False,LV_Channel_list,PopUp)
        if not self.last_op_ok:
            return self.BI_CheckIDs_failed_terminate("Can't stop LVs.")
        time.sleep(BI_SLEEP_AFTER_LVSET)
        #check LV stop    
        for row in Slot_list:
            if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_STAT_COL).text()!="OFF"):
                return self.BI_CheckIDs_failed_terminate("LVs check failed.")
            
        self.BI_Update_PowerStatus_sig.emit(-1,True,"OFF_dummy")#isLV=True means LV,slot=-1 means all, update GUI-side
        
        self.SharedDict["BI_Action"].setText("None")
        self.SharedDict["BI_Status"].setText("Idle")
                
        self.logger.info("BurnIn CheckIDs COMPLETED SUCCESFULLY!")
        self.BI_terminated.emit()
        
    ## BI main function
    # implemented as a is a Pyqt slot
    @pyqtSlot()            
    def BI_Start_Cmd(self):
    
        stepAllowed = ["COOL","HEAT","LV_ON","LV_OFF","HV_ON","HV_OFF","SCANIV"]#WAIT and DAQ are treated separately
        self.SharedDict["BI_Active"]=True
        self.logger.info("Starting BurnIN...")
        
        #creating parameter dictionary for the current session
        session_dict={}
        session_dict["Step"]             = 1
        session_dict["StepList"]         = self.SharedDict["StepList"]
        session_dict["Action"]           = "Undef"
        session_dict["Cycle"]            = 0
        session_dict["Status"]           = "Setup"
        session_dict["LowTemp"]          = self.SharedDict["BI_LowTemp"]
        session_dict["LowRamp"]          = self.SharedDict["BI_LowRamp"]
        session_dict["LowKeep"]          = self.SharedDict["BI_LowKeep"]
        session_dict["HighTemp"]         = self.SharedDict["BI_HighTemp"]
        session_dict["HighRamp"]         = self.SharedDict["BI_HighRamp"]
        session_dict["HighKeep"]         = self.SharedDict["BI_HighKeep"]
        session_dict["Operator"]         = self.SharedDict["BI_Operator"]
        session_dict["Description"]      = self.SharedDict["BI_Description"]
        session_dict["Session"]          = "-1"
        session_dict["ActiveSlots"]      = self.SharedDict["BI_ActiveSlots"]
        session_dict["ModuleIDs"]        = self.SharedDict["BI_ModuleIDs"]
        session_dict["TestType"]         = "Undef"
        session_dict["Timestamp"]        = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
        session_dict["CycleTimestamp"]   = "NoCycleNoTime"
        session_dict["fc7ID"]            = "Undef"
        session_dict["Current_ModuleID"] = "Undef"
        session_dict["fc7Slot"]          = "Undef"
        session_dict["Current_ModuleHV"] = "Undef"
        session_dict["Current_Slot"]     = -1
        session_dict["WorkingTemp"]      = 20

        session_dict["NCycles"] = [item.upper() for item in session_dict["StepList"]].count("COOL")    
        
        #check if file session already exists (aka a session was stopped or crashed)
        if (os.path.exists("Session.json")):
            self.logger.info("Found session file.")
            self.SharedDict["WaitInput"]=True
            self.Request_confirm_sig.emit("Resume last session?")
            while self.SharedDict["WaitInput"]:
                        time.sleep(0.1)
            if self.SharedDict["Confirmed"]:
                try:
                    with open('Session.json') as json_file:
                        session_dict={}
                        session_dict = json.load(json_file)
                        self.logger.info(session_dict)
                        #updating values in main GUI tab
                        self.BI_Update_GUI_sig.emit(session_dict)
                        self.logger.info("BI :Previous session parameters loaded")
                        self.logger.info("Current Session: "+session_dict["Session"])
                        self.logger.info("Current Thermal Cycle: "+str(session_dict["Cycle"]))
                        self.logger.info("Current Step: "+str(session_dict["Step"]))
                        self.logger.info("Current Action: "+session_dict["Action"])
                        session_dict["Status"]    = "Recovery"
                        
                        if len(session_dict["StepList"])==0:
                            self.BI_Abort("Empty cycle description")
                            return    
                        for step in self.SharedDict["StepList"]:
                            if not ((step.upper() in stepAllowed)) and (step[0:3].upper()!="DAQ") and (step[0:4].upper()!="WAIT"):
                                self.BI_Abort("Undefined step in cycle description")
                                return
                        
                except Exception as e:
                    self.logger.error(e)
                    self.logger.error("BI :Error reloading session parameters from Json file")
                    self.BI_Abort("Error while recovering session info. Please start new session")
                    return
            else:
                self.logger.info("Previous session overridden. Starting new session")
                if len(session_dict["StepList"])==0:
                    self.BI_Abort("Empty cycle description")
                    return
                for step in self.SharedDict["StepList"]:
                    if not ((step.upper() in stepAllowed)) and (step[0:3].upper()!="DAQ") and (step[0:4].upper()!="WAIT"):
                        self.BI_Abort("Undefined step in cycle description")
                        return
                self.DB_interface.StartSesh(session_dict)
                self.BI_Update_Status_file(session_dict)
                self.BI_Clear_Monitor_sig.emit()

        else:
            self.logger.info("No session file found. Starting new BurnIn session")
            if len(session_dict["StepList"])==0:
                self.BI_Abort("Empty cycle description")
                return    
            for step in self.SharedDict["StepList"]:
                if not ((step.upper() in stepAllowed)) and (step[0:3].upper()!="DAQ") and (step[0:4].upper()!="WAIT"):
                    self.BI_Abort("Undefined step in cycle description")
                    return
            self.DB_interface.StartSesh(session_dict)
            self.BI_Update_Status_file(session_dict)
            self.BI_Clear_Monitor_sig.emit()

        self.SharedDict["TestSession"]=session_dict["Session"]
        
        
        # starting setup/recovery procedure
        
        self.SharedDict["BI_Status"].setText(session_dict["Status"])
            
        self.SharedDict["BI_Action"].setText(session_dict["Action"])
        self.SharedDict["BI_Cycle"].setText(str(session_dict["Cycle"])+" of "+str(session_dict["NCycles"]))
        self.SharedDict["BI_SUT"].setText("None") 
                    
        
        #checking sub-system information
            
        if not (self.SharedDict["CAEN_updated"] and self.SharedDict["FNALBox_updated"] and self.SharedDict["Julabo_updated"]):
            self.BI_Abort("CAEN/FNAL/JULABO infos are not updated")
            return
        if not (self.SharedDict["Ctrl_StatusDoor"].text() == "CLOSED"):
            self.BI_Abort("DOOR is not closed!")
            return
        self.logger.info("BurnIn test started...")
        
        #selecting slots under test : LV/HV names defined && slot marked as active in BI tab
        
        LV_Channel_list=[]
        HV_Channel_list=[]
        Slot_list=[]
        
        for row in range(NUM_BI_SLOTS):
            LV_ch_name = self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_NAME_COL).text()
            HV_ch_name = self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_NAME_COL).text() 
            if (LV_ch_name != "?" and HV_ch_name != "?" and session_dict["ActiveSlots"][row]):
                LV_Channel_list.append(LV_ch_name)
                HV_Channel_list.append(HV_ch_name)
                Slot_list.append(row)

        
        self.logger.info("BurnIn test active slots: "+str(Slot_list))
        self.logger.info("BurnIn test HV names: "+str(HV_Channel_list))
        self.logger.info("BurnIn test LV names: "+str(LV_Channel_list))               
        
        PopUp=False
        
        #lock magnet
        if not self.BI_Action(self.Ctrl_SetLock_Cmd,True,True,PopUp):
            return
            
        #start high flow if needed
        try:
            dp = float(self.SharedDict["Ctrl_IntDewPoint"].text())
        except Exception as e:
            dp=0.0
        if dp > BI_HIGHFLOW_THRESHOLD and self.SharedDict["Ctrl_StatusFlow"].text()!="HIGH":
            if not self.BI_Action(self.Ctrl_SetHighFlow_Cmd,True, True,PopUp):
                return
            
        #sel SP    
        if not self.BI_Action(self.Ctrl_SelSp_Cmd,True,0,PopUp):
            return
                
        #start JULABO    
        if not self.BI_Action(self.Ctrl_PowerJulabo_Cmd,True,True,PopUp):
            return
        
        session_dict["Status"] = "Cycling"
        self.SharedDict["BI_Status"].setText(session_dict["Status"])

        ######cycle start
        if (session_dict["Status"]=="Recovery"):
            self.logger.info("BI: recovered from step "+session_dict["Step"]+", thermal cycle "+str(session_dict["Cycle"]) + " of "+str(session_dict["NCycles"]))
        
        while session_dict["Step"]-1 < len(session_dict["StepList"]):
        
            session_dict["Action"]=session_dict["StepList"][session_dict["Step"]-1]
            self.SharedDict["BI_Step"].setText(str(session_dict["Step"])+" of "+str(len(session_dict["StepList"])))
            
            if (session_dict["Action"].upper()=="COOL"):
                self.logger.info("BI: ramping down...")
                self.SharedDict["BI_Action"].setText("Cooling")
                self.SharedDict["BI_SUT"].setText("None")
                session_dict["WorkingTemp"] = session_dict["LowTemp"]
                # upload a new BI cycle to DB
                session_dict["Cycle"]          = session_dict["Cycle"]+1
                session_dict["CycleTimestamp"] = datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
                self.logger.info("BI: thermal cycle "+str(session_dict["Cycle"]-1) + " of "+str(session_dict["NCycles"]))
                self.SharedDict["BI_Cycle"].setText(str(session_dict["Cycle"]-1)+" of "+str(session_dict["NCycles"]))
                self.DB_interface.StartCycle(session_dict) #pass the cycle start time, not the burnin timestamp
                #
                self.BI_Update_Status_file(session_dict)
                if float(self.SharedDict["LastFNALBoxTemp0"].text()) > session_dict["LowTemp"]:  #expected
                    self.logger.info("BI: cooling")
                else:
                    self.logger.info('BI: "cooling" to a higher temperature')
                if not self.BI_Action(self.BI_GoLowTemp,True,session_dict,session_dict["LowTemp"]):
                    return

                    
            if (session_dict["Action"].upper()=="HEAT"):
                self.logger.info("BI: going to high temp")
                self.SharedDict["BI_Action"].setText("Heating")
                self.SharedDict["BI_SUT"].setText("None") 
                session_dict["WorkingTemp"]=session_dict["HighTemp"]
                self.BI_Update_Status_file(session_dict)
                if float(self.SharedDict["LastFNALBoxTemp0"].text()) < session_dict["HighTemp"]:  #expected
                    self.logger.info("BI: heating")
                else:
                    self.logger.info('BI: "heating" to a lower temperature')
                if not self.BI_Action(self.BI_GoHighTemp,True,session_dict,session_dict["HighTemp"]):
                    return

                
            if (session_dict["Action"].upper()[0:3]=="DAQ"):
                self.logger.info("BI: testing...")
                self.SharedDict["BI_Action"].setText(session_dict["Action"][4:]+"  Module test")
                self.SharedDict["BI_TestActive"]=True
                session_dict["TestType"]=session_dict["Action"][4:]
                # Determine starting slot index for recovery
                start_slot_index = 0
                if session_dict["Current_Slot"] >= 0 and session_dict["Current_Slot"] in Slot_list:
                    # Resume from the last tested slot (skip already completed modules)
                    start_slot_index = Slot_list.index(session_dict["Current_Slot"])
                    self.logger.info("BI: Resuming module testing from slot index %d (slot %d)" % (start_slot_index, Slot_list[start_slot_index] if start_slot_index < len(Slot_list) else -1))
                for slot_index in range(start_slot_index, len(Slot_list)):
                    slot = Slot_list[slot_index]
                    session_dict["fc7ID"]=self.SharedDict["BI_fc7IDs"][slot]
                    session_dict["fc7Slot"]=self.SharedDict["BI_fc7Slots"][slot]
                    session_dict["Current_ModuleID"]    = self.SharedDict["BI_ModuleIDs"][slot]
                    session_dict["Current_Slot"] = slot
                    self.BI_Update_Status_file(session_dict)
                    self.SharedDict["BI_SUT"].setText(str(slot+1)) 
                    self.logger.info("BI: testing BI slot "+str(slot)+": module name "+session_dict["Current_ModuleID"]+", fc7 slot "+session_dict["fc7Slot"]+",board "+session_dict["fc7ID"])
                    self.BI_CheckID_isOK_sig.emit(slot,0)#0 means we just started testing
                    if not self.BI_Action(self.BI_StartTest_Cmd,False,session_dict):
                        return
                    if self.last_op_ok:
                        self.BI_CheckID_isOK_sig.emit(slot,1)#1 means success
                    else:
                        self.BI_CheckID_isOK_sig.emit(slot,2)#2 means failure
                     #   if (self.SharedDict["ModuleFailures"][slot] >= BI_ACTION_FAILURE_EXCLUDE): #too many failures
                     #       Slot_list.remove(slot)
                        
                        
                self.SharedDict["BI_TestActive"]=False
                session_dict["TestType"]="Undef"
                session_dict["Current_Slot"]=-1  # Reset after completing all modules in this step

            if (session_dict["Action"].upper()[0:4]=="WAIT"):
                try:
                    #acquire wait time (check if the syntax is bad and cast to int)
                    wait_time = int(session_dict["Action"][5:])
                except Exception as e:
                    self.logger.error(e)
                    self.last_op_ok= False
                    return
                self.logger.info(f"BI: waiting {wait_time} seconds.") #FT:add a a progress bar
                self.SharedDict["BI_Action"].setText(session_dict["Action"])
                self.SharedDict["BI_TestActive"]=True
                for i in range(wait_time):#We do it like this so it is possible to interrupt the process
                    if self.SharedDict["BI_StopRequest"]:
                        self.logger.error(f"WORKER: Aborting {wait_time} seconds wait on external request")
                        self.last_op_ok= False
                        break
                    else:
                        time.sleep(1)
                self.SharedDict["BI_TestActive"]=False
                
            if (session_dict["Action"].upper()=="SCANIV"):
                self.logger.info("BI: IV scan...")
                self.SharedDict["BI_Action"].setText("IV scan")
                self.SharedDict["BI_TestActive"]=True
                self.BI_Update_Status_file(session_dict)
                self.SharedDict["BI_SUT"].setText("All selected slots") 
                self.logger.info("BI: IV scans for all selected modules")
                Name_list = []
                for slot in Slot_list:
                    self.BI_CheckID_isOK_sig.emit(slot,0)#0 means we just started testing
                    Name_list.append(self.SharedDict["BI_ModuleIDs"][slot])
                    self.BI_Update_PowerStatus_sig.emit(slot,False,"SCAN")#isLV=False means HV
                #Launching parallel IV Scan
                if not self.BI_Action(self.BI_StartIV_Cmd,False,session_dict,Name_list,HV_Channel_list):
                    return
                for slot in Slot_list:#This currently marks all scans as failed unless all succeed
                    if self.last_op_ok:
                        self.BI_CheckID_isOK_sig.emit(slot,1)#1 means success
                    else:
                        self.BI_CheckID_isOK_sig.emit(slot,2)#2 means failure
                self.BI_Update_PowerStatus_sig.emit(-1,False,"scan")#isLV=False means HV, slot=-1 means all, update GUI-side
                self.SharedDict["BI_TestActive"]=False
                        
            if (session_dict["Action"].upper()=="LV_ON"):
                self.logger.info("BI: Starting LVs")
                self.SharedDict["BI_Action"].setText("Starting LVs")
                self.SharedDict["BI_SUT"].setText("None") 
                self.BI_Update_Status_file(session_dict)
                self.BI_Update_PowerStatus_sig.emit(-2,True,"ON_dummy")#isLV=True means LV,slot=-2 means all, but command only started
                if not self.BI_Action(self.Ctrl_PowerLV_Cmd,True,True,LV_Channel_list,PopUp):
                    return
                time.sleep(BI_SLEEP_AFTER_LVSET)
                #check all LVs are ON
                for row in Slot_list:
                    if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_STAT_COL).text()!="ON"):
                        self.BI_Abort("BI aborted: some LVs was not turned ON")
                        return
                self.BI_Update_PowerStatus_sig.emit(-1,True,"ON_dummy")#isLV=True means LV,slot=-1 means all, update GUI-side
            
                        
            if (session_dict["Action"].upper()=="LV_OFF"):
                self.logger.info("BI: Stopping LVs")
                self.SharedDict["BI_Action"].setText("Stopping LVs")
                self.SharedDict["BI_SUT"].setText("None") 
                self.BI_Update_Status_file(session_dict)
                self.BI_Update_PowerStatus_sig.emit(-2,True,"OFF_dummy")#isLV=True means LV,slot=-2 means all, but command only started
                if not self.BI_Action(self.Ctrl_PowerLV_Cmd,True,False,LV_Channel_list,PopUp):
                    return
                time.sleep(BI_SLEEP_AFTER_LVSET)
                #check all LVs are OFF
                for row in Slot_list:
                    if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_STAT_COL).text()!="OFF"):
                        self.BI_Abort("BI aborted: some LVs was not turned OFF")
                        return
                self.BI_Update_PowerStatus_sig.emit(-1,True,"OFF_dummy")#isLV=True means LV,slot=-1 means all, update GUI-side
                        
            if (session_dict["Action"].upper()=="HV_ON"):
                self.logger.info("BI: Starting HVs")
                self.SharedDict["BI_Action"].setText("Starting HVs")
                self.SharedDict["BI_SUT"].setText("None") 
                self.BI_Update_Status_file(session_dict)
                self.BI_Update_PowerStatus_sig.emit(-2,False,"ON_dummy")#isLV=False means HV,slot=-2 means all, but command only started
                if not self.BI_Action(self.Ctrl_PowerHV_Cmd,True,True,HV_Channel_list,PopUp):
                    return
                time.sleep(BI_SLEEP_AFTER_HVSET)
                #check all HVs are ON
                for row in Slot_list:
                    if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text()!="ON"):
                        self.BI_Abort("BI aborted: some HVs was not turned ON")
                        return
                self.BI_Update_PowerStatus_sig.emit(-1,False,"ON_dummy")#isLV=False means HV,slot=-1 means all, update GUI-side
                        
            if (session_dict["Action"].upper()=="HV_OFF"):
                self.logger.info("BI: Stopping HVs")
                self.SharedDict["BI_Action"].setText("Stopping HVs")
                self.SharedDict["BI_SUT"].setText("None") 
                self.BI_Update_Status_file(session_dict)
                self.BI_Update_PowerStatus_sig.emit(-2,False,"OFF_dummy")#isLV=False means HV,slot=-2 means all, but command only started
                if not self.BI_Action(self.Ctrl_PowerHV_Cmd,True,False,HV_Channel_list,PopUp):
                    return
                time.sleep(BI_SLEEP_AFTER_HVSET)
                #check all HVs are OFF
                for row in Slot_list:
                    if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text()!="OFF"):
                        self.BI_Abort("BI aborted: some LVs was not turned OFF")
                        return
                self.BI_Update_PowerStatus_sig.emit(-1,False,"OFF_dummy")#isLV=False means HV,slot=-1 means all, update GUI-side
            
            session_dict["Step"]=session_dict["Step"]+1
        
        if (os.path.exists("Session.json")):        
            os.remove("Session.json")
            self.logger.info("BI: Session json file deleted")
        else:
            self.logger.info("BI: Could not locate session json file")
        
        self.SharedDict["BI_Status"].setText("Stopping")
        self.SharedDict["BI_SUT"].setText("None") 
        
        #stop HV
        self.SharedDict["BI_Action"].setText("Stop HVs")
        HV_mod=False
        for row in Slot_list:
            if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text()!="OFF"):
                HV_mod=True
                if not self.BI_Action(self.Ctrl_PowerHV_Cmd,True,False,HV_Channel_list,PopUp):
                    return
        if HV_mod:
            time.sleep(BI_SLEEP_AFTER_HVSET)
            #check HV stop
            for row in Slot_list:
                if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_HV_STAT_COL).text()!="OFF"):
                    self.BI_Abort("BI aborted: some HVs was not turned OFF")
                    return
            
        
        #stop LV
        self.SharedDict["BI_Action"].setText("Stop LVs")
        LV_mod=False
        for row in Slot_list:
            if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_STAT_COL).text()!="OFF"):
                LV_mod=True
                if not self.BI_Action(self.Ctrl_PowerLV_Cmd,True,False,LV_Channel_list,PopUp):
                    return
        if LV_mod:
            time.sleep(BI_SLEEP_AFTER_LVSET)
            #check LV stop    
            for row in Slot_list:
                if(self.SharedDict["CAEN_table"].item(row,CTRLTABLE_LV_STAT_COL).text()!="OFF"):
                    self.BI_Abort("BI aborted: some LVs was not turned OFF")
                    return
                
        #put JULABO to 20 degree    
        self.SharedDict["BI_Action"].setText("Closing")
        if not self.BI_Action(self.Ctrl_SetSp_Cmd,True,0,20.0,PopUp): #FT this shouldn't be hardcoded to 20 but be contextual
            return    
        
        #lower dry air flow
        if self.SharedDict["Ctrl_StatusFlow"].text()=="HIGH":
            if not self.BI_Action(self.Ctrl_SetHighFlow_Cmd,True, False,PopUp):
                return
                
        self.logger.info("BurnIn test COMPLETED SUCCESFULLY!")
        self.SharedDict["BI_Active"]=False
        self.SharedDict["BI_Status"].setText("Idle")
        self.SharedDict["BI_Action"].setText("None")
        self.SharedDict["BI_StopRequest"]=False
        if os.path.exists("Session.json"):
            os.remove("Session.json")
        self.BI_terminated.emit()
    
    ## BI Abort function    
    def BI_Abort(self,Reason_str):
    
            Warning_str = "BURN IN test failed"
            self.SharedDict["BI_Status"].setText("Aborted")
            #self.Request_msg.emit(Warning_str,Reason_str)
            self.logger.info("WORKER: BI aborted"+ Reason_str )
            self.SharedDict["BI_Active"]=False
            self.SharedDict["BI_StopRequest"]=False
            self.SharedDict["BI_TestActive"]=False
            self.BI_terminated.emit()
        
    
    ## BI Action function. used to execute a defined operation.        
    def BI_Action(self,Action, abort_if_fail, *args):
        retry=BI_ACTION_RETRIES
        BI_action_start_time=datetime.now()
        BI_action_timedelta=timedelta(seconds = 0)
        while (retry and (BI_action_timedelta.total_seconds()< BI_ACTION_RETRY_MAX_TIME)):
            Action(*args)
            BI_action_timedelta=datetime.now()-BI_action_start_time #check time from start of attempts
            #
            if self.SharedDict["BI_StopRequest"]:
                self.BI_Abort("BI: aborted for user or Supervisor request")
                return False
            if not (self.last_op_ok):
                if (BI_action_timedelta.total_seconds()>= BI_ACTION_RETRY_MAX_TIME):
                    self.logger.warning("BI: continuously failed to do action for longer than " +str(BI_ACTION_RETRY_MAX_TIME) + " seconds")
                    # give up, exit while statement
                else:
                    self.logger.warning("BI: failed to do action... new try in "+str(BI_ACTION_RETRY_SLEEP)+" seconds")
                    time.sleep(BI_ACTION_RETRY_SLEEP)
                    # retry after sleep
                retry=retry-1
            else:
                return True
        #steps below occur if the Action fails even after retries
        if abort_if_fail:
            self.BI_Abort("BI: Failed to do action "+str(BI_ACTION_RETRIES-retry)+" time(s) over " + str(BI_action_timedelta.total_seconds()) + " seconds... aborting.")
            return False
        else:
            self.logger.warning("BI: Failed to do action "+str(BI_ACTION_RETRIES-retry)+" time(s) over " + str(BI_action_timedelta.total_seconds()) + " seconds. Moving to next action.")
            #Check if the failure was caused by one particular module
            if (self.SharedDict["BI_SUT"].text().isnumeric()):
                failed_slot = int(self.SharedDict["BI_SUT"].text())-1
                self.SharedDict["ModuleFailures"][failed_slot] +=1
                if False and (self.SharedDict["ModuleFailures"][failed_slot] >= BI_ACTION_FAILURE_EXCLUDE): #disabled manually
                    self.logger.warning("BI: Slot "+failed_slot+" accrued " + str(self.SharedDict["ModuleFailures"][failed_slot]) + " failures; excluding it from test.")
                    #slot has failed too many times, exclude it
                    ##                    self.SharedDict["BI_ActiveSlots"].remove(failed_slot) #verify if this is needed, might break things

                    failed_slot_LV = self.SharedDict["CAEN_table"].item(failed_slot,CTRLTABLE_LV_NAME_COL).text()
                    failed_slot_HV = self.SharedDict["CAEN_table"].item(failed_slot,CTRLTABLE_HV_NAME_COL).text()
                    LV_Channel_list.remove(failed_slot_LV)
                    HV_Channel_list.remove(failed_slot_HV)
                    #turn off HV (try 3 times)
                    self.SharedDict["BI_Action"].setText("Stopping failed module HV")
                    self.logger.info("BI: Stopping failed module HV")
                    for i in range(3):
                        if(self.SharedDict["CAEN_table"].item(failed_slot,CTRLTABLE_HV_STAT_COL).text()!="OFF"):
                            self.Ctrl_PowerHV_Cmd(False,[failed_slot_HV],PopUp)
                            time.sleep(BI_SLEEP_AFTER_HVSET)
                        else:
                            break
                    if(self.SharedDict["CAEN_table"].item(failed_slot,CTRLTABLE_HV_STAT_COL).text()!="OFF"):
                        self.BI_Abort("BI aborted: failed to turn off faulty module HV")
                        return
                    #turn off LV too (try 3 times)
                    self.SharedDict["BI_Action"].setText("Stopping failed module LV")
                    self.logger.info("BI: Stopping failed module LV")
                    for i in range(3):
                        if(self.SharedDict["CAEN_table"].item(failed_slot,CTRLTABLE_LV_STAT_COL).text()!="OFF"):
                            self.Ctrl_PowerLV_Cmd(False,[failed_slot_LV],PopUp)
                            time.sleep(BI_SLEEP_AFTER_LVSET)
                        else:
                            break
                    if(self.SharedDict["CAEN_table"].item(failed_slot,CTRLTABLE_LV_STAT_COL).text()!="OFF"):
                        self.BI_Abort("BI aborted: failed to turn off faulty module LV")
                        return
            return True

    ## BI function to ramp down in temp
    def BI_GoLowTemp(self,session_dict,LowTemp):
        self.BI_GoSelectedTemp(session_dict,LowTemp,isCooling=True,PopUp=False)

    ## BI function to ramp up in temp
    def BI_GoHighTemp(self,session_dict,HighTemp):
        self.BI_GoSelectedTemp(session_dict,HighTemp,isCooling=False,PopUp=False)
        
    ## BI generic function to change temp
    def BI_GoSelectedTemp(self,session_dict,SelectedTemp,isCooling,PopUp=False):

        TempTolerance   = BI_TEMP_TOLERANCE
        TempRampOffset  = session_dict["LowRamp"] if isCooling else session_dict["HighRamp"]
        TempKeepOffset  = session_dict["LowKeep"] if isCooling else session_dict["HighKeep"]
        verb = "cooling" if isCooling else "heating"
        
        self.last_op_ok= True
        TargetTemp = SelectedTemp+TempRampOffset

        last_step=False # enter while loop at least once
        if (abs(float(self.SharedDict["LastFNALBoxTemp0"].text())-SelectedTemp) < TempTolerance):
            #... unless we're already where we want to be, in which case we move to keep mode
            last_step = True

        nextTemp = session_dict["HighTemp"] #initialise to a safe value
        #cooling loops
        while (not last_step):
            try:
                #acquire dewpoint, must be done at every step
                dewPoint = float(self.SharedDict["Ctrl_IntDewPoint"].text())
            except Exception as e:
                self.logger.error(e)
                self.last_op_ok= False
                return
            
            minTempAllowed = max(computeTempFromTargetRH(dewPoint,BI_MIN_RH_PERCENTAGE), dewPoint+BI_DEWPOINT_MARGIN)
            print (f"BI: dew point: {dewPoint:.2f}°C, minimum allowed temperature: {minTempAllowed:.2f}°C, target temperature: {TargetTemp:.2f}°C")
            print (f"BI: computed minimum allowed temperature from dew point and RH: {computeTempFromTargetRH(dewPoint,BI_MIN_RH_PERCENTAGE):.2f}°C, minimum allowed temperature from dew point margin: {dewPoint+BI_DEWPOINT_MARGIN:.2f}°C")
            if (TargetTemp > minTempAllowed):#if the temperature we aim for is allowed given the dew point, we can go there directly
                nextTemp = TargetTemp
                self.logger.info(f"BI: target temp {TargetTemp:.2f}°C is above minimum allowed temperature {minTempAllowed:.2f}°C, going directly to target temp.")
                last_step = True
            else: #if not, we need to do an intermediate step at the minimum allowed temperature, switch to high flow and reevaluate the dew point there
                nextTemp = minTempAllowed
                self.logger.info(f"BI: target temp {TargetTemp:.2f}°C is below minimum allowed temperature {minTempAllowed:.2f}°C, going to minimum allowed temp {minTempAllowed:.2f}°C and switching to high flow.")
                if not self.BI_Action(self.Ctrl_SetHighFlow_Cmd,True, True,PopUp):
                    return
                
            #set to hold temperature at the target nextTemp
            if not self.BI_Action(self.Ctrl_SetSp_Cmd,True,0,nextTemp,PopUp):
                self.last_op_ok= False
                return    

            #while changing temperature, check if we reach the target and adjust the flow
            while(True):
                try:
                    self.logger.info(f"BI: {verb} to target temperature {SelectedTemp:.2f}°C, current temperature {self.SharedDict['LastFNALBoxTemp0'].text()}°C, next intermediate target {nextTemp:.2f}°C.")
                    dewPoint = float(self.SharedDict["Ctrl_IntDewPoint"].text())
                    #dry airflow increases heat and lowers humidity
                    #I want high flow when warming up or when the dew point is too high during the cooling phase
                    #If the dew point is sufficiently low and I'm cooling, switch to low flow
                    #If we are not at the last step, then it's obviously the former and lowering humidity takes priority
                    if last_step and isCooling:
                        if self.SharedDict["Ctrl_StatusFlow"].text()=="HIGH":
                            self.logger.info("BI: setting low flow....")    
                            if not self.BI_Action(self.Ctrl_SetHighFlow_Cmd,True,False,PopUp):
                                return
                    elif self.SharedDict["Ctrl_StatusFlow"].text()!="HIGH":
                        self.logger.info("BI: setting high flow....")    
                        if not self.BI_Action(self.Ctrl_SetHighFlow_Cmd,True,True,PopUp):
                            return

                    ## take the OW temperatures of the SELECTED slots as reference
                    active_slots = self.SharedDict.get("BI_ActiveSlots", [])
                    ow_temps = [float(self.SharedDict[f"LastFNALBoxOW{i}"].text()) 
                                for i, is_active in enumerate(active_slots) if is_active]
                    
                    ## if no active slot, use Temp0 as reference and issue a warning
                    if not any(active_slots):
                        self.logger.warning("BI: You are running the burn in test without any active slot! Please check your settings. Using Temp0 as reference for temperature checks.")
                        ow_temps = [float(self.SharedDict["LastFNALBoxTemp0"].text())]

                    ## computer the average and spread of the OW temperatures, and issue a warning if the spread is above a threshold
                    ow_temps_avg = sum(ow_temps)/len(ow_temps) if len(ow_temps)>0 else 0
                    ow_temps_spread_max = max(abs(temp - ow_temps_avg) for temp in ow_temps) if len(ow_temps)>0 else 0
                    self.logger.debug(f"BI: OW temperatures: avg={ow_temps_avg:.2f}, spread={ow_temps_spread_max:.2f}. ")
                    ## if all sensors measure roughly the same temperature...
                    if ow_temps_spread_max < OW_TEMP_SPREAD_THR:
                        ## ...use the average of the OW temperatures to decide if we should switch to the next step
                        if isCooling:
                            if last_step:
    #                            if (float(self.SharedDict["LastFNALBoxTemp0"].text())-SelectedTemp < TempTolerance):
                                if (ow_temps_avg-SelectedTemp < TempTolerance):
                                    #this happens when we get close enough to the selected temp FROM ABOVE
                                    #not using absolute value, if the FNALBox doesn't respond and the temperature does not update, we might go past the target
                                    break
                            else: #last_step = False
    #                           if (float(self.SharedDict["LastFNALBoxTemp0"].text())-nextTemp < TempTolerance + 5.):
                                if (ow_temps_avg-nextTemp < TempTolerance + 5.):
                                    #this happens when we get close enough to our intermediate step FROM ABOVE
                                    #remeasure the dewpoint and reevaluate the target temperature
                                    #this might be slow if threshold is set at nextTemp, but subject to user error if set to (nextTemp-TempRampOffset). We hardcode a value
                                    break
                        else: #if heating
    #                      if (SelectedTemp - float(self.SharedDict["LastFNALBoxTemp0"].text()) <  TempTolerance):
                            if (SelectedTemp - ow_temps_avg <  TempTolerance):
                                #this happens when we get close enough to the selected temp FROM BELOW
                                break
                    else: ## if the OW temperatures are not consistent, issue a warning and wait
                        self.logger.warning(f"BI: OW temperature spread above threshold! Spread: {ow_temps_spread_max:.2f}, ow_temps: {ow_temps}, active_slots: {active_slots}. I will not move to the next step until the spread is reduced below {OW_TEMP_SPREAD_THR}.")
                    #
                    if self.SharedDict["BI_StopRequest"]:
                        self.last_op_ok= False
                        return    
                    if not (self.SharedDict["CAEN_updated"] and self.SharedDict["FNALBox_updated"] and self.SharedDict["Julabo_updated"]):
                        if not (self.SharedDict["CAEN_updated"]):
                            self.logger.info("BI: CAEN info not updated while %s..."%(verb))
                        if not (self.SharedDict["FNALBox_updated"]):
                            self.logger.info("BI: FNAL info not updated while %s..."%(verb))
                        if not (self.SharedDict["Julabo_updated"]):
                            self.logger.info("BI: Julabo info not updated while %s..."%(verb))
                        self.last_op_ok= False
                        return
                    time.sleep(BI_SLEEP_AFTER_TEMP_CHECK)
                except Exception as e:
                    self.logger.error(e)
                    self.last_op_ok= False
                    return
            #end while(True)
        #end while (not last_step)

        #set high flow in case it was set to low
        if not self.BI_Action(self.Ctrl_SetHighFlow_Cmd,True,True,PopUp):
            return
        # set target temperature mantain
        TargetTemp = SelectedTemp+TempKeepOffset #usually if we are cooling we aim slightly lower, we might do the same for heating
        self.logger.info("BI: Keep temperature...")
        if not self.BI_Action(self.Ctrl_SetSp_Cmd,True,0,TargetTemp,PopUp):
            self.last_op_ok= False
            return
               
    def BI_Update_Status_file(self,session_dict):
    
        with open("Session.json", "w") as outfile: 
            json.dump(session_dict, outfile)


    def BI_StartIV_Cmd(self, session_dict, name_list, HV_list):
        session=self.SharedDict["TestSession"]
        modules = session_dict["ModuleIDs"]
        self.logger.info("Starting IV scan on modules "+','.join(name_list)+" with HV channels "+','.join(HV_list)+" ...")
        self.last_op_ok= True

    
        cmd = "python3 iv_parallel.py --channels "+','.join(HV_list)+ " --module-names "+ ','.join(name_list) + " --scan-type "+ self.IV_scanType+ " --delay "+ self.IV_delay +" --settling-time "+ self.IV_settlingTime+  " --store-locally --upload --session " + session
        self.logger.info("Executing command: " + cmd)

        try:
            proc = subprocess.Popen(cmd.split(), cwd=self.BIcwd,stdout=subprocess.PIPE, stderr=subprocess.STDOUT)                                    
            
            while(proc.returncode==None):
                
                if self.SharedDict["BI_StopRequest"]:
                    self.logger.error("WORKER: Aborting module IV scan on external request")
                    proc.kill()
                    self.last_op_ok= False
                    return
                try:
                    outs, errs = proc.communicate(timeout=TEST_PROCESS_SLEEP)
                    self.logger.info("BI IV SCAN SUBPROCESS: "+outs.decode())
                    #self.logger.error("BI TEST SUBPROCESS: "+errs.decode())
                    break
                except subprocess.TimeoutExpired:
                    self.logger.info("WORKER: Waiting IV SCAN completion....")
                    #while True:
                    #    inline = proc.stdout.readline()
                    #    if not inline:
                    #        break
                    #    self.logger.info("BI TEST SUBPROCESS: "+inline.decode())
            
            if proc.returncode ==0:
                self.logger.info("Module IV Scan succesfully completed with exit code "+str(proc.returncode))
            elif proc.returncode==None:
                self.logger.info("Module IV Scan succesfully completed with exit code NONE")
            else:
                self.logger.error("Module IV Scan failed with exit code "+str(proc.returncode))
                self.last_op_ok= False
                
        except Exception as e:
            self.logger.error("Error during IV Scan")
            self.logger.error(e)
            self.last_op_ok= False
            
            
    def BI_StartTest_Cmd(self, session_dict):
        module = session_dict["Current_ModuleID"]
        self.logger.info("Starting module "+module+" test...")
        session=self.SharedDict["TestSession"]
        
        if session_dict["TestType"].upper()=="DRYTEST":
            self.logger.info("Dry run. Just waiting 60 s.")
            time.sleep(60)
            return True 
        test_type = session_dict["TestType"]
        #test_type = "readOnlyID"    
        #if session_dict["TestType"]=="FullTest":
        #    test_type = "PSfullTest"
        #elif session_dict["TestType"]=="QuickTest":
        #    test_type = "PSquickTest"
        #elif session_dict["TestType"]=="CheckID":
        #    test_type = "readOnlyID"
        #else :
        #    self.logger.warning("Unrecognized test type: "+test_type+". Checking ID")
        #
        self.logger.info("Test type: "+test_type)
        
        fc7Slot = session_dict["fc7Slot"]
        fc7ID = session_dict["fc7ID"]
        
        self.last_op_ok= True
        
        #create non-blocking process
        if self.Ph2_ACF_version=="latest":
            cmd = "python3 moduleTest.py -c "+test_type+ " --board "+ fc7ID + " --slot "+ fc7Slot +" --module "+ module+  " --session " + session
        else:
            cmd = "python3 moduleTest.py -c "+test_type+ " --board "+ fc7ID + " --slot "+ fc7Slot +" --module "+ module+  " --session " + session+" --version "+ self.Ph2_ACF_version
        
        self.logger.info("Executing command: " + cmd)
        try:    
            proc = subprocess.Popen(cmd.split(), cwd=self.BIcwd,stdout=subprocess.PIPE, stderr=subprocess.STDOUT)                                    
            
            while(proc.returncode==None):
                
                if self.SharedDict["BI_StopRequest"]:
                    self.logger.error("WORKER: Aborting module test on external request")
                    proc.kill()
                    self.last_op_ok= False
                    return
                try:
                    outs, errs = proc.communicate(timeout=TEST_PROCESS_SLEEP)
                    self.logger.info("BI TEST SUBPROCESS: "+outs.decode())
                    #self.logger.error("BI TEST SUBPROCESS: "+errs.decode())
                    break
                except subprocess.TimeoutExpired:
                    self.logger.info("WORKER: Waiting test completion....")
                    #while True:
                    #    inline = proc.stdout.readline()
                    #    if not inline:
                    #        break
                    #    self.logger.info("BI TEST SUBPROCESS: "+inline.decode())
            
            if proc.returncode ==0:
                self.logger.info(session_dict["TestType"]+" Module test succesfully completed with exit code "+str(proc.returncode))
            elif proc.returncode==None:
                self.logger.info(session_dict["TestType"]+" Module test succesfully completed with exit code NONE")
            else:
                self.logger.error(session_dict["TestType"]+" Module test failed with exit code "+str(proc.returncode))
                self.last_op_ok= False
                
        except Exception as e:
            self.logger.error("Erro while testing")
            self.logger.error(e)
            self.last_op_ok= False
                    
    
    @pyqtSlot(bool)                
    def MT_StartTest_Cmd(self, dry=False, PopUp=False):
            self.logger.info("Starting module test...Please wait till completion")
            Warning_str = "Please wait..."
            Reason_str = "Module test ongoing."
            if PopUp:
                self.Request_msg.emit(Warning_str,Reason_str)
            session=self.SharedDict["TestSession"]
            if dry:
                result = subprocess.run(["python3", "moduleTest.py", "--board", "fc7ot2", "--slot", "0" ,"--module", "PS_26_05-IPG_00102",  "--session", session, "--useExistingModuleTest","T2023_12_04_16_26_11_224929"],
                                                    cwd=self.BIcwd)
            else:
                result = subprocess.run(["python3", "moduleTest.py", "--board", "fc7ot2", "--slot", "0" ,"--module", "PS_26_05-IPG_00102",  "--session", session],
                                                    cwd=self.BIcwd)
            self.logger.info(result.stdout)
            self.logger.error(result.stderr)
            self.logger.info("Module test completed!")
            
    
    def MT_UploadDB_Cmd(self):
        pass