def PingStatus(self, IpAddress):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: PingStatus
# Input: IpAddress
# Description:Pings the machine (with IpAddress provided as an argument)
# Return: StatusResult() object
#-------------------------------------------------------------------------------------------------------------------
"""
result = CommandLine.RunCommand('ping ' + IpAddress, 30)
if result.Status.HasError():
logger.error("Error in pinging host {0} . {1}".format(
IpAddress, result.CmdResult.Output))
return StatusResult.Error("Error in pinging host {0} . {1}".format(
IpAddress, result.CmdResult.Output))
logger.info(result.CmdResult.Output)
if ('unreachable.' in result.CmdResult.Output):
#No route from the local system. Packets sent were never put on the wire.
return StatusResult.Error('IpAddress is unreacheable. ' +
result.CmdResult.Output)
elif ('Ping request could not find host' in result.CmdResult.Output):
return StatusResult.Error('host_not_found. ' +
result.CmdResult.Output)
elif ('Request timed out.' in result.CmdResult.Output):
return StatusResult.Error('Connection time out' +
result.CmdResult.Output)
return StatusResult.Success()
def GetSinglePlotStatistics(self, statisticList):
logger.info("Getting Single Plot Statistics ")
methodString = "-m GetSinglePlotStatistics-1,1"
result = self.SendCommandAndGetResponse(methodString)
if result.Status.HasError():
logger.error(
"Error in Sending Command to get Single Point Statistics")
return result
current = "current : "
voltage = "voltage : "
match = re.findall(current + '(.*?);', result.CmdResult.Output,
re.DOTALL)
if len(match) < 1:
return StatusResult.Error("Could not read Current Value")
# logger.info("Current : " + match[0])
current = match[0]
match = re.findall(voltage + '(.*?);', result.CmdResult.Output,
re.DOTALL)
if len(match) < 1:
return StatusResult.Error("Could not read Voltage Value")
# logger.info("Voltage : " + match[0])
voltage = match[0]
statisticList[0] = current
statisticList[1] = voltage
return StatusResult.Success()
def CheckTSens(self, thermalZone):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: CheckTSens
# Input: Takes 1 argument
# argument1: thermalZone
# Description: Checks temperature on device and reports when it's stable
#---------------------------------------------------------------------------------------------------
"""
logger.info("Calling CheckTSens function")
methodString = "-m CheckTSens-" + str(thermalZone)
result = self.SendCommandAndGetResponse(methodString)
if result.Status.HasError():
logger.error("Error in running CheckTSens")
return result.Status
tSens5Temperature = "TSens5Temperature : "
match = re.findall(tSens5Temperature + '(.*?);',
result.CmdResult.Output, re.DOTALL)
if len(match) < 1:
return None
tSens5Temperature = match[0]
logger.debug("CheckTSens function working fine")
return tSens5Temperature
def StartMeasurement(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: StartMeasurement
# Input: Takes no argument
# Description: Starts power measurement on ALPACA
# Return: StatusResult() object
#-------------------------------------------------------------------------------------------------------------------
"""
if self.boardHasEpm:
if self.epm.getData:
logger.warning('ALPACA : Measurement already running. Stopping previous measurement')
result = self.StopMeasurement()
if result.HasError():
logger.error('ALPACA : Error stopping previous measurement')
return result
logger.info('ALPACA : Starting measurement')
try:
self.epm.StartMeasurement()
except Exception as e:
logger.error(str(e))
return StatusResult.Error('ALPACA : ', str(e))
return StatusResult.Success()
def PIDControl(self, thermalZone, desiredTemperature, timeout, SVTemp=25):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: PIDControl
# Input: Takes 4 arguments
# argument1: thermal Zone
# argument2: desiredTemperature in degree C
# argument3: timeout in seconds.
# argument4: SVTemp Temperature in degree C, default value is 25.0C
# Description: Sets RV temperature, reports device temperature
#-------------------------------------------------------------------------------------------------------------------
"""
msTimeout = timeout * 1000
logger.info("Inside PIDControl function")
methodString = "-m PIDControl-" + str(thermalZone) + "," + str(
desiredTemperature) + "," + str(msTimeout) + "," + str(SVTemp)
logger.info(methodString)
result = self.SendCommandAndGetResponse(methodString, timeout)
logger.debug(result.CmdResult.Output)
if result.Status.HasError():
logger.error("Error in running PIDControl")
return result.Status
logger.debug("PIDControl function working fine")
return StatusResult.Success()
def RebootDevice(self) :
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: RebootDevice
# Input: Takes no argument
# Description: Reboots Device by switching Power & USB
# Return: StatusResult() object
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Turning Off Device")
result = self.PowerOff()
if result.HasError():
return result
result = self.UsbOff()
if result.HasError():
return result
time.sleep(2)
logger.info("Booting up Device")
result = self.PowerOn()
if result.HasError():
return result
result = self.UsbOn()
if result.HasError():
return result
return result
def SetDataCollectionPath(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SetDataCollectionPath
# Input: Takes no argument
# Description: Sets up path to save UDAS waveform on automation PC
# Return: StatusResult() object
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Setting Logs Location for saving UDAS")
if self.boardHasEpm:
if self.epm.getData:
logger.warning('ALPACA : Measurement already running. Stopping previous measurement')
result = self.StopMeasurement()
if result.HasError():
logger.error('ALPACA : Error stopping previous measurement')
return result
self.logsPath = "C:\\Automation\\Logs\\" + str(datetime.now().strftime('%Y-%m-%d_%H-%M-%S'))
if self.boardHasEpm:
try:
logger.info('ALPACA : Log directory path : ' + self.logsPath)
self.epm.SetLogDirectory(self.logsPath)
except Exception as e:
logger.error(str(e))
return StatusResult.Error('ALPACA : ', str(e))
return StatusResult.Success()
def ControlTemperature(self,
thermalZone,
desiredTemperature,
timeout,
SVTemp=25):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: ControlTemperature
# Input: Takes 4 argument
# argument1: thermalZone
# argument2: desiredTemperature
# argument3: timeout in seconds
# argument4: SVTemp
# Description: Controls temperature on device
#---------------------------------------------------------------------------------------------------
"""
logger.info("Calling ControlTemperature function")
methodString = "-m ControlTemperature-" + str(thermalZone) + "," + str(
desiredTemperature) + "," + str(timeout * 1000) + "," + str(SVTemp)
#logger.debug(methodString)
result = self.SendCommandAndGetResponse(methodString, timeout)
logger.debug(result.CmdResult.Output)
if result.Status.HasError():
logger.error("Error in running ControlTemperature")
return result.Status
logger.debug("ControlTemperature function working fine")
return StatusResult.Success()
def StartAcquisition(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: StartAcquisition
# Description: Starts Acquisition on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Starting Acquisition")
commandToRun = "StartAcquisition()"
result = self.SendCommandAndGetResponse(commandToRun, False)
if (result.HasError()):
return result
status = KratosConstants.ExtAcquisitionStatus.UNKNOWN
logger.info("Kratos: Waiting For Acquisition To Be Ready")
# Wait for up to 60seconds for the waiting for trigger screen
startTime = datetime.datetime.now()
while (status !=
KratosConstants.ExtAcquisitionStatus.WAITING_FOR_TRIGGER
and (datetime.datetime.now() - startTime).seconds < 60):
time.sleep(2)
status = self.GetExtAcquisitionStatus()
if (status !=
KratosConstants.ExtAcquisitionStatus.WAITING_FOR_TRIGGER):
return StatusResult.Error(
"Kratos: Acquisition Is Not Ready. Check That A Measurement Can Be Performed Manually"
)
return StatusResult.Success()
def GetSinglePlotStatistics(self, statisticList):
logger.info("Getting Single Plot Statistics ")
for channel in ['CURRENT', 'VOLTAGE']:
commandToRun = f"GetSinglePlotStatistics(0,{channel})"
result = self.SendCommandAndGetResponse(commandToRun)
if result.HasError():
logger.error(f"Error in reading battery {channel}")
return result
dataFields = None
if self.LastApiResponse:
dataFields = self.LastApiResponse.split(",")
if (dataFields == None or len(dataFields) < 3):
return StatusResult.Error(
f"Kratos: Failed to parse response while reading battery {channel} value. Response: {self.LastApiResponse}"
)
if channel == 'CURRENT':
statisticList[0] = dataFields[2]
else:
statisticList[1] = dataFields[2]
return StatusResult.Success()
def GetAcquisitionError(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: GetAcquisitionError
# Description: Get Acquisition Error if encountered
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Getting Acquisition Error")
commandToRun = "GetAcquisitionError()"
result = self.SendCommandAndGetResponse(commandToRun, False)
if result.HasError():
return result
outputs = None
if self.LastApiResponse:
outputs = self.LastApiResponse.split(",")
if (outputs == None or len(outputs) == 0):
return StatusResult.Error(
f"Incorrect response from Kratos while checking for Acquisition errors. Response: {self.LastApiResponse}"
)
if (outputs[0] != "NO ERROR"):
return StatusResult.Error(
f"Error response from Kratos while checking for Acquisition errors. Response: {self.LastApiResponse}"
)
return StatusResult.Success()
def stopsystem(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: stopsystem
# Description: Stop the TBSLTE system and check system is in stopped mode at end
# Input: Takes no argument
# Examples:
# stopsystem()
# It will stop TBSLTE sytem
# Return: StatusResult() object
#-------------------------------------------------------------------------------------------------------------------
"""
if not self._get_tbslteutil_handle():
return StatusResult.Error("TBSLTEUtil handle not initialized")
try:
output = self._tbslte_handle.stop_system()
except Exception as e:
return StatusResult.Error(
f"TBSLTEUtil threw an exception while stopping the system: {e}"
)
if output == 0:
return StatusResult.Error("Failed to stop the TBS system")
elif output == 2:
logger.debug(
"TBSLTE system was already stopped before calling the 'stopsystem' function"
)
logger.info("TBSLTE system is stopped successfully")
return StatusResult.Success()
def startsystem(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: startsystem
# Description: Start the system with the previously deployed template
# Input: Takes no argument
# Examples:
# startsystem()
# It will start TBSLTE sytem with the previously deployed template
# and check if system is running at end
# Return: StatusResult() object
#-------------------------------------------------------------------------------------------------------------------
"""
if not self._get_tbslteutil_handle():
return StatusResult.Error("TBSLTEUtil handle not initialized")
try:
output = self._tbslte_handle.start_system()
except Exception as e:
return StatusResult.Error(
f"TBSLTEUtil threw an exception while starting the system: {e}"
)
if output == 0:
return StatusResult.Error("Failed to start the TBS system")
elif output == 2:
logger.debug(
"TBSLTE system was already running before calling the 'startsystem' function"
)
logger.info("TBSLTE system is up and running")
return StatusResult.Success()
def SendSwTrigger(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SendSwTrigger
# Description: Send SW Trigger command to start measurement
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Sending Software Trigger")
methodString = "-m SendSwTrigger"
return self.SendCommandAndGetResponse(methodString)
def DmmMuxCalibration(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: DmmMuxCalibration
# Description: Performs Dmm Mux Calibration on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Performing Dmm Mux Calibration")
methodString = "-m DmmMuxCalibration"
return self.SendCommandAndGetResponse(methodString)
def SelfCalibration(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SelfCalibration
# Description: Performs Self Calibration
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Performing Self Calibration")
methodString = "-m SelfCalibration"
return self.SendCommandAndGetResponse(methodString)
def GetAcquisitionError(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: GetAcquisitionError
# Description: Get Acquisition Error if encountered
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Getting Acquisition Error")
methodString = "-m GetAcquisitionError"
return self.SendCommandAndGetResponse(methodString)
def StopAcquisition(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: StopAcquisition
# Description: Stops Acquisition if in progress
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Stopping Acquisition")
methodString = "-m StopAcquisition"
return self.SendCommandAndGetResponse(methodString)
def StartAcquisition(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: StartAcquisition
# Description: Starts Acquisition on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Starting Acquisition")
methodString = "-m StartAcquisition"
return self.SendCommandAndGetResponse(methodString)
def DmmMuxCalibration(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: DmmMuxCalibration
# Description: Performs Dmm Mux Calibration on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Performing Dmm Mux Calibration")
commandToRun = "DmmMuxCalibration()"
return self.SendCommandAndGetResponse(commandToRun, False)
def SelfCalibration(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SelfCalibration
# Description: Performs Self Calibration
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Performing Self Calibration")
commandToRun = "SelfCalibration()"
return self.SendCommandAndGetResponse(commandToRun, False)
def LoadChannelConfiguration(self, configurationFile):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: LoadChannelConfiguration
# Input: Takes argument :
# configurationFile: Path of the cfg file to Load
# Description: Loads the specified configuration file on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Loading Channel Configuration : " + configurationFile)
commandToRun = "LoadChannelConfiguration(" + configurationFile + ")"
return self.SendCommandAndGetResponse(commandToRun)
def SetUsbConnection(self, enable):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SetUsbConnection
# Input: Takes argument :
# enable: true / false
# Description: Enables/Disables the USB Connection on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Setting USB Connection to : " + enable)
methodString = "-m SetUsbConnection-" + enable
return self.SendCommandAndGetResponse(methodString)
def SetOutputDirectory(self, outputDirPath):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SetOutputDirectory
# Input: Takes argument :
# outputDirPath: Absolute Logs Directory Path
# Description: Sets Path on the Kratos PC to save UDAS Files
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Setting UDAS Output Directory to : " + outputDirPath)
commandToRun = f"SetOutputDirectory({outputDirPath})"
return self.SendCommandAndGetResponse(commandToRun)
def SetUsbConnection(self, enable):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SetUsbConnection
# Input: Takes argument :
# enable: true / false
# Description: Enables/Disables the USB Connection on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Setting USB Connection to : " + enable)
setOut = "ON" if (enable == 'true') else "OFF"
commandToRun = "SetUsbConnection(1," + setOut + ")"
return self.SendCommandAndGetResponse(commandToRun, False)
def SetPowerSupplyOutput(self, enable):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SetPowerSupplyOutput
# Input: Takes argument :
# enable: true/false to enable or disable Power
# Description: Power ON/OFF Device by turning on Kratos Power ON/OFF
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Setting PowerSupply Output to " + enable)
setOut = "ON" if (enable == 'true') else "OFF"
commandToRun = "SetPowerSupplyOutput(1," + setOut + ")"
return self.SendCommandAndGetResponse(commandToRun)
def SetPowerSupplyOutput(self, enable):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SetPowerSupplyOutput
# Input: Takes argument :
# enable: true/false to enable or disable Power
# Description: Power ON/OFF Device by turning on Kratos Power ON/OFF
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Setting PowerSupply Output to " + enable)
methodString = "-m SetPowerSupplyOutput-" + enable
result = self.SendCommandAndGetResponse(methodString)
return result
def ConfigurePowerSupply(self, voltage, currentLimit, ovp):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: ConfigurePowerSupply
# Input: Takes argument :
# voltage: Voltage to be set on Kratos
# currentLimit: Current Limit to be set on Kratos
# ovp: OVP to be set
# Description: Sets Voltage, Current & OVP on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Configuring Power Supply ")
commandToRun = f"ConfigurePowerSupply(1,{voltage},{currentLimit},{ovp})"
return self.SendCommandAndGetResponse(commandToRun)
def SetDefaultOptions(self):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: SetDefaultOption
# Input: Takes No Arguments
# Description: Sets default of parameters :
# checkCal : False, ignoreSelfCal : false, ignoreExtCal : True, enforceMaxVBat : False, checkConnectors : True, autoSaveData : True
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info(
"Setting Default Options - checkCal : False, ignoreSelfCal : false, ignoreExtCal : True, enforceMaxVBat : False, checkConnectors : True, autoSaveData : True"
)
commandToRun = "SetOptions(CHK_CAL=OFF,IGNORE_SELF_CAL=OFF,IGNORE_EXT_CAL=ON,ENFORCE_MAX_VBAT=OFF,CHK_CONNECTORS=ON,AUTOSAVE=ON)"
return self.SendCommandAndGetResponse(commandToRun)
def ConfigurePowerSupply(self, voltage, currentLimit, ovp):
"""
#-------------------------------------------------------------------------------------------------------------------
# Name: ConfigurePowerSupply
# Input: Takes argument :
# voltage: Voltage to be set on Kratos
# currentLimit: Current Limit to be set on Kratos
# ovp: OVP to be set
# Description: Sets Voltage, Current & OVP on Kratos
#-------------------------------------------------------------------------------------------------------------------
"""
logger.info("Configuring Power Supply ")
methodString = "-m ConfigurePowerSupply-" + voltage + "," + currentLimit + "," + ovp
return self.SendCommandAndGetResponse(methodString)
