LCATcmdDb.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__ = "Wrapper class for LCAT based telecommands"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/03/07 23:59:37 $"
__version__  = "$Revision: 1.20 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import logging as log
from binascii import hexlify

# import generated Python classes from the LCAT package
import LCAT_cmd_db

from LICOS.lib.cmdTlmDb.cmdTlmDb       import CmdDb
from LICOS.lib.cmdTlmDb.TelemetryEvent import TelemetryEvent
from LICOS.lib.cmdTlmDb.LMC            import LMC
from LICOS.lib.cmdTlmDb.LHK            import LHK
from LICOS.lib.cmdTlmDb.MEM            import MEM
from LICOS.lib.cmdTlmDb.PBC            import PBC
from LICOS.lib.cmdTlmDb.FILE           import FILE
from LICOS.lib.cmdTlmDb.LFS            import LFS
from LICOS.lib.cmdTlmDb.LSM            import LSM
from LICOS.lib.cmdTlmDb.LTC            import LTC
from LICOS.lib.cmdTlmDb.LCM            import LCM
from LICOS.lib.cmdTlmDb.LIM            import LIM
from LICOS.lib.cmdTlmDb.LCI            import LCI
from LICOS.lib.cmdTlmDb.LPA            import LPA
from LICOS.lib.cmdTlmDb.DDT            import DDT

class LCATcmdDb(CmdDb):
  """!\brief Database wrapper class for LCAT based telecommands

  This class contains all telecommands based on the generated LCAT_cmd_db
  database. The telecommands are grouped by packages. A sample usage of
  queuing the telecommands to the VSC is shown below:

  \code
  from   LICOS.lib.cmdTlmDb.LCATcmdDb import LCATcmdDb
  .
  .
  lcat = LCATcmdDb(self.vsc)
  mem = lcat.MEM
  packet = mem.LMEMDUMPMEM(LMEMLATUNIT=1, LMEMTRANID=2, LMEMPAD=3,
                  LMEMADDRESSHI=4, LMEMADDRESSLO=5, LMEMSIZEHI=6, LMEMSIZELO=7)

  \endcode
  """

  def __init__(self, vsc):
    """!\brief LCATcmdDb constructor.

    \param vsc VPI_Proxy object.
    """
    CmdDb.__init__(self, vsc)
    self.__dbModule = LCAT_cmd_db
    self.__cmdDict = self.__dbModule.CmdDict()
    self.LMC  = LMC(self)
    self.LHK  = LHK(self)
    self.MEM  = MEM(self)
    self.PBC  = PBC(self)
    self.FILE = FILE(self)
    self.LFS  = LFS(self)
    self.LSM  = LSM(self)
    self.LTC  = LTC(self)
    self.LCM  = LCM(self)
    self.LIM  = LIM(self)
    self.LCI  = LCI(self)
    self.LPA  = LPA(self)
    self.DDT  = DDT(self)

    self.__cmdConfirmTelem = TelemetryEvent(vsc.getDiagHandler(),
                                            [self.getVsc().getTlmDb().getApidFromName('CmdConfirm')],
                                            self.__confirmation
                                            )
    self.__confPacket = None
    self.__confCallback = self.confirmation

  def getCmdDict(self):
    """!\brief Return the command dictionary.

    \return Command dictionary
    """
    return self.__cmdDict

  def getDbModule(self):
    """!\brief Return the generated database module.

    \return Database module
    """
    return self.__dbModule

  def setCmdConfirmCallback(self, callback):
    """!\brief Set the user script callback for the command confirmation telemetry.

    \param callback Callback method
    """
    self.__confCallback = callback

  def getCmdConfirmCallback(self):
    """!\brief Get the current command confirmation callback.

    \return Command confirmation callback.
    """
    return self.__confCallback

  def confirmation(self, telemetry):
    """!\brief Default callback for command confirmation telemetry

    \param Raw telemetry packet
    """
    confPacket = self.getVsc().getTlmDb().decodeTelemetry(telemetry, dump=True)
    # Dump the rest of the command packet in binary
    # Start of command payload is 0x22 bytes after beginning of telemetry packet.
    # start of command payload is referenced to beginning of command packet
    #    (0x1a bytes after start of telemetry packet)
    for i in range(0x22, telemetry.sizeofPayload(), 2):
      log.debug("  %15s 0x%02x: 0x%s " %\
                ( "ITC_PAYLOAD", i - 0x1a, hexlify(telemetry.payload()[i:i+2])) )

    log.info(self.getVsc().getTlmDb().msgByValue(confPacket.get_payload("ITC_EXESTATUS")))

  def quietConfirmation(self, telemetry):
    """!\brief quiet callback for command confirmation telemetry

    \param Raw telemetry packet
    """
    pass

  def getConfirmationPacket(self):
    """!\brief Retrieve the last command confirmation packet received.

    """
    return self.__confPacket

  def getConfirmationMsg(self):
    """!\brief Retrieve the status inside the last command confirmation packet received.

    """
    if self.__confPacket is not None:
      return self.__confPacket.get_payload('ITC_EXESTATUS')
    else:
      return 0xffffffff    # Bad message number?  --JHP


  def __confirmation(self, telemetry):
    """!\brief Callback for the command confirmation telemetry.

    \param Raw telemetry packet
    """
    if self.__confCallback is not None:
      self.__confCallback(telemetry)
    self.__confPacket = self.getVsc().getTlmDb().decodeTelemetry(telemetry, dump=False)

  def waitForConfirmation(self, timeout=10, quiet=False):
    """!\brief Wait for the command confirmation packet.

    \param timeout  Amount of time to wait for the command
                    confirmation packet

    \return True  if a command confirmation packet is received.
            False if no command confirmation packet is received before
                  the timeout.
    """
    cmdConfirmTelemReceived = self.__cmdConfirmTelem.wait(timeout, quiet)
    if not cmdConfirmTelemReceived:
      if not quiet:
        log.warn("Timeout waiting for command confirmation")
      self.__confPacket = None
    return cmdConfirmTelemReceived

  def waitForSuccessfulConfirmation(self, timeout=10, quiet=False):
    """!\brief Wait for successful command confirmation telemetry.

    \param timeout Number of seconds to wait for the confirmation.

    \return True if command confirmation was successful, False otherwise.
    """
    result = True
    if self.waitForConfirmation(timeout, quiet):
      if not self.getVsc().getTlmDb().msgIsSuccess(self.__confPacket.get_payload("ITC_EXESTATUS")):
        result = False
    else:
      result = False
    return result

  def enableCmdConfirmTelem(self):
    self.__cmdConfirmTelem.enable()

  def disableCmdConfirmTelem(self):
    self.__cmdConfirmTelem.disable()

  def isCmdConfirmTelemEnabled(self):
    return self.__cmdConfirmTelem.isEnabled()

---