gDb.py

#!/usr/local/bin/python
#
#                               Copyright 2004
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#


__facility__ = "Online"
__abstract__ = "GLAST functional block base class"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/07/17 18:25:20 $").split(' ')[1]
__version__ = "$Revision: 2.23 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import gAttr
from LATTE.client.gNode import Node

class Gdb(Node):
  """\brief Base class for all GLAST LAT functional blocks.

     Uses __getattr__ and __setattr__ methods to feature an SCL like syntax
     for referencing attributes
  """

  def __init__(self, client, parent, id, valid_attrs=[], addr=None, flags=None):
    """gNode constructor.

    \param valid_regs A list of valid attribute names.
    """
    Node.__init__(self, client)
    self.__parent = parent
    self.__id = id
    if addr is None:
      self.__addr = id
    else:
      self.__addr = addr

    attrDict = _regList()
    self.__dict__['regs'] = attrDict

    #Instantiate all attributes
    for attr in valid_attrs:
      attrDict[attr.getName()] = attr.create(self)

    self.__dict__['_Gdb__flags'] = flags

  def up(self):
    """Return the parent of this component
    """
    return self.__parent

  def id(self):
    """Return the hardware id of this component
    """
    return self.__id

  def addr(self):
    """Return the hardware address of this component
    """
    return self.__addr

  def root(self):
    """Return the root node in this node's hierarchy

    \return The root node
    """
    root = self
    while root.up() is not None:
      root = root.up()
    return root

  def getIdTuple(self):
    """Return the node id(s) in this node's hierarchy

    \return The root node
    """
    idtuple = []
    root = self
    while root.up() is not None:
      idtuple.append(root.id())
      root = root.up()
    idtuple.reverse()
    return tuple(idtuple)

  def getName(self):
    return self.__class__.__name__

  def getOpaque(self, name=None):
    """\brief Retrieves the named opaque data included in the schema
    The opaque data needs to be associated with a node therefore this
    method only returns the opaque data that is associated with that
    node.

    \param  name Name of the opaque XML data (optional)

    \return      A list of XML DOM objects matching \a name
                 or if \a name is None a dictionary of a list
                 of XML DOM objects
    """
    root = self.root()
    rname = root.__class__.__name__
    rdict = root.__dict__
    opaque = rdict["_" + rname + '__opaque']
    if self in opaque:
      if name is None:
        return opaque[self]
      elif name in opaque[self]:
        return opaque[self][name]

  def getSerialNos(self, component=None):
    """\brief Retrieves the serial numbers associated with the node

    \param  component Hardware component identifier (optional)

    \return           A dictionary matching \a component
                      or if \a component is None a dictionary of all
                      components and their serial numbers
    """
    root = self.root()
    rname = root.__class__.__name__
    rdict = root.__dict__
    serialnos = rdict["_" + rname + '__serialnos']
    if self in serialnos:
      if component is None:
        return serialnos[self]
      elif component in serialnos[self]:
        return {component: serialnos[self][component]}

  def getExcludeFlags(self):
    """\brief Retrieves the exclude reasons associated with the node

    \return A list of excludes that match the current node, if there
            are no excludes specified then an empty list is returned.
    """
    root = self.root()
    rname = root.__class__.__name__
    rdict = root.__dict__
    excludes = rdict["_" + rname + '__excludes']
    if self in excludes:
      return excludes[self]
    else:
      return []

  def setFlag(self, key, value):
    """\brief Set generic flags for the node.

    Flags are passed by gSchemaConfig when the <flags> section
    in the schema is parsed.

    \param key Entry key, must already exists.
    \param value New value to be set for key.
    """
    if key in self.__flags:
      self.__flags[key] = value
    else:
      raise AttributeError("Attribute " + key + " not found")


  def getFlag(self, key, integer=False):
    """\brief Returns the value which corresponds to key.

    Returns the value which corresponds to key.

    \param key Entry key.
    \return Flag value corresponding to key.
    """
    if key in self.__flags:
      flag = self.__flags[key]
      if integer and isinstance(flag, str): return int(flag, 0)
      return flag
    else:
      raise AttributeError("Attribute " + key + " not found")

  def attrIter(self):
    """\brief Iterator for attributes

    Iterates over attribute objects belonging to the current
    node returning each object in the order that is specified
    in the node's __attrs member.
    """
    attrs = getattr(self, "_%s__attrs" % self.__class__.__name__)
    for attr in attrs:
      yield self.regs[attr.getName()]

## private:
#
#  The following was an attempt to optimize access for mixed case attribute
#  names.  Unfortunately we run into trouble with the tem.regs['configuration']
#  type notation, and with constructs like 'for reg in regs' which returns
#  the attribute in each casing.  We punt on it for now (Thu Aug 19 2004)
#
#   def __setattr__(self, attribute, value):
#     attrDict = self.__dict__
#     if attribute in attrDict:
#       attrDict[attribute] = value
#       return
#     try:
#       regs = attrDict['regs']
#     except KeyError:
#       attrDict[attribute] = value
#       return
#     try:
#       regs[attribute].set(value, 0, self)
#     except KeyError:
#       try:
#         attr = regs[attribute.lower()]
#       except KeyError:
#         raise AttributeError("Attribute " + attribute + " not found")
#       regs[attribute] = attr
#       attr.set(value, 0, self)

#   def __getattr__(self, attribute):
#     attrDict = self.__dict__
#     if attribute in attrDict:
#       return attrDict[attribute]
#     try:
#       regs = attrDict['regs']
#       return regs[attribute].get(0, self)
#     except KeyError:
#       try:
#         attr = regs[attribute.lower()]
#       except KeyError:
#         raise AttributeError("Attribute " + attribute + " not found")
#       regs[attribute] = attr
#       return attr.get(0, self)

  def __setattr__(self, attribute, value):
    """Gets called when a syntax like 'gtem.configuration = 5' is used"""
    attrDict = self.__dict__
    try:
      regs = attrDict['regs']
      if attribute in regs:
        regs[attribute].set(value, 0, self)
      elif attribute in attrDict:
        attrDict[attribute] = value
      else:
        raise AttributeError("Attribute " + attribute + " not found")
    except KeyError:
      if 'regs' not in attrDict:
        attrDict[attribute] = value
      else:
        raise AttributeError("Attribute " + attribute + " not found")

  def __getattr__(self, attribute):
    """Gets called when a syntax like 'print gtem.configuration' is used"""
    try:
      return self.__dict__['regs'][attribute].get(0, self)
    except KeyError:
      raise AttributeError("Attribute " + attribute + " not found")

class _regList(dict):
  def __init__(self):
    dict.__init__(self)

  def __getitem__(self, attribute):
    return dict.__getitem__(self, attribute.lower())

  def __setitem__ (self, attribute, value):
    dict.__setitem__(self, attribute.lower(), value)

  def get (self, attribute, default=None):
    return dict.get(self, attribute.lower(), default)

  def has_key(self, attribute):
    return dict.has_key(self, attribute.lower())

  def __contains__(self, attribute):
    return dict.__contains__(self, attribute.lower())

class Children(dict):
  BCASTID = 0xff

  def __init__(self, parent, type):
    dict.__init__(self)
    self.__parent = parent
    self.__type = type
    self.__bcast = None

  def remove(self, id):
    if id in self:
      self.__delitem__(id)
    elif id == Children.BCASTID:
      self.__bcast = None
    else:
      print "*** gDb: id %d not found for %s %d" %(id, self.__parent.getName(), self.__parent.id())

  def add(self, id):
    if id == Children.BCASTID:
      if self.__bcast is not None:
        print "*** gDb: bcast %s already exists for %s %d" \
              %(self.__bcast.getName(),
                self.__parent.getName(), self.__parent.id())
      else:
        self.__bcast = self.__type(self.__parent.client(), self.__parent, id)
        return self.__bcast
    elif id in self:
      print "*** gDb: child %s %d already exists for %s %d" \
            %(self[id].getName(), id,
              self.__parent.getName(), self.__parent.id())
    else:
      self[id] = self.__type(self.__parent.client(), self.__parent, id)
      return self[id]

  def down(self, id):
    if id in self:
      return self[id]
    elif id == Children.BCASTID:
      return self.__bcast
    else:
      return None

  def exists(self, id):
    if id in self:
      return True
    elif id == Children.BCASTID and self.__bcast is not None:
      return True
    return False

  def all(self):
    return self.__bcast

class Lem(Node):
  ADDR_TEM_BASE  = 0x00
  ADDR_GEM       = 0x10
  ADDR_AEM       = 0x11
  ADDR_EBM       = 0x12
  ADDR_PDU_BASE  = 0x13
  ADDR_CRU       = 0x1E
  ADDR_SLV_BCAST = 0x1F
  ADDR_MASTER    = 0x20

  NPDUS = 2
  NTEMS = 16
  NCCCS = 4
  NCRCS = 4
  NCFES = 12
  NTCCS = 8
  NTRCS = 9
  NTFES = 24
  NARCS = 12
  NAFES = 18

  CCCBCAST = 0xFF
  CRCBCAST = 0xFF
  CFEBCAST = 0xFF
  TCCBCAST = 0xFF
  TRCBCAST = 0xFF
  TFEBCAST = 0xFF
  ARCBCAST = 0x1F
  AFEBCAST = 0x1F

  GEM_CC   = 0
  GEM_TAM  = 1
  GEM_STAT = 2
  GEM_SCHD = 3
  GEM_ROI  = 4
  GEM_IE   = 5
  GEM_WIN  = 6

  # Parity select
  PARITY_ODD   = 0
  PARITY_EVEN  = 1

  # Parity type
  PARITY_CMD_STRING  = 0
  PARITY_CMD_PAYLOAD = 1
  PARITY_ACCESS_DESC = 2

  def __init__(self, client):
    Node.__init__(self, client)

  def setParity(self, parity_type, parity_select):
    return self.cmdrsp('LEM_set_parity', parity_type, parity_select)

  def getParity(self, parity_type):
    rsp = self.cmdrsp('LEM_get_parity', parity_type)
    return rsp.status()

---