VscCvt.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "Current Value Table Server"
__author__  = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/03/19 00:00:11 $").split(' ')[1]
__version__ = "$Revision: 1.16 $"
__release__  = "$Name: HEAD $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import logging as log
import struct, time, threading, socket, asyncore, sys
from ConfigParser import *
import VSC, CCSDS

from LICOS.lib.currValTable.CurrValServer   import CurrentValueFactory
from LICOS.lib.currValTable.CurrValTable    import CurrentValueTable
from LICOS.tools.proxy.VscProxyTools        import encodePacket, getip
from LICOS.lib.cmdTlmDb.LCATtlmDb           import ccsdsTlmHdr, LICOS_VscTlmPacketFactory
from LICOS.tools.proxy.VscProxyPorts        import VscProxyPorts

import LICOS.util.gOptions as gOptions

killEvent = threading.Event()
killEvent.clear()

def asyncore_loop(timeout=1.0, use_poll=False, map=None):
  """replace the asyncore central loop and run it its own thread.
     Valid for Python 2.3.x
     Python 2.4 has an extra agument for loop, count.
  """
  if map is None:
      map = asyncore.socket_map

  if use_poll:
    if hasattr(select, 'poll'):
      poll_fun = asyncore.poll3
    else:
      poll_fun = asyncore.poll2
  else:
    poll_fun = asyncore.poll

  while map and not killEvent.isSet():
    poll_fun(timeout, map)
    sys.stdout.flush()


class CvtRouter(VSC.VscRouting.TelemetryRouter):
  def __init__(self, cvt):
    VSC.VscRouting.TelemetryRouter.__init__(self)
    self.__packet = CCSDS.Ccsds.Telemetry(0, 0, 0)
    self.__cvt = cvt
    self.count = 0

  def allocate(self):
    return self.__packet

  def catchall(self, dat):
    apIdPkt = LICOS_VscTlmPacketFactory(dat)
    if apIdPkt is None:
      hdr = ccsdsTlmHdr(struct.unpack('!H', packet[0:2])[0])
      print "ccsdsCVT received apID %d = 0x%03x which is unrecognized as telemetry" % (hdr.apid, hdr.apid)

    aTime = apIdPkt.secs + apIdPkt.usecs/1E6
    #print apIdPkt, aTime

    apIdPkt.decode_payload()
    # toss each mnemonic in the cvt and then...
    for mnem in apIdPkt.get_payload_list():
      # print mnem, apIdPkt.get_payload(mnem)
      self.__cvt.setValue(mnem, apIdPkt.get_payload(mnem), aTime)
    # add in the packet as well
    cvt.setValue(apIdPkt.name.upper(), encodePacket(dat), aTime)

    if self.count%500 >= 0:
      # print self.__class__, dir(self), self.__str__()
      log.debug( "%s found %d packets.  Last packet=%s at %s" %( self.__class__, self.count, apIdPkt, aTime))
    self.count += 1

class CvtProxy(VSC.VscProxy.Proxy):
  """Define our own proxy
  """
  def __init__(self, ip_vsc, vscPort=39900, cvt=None):
    VSC.VscProxy.Proxy.__init__(self, ip_vsc, vscPort)

    # create the master routers
    self.tlmRouter     = CvtRouter(cvt)
    self.vscRouter     = CvtRouter(cvt)

    # create the subsidiary handlers and register them with the routers
    print "CvtProxy inserting telemrouters"
    self.latTelemetry(self.tlmRouter)
    self.vscTelemetry(self.vscRouter)

class VscCVT(CurrentValueTable):
  def __init__(self, ip_vsc, vscPort):
    super(VscCVT, self).__init__()
    self.__ip_vsc = ip_vsc
    print "Creating CVT proxy, connecting to %x:%d" % ( ip_vsc, vscPort )
    self.__proxy = CvtProxy(ip_vsc, vscPort, cvt=self)



if __name__ == '__main__':
  options = gOptions.Options(['proxyHost', 'config'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(str(msg))
    exit

  ip_vsc = getip(options.proxyHost)
  configFile = options.config
  config = ConfigParser()
  config.read(configFile)

  # create port offsets
  portTool = VscProxyPorts(config.getint('vsc', 'proxyPortBase'))
  cvtPort = portTool.cvtOut()
  vscPort = portTool.cvt()

  # Build CVT proxy client and CVT server
  cvt = VscCVT(ip_vsc, vscPort)
  cvs = CurrentValueFactory(cvtPort, cvt)

  # start asynchronous processing loop
  asyncore_loop()

  killEvent.set()












#eof

---