SocketCVT.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: 2005/11/30 18:44:22 $").split(' ')[1]
__version__ = "$Revision: 1.5 $"
__release__  = "$Name: HEAD $"
__credits__ = "SLAC"

import LICOS.copyright_SLAC

import struct, time
import asyncore, threading, socket


from LICOS.lib.currValTable.CurrValServer         import CurrentValueFactory
from LICOS.lib.currValTable.CurrValTable          import CurrentValueTable
from LICOS.lib.currValTable.StringTcpProtocol     import Int16StringProtocol
import LICOS.util.gOptions as gOptions
from LICOS.lib.cmdTlmDb.LCATtlmDb           import ccsdsTlmHdr, LICOS_VscTlmPacketFactory


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)

class SocketCVTClient(Int16StringProtocol):
  def __init__(self, cvt, host, port):
    super(SocketCVTClient, self).__init__()

    # build the main connection socket
    self.create_socket(socket.AF_INET,socket.SOCK_STREAM)

    self.__host = host
    self.__port = port
    self.__cvt  = cvt
    self.__connect()

  def __connect(self):
    self.connect( (self.__host, self.__port) )
    time.sleep(0.05)
    self.send("ok CCSDS\n")

  def handle_connect(self):
    # print "handle_connect"
    pass

  def handle_close(self):
    # Try an exponential reconnect?  ****REVISIT****
    self.close()

  def stringReceived(self, line):
    self.__cvt.dispatch(line)

class ccsdsCVT(CurrentValueTable):
  def dispatch(self, packet):
    apIdPkt = LICOS_TlmPacketFactory(packet)
    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()
    for mnem in apIdPkt.get_payload_list():
      # print mnem, apIdPkt.get_payload(mnem)
      self.setValue(mnem, apIdPkt.get_payload(mnem), aTime)
    # add in the packet as well
    self.setValue(apIdPkt.name.upper(), packet, aTime)

    self.setValue("LASTPACKET", apIdPkt.name.upper(), aTime)

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

  pktHost = options.pktHost
  pktPort = int(options.pktPort)
  cvtPort = int(options.cvtPort)

  cvt = ccsdsCVT()
  cvc = SocketCVTClient(cvt, pktHost, pktPort)
  cvs = CurrentValueFactory(cvtPort, cvt)

  asyncore_loop(0.5)

  killEvent.set()






#eof

---