test_vsc.py

Go to the documentation of this file.

#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "Simple VSC simulator used for testing tele-commands"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/04/27 18:22:56 $"
__version__  = "$Revision: 1.6 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from LICOS.tools.proxy.VscProxyPorts import VscProxyPorts
from LICOS.util.gOptions             import Options

import socket
import types
import threading
from   SocketServer import ThreadingTCPServer, StreamRequestHandler
import errno
import select
from  time import sleep
from binascii import hexlify
from LCAT_decoder import *

VSC_CTL_PORT = 3000
VSC_CMD_PORT = 3001
VSC_TLM_PORT = 3002
LAT_TLM_PORT = 3003
LAT_SCI_PORT = 4001

def startListenerThread(name, port):
  """!\brief Start the VSC listener thread.

  \param port The port that the listener will listen on
  """
  tcpserver = VscSocketReceiver(port=port)
  runTCPThread = threading.Thread(target=runTCP, name=name, args=(tcpserver,))
  runTCPThread.start()
  return runTCPThread

def runTCP(tcpserver):
  """!\brief Start the listener loop.

  """
  tcpserver.serve_until_stopped()

class VscSocketHandler(StreamRequestHandler):
  """!\brief VSC packet handler.

  """
  def handle(self):
    """!\brief Handle the incoming packet.

    """
    while 1:
      try:
        ccsds = self.connection.recv(1024)
        if len(ccsds) == 0:
          break
        else:
          print "ccsds packet  = %s" % hexlify(ccsds)
          #ccsds = ccsdsPacket(ccsds)
          #print "header        = 0x%08x" % ccsds.header.ui
          #print "  apid        = 0x%x" % ccsds.header.apid
          #print "  secHead     = 0x%x" % ccsds.header.secHead
          #print "  type        = 0x%x" % ccsds.header.type
          #print "  version     = 0x%x" % ccsds.header.version
          #print "  seqCnt      = 0x%x" % ccsds.header.seqCnt
          #print "  seqFlg      = 0x%x" % ccsds.header.seqFlg
          #print "length        = 0x%x" % ccsds.length
          #print "seconds       = 0x%x" % ccsds.seconds
          #print "subSeconds    = 0x%x" % ccsds.subSeconds
          #print "payload       = %s" % hexlify(ccsds.payload)
          #print "-"*80
      except socket.error, e:
        if type(e.args) != types.TupleType:
          raise e
        else:
          errcode = e.args[0]
          if errcode != errno.ECONNRESET:
            raise e
          break


class VscSocketReceiver(ThreadingTCPServer):
  """!\brief VSC socket receiver.

  """
  allow_reuse_address = 1

  def __init__(self, host='', port=None,
      handler=VscSocketHandler):
    """!\brief VscSocketReceiver constructor.

    \param host    Host name
    \param port    Listen port
    \param handler Packet handler
    """
    ThreadingTCPServer.__init__(self, (host, port), handler)
    self.__abort = 0
    self.timeout = 1
    self.handler = handler

  def abort(self):
    """!\brief Signal the abort.

    """
    self.__abort = 1

  def serve_until_stopped(self):
    """!\brief Main listener loop.

    """
    while not self.__abort:
      rd, wr, ex = select.select([self.socket.fileno()],
                                 [], [],
                                 self.timeout)
      if rd:
        self.handle_request()

def usage():
  return """

test_vsc usage:

Optional options:
--portbase    specify the port base

Example:
$ test_vsc --portbase 3000

"""

if __name__ == "__main__":
  options = Options([],['portbase'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(usage())
    raise Exception, msg

  if options.portbase is None:
    portbase = 3000
  else:
    portbase = int(options.portbase)
  ports = VscProxyPorts(portbase)
    
  ctlThread       = startListenerThread('VscControl',      ports.vsc())
  diagThread      = startListenerThread('VscDiagnostic',   ports.diagnostic())
  tlmThread       = startListenerThread('VscTelemetry',    ports.telemetry())
  #latTlmThread    = startListenerThread('VscLatTelemetry', LAT_TLM_PORT_OFFSET)
  #latScicmdThread = startListenerThread('VscLatScience',   LAT_SCI_PORT_OFFSET)
  
  print "Ready."
  while 1:
    sleep(1.0)

---