TelemetryEvent.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__ = "Helper class for handling telemetry"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/09/13 00:08:27"
__updated__  = "$Date: 2006/03/22 03:16:00 $"
__version__  = "$Revision: 1.5 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import logging as log
import threading

from LICOS.lib.cmdTlmDb.LCATtlmDb import LICOS_VscTlmPacketFactory

class TelemetryEvent(object):
  """!\brief Helper class for handling telemetry
  """
  def __init__(self, telemHandler, apidList, callback=None):
    """!\brief TelemetryEvent constructor.

    \param Telemetry handler instance
    \param apidList  List of apids
    \param callbcak  Callback method
    """
    self.__apidList = apidList
    self.__telemetryReceived = threading.Event()
    self.__telemHandler = telemHandler
    self.__telemCallback = callback
    self.__telemetryProcessed = threading.Event()
    self.__telemetryProcessed.set()

  def __notification(self, telemetry):
    """!\brief Callback for the command confirmation telemetry.

    \param telemetry Raw telemetry packet
    """
    if self.__telemCallback is not None:
      self.__telemCallback(telemetry)
    self.__telemetryReceived.set()
    self.__telemetry = telemetry
    self.__telemetryProcessed.wait()

  def wait(self, timeout=10, quiet=False):
    """!\brief Wait for telemetry.

    \param timeout Wait timeout value

    \return False if the telemetry is not received within the given \a timeout.
            True  if the telemetry is received.
    """
    self.__telemetryProcessed.clear()
    self.__telemetryReceived.wait(timeout)
    if not self.__telemetryReceived.isSet():
      self.__telemetryProcessed.set()
      if not quiet:
        log.warn("Timeout waiting for telemetry")
      return False
    else:
      self.__telemetryReceived.clear()
      self.__telemetryProcessed.set()
      return True

  def waitForPayload(self, payloads, timeout=10, quiet=False):
    """!\brief Wait for telemetry and return a list of payload values.

    \param timeout  Wait timeout value
    \param payloads Payload names to query for

    \return A list of payload values or None if the telemetry
            is not received within the given \a timeout.
            If any of the payload names are invalid then
            None is returned for that payload
    """
    self.__telemetryProcessed.clear()
    self.__telemetryReceived.wait(timeout)
    if not self.__telemetryReceived.isSet():
      self.__telemetryProcessed.set()
      if not quiet:
        log.warn("Timeout waiting for telemetry")
      return None
    else:
      self.__telemetryReceived.clear()
      pkt = LICOS_VscTlmPacketFactory(self.__telemetry)
      pkt.decode_payload()
      values = []
      pktPayloads = pkt.get_payload_list()
      for payload in payloads:
        if payload in pktPayloads:
          value = pkt.get_payload(payload)
        else:
          value = None
        values.append(value)
      self.__telemetryProcessed.set()
      return values

  def enable(self):
    """!\brief Enable the callback.

    """
    self.__telemHandler.register(self.__apidList, self.__notification)

  def disable(self):
    """!\brief Disable the callback.

    """
    self.__telemHandler.unregister(self.__apidList, self.__notification)

  def isEnabled(self):
    """!\brief Find out if the telemetry event is enabled

    \return Boolean indicating whether telemtry event is enabled or not
    """
    return self.__telemHandler.isregistered(self.__apidList, self.__notification)

---