seTelemetryHandler.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__ = "Diagnostics telemetry handler class"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/09/19 10:00:00"
__updated__  = "$Date: 2005/11/10 02:55:07 $"
__version__  = "$Revision: 1.5 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from VSC import VscHandling

import LICOS.core.dispatch.dispatcher as dispatcher

import threading

class seTelemetryHandler(VscHandling.TelemetryHandler):
  """!\brief Script Engine telemetry handler class.

  """
  def __init__(self, apidRangeList):
    """!\brief seTelemetryHandler constructor.

    \param apidRangeList List containing from and to apids
    """
    VscHandling.TelemetryHandler.__init__(self)
    for (fromApId, toApId) in apidRangeList:
      self.handle(fromApId, toApId)
    #self.callbacks = {}
    #self.__lock = threading.Lock()

  def process(self, telemetry):
    """!\brief Callback method for the telemetry handler.

    \param telemetry Raw telemetry packet
    """
    #self.__lock.acquire()
    #if telemetry.apid() in self.callbacks:
    #  for callback in self.callbacks[telemetry.apid()]:
    #    callback(telemetry)
    #if id(self) in dispatcher.connections:
    #  if telemetry.apid() in dispatcher.connections[id(self)]:
    dispatcher.sendExact(telemetry.apid(), self, telemetry)

    #print "VscTelemetryHandler called apid 0x%x " \
    #      "at seconds 0x%x useconds 0x%x length %d" % \
    #        (telemetry.apid(), telemetry.secs(), telemetry.usecs(),
    #         telemetry.length()+1)
    #self.__lock.release()

  def register(self, apids, callback):
    """!\brief Register a callback for a given telemetry apid.

    \param apids    Telemetry apids
    \param callback Callback method
    """
    #self.__lock.acquire()
    for apid in apids:
      #if apid not in self.callbacks:
      #  self.callbacks[apid] = [callback]
      #else:
      #  self.callbacks[apid].append(callback)
      dispatcher.connect(callback, signal=apid, sender=self)
    #self.__lock.release()

#  def clear(self):
#    """!\brief Clear all registered callbacks.

#    """
#    self.__lock.acquire()
#    self.callbacks.clear()
#    self.__lock.release()

  def unregister(self, apids, callback):
    """!\brief Unregister a registered callback.

    \param apids    Telemetry apids
    \param callback Callback method
    """
    #self.__lock.acquire()
    for apid in apids:
      dispatcher.disconnect(callback, signal=apid, sender=self)
      #if apid in self.callbacks:
      #  if callback in self.callbacks[apid]:
      #    self.callbacks[apid].remove(callback)
    #self.__lock.release()

  def isregistered(self, apids, callback):
    """!\brief Check if \a apids are registered with \a callback.

    \param apids    Telemetry apids
    \param callback Callback method
    """
    for apid in apids:
      receivers = dispatcher.liveReceivers(dispatcher.getReceivers(self, apid))
      if callback not in receivers:
    #  if callback not in self.callbacks[apid]:
        return False
    return True

---