testVscMinimal.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "Minimal data taking application - VSC version"
__author__   = "S. Tuvi <Stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/04/14 02:22:47 $"
__version__  = "$Revision: 1.14 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import logging as log
import            struct
import            time
import            sys

from LICOS.lib.LATconstants              import *
from LICOS.lib.cmdTlmDb.PBC              import PBC

from LICOS.lib.scriptEngine.seAppBase    import seAppBase
from LICOS.lib.scriptEngine.ArgumentImpl import ArgumentImpl
from LICOS.lib.cmdTlmDb.LCATcmdDb        import LCATcmdDb
from LICOS.lib.cmdTlmDb.LCATtlmDb        import LCATtlmDb
from LICOS.lib.testReport.rcTestReport   import rcTestReport

#  Example application implementation.
class testVscMinimal(seAppBase):
  """!\brief Sample script based on seAppBase that demonstrates tele-commands.

  Demonstrates queuing memory dump commands to the VSC.

  """
  def __init__(self, common):
    """!\brief MemDump constructor.

    \param common ScriptEngineCommon constructor
    """
    seAppBase.__init__(self, common)
    log.debug("%s.__init__()" % self.getName())
    self.__arg = None
    self.__tr = rcTestReport()

  def getName(self):
    """!\brief Return the name of this class.

    \return Class name
    """
    return self.__class__.__name__

  def setup(self):
    """!\brief SETUP transition method.

    """
    log.debug("%s.setup()" % self.getName())

    hwConfig = self.prefs['hwConfig']
    if len(hwConfig) == 0:
      pass
    else:
      log.debug("Setting cross strapping from --vscConfig item")
      siuIdPhysical = int(hwConfig['siuIdPhysical'])
      pduId         = int(hwConfig['pduId'])
      #siuSelect     = hwConfig['siuSelect']
      #daqSelect     = hwConfig['daqSelect']
      priFeed       = int(hwConfig['primaryFeed'])
      priGasu       = int(hwConfig['primaryGasu'])
      firstEpuId    = int(hwConfig['firstEpuId'])
      secondEpuId   = int(hwConfig['secondEpuId'])

    # Now done in ScriptEngineCommon
    #self.vsc.siuSelect(getattr(self.vsc, siuSelect))
    #self.vsc.daqSelect(getattr(self.vsc, daqSelect))

    if self.rc is None:
      self.__arg = userArgText()
    else:
      self.rc.execGUImethod(self.createGUI)

  def createGUI(self):
    """!\brief Create the argument GUI.

    Must be passed to an execGUImethod.
    This is done here in a separate method so that the GUI creation
    and deletion is done in the GUI thread.

    Executing self.__arg = self.rc.createGUI(userArgument, self.rc, 'test1', 1)
    does not work since the GUI object was being garbage collected (deleted)
    in the non-GUI thread.
    """
    self.__arg = userArgument(self.rc, 'test1', 1)

  def run(self):
    """!\brief RUN transition method.

    """
    log.debug("%s.run()" % self.getName())

    self.startTestReport("testVscMinimal")

    caption = "Enter number of HSK AemEnv0 diagnostic packets to be requested"
    if self.rc is None:
      hskCount = self.__arg.getValue(caption)
    else:
      hskCount = self.rc.execGUImethod(self.__arg.getValue, caption)

    if hskCount is None:
      self.setCompletionStatus(self.COMPL_STATUS_ABORTED)
      return -1

    lcat = LCATcmdDb(self.vsc)
    lcat.enableCmdConfirmTelem()
    lcatTlm = LCATtlmDb()
    mem = lcat.MEM
    memAddr = PBC.WATCHDOG_TIMER_ADDRESS
    result = mem.dumpMemory(FSW_UNIT_SIU, memAddr, size=1, tranID=0, dest=FSW_DEST_1553)
    secs = (struct.unpack('!I',result)[0])*PBC.WATCHDOG_TIMER_SECS_PER_CLK
    log.info("Watchdog timer set to %.2f seconds." % secs)
    lhk = lcat.LHK
    apid = lcatTlm.getApidFromName('AemEnv0')
    lhk.requestDiagHskPacket(apid, payloadMnems=[], timeout=10,
                             count=hskCount, interval=0x64)
    self.setCompletionStatus(self.COMPL_STATUS_PASSED)
    lcat.disableCmdConfirmTelem()
    # End of run

  def stopRun(self):
    self.addAddlInputFile(sys.modules[self.__class__.__name__].__file__)
    self.closeTestReport()

  def teardown(self):
    """!\brief TEARDOWN transition method.

    """
    # Allow the C++ object to be deleted
    if self.__arg is not None:
      self.__arg.deleteLater()

  def startTestReport(self, title, configPrefs=None):
    """!\brief Add heading and summary to the test report.

    """
    tr = self.__tr
    tr.initReport(title + ' [%s]' % self.runId)
    tr.addHeading(self.getName())
    tr.addHeading(title)
    tr.addHeading(time.asctime())
    self.addHwConfigToReport()
    summary = tr.addSection('Test Summary')
    if configPrefs is not None:
      cfgFile = os.path.split(self.__configFile)[1]
      tr.addSectionItem(summary, 'Configuration file', cfgFile, cfgFile)
      tr.addSectionItem(summary, 'Configuration file version', configPrefs["config"]["version"])
      tr.addSectionItem(summary, 'Configuration file release', configPrefs["config"]["release"])
    tr.addSectionItem(summary, 'Run Id', self.runId)
    runReportFile = '%s_rcReport.xml' % self.runId
    tr.addSectionItem(summary, 'Run Report', runReportFile, runReportFile)
    tr.addSectionItem(summary, "HTML test", tr.escape("The text that produced the following item is: <b>This text should be in bold</b>"))
    tr.addSectionItem(summary, "HTML test", "<b>This text should be in bold</b>")

  def closeTestReport(self):
    """!\brief Close the test report and add it to exported file list.

    """
    tr = self.__tr
    summary = tr.findSection("Test Summary")
    tr.addSectionItem(summary, "Completion Status", self.getCompletionStatusStr())
    testReportFile = os.path.join(self.prefs["reportdir"],
                                  '%s_%s.html' % (self.getName(), self.runId))
    self.__tr.transformToFile(LICOS_TEST_REPORT_XSL, testReportFile)
    self.addExportedFile(testReportFile, delete=True)

  def addHwConfigToReport(self):
    hwConfig = self.prefs['hwConfig']
    siuIdPhysical = hwConfig['siuIdPhysical']
    pduId         = hwConfig['pduId']
    siuSelect     = hwConfig['siuSelect']
    daqSelect     = hwConfig['daqSelect']
    priFeed       = hwConfig['primaryFeed']
    priGasu       = hwConfig['primaryGasu']
    firstEpuId    = hwConfig['firstEpuId']
    secondEpuId   = hwConfig['secondEpuId']
    hvbs          = hwConfig['hvbs']
    tr = self.__tr
    hwSection = tr.addSection('Hardware Configuration')
    tr.addSectionItem(hwSection, "Preset Configuration", str(self.common.getLatConfigId()))
    tr.addSectionItem(hwSection, 'SIU Cross Strapping', siuSelect)
    tr.addSectionItem(hwSection, 'DAQ Cross Strapping', daqSelect)
    if priFeed:
      value = "Primary"
    else:
      value = "Redundant"
    tr.addSectionItem(hwSection, 'DAQ Feed', value)
    if siuIdPhysical:
      value = "Primary"
    else:
      value = "Redundant"
    tr.addSectionItem(hwSection, 'SIU', value)
    if priGasu:
      value = "Primary"
    else:
      value = "Redundant"
    tr.addSectionItem(hwSection, 'GASU', value)
    tr.addSectionItem(hwSection, 'EPU-A', str(firstEpuId))
    tr.addSectionItem(hwSection, 'EPU-B', str(secondEpuId))
    tr.addSectionItem(hwSection, 'ACD HVBS', str(hvbs))
    if pduId == 0:
      value = "Primary"
    else:
      value = "Redundant"
    tr.addSectionItem(hwSection, 'PDU', value)


#  This class puts up a GUI for inputting a value of some sort.  It is used by
#  the userApplication example to get the number of self triggers to take.
class userArgument(ArgumentImpl):
  """!\brief GUI for getting the user to input some sort of value.

  """
  def __init__(self, parent = None, name = None, modal = 0, fl = 0):
    """!\brief userArgument constructor.

    \param parent Parent GUI
    \param name   GUI name
    \param modal  Whether the dialog is modal or not
    \param fl     GUI flags
    """
    ArgumentImpl.__init__(self, parent, name, modal, fl)
    self.__value = 0
    self.setCaption("Hello world!")

  def OKButtonClicked(self):
    """!\brief Slot for the OK button.

    """
    self.__value = int(self.ArgumentList.text().latin1())
    self.close()

  def CancelButtonClicked(self):
    """!\brief Slot for the Cancel button.

    """
    self.__value = None
    self.close()

  def getValue(self, caption):
    """!\brief Bring up the GUI and return a value when OK is clicked.

    \param caption Dialog caption

    \return The value entered by the user
    """
    self.setCaption(caption)
    self.show()
    self.exec_loop()
    return self.__value

class userArgText(object):
  """!\brief Text user interface for getting the user to input some sort of value.

  """
  def __init__(self):
    """!\brief userArgText constructor.

    """
    pass

  def getValue(self, caption):
    """!\brief Use console input to return a value from the user.

    \return The value entered by the user
    """
    return int(raw_input("%s: " % (caption)))

---