TelemetryProxy.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 Proxy class"
__author__   = "S. Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/09/06"
__updated__  = "$Date: 2006/04/25 17:22:01 $"
__version__  = "$Revision: 1.19 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import os
import sys
import time
from ConfigParser import ConfigParser

import VSC
import CCSDS

from LICOS.util.gOptions             import Options
from LICOS.tools.proxy.VscProxyPorts import VscProxyPorts
from LICOS.tools.proxy.VscProxyTools import getip, VscProxyLogger

class VscTelemetryRouter(VSC.VscRouting.TelemetryRouter):
  def __init__(self, streamList):
    VSC.VscRouting.TelemetryRouter.__init__(self)
    self.__packet = CCSDS.Ccsds.Telemetry(0, 0, 0)
    self.__streamList = streamList
    if len(self.__streamList) == 0:
      raise "cannot have empty stream list"
    self.__counter = 0

  def allocate(self):
    return self.__packet

  def catchall(self, ccsds):
    self.__counter += 1
    for stream in self.__streamList:
      stream.send_nothrow(ccsds)

  def packets(self):
    return self.__counter


class TelemetryProxy(VSC.VscProxy.Proxy):
  """!\brief Stand alone telemetry proxy

  Standalone telemetry proxy provides several features:
  1: Pass through VSC.VscCcsds packets to a script engine connection.
  2: Pass through VSC.VscCcsds packets to the CVT
  3: Archiving of raw CCSDS stream to an ISOC archiver
  """
  def __init__(self, ip_vsc, config, noarchiver):
    ports = VscProxyPorts(config.getint('vsc', 'proxyPortBase'))
    VSC.VscProxy.Proxy.__init__(self, ip_vsc, ports.vsc())

    # create the pass through handlers to ScriptEngine
    self.__vscScriptSender = VSC.VscNetwork.TelemetrySender()
    self.__latScriptSender = VSC.VscNetwork.TelemetrySender()
    # connect plumbing for ScriptEngine pass through
    print "Creating ScriptEngine passthrough on port %d" % ports.telemetry()
    self.__connector = VSC.VscProxy.RequestRouter(ports.telemetry())
    self.__connector.handle(self.__vscScriptSender, VSC.VscProxy.VscTelemetry)
    self.__connector.handle(self.__latScriptSender, VSC.VscProxy.LatTelemetry)
    self.__connector.start()

    # create the pass through handlers to CVT
    self.__vscCvtSender    = VSC.VscNetwork.TelemetrySender()
    self.__latCvtSender    = VSC.VscNetwork.TelemetrySender()
    # connect plumbing for CVT pass through
    print "Creating CVT connector on port %d" % ports.cvt()
    self.__cvtConnector = VSC.VscProxy.RequestRouter(ports.cvt())
    self.__cvtConnector.handle(self.__vscCvtSender, VSC.VscProxy.VscTelemetry)
    self.__cvtConnector.handle(self.__latCvtSender, VSC.VscProxy.LatTelemetry)
    self.__cvtConnector.start()

    # create the pass through handlers to telemetry monitor
    self.__vscMonSender    = VSC.VscNetwork.TelemetrySender()
    self.__latMonSender    = VSC.VscNetwork.TelemetrySender()
    print "Creating monitor passthrough on port %d" % ports.telemMon()
    self.__monConnector = VSC.VscProxy.RequestRouter(ports.telemMon())
    self.__monConnector.handle(self.__vscMonSender, VSC.VscProxy.VscTelemetry)
    self.__monConnector.handle(self.__latMonSender, VSC.VscProxy.LatTelemetry)
    self.__monConnector.start()

    vscStreams = [self.__vscScriptSender, self.__vscCvtSender, self.__vscMonSender]
    latStreams = [self.__latScriptSender, self.__latCvtSender, self.__latMonSender]

    if noarchiver is False:
      # Import here if archiving is enabled otherwise Windows will complain -ST
      from LICOS.tools.proxy.VscArchivers  import VscArchiver
      archive_path = config.get('paths','archive_path')
      granularity  = config.getint('ccsds_archivers', 'granularity')
      self.__archiver = VscArchiver(apIdGrp = "HSK",
                                    path = archive_path,
                                    granularity = granularity)
      vscStreams.append(self.__archiver)
      latStreams.append(self.__archiver)

    self.vscRouter = VscTelemetryRouter(vscStreams)
    self.latRouter = VscTelemetryRouter(latStreams)
    self.vscTelemetry(self.vscRouter)
    self.latTelemetry(self.latRouter)


if __name__ == '__main__':
  options = Options(['vscip', 'config'], [], ['logtime', 'noarchiver'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(str(msg))
    sys.exit()

  if options.logtime is not None:
    sys.stdout = VscProxyLogger('telemetry proxy: ')
    sys.stderr = sys.stdout

  vscip = getip(options.vscip)
  config = ConfigParser()
  config.read(options.config)
  dumpInterval = config.getint('vsc', 'dumpInterval')
  noarchiver = (options.noarchiver is not None)
  proxy = TelemetryProxy(vscip, config, noarchiver)

  while True:
    time.sleep(dumpInterval)
    print 'received %d VSC packets' %proxy.vscRouter.packets()
    print 'received %d LAT packets' %proxy.latRouter.packets()
    sys.stdout.flush()

---