ScriptEngineConnector.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__ = "VSC Proxy connector class"
__author__   = "S. Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/09/06"
__updated__  = "$Date: 2006/04/21 20:54:55 $"
__version__  = "$Revision: 1.31 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import VSC, CCSDS
import struct
import socket
import logging as log


from LCAT_encoder import LCAT_CmdPacketFactory

from LICOS.tools.proxy.VscProxyTools        import getip
from LICOS.tools.proxy.VscProxyPorts        import VscProxyPorts
from LICOS.scriptEngine.seTelemetryHandler  import seTelemetryHandler
from LICOS.scriptEngine.seCmdCountMon       import seCmdCountMon

class ScriptEngineConnector(object):
  """!\brief Script Engine proxy connector class.

  This class creates three VSC proxies, one to the control stream to
  send tele-commands, one to the diagnostics proxy and one to the
  telemetry proxy.
  """
  AA = VSC.VscProxy.AA
  AB = VSC.VscProxy.AB
  BA = VSC.VscProxy.BA
  BB = VSC.VscProxy.BB

  BOOTFLAG_UPPERBANK  = 0x5400
  BOOTFLAG_LOWERBANK  = 0xA800
  BOOTFLAG_MNTEEPROM  = 0xC000

  VscCtrlPort        = 3000

  DownloadSiuPids = VSC.VscProxy.DownloadSiuPids

  def __init__(self, vscHost, diagHost=None, telemHost=None,
               archiver=None, cmdDebug=None, portBase=None):
    """!\brief ScriptEngineConnector constructor.

    \param vscHost   VSC host name or IP address.  Required option.
    \param diagHost  Diagnostics telemetry process proxy host name or IP address (Default: None)
    \param telemHost Telemetry proxy process host name or IP address (Default: None)
    \param archiver  Command archiver object (Default: None)
    \param cmdDebug  If set, command debugging is turned on.  (Warning, verbose output to follow)
    \param portBase  If set, defines the base for the VSC port mapping.  If None, uses self.VscCtrlPort

    Note:  When diagHost and/or telemHost is None, no diagnostic or standard
    telemetry will be received.
    """
    apidRangeList = ([0x000, 0xfff],)
    if portBase is None:
      portBase = self.VscCtrlPort

    ports = VscProxyPorts(portBase)

    if diagHost is not None:
      ip_dia = getip(diagHost)
      self.__diag = VSC.VscProxy.Proxy(ip_dia, ports.diagnostic())
      self.__diagHandler = seTelemetryHandler(apidRangeList)
      self.__pidsHandler  = sePidsHandler()
      self.__vscdRouter   = LicosTelemetryRouter(self.__pidsHandler)
      self.__latdRouter   = LicosTelemetryRouter(self.__diagHandler)
      self.__diag.vscDiagnostic(self.__vscdRouter)
      self.__diag.latDiagnostic(self.__latdRouter)
    else:
      self.__diagHandler = None
      self.__pidsHandler = None

    if telemHost is not None:
      ip_tel = getip(telemHost)
      self.__tele = VSC.VscProxy.Proxy(ip_tel, ports.telemetry())
      self.__telemHandler = seTelemetryHandler(apidRangeList)
      self.__vscRouter   = LicosTelemetryRouter(self.__telemHandler)
      self.__latRouter   = LicosTelemetryRouter(self.__telemHandler)
      self.__tele.vscTelemetry(self.__vscRouter)
      self.__tele.latTelemetry(self.__latRouter)
    else:
      self.__telemHandler = None

    ip_vsc = getip(vscHost)
    self.__ctrl = VSC.VscProxy.Controller(ip_vsc, ports.vsc())
    self.__archiver = archiver
    self.__tlmDb = None

    # Command count for commands sent from the ScriptEngineConnector
    # since the start of ScriptEngine.
    self.__cmdCount = 0

    self.__cmdDebug = cmdDebug

  def initCmdCountMon(self):
    """!\brief Initialize the command count monitor.

    """
    # Command count monitor which polls on CmdCnt0 telemetry (if it exists)
    self.__cmdCountMon = seCmdCountMon(self)
    self.__cmdCountMon.startMonitor()

  def getCmdCountMon(self):
    """!\brief Retrieve the command count monitor instance.

    \return seCmdCountMon instance
    """
    return self.__cmdCountMon

  def getCmdDebug(self):
    """!\brief Retrieve the command debug flag.

    \return Command debug flag.
    """
    return (self.__cmdDebug is not None)

  def getDiagHandler(self):
    """!\brief Retrieve the diagnostic telemetry handler.

    \return seTelemetryHandler instance
    """
    return self.__diagHandler

  def getTelemHandler(self):
    """!\brief Retrieve the LAT/VSC telemetry handler.

    \return seTelemetryHandler instance
    """
    return self.__telemHandler

  def getPidsHandler(self):
    """!\brief Retrieve the pids telemetry handler.

    \return sePidsHandler instance
    """
    return self.__pidsHandler


  def getArchiver(self):
    """!\brief Retrieve the command archiver object.

    \return A VscArchiver instance
    """
    return self.__archiver

  def getTlmDb(self):
    return self.__tlmDb

  def setTlmDb(self, db):
    self.__tlmDb = db

  def bootSIU(self, siuId=0, flags_hi=None, flags_lo=None):
    """!\brief Boot the SIU.

    \param siuId    SIU unit
    \param flags_hi SIU boot flags MSW
    \param flags_lo SIU boot flags LSW
    """
    if flags_hi is None:
      flags_hi = self.BOOTFLAG_UPPERBANK
    if flags_lo is None:
      flags_lo = self.BOOTFLAG_MNTEEPROM

    cmd = LCAT_CmdPacketFactory('LPBCRTOSEXEC')
    cmd.set_payload('LPBCLATUNIT', siuId)
    cmd.set_payload('LPBCPAD1',0x0)
    cmd.set_payload('LPBCPAD2',0x0)
    cmd.set_payload('LPBCSBCFLAGSHI',flags_hi)
    cmd.set_payload('LPBCSBCFLAGSLO',flags_lo)
    self.execute(cmd)

  def bootEPU(self, epuId=0, flags_hi=None, flags_lo=None):
    """!\brief Send boot telecommand to the EPU

    \param epuId EPU id
    \param flags EPU boot flags
    """
    if flags_hi is None:
      flags_hi = self.BOOTFLAG_UPPERBANK
    if flags_lo is None:
      flags_lo = self.BOOTFLAG_MNTEEPROM

    cmd = LCAT_CmdPacketFactory('LPBCRTOSEXEC')
    cmd.set_payload('LPBCLATUNIT',epuId+1)
    cmd.set_payload('LPBCPAD1',0x0)
    cmd.set_payload('LPBCPAD2',0x0)
    cmd.set_payload('LPBCSBCFLAGSHI',flags_hi)
    cmd.set_payload('LPBCSBCFLAGSLO',flags_lo)
    self.execute(cmd)

  def resetSIU(self, siuId=0):
    """!\brief Initiate a warm reboot of the SIU

    \param siuId SIU unit
    """
    cmd = LCAT_CmdPacketFactory('LPBCRESET')
    cmd.set_payload('LPBCLATUNIT', siuId)
    cmd.set_payload('LPBCPAD1',0x0)
    cmd.set_payload('LPBCPAD2',0x0)
    cmd.set_payload('LPBCPRIFLAGSHI', 0)
    cmd.set_payload('LPBCPRIFLAGSLO', 0)
    self.execute(cmd)

  def resetEPU(self, epuId=0):
    """!\brief Initiate a warm reboot of the EPU

    \param epuId EPU id
    """
    cmd = LCAT_CmdPacketFactory('LPBCRESET')
    cmd.set_payload('LPBCLATUNIT', epuId+1)
    cmd.set_payload('LPBCPAD1',0x0)
    cmd.set_payload('LPBCPAD2',0x0)
    cmd.set_payload('LPBCPRIFLAGSHI', 0)
    cmd.set_payload('LPBCPRIFLAGSLO', 0)
    self.execute(cmd)

  def mainFeedOn(self, siuId=0, pduId=0, mfPri=1, dabPri=1, dabRed=0, ppsRed=0, ppsInt=0, ssrRed=0, gbmRed=0):
    """!\brief Turn on the main feed.

    The default parameter values turn on the PDU and GASU at the same time.

    To turn on the PDU only:
     pduId = PDU id,
     mfPri = 1
     dabPri = 0
     dabRed = 0

    To turn on the primary GASU (after turning on the PDU):
     pduId = PDU id,
     mfPri = 1
     dabPri = 1
     dabRed = 0

    To turn on the redundant GASU (after turning on the PDU):
     pduId = PDU id,
     mfPri = 1
     dabPri = 0
     dabRed = 1

    \param siuId  SIU unit
    \param pduId  PDU unit
    \param mfPRi  Primary main-feed selection
    \param dabPri Primary DAB selection
    \param dabRed Redundant DAB selection
    \param ppsRed Redundant PPS selection
    \param ppsInt PPS selection
    """
    cmd = LCAT_CmdPacketFactory('LIMMAINFEEDON')
    cmd.set_payload('LIMSIUPAD0', 0)
    cmd.set_payload('LIMSIUID', siuId)
    cmd.set_payload('LIMSIUSSRRED', ssrRed)
    cmd.set_payload('LIMSIUGBMRED', gbmRed)
    cmd.set_payload('LIMSIUPPSRED', ppsRed)
    cmd.set_payload('LIMSIUPPSINT', ppsInt)
    cmd.set_payload('LIMSIUPAD1', 0)
    cmd.set_payload('LIMSIUMFPRI', mfPri)
    if pduId == 0:
      cmd.set_payload('LIMSIUPDU0', 1)
      cmd.set_payload('LIMSIUPDU1', 0)
    elif pduId == 1:
      cmd.set_payload('LIMSIUPDU0', 0)
      cmd.set_payload('LIMSIUPDU1', 1)
    else:
      cmd.set_payload('LIMSIUPDU0', 0)
      cmd.set_payload('LIMSIUPDU1', 0)
    cmd.set_payload('LIMSIUDABPRI', dabPri)
    cmd.set_payload('LIMSIUDABRED', dabRed)
    self.executeTeleCmd(cmd)


  def powerOnEpuOnly(self, epuId=0, pduId=0):
    """!\brief Power on the EPU only

    \param epuId EPU id
    \param pduId PDU id
    """
    self.setPowerEpuOnly(epuId, pduId, powerOn=1)

  def powerOffEpuOnly(self, epuId=0, pduId=0):
    """!\brief Power off the EPU only

    \param epuId EPU id
    \param pduId PDU id
    """
    self.setPowerEpuOnly(epuId, pduId, powerOn=0)

  def setPowerEpuOnly(self, epuId, pduId, powerOn):
    if powerOn:
      cmd = LCAT_CmdPacketFactory('LIMPOWERON')
    else:
      cmd = LCAT_CmdPacketFactory('LIMPOWEROFF')
    for i in range(16):
      cmd.set_payload('LIMPWRTEMSEL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMPDU%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMCAL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMTKR%02d' % i, 0)
    if epuId == 0:
      cmd.set_payload('LIMPWREPUSEL02',0)
      cmd.set_payload('LIMPWREPUSEL01',0)
      cmd.set_payload('LIMPWREPUSEL00',1)
    elif epuId == 1:
      cmd.set_payload('LIMPWREPUSEL02',0)
      cmd.set_payload('LIMPWREPUSEL01',1)
      cmd.set_payload('LIMPWREPUSEL00',0)
    else:
      cmd.set_payload('LIMPWREPUSEL02',1)
      cmd.set_payload('LIMPWREPUSEL01',0)
      cmd.set_payload('LIMPWREPUSEL00',0)
    cmd.set_payload('LIMPWREPUPDU02',pduId)
    cmd.set_payload('LIMPWREPUPDU01',pduId)
    cmd.set_payload('LIMPWREPUPDU00',pduId)
    cmd.set_payload('LIMPWRACDSEL',0)
    cmd.set_payload('LIMPWRACDPDU',0)
    cmd.set_payload('LIMPWRACDSUPRED',0)
    for i in range(12):
      cmd.set_payload('LIMPWRACDFREE%02d' % i, 0)
    self.executeTeleCmd(cmd)

  def powerOnTemOnly(self, temId, pduId=0):
    self.setPowerTemOnly(temId, pduId, powerOn=1)

  def powerOffTemOnly(self, temId, pduId=0):
    self.setPowerTemOnly(temId, pduId, powerOn=0)

  def setPowerTemOnly(self, temId, pduId, powerOn):
    if powerOn:
      cmd = LCAT_CmdPacketFactory('LIMPOWERON')
    else:
      cmd = LCAT_CmdPacketFactory('LIMPOWEROFF')
    for i in range(16):
      if i == temId:
        power = 1
      else:
        power = 0
      cmd.set_payload('LIMPWRTEMSEL%02d' % i, power)
      cmd.set_payload('LIMPWRTEMPDU%02d' % i, pduId)
      cmd.set_payload('LIMPWRTEMCAL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMTKR%02d' % i, 0)
    for i in range(3):
      cmd.set_payload('LIMPWREPUSEL%02d' % i, 0)
      cmd.set_payload('LIMPWREPUPDU%02d' % i ,0)
    cmd.set_payload('LIMPWRACDSEL',0)
    cmd.set_payload('LIMPWRACDPDU',0)
    cmd.set_payload('LIMPWRACDSUPRED',0)
    for i in range(12):
      cmd.set_payload('LIMPWRACDFREE%02d' % i, 0)
    self.executeTeleCmd(cmd)

  def powerOnCalOnly(self, temId):
    self.setPowerCalOnly(temId, powerOn=1)

  def powerOffCalOnly(self, temId):
    self.setPowerCalOnly(temId, powerOn=0)

  def setPowerCalOnly(self, temId, powerOn):
    if powerOn:
      cmd = LCAT_CmdPacketFactory('LIMPOWERON')
    else:
      cmd = LCAT_CmdPacketFactory('LIMPOWEROFF')
    for i in range(16):
      if i == temId:
        power = 1
      else:
        power = 0
      cmd.set_payload('LIMPWRTEMSEL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMPDU%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMCAL%02d' % i, power)
      cmd.set_payload('LIMPWRTEMTKR%02d' % i, 0)
    for i in range(3):
      cmd.set_payload('LIMPWREPUSEL%02d' % i, 0)
      cmd.set_payload('LIMPWREPUPDU%02d' % i ,0)
    cmd.set_payload('LIMPWRACDSEL',0)
    cmd.set_payload('LIMPWRACDPDU',0)
    cmd.set_payload('LIMPWRACDSUPRED',0)
    for i in range(12):
      cmd.set_payload('LIMPWRACDFREE%02d' % i, 0)
    self.executeTeleCmd(cmd)

  def setBiasVoltageCal(self, temId, biasVoltage):
    cmd = LCAT_CmdPacketFactory('LIMBIASCAL')
    for i in range(16):
      if i == temId:
        valid   = 1
        calBias = biasVoltage
      else:
        valid   = 0
        calBias = 0
      cmd.set_payload('LIMCALVALID%02d' % i, valid)
      cmd.set_payload('LIMCALBIAS%02d' % i, calBias)
    self.executeTeleCmd(cmd)

  def powerOnTkrOnly(self, temId):
    self.setPowerTkrOnly(temId, powerOn=1)

  def powerOffTkrOnly(self, temId):
    self.setPowerTkrOnly(temId, powerOn=0)

  def setPowerTkrOnly(self, temId, powerOn):
    if powerOn:
      cmd = LCAT_CmdPacketFactory('LIMPOWERON')
    else:
      cmd = LCAT_CmdPacketFactory('LIMPOWEROFF')
    for i in range(16):
      if i == temId:
        power = 1
      else:
        power = 0
      cmd.set_payload('LIMPWRTEMSEL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMPDU%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMCAL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMTKR%02d' % i, power)
    for i in range(3):
      cmd.set_payload('LIMPWREPUSEL%02d' % i, 0)
      cmd.set_payload('LIMPWREPUPDU%02d' % i ,0)
    cmd.set_payload('LIMPWRACDSEL',0)
    cmd.set_payload('LIMPWRACDPDU',0)
    cmd.set_payload('LIMPWRACDSUPRED',0)
    for i in range(12):
      cmd.set_payload('LIMPWRACDFREE%02d' % i, 0)
    self.executeTeleCmd(cmd)

  def setBiasVoltageTkr(self, temId, biasVoltage):
    cmd = LCAT_CmdPacketFactory('LIMBIASTKR')
    for i in range(16):
      if i == temId:
        valid   = 1
        tkrBias = biasVoltage
      else:
        valid   = 0
        tkrBias = 0
      cmd.set_payload('LIMTKRVALID%02d' % i, valid)
      cmd.set_payload('LIMTKRBIAS%02d' % i, tkrBias)
    self.executeTeleCmd(cmd)

  def powerOnAemOnly(self, pduId=0, supRed=0):
    self.setPowerAemOnly(pduId, supRed, powerOn=1)

  def powerOffAemOnly(self, pduId=0, supRed=0):
    self.setPowerAemOnly(pduId, supRed, powerOn=0)

  def setPowerAemOnly(self, pduId, supRed, powerOn):
    if powerOn:
      cmd = LCAT_CmdPacketFactory('LIMPOWERON')
    else:
      cmd = LCAT_CmdPacketFactory('LIMPOWEROFF')
    for i in range(16):
      cmd.set_payload('LIMPWRTEMSEL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMPDU%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMCAL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMTKR%02d' % i, 0)
    for i in range(3):
      cmd.set_payload('LIMPWREPUSEL%02d' % i, 0)
      cmd.set_payload('LIMPWREPUPDU%02d' % i ,0)
    cmd.set_payload('LIMPWRACDSEL', 1)
    cmd.set_payload('LIMPWRACDPDU', pduId)
    cmd.set_payload('LIMPWRACDSUPRED', supRed)
    for i in range(12):
      cmd.set_payload('LIMPWRACDFREE%02d' % i, 0)
    self.executeTeleCmd(cmd)

  def powerOnFreeBoardOnly(self, freeId):
    self.setPowerFreeBoardOnly(freeId, powerOn=1)

  def powerOffFreeBoardOnly(self, freeId):
    self.setPowerFreeBoardOnly(freeId, powerOn=0)

  def setPowerFreeBoardOnly(self, freeId, powerOn):
    if powerOn:
      cmd = LCAT_CmdPacketFactory('LIMPOWERON')
    else:
      cmd = LCAT_CmdPacketFactory('LIMPOWEROFF')
    for i in range(16):
      cmd.set_payload('LIMPWRTEMSEL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMPDU%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMCAL%02d' % i, 0)
      cmd.set_payload('LIMPWRTEMTKR%02d' % i, 0)
    for i in range(3):
      cmd.set_payload('LIMPWREPUSEL%02d' % i, 0)
      cmd.set_payload('LIMPWREPUPDU%02d' % i ,0)
    cmd.set_payload('LIMPWRACDSEL', 0)
    cmd.set_payload('LIMPWRACDPDU', 0)
    cmd.set_payload('LIMPWRACDSUPRED', 0)
    for i in range(12):
      if i == freeId:
        power = 1
      else:
        power = 0
      cmd.set_payload('LIMPWRACDFREE%02d' % i, power)
    self.executeTeleCmd(cmd)

  def setBiasVoltageAcd(self, freeId, saaBiasVoltage, hvBiasVoltage):
    cmd = LCAT_CmdPacketFactory('LIMBIASACD')
    for i in range(12):
      if i == freeId:
        valid   = 1
        saaBias = saaBiasVoltage
        hvBias  = hvBiasVoltage
      else:
        valid   = 0
        saaBias = 0
        hvBias  = 0
      cmd.set_payload('LIMARCSAAVALID%02d' % i, valid)
      cmd.set_payload('LIMARCSAABIAS%02d'  % i, saaBias)
      cmd.set_payload('LIMARCHVVALID%02d'  % i, valid)
      cmd.set_payload('LIMARCHVBIAS%02d'   % i, hvBias)
    self.executeTeleCmd(cmd)

  # This version only works with post B0-6-2 libraries -ST 02/16/06
  def setBiasVoltageAcdNew(self, freeId, saaBiasVoltage, hvBiasVoltage, hv1bs, hv2bs, priGasu=1):
    """!\brief Set ACD bias voltages for free board.

    \param freeId         Free board id
    \param saaBiasVoltage SAA voltage in counts
    \param hvBiasVoltage  HVBS voltage in counts
    \param hv1bs          Enable HV1
    \param hv2bs          Enable HV2
    \param priGasu        Primary GASU flag to determine the veto enables
    """
    cmd = LCAT_CmdPacketFactory('LIMBIASACD')
    for i in range(12):
      if i == freeId:
        valid   = 1
        saaBias = saaBiasVoltage
        hvBias  = hvBiasVoltage
        hv1nbl  = hv1bs
        hv2nbl  = hv2bs
      else:
        valid   = 0
        saaBias = 0
        hvBias  = 0
        hv1nbl  = hv1bs
        hv2nbl  = hv2bs

      if priGasu:
        vetoena = 1
        vetoenb = 0
      else:
        vetoena = 0
        vetoenb = 1

      cmd.set_payload('LIMARCSAAVALID%02d' % i, valid)
      cmd.set_payload('LIMARCSAABIAS%02d'  % i, saaBias)
      cmd.set_payload('LIMARCHVVALID%02d'  % i, valid)
      cmd.set_payload('LIMARCHVBIAS%02d'   % i, hvBias)
      cmd.set_payload('LIMARCVETOENA%02d'  % i, vetoena)
      cmd.set_payload('LIMARCVETOENB%02d'  % i, vetoenb)
      cmd.set_payload('LIMARCHV1BS%02d'    % i, hv1nbl)
      cmd.set_payload('LIMARCHV2BS%02d'    % i, hv2nbl)
    self.executeTeleCmd(cmd)

  def start(self, time=0):
    """!\brief Start the scheduler.

    \param time Time
    """
    start = VSC.VscProxy.Scheduler(VSC.VscProxy.Start, time)
    self.__ctrl.execute(start)

  def stop(self):
    """!\brief Stop the scheduler.

    """
    stop = VSC.VscProxy.Scheduler(VSC.VscProxy.Stop)
    self.__ctrl.execute(stop)

  def getCmdTuple(self, cmd):
    """!\brief Retrieve the command tuple.

    \param cmd Command object

    \return A tuple containing (cmdName, payloadDict)
    """
    payloadDict = {}
    for payload in cmd.get_payload_list():
      value = cmd.get_payload(payload)
      payloadDict[payload] = value
    cmdTuple = (cmd.name, payloadDict)
    return cmdTuple

  def logCmd(self, cmdTuple):
    """!\brief Log the command and its payloads.

    \param cmdTuple Command tuple generated from the getCmdTuple method.
    """
    (cmdName, payloadDict) = cmdTuple
    log.debug("%s(" % cmdName)
    payloads = payloadDict.keys()
    payloads.sort()
    for payload in payloads:
      log.debug("   %s=0x%x" % (payload, payloadDict[payload]))
    log.debug(")")

  def execute(self, cmd):
    """!\brief Send the command to the VSC.

    \param cmd Command object

    \return Encoded tele-command packet
    """
    if self.__cmdDebug is not None:
      self.logCmd(self.getCmdTuple(cmd))
    packet = cmd.encode_vsc()
    if self.__archiver is not None:
      self.__archiver.send(packet)
    self.__ctrl.execute(packet)
    return packet

  def executeTeleCmd(self, cmd):
    """!\brief Send the command to the VSC and increment command counter.

    \param cmd Command object

    \return Encoded tele-command packet
    """
    self.__cmdCount+=1
    return self.execute(cmd)

  def m7(self, starttime, endtime):
    """!\brief Send the magic seven.

    """
    att1 = VSC.VscCcsds.Attitude(160000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att2 = VSC.VscCcsds.Attitude(360000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att3 = VSC.VscCcsds.Attitude(560000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att4 = VSC.VscCcsds.Attitude(760000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att5 = VSC.VscCcsds.Attitude(960000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    data = VSC.VscCcsds.Data    (800000, 1., 2., 3., 1., 2., 3.,
                                 VSC.VscCcsds.Data.Idle, 99, 0)
    tone = VSC.VscCcsds.TimeTone(True)
    for timebase in range(starttime, endtime):
      self.__ctrl.schedule(timebase, att1, att2, att3, att4, att5, data, tone);

  def m7default(self):
    """!\brief Send the default magic seven.

    """
    att1 = VSC.VscCcsds.Attitude(160000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att2 = VSC.VscCcsds.Attitude(360000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att3 = VSC.VscCcsds.Attitude(560000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att4 = VSC.VscCcsds.Attitude(760000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    att5 = VSC.VscCcsds.Attitude(960000, 1., 2., 3., 4., 10.0, 11.0, 12.0)
    data = VSC.VscCcsds.Data    (800000, 1., 2., 3., 1., 2., 3.,
                                 VSC.VscCcsds.Data.Idle, 99, 0)
    tone = VSC.VscCcsds.TimeTone(True)
    self.__ctrl.schedule(att1, att2, att3, att4, att5, data, tone);

  def m7off(self):
    """!\brief Send a blank schedule() to turn off magic seven.
    """
    self.__ctrl.schedule()

  def siuSelect(self, path):
    """!\brief Select SIU.

    \param path SIU path
    """
    cmd = VSC.VscProxy.SiuInterface(path)
    self.__ctrl.execute(cmd)

  def daqSelect(self, path):
    """!\brief Select DAQ.

    \param path DAQ path
    """
    cmd = VSC.VscProxy.DaqInterface(path)
    self.__ctrl.execute(cmd)

  def ssr(self, enable):
    """!\brief Enable or disable SSR.

    \param enable Boolean enable/disable flag
    """
    if enable:
      enableFlag = VSC.VscProxy.Enable
    else:
      enableFlag = VSC.VscProxy.Disable
    cmd = VSC.VscProxy.SsrInterface(enableFlag)
    self.__ctrl.execute(cmd)

  def toggle(self, lines, values):
    """!\brief Toggle lines.

    \param lines  Lines
    \param values Values
    """
    cmd = VSC.VscProxy.ToggleLines(lines, values)
    self.__ctrl.execute(cmd)

  def pids(self):
    """!\brief Download SIU pids.

    """
    cmd = VSC.VscProxy.Download(VSC.VscProxy.DownloadSiuPids)
    self.__ctrl.execute(cmd)

  def reset(self):
    """!\brief Reset the VSC proxy.

    """
    cmd = VSC.VscProxy.Reset()
    self.__ctrl.execute(cmd)

  def grb(self):
    """!\brief grb.

    """
    cmd = VSC.VscProxy.Grb()
    self.__ctrl.execute(cmd)

  def monitor(self, state):
    """!\brief monitor method.

    monitor the VSC telemetry on state (state)
    """
    cmd = VSC.VscProxy.Monitor(state)
    self.__ctrl.execute(cmd)

  def getCmdCount(self):
    """!\brief Retrieve number of commands sent to the VSC
    since the start of the ScriptEngine.

    \return Command count since the start of the ScriptEngine
    """
    return self.__cmdCount

  def getController(self):
    """!\brief Return the VSC controller instance

    \return VSC.VscProxy.Controller instance
    """
    return self.__ctrl


class LicosTelemetryRouter(VSC.VscRouting.TelemetryRouter):
  """!\brief Telemetry router class.

  """
  def __init__(self, handler):
    """!\brief LicosTelemetryRouter constructor.

    """
    VSC.VscRouting.TelemetryRouter.__init__(self)
    self.insert(handler)

  def allocate(self):
    """!\brief Virtual method called by the VSC to allocate memory for the Telemetry object.

    """
    self.__packet = CCSDS.Ccsds.Telemetry(0, 0, 0)
    return self.__packet

  def catchall(self, ccsds):
    """!\brief If an apid is not handled this method is called.

    \param ccsds Raw packet
    """
    #log.debug("LicosTelemetryRouter.catchAll no handler found for apid 0x%x" % \
    #      (ccsds.apid())
    pass

class LicosScienceRouter(VSC.VscRouting.ScienceRouter):
  """!\brief Science router class.

  """
  def __init__(self, handler):
    """!\brief LicosScienceRouter constructor.

    """
    VSC.VscRouting.ScienceRouter.__init__(self)
    self.insert(handler)

  def allocate(self):
    """!\brief Virtual method called by the VSC to allocate memory for the Telemetry object.

    """
    self.__packet = CCSDS.Ccsds.Science(0, 0, 0)
    return self.__packet

  def catchall(self, ccsds):
    """!\brief If an apid is not handled this method is called.

    \param ccsds Raw packet
    """
    log.debug("LicosScienceRouter.catchall: SSR event apid 0x%x length %d" %(ccsds.apid(), ccsds.length()))

class sePidsHandler(seTelemetryHandler):
  def __init__(self):
    seTelemetryHandler.__init__(self, [(ScriptEngineConnector.DownloadSiuPids,
                                       ScriptEngineConnector.DownloadSiuPids)])
    self.__pids = 0

  def process(self, telemetry):
    (pad, tid, pids) = struct.unpack('!HII', telemetry.payload())
    log.debug("VscPidsHandler at seconds 0x%x useconds 0x%x tid 0x%x pids 0x%x" \
          % (telemetry.secs(), telemetry.usecs(), tid, pids))
    self.__pids = pids
    seTelemetryHandler.process(self, telemetry)

  def getPID5(self):
    # PID value should be inverted
    return ~self.__pids & 0x1

  def getPID6(self):
    # PID value should be inverted
    return ~(self.__pids >> 1) & 0x1

---