TeleCmdTesterImpl.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__ = "Telecommand tester GUI"
__author__   = "S. Tuvi <STuvi@SLAC.Stanford.edu>"
__date__     = "2005/07/15 23:45:02"
__updated__  = "$Date: 2006/02/10 21:51:14 $"
__version__  = "$Revision: 1.13 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from qt import *
from qttable import *
import sys
import types
import logging as log

from LICOS.tools.teleCmdGUI.TeleCmdTester    import TeleCmdTester
from LICOS.util.gOptions                     import Options
from LICOS.scriptEngine.ScriptEngineConnector import ScriptEngineConnector

class TeleCmdTesterImpl(TeleCmdTester):
  """!\brief Real time tele-commanding facility

  This tool provides the ability to send tele-commands to the VSC in
  real time. The user can enter a tele-command database based on which
  the command mnemonics and their payloads will be populated.

  The GUI provides the means to construct a tele-command as it is allowed
  in LICOS test scripts. The command can be pasted in to the command window
  and queued to the VSC.

  Currently only one command execution at a time is supported.

  """

  PAYLOAD_COL_MNEM = 0
  PAYLOAD_COL_VAL  = 1
  PAYLOAD_COL_DESC = 2

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

    \param parent The parent GUI (typically the Run Control GUI)
    \param name   Name of the GUI
    \param fl     Qt flags
    """
    TeleCmdTester.__init__(self, parent, name, fl | Qt.WGroupLeader)
    # Connect the signals
    self.connect(self.buttonPasteCmd,SIGNAL("clicked()"),self.pasteCommand)
    self.connect(self.buttonClearCmd,SIGNAL("clicked()"),self.clearCommand)
    self.connect(self.buttonQueue,SIGNAL("clicked()"),self.queueCommand)
    self.connect(self.buttonChangeDb,SIGNAL("clicked()"),self.changeDb)
    self.connect(self.comboPackage,SIGNAL("activated(const QString &)"),self.populateTeleCommands)
    self.connect(self.comboTeleCmd,SIGNAL("activated(const QString &)"),self.populatePayloads)
    self.connect(self.buttonZeroOutPayload,SIGNAL("clicked()"),self.zeroOutPayloads)

    # Initialize the payload table properties
    self.setupPayloadTable()
    if type(server) is types.StringType:
      # Connect to the VSC
      self.__server = server
      self.__vsc = self.connectVSC()
    else:
      self.__vsc = server
    # Use the default database module LCATcmdDb
    self.changeDb()

  def setupPayloadTable(self):
    """!\brief Initialize the payload table properties

    Set the selection mode to single row.
    Set the Description column stretchable.
    """
    self.tablePayloads.setSelectionMode(QTable.SingleRow)
    self.tablePayloads.setColumnStretchable(TeleCmdTesterImpl.PAYLOAD_COL_DESC,1)

  def populatePackages(self):
    """!\brief Populate the package list

    """
    packages = self.__db.getPackages()
    packages.sort()
    for pkg in packages:
      self.comboPackage.insertItem(pkg)
    self.populateTeleCommands()

  def populateTeleCommands(self):
    """!\brief Populate the telecommand list

    """
    curPkg = str(self.comboPackage.currentText())
    pkg = None
    if curPkg in self.__teleCmds:
      pkg = self.__teleCmds[curPkg]
    elif hasattr(self.__db, curPkg):
      pkg  = getattr(self.__db, curPkg)
      self.__teleCmds[curPkg] = pkg
    self.comboTeleCmd.clear()
    if pkg is not None:
      cmds = pkg.getCmds()
      cmds.sort()
      for cmd in pkg.getCmds():
        self.comboTeleCmd.insertItem(cmd)
    self.populatePayloads()

  def populatePayloads(self):
    """!\brief Populate the payload table

    """
    curPkg = str(self.comboPackage.currentText())
    curCmd = str(self.comboTeleCmd.currentText())
    if curPkg in self.__teleCmds:
      pkg = self.__teleCmds[curPkg]
      self.textCmdDescription.setText(pkg.getCmdObj(curCmd).descr)
      payloadList = pkg.getPayloadList(curCmd)
      self.tablePayloads.setNumRows(len(payloadList))
      row = 0
      for payloadMnemonic in payloadList:
        self.tablePayloads.setItem(row, TeleCmdTesterImpl.PAYLOAD_COL_MNEM,
                                   QTableItem(self.tablePayloads,
                                              QTableItem.Never,
                                              payloadMnemonic))
        payloadBrief = pkg.getPayloadDef(curCmd, payloadMnemonic)[2]
        self.tablePayloads.setText(row, TeleCmdTesterImpl.PAYLOAD_COL_VAL, "")
        self.tablePayloads.setItem(row, TeleCmdTesterImpl.PAYLOAD_COL_DESC,
                                   QTableItem(self.tablePayloads,
                                              QTableItem.Never,
                                              payloadBrief))
        row += 1
    else:
      self.tablePayloads.setNumRows(0)

  def zeroOutPayloads(self):
    for row in range(self.tablePayloads.numRows()):
      self.tablePayloads.setText(row, TeleCmdTesterImpl.PAYLOAD_COL_VAL, "0")

  def pasteCommand(self):
    """!\brief Paste the telecommand into the command window

    """
    # Force an endEdit
    self.tablePayloads.setReadOnly(1)
    self.tablePayloads.setReadOnly(0)

    curPkg = str(self.comboPackage.currentText())
    curCmd = str(self.comboTeleCmd.currentText())
    keywords = ""
    for row in range(self.tablePayloads.numRows()):
      keywords += str(self.tablePayloads.text(row, TeleCmdTesterImpl.PAYLOAD_COL_MNEM)) + \
                  "=" + str(self.tablePayloads.text(row, TeleCmdTesterImpl.PAYLOAD_COL_VAL))
      if row != self.tablePayloads.numRows() - 1:
        keywords += ", "
    cmdText = curPkg + "." + curCmd + "(" + keywords + ")"
    self.textSandbox.insert(cmdText)

  def clearCommand(self):
    """!\brief Clear the command window

    """
    self.textSandbox.setText("")

  def queueCommand(self):
    """!\brief Queue the command to the VSC

    """
    cmdText = str(self.textSandbox.text())
    cmdText = 'self.getDB().' + cmdText
    exec(cmdText)

  def changeDb(self):
    """!\brief Change the database module

    """
    self.__db = self.initDb()
    if self.__db is not None:
      self.__teleCmds = {}
      self.populatePackages()
    else:
      self.clearGUI()

  def clearGUI(self):
    """!\brief Clear the GUI

    """
    self.comboPackage.clear()
    self.comboTeleCmd.clear()
    self.tablePayloads.setNumRows(0)
    self.textCmdDescription.setText("")

  def initDb(self):
    """!\brief Import and initialize the database module

    """
    db = str(self.textDatabase.text())
    try:
      exec("from LICOS.lib.cmdTlmDb.%s import %s" % (db, db))
      return getattr(sys.modules['LICOS.lib.cmdTlmDb.%s' % db], db)(self.__vsc)
    except ImportError:
      log.exception("Unable to import database %s" % db)
    except Exception, e:
      log.exception(e)
    return None

  def getDB(self):
    """!\brief Retrieve the current database instance

    \return Current database instance
    """
    return self.__db

  def connectVSC(self):
    """!\brief Connect to the Script Engine Proxy.

    """
    vsc = ScriptEngineConnector( vscHost=self.__server,
                                 diagHost=None,
                                 telemHost=None)
    vsc.start()
    self.__vsc = vsc
    return vsc


def usage():
  return """

TeleCmdTesterImpl Usage:

Mandatory options:
--server    specify the VSC server

Example:
$ TeleCmdTesterImpl --server lat-elf9

"""

if __name__ == "__main__":
  options = Options(['server'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(usage())
    raise Exception, msg

  a = QApplication(sys.argv)
  tct = TeleCmdTesterImpl(options.server)
  QObject.connect(a,SIGNAL("lastWindowClosed()"), a, SLOT("quit()"))
  a.setMainWidget(tct)
  tct.show()
  a.exec_loop()

---