TelemMonitorImpl.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__ = "Telemetry Monitor"
__author__   = "S. Tuvi <STuvi@SLAC.Stanford.edu>"
__date__     = "2005/09/15 23:45:02"
__updated__  = "$Date: 2006/04/28 01:41:36 $"
__version__  = "$Revision: 1.19 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from qt import *
from qttable import *
import sys
import types
import logging as log
from Queue import Queue
import time
import atexit
import threading
from ConfigParser import ConfigParser

import VSC

from LICOS.tools.monitor.TelemMonitor         import TelemMonitor
from LICOS.util.gOptions                      import Options
from LICOS.core.thread.taskEngine             import TaskEngine
from LICOS.lib.cmdTlmDb.LCATtlmDb             import LCATtlmDb
from LICOS.core.thread.guiBridges             import GUIbridge

from LICOS.scriptEngine.ScriptEngineConnector import LicosTelemetryRouter

from LICOS.tools.proxy.VscProxyTools        import getip
from LICOS.tools.proxy.VscProxyPorts        import VscProxyPorts
from LICOS.scriptEngine.seTelemetryHandler  import seTelemetryHandler




class TelemMonitorImpl(TelemMonitor):
  """!\brief Telemetry monitoring GUI.

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

    \param parent The parent GUI (typically the Run Control GUI)
    \param name   Name of the GUI
    \param fl     Qt flags
    """
    TelemMonitor.__init__(self, None, name, fl | Qt.WGroupLeader)
    atexit.register(self.shutdown)
    self.__parent = parent
    self.textTelem.setMaxLogLines(9999)
    self.__telemConsumer = None
    self.__telemHandler  = None
    self.__guiBridge     = None
    self.__verbose       = False
    self.__telemHandler = telemHandler
    self.initialize()
    self.connect(self.buttonClear, SIGNAL("clicked()"), self.clearAction)
    self.connect(self.buttonPause, SIGNAL("clicked()"), self.pauseAction)
    self.connect(self.buttonVerbose,SIGNAL("toggled(bool)"),self.verboseAction)
    self.comboTelemFilter.insertItem(" ")
    #self.connect(self.comboTelemFilter, SIGNAL("activated(const QString&)"), self.filterTelemetry)

  def initialize(self):
    self.__quit = False
    self.__pause = False
    self.__lcatTlm = LCATtlmDb()
    self.__telemQueue = Queue()
    self.__telemConsumer = TaskEngine("TelemMonitorConsumer")
    self.__telemConsumer.start()
    self.__telemConsumer.spawn(self.consumeTelemPackets)
    self.__guiThread = threading.currentThread()
    self.__guiBridge = GUIbridge(self.__guiThread)
    self.__telemHandler.register(self.__lcatTlm.getApids(), self.process)


  def process(self, telemetry):
    """!\brief Store the incoming telemetry in a queue.

    \param telemetry Raw packet
    """
    if self.isVisible():
      self.__telemQueue.put(telemetry)

  def consumeTelemPackets(self):
    """!\brief Main thread loop which consumes packets from the queue.

    """
    while not self.__quit:
      if self.__telemQueue.empty() or self.__pause:
        time.sleep(.1)
        continue
      self.execGUImethod(self.__updateGUI)

  def __updateGUI(self):
    """!\brief Retrieve a packet from the queue and display it on the GUI.

    """
    while not self.__telemQueue.empty():
      if self.__quit or self.__pause: break
      telem = self.__telemQueue.get()
      time.sleep(.005)
      #msg = "TelemetryHandler called, apid 0x%x " \
      #      "at seconds 0x%x useconds 0x%x length %d" % \
      #      (telem.apid(), telem.secs(), telem.usecs(), telem.length())
      #log.debug(msg)
      #self.textTelem.append(msg)
      pkt = self.__lcatTlm.decodeTelemetry(telem)
      if pkt.name == 'LCMMSGOUTC':
        self.textTelem.append(self.__lcatTlm.msgOutToText(pkt))
      elif pkt.name == 'CmdConfirm':
        statusTuple = self.__lcatTlm.msgByValue(pkt.get_payload("ITC_EXESTATUS"))
        if statusTuple is not None:
          telemDump = "CVT - %s: %s" % (statusTuple[0], statusTuple[1])
        else:
          telemDump = "CVT - Unparsable MSG: 0x%08x" % pkt.get_payload("ITC_EXESTATUS")
        if self.__verbose:
          for (name, value) in self.__lcatTlm.getPayloadData(pkt):
            telemDump += "\n  %20s: 0x%x" % (name, value)
        self.textTelem.append(telemDump)
      else:
        if str(self.comboTelemFilter.currentText()) == " " or \
           str(self.comboTelemFilter.currentText()) == pkt.name:
          telemDump = "Telemetry Name: %s Apid: 0x%04x" % (pkt.name, pkt.apid)
          if self.__verbose:
            for (name, value) in self.__lcatTlm.getPayloadData(pkt):
              telemDump += "\n  %20s: 0x%x" % (name, value)
          self.textTelem.append(telemDump)
        found = False
        for i in range(self.comboTelemFilter.count()):
          if pkt.name == str(self.comboTelemFilter.text(i)):
            found = True
            break
        if not found:
          self.comboTelemFilter.insertItem(pkt.name)
          self.comboTelemFilter.listBox().sort()

  def clearAction(self):
    """!\brief Handle Clear button clicked action.

    """
    self.textTelem.clear()

  def pauseAction(self):
    """!\brief Handle the Pause/Unpause button clicked action.

    """
    if self.buttonPause.text() == "Pause":
      self.__pause = True
      self.buttonPause.setText("Unpause")
      if self.__telemHandler is not None:
        self.__telemHandler.unregister(self.__lcatTlm.getApids(), self.process)
    else:
      self.__pause = False
      self.buttonPause.setText("Pause")
      if self.__telemHandler is not None:
        self.__telemHandler.register(self.__lcatTlm.getApids(), self.process)

  def verboseAction(self, on):
    """!\brief Handle the Verbose button toggle action.

    \param on Toggle is on

    """
    if on:
      self.__verbose = True
    else:
      self.__verbose = False

  def shutdown(self):
    """!\brief Shutdown the monitor.

    """
    self.__quit = True
    if self.__telemConsumer is not None:
      self.__telemConsumer.shutdown()
    apids = self.__lcatTlm.getApids()
    if self.__telemHandler is not None and self.__telemHandler.isregistered(apids, self.process):
      self.__telemHandler.unregister(apids, self.process)
    if self.__guiBridge is not None:
      self.__guiBridge.shutdown()

  def customEvent(self, e):
    """This method overrides the QObject base class's.  There is generally
    no reason to call this method directly.  It is called by the Qt
    infrastructure whenever the custom event is posted, e.g. by the following
    three methods of this class: createGUI, execGUImethodNR and execGUImethod.
    """
    self.__guiBridge.handleCustomEvent(e)

  def execGUImethodNR(self, func, *args, **kwargs):
    """Method used for executing a GUI function from a non-GUI thread.
    Use this method when no (useful) response is expected or
    when waiting for one could cause a deadlock.  Any response from the
    function is lost."""
    if self.__quit: return # Don't try to update the GUI during shutdown

    return self.__guiBridge.execGUImethodNR(self, func, *args, **kwargs)

  def execGUImethod(self, func, *args, **kwargs):
    """Method used for executing a GUI function from a non-GUI thread.
    Use this method when a response is expected from the function and
    when it is appropriate to wait for it (no deadlock arises)"""
    if self.__quit: return # Don't try to update the GUI during shutdown

    return self.__guiBridge.execGUImethod(self, func, *args, **kwargs)

def usage():
  """!\brief Output command line usage.

  """
  return """

TelemMonitorImpl Usage:

Mandatory options:
--proxyHost Specify the proxy host
--type Specify the telemetry type ("telemetry" or "diagnostic")
--vscConfig Specify the VSC configuration file path

Example:
$ TelemMonitorImpl --proxyHost localhost --type telemetry --vscConfig vsc.cfg

"""

if __name__ == "__main__":
  log.getLogger().setLevel(log.INFO)
  options = Options(['proxyHost','type','vscConfig'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(usage())
    raise Exception, msg

  a = QApplication(sys.argv)
  vscConfig = ConfigParser()
  vscConfig.read(options.vscConfig)
  ports = VscProxyPorts(vscConfig.getint('vsc', 'proxyPortBase'))
  if options.type == "telemetry":
    port = ports.telemMon()
  else:
    port = ports.diagMon()
  #handler = createHandler(options.host, port)
  apidRangeList = ([0x000, 0xfff],)
  ip_tel = getip(options.proxyHost)
  tele = VSC.VscProxy.Proxy(ip_tel, port)
  telemHandler = seTelemetryHandler(apidRangeList)
  vscRouter   = LicosTelemetryRouter(telemHandler)
  latRouter   = LicosTelemetryRouter(telemHandler)
  if options.type == "telemetry":
    tele.vscTelemetry(vscRouter)
    tele.latTelemetry(latRouter)
  else:
    tele.vscDiagnostic(vscRouter)
    tele.latDiagnostic(latRouter)
  dm = TelemMonitorImpl(telemHandler)
  if options.type == "telemetry":
    dm.setCaption("Telemetry Monitor (standalone)")
  else:
    dm.setCaption("Diagnostic Telemetry Monitor (standalone)")
  a.setMainWidget(dm)
  dm.show()
  a.exec_loop()

---