cmdTlmDb.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__ = "Base class for all command database wrapper classes"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2006/01/25 23:11:06 $"
__version__  = "$Revision: 1.15 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import logging as log

class CmdDb(object):
  """!\brief Base class for Telecommand wrapper classes.

  This class takes a FSW generated Python module as its constructor.
  All package classes and its member command mnemonic methods are
  instantiated here.
  """

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

    \param vsc The VSC proxy
    """
    self.__vsc = vsc

  def getPackages(self):
    """!\brief Retrieve list of available packages

    This method returns a list of available packages for the
    database instantiated.

    \return List of packages.
    """
    return self.getCmdDict().mnemonics.keys()

  def getVsc(self):
    return self.__vsc

class CmdPkg(object):
  """!\brief Base class for package classes

  There is a corresponding package class for each of the packages provided by the
  command and telemetry database. The telecommand mnemonics are grouped by these
  packages and LICOS syntax requires that they be specified when queueing telecommands
  to the VSC.

  See <a target="_blank"
  href="http://www.slac.stanford.edu/exp/glast/flight/web/a_cat/prod/WMA/hide/cmd_kwp_L_pkt.shtml">this link</a>
   for a list of packages and their telecommands.

  """

  def __init__(self, db):
    """!\brief CmdPkg constructor.

    \param db  Generated module containing command and
               telemetry database classes.

    The constructor extracts the class corresponding to each telecommand
    mnemonic belonging to the package provided by the sub-class and
    converts it to a method member of that package subclass.

    For example if LHK is the sub-class then the three telecommand classes
    from the generated LCAT_cmd_db module are converted to member methods
    of the LHK class.

    Each member method contains named arguments where each argument is named
    after the corresponding telecommand payload. As with Python methods, the
    payload names are optional when passing the arguments to the telecommands.
    """
    self.__mneObj = {}
    self.__db = db
    self.__cmdCount = 0

    # Retrieve the telecommand mnemonics for this package
    cmdDict = db.getCmdDict().mnemonics
    mneClass = self.__class__.__name__
    if mneClass in cmdDict:
      self.__cmdList = cmdDict[mneClass]
    else:
      raise RuntimeError, "%s does not exist in database %s" % (mneClass, db)

    #print self.__cmdList

    # For each telecommand in the package, create a method based on the class
    for name in self.__cmdList:
      self.__mneObj[name] = getattr(db.getDbModule(), name)()
      setattr(self, name, self.__methodClosure(name))

  def __methodClosure(self, name):
    # Given a telecommand mnemonic, this method converts the mnemonic class
    # defined in the generated telecommand dictionary module (such as LCAT_cmd_db)
    # to a method and returns it to the caller.
    def method(*args, **kwargs):
      # This is the code that will be executed when a script calls a
      # telecommand mnemonic.

      # Get a list of payload mnemonics for this telecommand.
      kwList = self.__mneObj[name].get_payload_list()
      valList = len(kwList) * [None]
      i = 0
      # Add the non-keyword argument values
      for val in args:
        valList[i] = val
        i += 1
      # Add the keyword argument values and do sanity checks.
      for (arg, val) in kwargs.items():
        # Handle the special flush argument
        if arg in kwList:
          i = kwList.index(arg)
          if valList[i] is None:
            valList[i] = val
          else:
            raise TypeError, "%s() got multiple values for keyword argument '%s'" % (name, arg)
        else:
          raise TypeError, "%s() got an unexpected keyword argument '%s'. Available arguments are %s" % (name, arg, kwList)

      numkw = 0
      for val in valList:
        if val is not None:
          numkw += 1
      if numkw != len(valList):
        raise TypeError, "%s() takes exactly %d arguments (%d given)" % (name, len(valList)+1, numkw+1)

      # If everything checks out we can actually call the class method to
      # set the payloads.
      for arg in kwList:
        i = kwList.index(arg)
        try:
          self.__mneObj[name].set_payload(arg, valList[i])
        except:
          log.error("Error in setting payload %s to %s" % (arg, valList[i]))
          raise

      #from binascii import hexlify
      #print "apid=0x%x payload=%s" % (packet.apid(), hexlify(packet.payload()))
      #print hexlify(packet)

      # Queue the packet to the VSC and return the packet to the caller
      # although it is probably not much use to the script
      packet = self.__db.getVsc().executeTeleCmd(self.__mneObj[name])
      self.__cmdCount+=1
      return packet
    return method

  def getPayloadValue(self, cmd, mnem):
    """!\brief Retrieve the payload value of a telecommand

    This method returns the payload value as set by the last
    call to the telecommand method.

    \param cmd  Telecommand mnemonic.
    \param mnem Payload mnemonic.

    \return Payload value
    """
    return self.__mneObj[cmd].get_payload(mnem)

  def getPayloadDef(self, cmd, mnem):
    """!\brief Retrieve the payload definion

    This method retrieves the list containing the payload definition
    as defined in the telecommand class.

    \param cmd  Telecommand mnemonic.
    \param mnem Payload mnemonic.

    \return A list containing the payload declaration.
            Right now the items in this list used by LICOS are
            payload mnemonic (index 0) and brief (index 2).

    """
    if cmd in self.__mneObj:
      for data in self.__mneObj[cmd].mnemList:
        if data[0] == mnem:
          return data

  def getPayloadList(self, cmd):
    """!\brief Retrieve payload mnemonics

    This method retrieves all the payload mnemonics
    that are needed for the telecommand \a cmd.

    \param cmd Telecommand mnemonic.

    \return List of payload mnemonics.
    """
    return self.__mneObj[cmd].get_payload_list()

  def getCmds(self):
    """!\brief Retrieve telecommand mnemonics

    This method retrieves all the telecommand mnemonics
    that are declared for this package.

    \return List of telecommand mnemonics.
    """
    return self.__cmdList

  def getCmdObj(self, cmd):
    """!\brief Retrieve the telecommand object

    This method retrieves the telecommand object
    for the telecommand \a cmd. It can be used
    to access members not exposed by this class.

    \param cmd Telecommand mnemonic.

    \return An instance of a telecommand class
    """
    return self.__mneObj[cmd]

  def getCmdDb(self):
    """!\brief Retrieve the module containing command database classes.

    \return Tele-command database module
    """
    return self.__db

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

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

  def getName(self):
    """!\brief Retrieve the package name.

    \return Package name
    """
    return self.__class__.__name__

class TlmDb(object):
  def __init__(self):
    pass

---