AlarmObjects.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Classes for determining alarm states"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "12/29/2005" # Created
__updated__  = ("$Date: 2006/04/28 01:20:18 $").split(' ')[1]
__version__  = "$Revision: 1.4 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from qt import *

from LICOS.tools.alarm.AlarmStates   import AlarmedItem, AlarmState

import LICOS.tools.alarm.LEDwidget   as LEDwidget
from LICOS.lib.currValTable.CurrValClient   import CurrValClient


class QLV_AlarmedItem(QListViewItem, AlarmedItem):
  icons = { AlarmState.InLimits   : LEDwidget.LEDpixmap(LEDwidget.green),
            AlarmState.Unknown    : LEDwidget.LEDpixmap(LEDwidget.white),
            AlarmState.NoLimit    : LEDwidget.LEDpixmap(LEDwidget.black),
            AlarmState.LoYel      : LEDwidget.LEDpixmap(LEDwidget.yellow),
            AlarmState.HiYel      : LEDwidget.LEDpixmap(LEDwidget.yellow),
            AlarmState.LoRed      : LEDwidget.LEDpixmap(LEDwidget.red),
            AlarmState.HiRed      : LEDwidget.LEDpixmap(LEDwidget.red),
            AlarmState.DscYel     : LEDwidget.LEDpixmap(LEDwidget.yellow),
            AlarmState.DscRed     : LEDwidget.LEDpixmap(LEDwidget.red),
#            AlarmState.Disabled   : LEDwidget.LEDpixmap(LEDwidget.blue),
            }
  messageBoxStates = { AlarmState.InLimits   : QMessageBox.Information,
                       AlarmState.Unknown    : QMessageBox.Information,
                       AlarmState.NoLimit    : QMessageBox.Information,
                       AlarmState.LoYel      : QMessageBox.Warning,
                       AlarmState.HiYel      : QMessageBox.Warning,
                       AlarmState.LoRed      : QMessageBox.Critical,
                       AlarmState.HiRed      : QMessageBox.Critical,
                       AlarmState.DscYel     : QMessageBox.Warning,
                       AlarmState.DscRed     : QMessageBox.Critical,
#                       AlarmState.Disabled   : QMessageBox.Information,
                       }
  raiseAlarmStates = [ AlarmState.LoYel,
                       AlarmState.HiYel,
                       AlarmState.LoRed,
                       AlarmState.HiRed,
                       AlarmState.DscYel,
                       AlarmState.DscRed,
                       ]


  def __init__(self, gui, parent=None, text=None, state=None):
    QListViewItem.__init__(self, parent, text)
    AlarmedItem.__init__(self, parent, state)
    self.__cv = None
    self.__gui = gui
    self.__name = text
    self.setPixmap(0, self.icons[self.state().stateEnum()] )

  def setState(self, state, forceUpdate = False):
    """!\brief Set the state of the current object

    \param state  Either an integer or an AlarmState object
    """
    curState = self.state()
    super(QLV_AlarmedItem, self).setState( state, forceUpdate )
    newState = self.state()
    self.setRawValue()
    self.setEngValue()
    
    if not self.isEnabled():
      self.setPixmap(0, LEDwidget.LEDpixmap(LEDwidget.blue))
    else:
      self.setPixmap(0, self.icons[self.state().stateEnum()])
      
      if self.state().stateEnum() in self.raiseAlarmStates and \
           newState != curState :
        if self.__cv is not None and self.__gui.popAlarms():
          self.raiseAlarm()

  def update(self, state):
    """!\brief Update my state with whatever the state should be

    \param state  The state
    """
    self.setState(state)
    pass

  def recalculate(self):
    """!\brief Recalculate this items state based on its children

    """
    self.setState( self.childStateSum() )

  def cv(self):
    return self.__cv

  def tlmDb(self):
    return self.__gui.tlmDb()

  def setCV(self, cv):
    self.__cv = cv

  def showInfo(self):
    self.__iw = QLV_InfoWidget(self)
    self.__iw.show()

  def showLimits(self):
    self.__iw = QLV_LimitsWidget(self)
    self.__iw.show()

  def expandChildren(self, expand=True):
    # Expand all Children of this item
    self.setOpen(expand)
    self.iterateChildren( self.__class__.expandChildren, expand)

  def setDescription(self, description):
    self.setText(3, description)

  def setRawValue(self):
    if self.cv() is not None:
      text ='0x%06x' %self.cv().rawValue()
      self.setText(1,text)

  def setEngValue(self):
    if self.cv() is not None:
      mnemObj = self.tlmDb().mnem(self.cv().name)
      egu = mnemObj.conversion().egu(self.cv().rawValue())
      text = mnemObj.conversion().tostring(egu)
#      try:
#        text = '%.2f' %egu
#      except:
#        text = '%s' %egu
      self.setText(2,text)

  def raiseAlarm(self):
    title = "%s alarm from Telemetry point %s" % ( self.state().state(), str(self.text(0)) )

    stateColor = self.icons[self.state().stateEnum()].color()
    message  = ""

    message += "%s has raised a %s alarm.<br><br>" % \
               ( str(self.text(0)), self.state().state())
    if self.__cv is not None:
      mnemObj = self.tlmDb().mnem(self.__cv.name)
      egu = mnemObj.conversion().egu( self.__cv.rawValue() )
      if egu is None:
        message += "EGU failed conversion<br>"
      else:
        message += "EGU value = %.2f<br>" % egu

      message += "Raw value = 0x%x<br>" % self.__cv.rawValue()
      if mnemObj.limit() is not None:
        message += "Limit Definition = %s<br>" % str(mnemObj.limit())

    mb = QMessageBox( title,
                      message,
                      self.messageBoxStates[self.state().stateEnum()],
                      QMessageBox.Ok,
                      QMessageBox.NoButton,
                      QMessageBox.NoButton,
                      self.__gui,
                      None,
                      False )
    mb.show()


  def name(self):
    return self.__name

class QLV_InfoWidget(QWidget):
  def __init__(self, alarmedItem, parent=None, name=None, fl=0):
    QWidget.__init__(self, parent, name, fl)

    self.layout = QGridLayout(self, 1,1,0,6)

    self.nameLbl   = QLabel(alarmedItem.text(0), self)
    self.stateLbl  = QLabel(alarmedItem.state().state(), self)
    self.nameLbl.setAlignment(Qt.AlignHCenter)

    self.stateLbl.setAlignment(Qt.AlignHCenter)
    stateColor = alarmedItem.icons[alarmedItem.state().stateEnum()].color()
    self.stateLbl.setPaletteForegroundColor(QColor(stateColor))

    self.layout.addWidget( self.nameLbl, 0, 0 )
    self.layout.addWidget( self.stateLbl, 1, 0 )

    if alarmedItem.cv() is not None:
      mnemObj = alarmedItem.tlmDb().mnem(alarmedItem.cv().name)
      egu     = mnemObj.conversion().egu(alarmedItem.cv().rawValue())

      try:
        msg = "Raw: 0x%06x    EGU: %.2f" % (alarmedItem.cv().rawValue(), egu)
      except:
        msg = "Raw: 0x%06x    EGU: %s" % (alarmedItem.cv().rawValue(), egu)
      self.valueLbl = QLabel(str(msg), self)
      self.valueLbl.setAlignment(Qt.AlignHCenter)
      self.layout.addWidget( self.valueLbl, 2, 0 )

class QLV_LimitsWidget(QWidget):
  def __init__(self, alarmedItem, parent=None, name=None, fl=0):
    QWidget.__init__(self, parent, name, fl)

    self.setCaption(QString("Limit Information"))
    self.layout = QGridLayout(self, 1,1,0,6)

    self.nameLbl   = QLabel(alarmedItem.text(0), self)
    self.nameLbl.setAlignment(Qt.AlignHCenter)


    self.layout.addWidget( self.nameLbl, 0, 0 )

    try:
      mnemObj = alarmedItem.tlmDb().mnem(alarmedItem.cv().name)
      msg = mnemObj.limit()
    except:
      msg = "No Limits"
    self.valueLbl = QLabel(str(msg), self)
    self.valueLbl.setAlignment(Qt.AlignHCenter)
    self.layout.addWidget( self.valueLbl, 2, 0 )


class AlarmClient(CurrValClient):
  def __init__(self, host, port, gui, mnemList):

    CurrValClient.__init__(self, host, port, mnemList)
    self.__gui = gui
    self.__updateCounter = 0
    # self.registerAll()  # moved to AlarmHandler.configure()

  def update(self, cv):
    self.__updateCounter += 1

    guiBridge = self.__gui.guiBridge()

    mnemObj = self.__gui.tlmDb().mnem(cv.name)
    egu     = mnemObj.conversion().egu(cv.rawValue())
    limit   = mnemObj.limit()
    try:
      guiBridge.execGUImethodNR( self.__gui,
                                 self.__gui.alarmItems()[cv.name].setCV,
                                 cv )
      if limit is not None:
        lc = limit.check(egu)
      else:
        lc = AlarmState.NoLimit
      guiBridge.execGUImethodNR( self.__gui,
                                 self.__gui.alarmItems()[cv.name].update,
                                 lc )
    except:
      print 'AlarmClient.update2 no alarmItem:',cv.name


  def reply(self, cv):
    pass

  def getUpdateCount(self):
    return self.__updateCounter

if __name__ == '__main__':
  pass

---