gNAT.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 COMM Card I/O node"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2004/08/24 23:09:08 $").split(' ')[1]
__version__ = "$Revision: 2.4 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import gDb
import gAttr

class GNAT(gDb.Gdb):
  """\brief GNAT node Record

  This node contains COMM card related functions.
  Each GNAT node is associated with one COMM card.
  A GNAT node can either be instantiated through the
  createGNATinstance method of GTEM, GAEM or GGLT nodes or
  it can be instantiated as a standalone node by creating an
  instance of it and calling its initHandle method with the
  pysical address of the COMM card. The other parameter that it
  needs is a slot. A slot is a placeholder for a GNAT handle.
  There are currently 16 slots available. When calling the
  createGNATinstance or initHandle methods the desired slot is
  passed and this is where the handle is stored for the duration
  of the session.
  Currently the GNAT node serves to major purposes:

    (1) Statistics:

        Contains registers for retrieving TX/RX ctrl and data cells
        as well as RX header parity and TX busy assert flags.

    (2) Pattern generator functionality:

        It is possible to use the exposed methods and registers to
        write bit streams to the COMM card. This functionality is
        available mostly for internal testing and should not be of
        and particular use to the subsystems.
  """
  __attrs = [
      # Registers
      gAttr.GattrRaw('stats_rx_ctrl_cells',     0, 2),
      gAttr.GattrRaw('stats_rx_data_cells',     1, 2),
      gAttr.GattrRaw('stats_rx_header_parity',  2, 2),
      gAttr.GattrRaw('stats_rx_cell_parity',    3, 2),
      gAttr.GattrRaw('stats_tx_ctrl_cells',     4, 2),
      gAttr.GattrRaw('stats_tx_data_cells',     5, 2),
      gAttr.GattrRaw('stats_tx_busy_assert',    6, 2),
      gAttr.GattrRaw('stats_clear',             7, 2),
      gAttr.GattrRaw('output_mask',             8, 4)
      ]

  def __init__(self, client):
    """\brief Initialize valid registers as Gattrs.

    Assign default values to members

    Usage:
    \code
      gn = GNAT()
    \endcode
    """
    gDb.Gdb.__init__(self, client, None, 0, self.__attrs)

  def initHandle(self, slot, physAddr):
    """\brief Initializes a new GNAT handle given a physical VME address.

    \param slot     A number between 0 and 15 to hold the GNAT handle.
                    Each GNAT handle should be assigned a unique slot number.
                    The GNAT handle persists at that slot while the session is active.
    \param physAddr Physical VME address of the COMM card.

    \return Status

    Usage:
    \code
      gn = GNAT()
      gn.setCmd(lat.getCmd())
      gn.initHandle(0, 0x08000000)
    \endcode
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATgetGh(slot, physAddr)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      else:
        self._Gnode__id = slot
      return status
    else:
      raise RuntimeError, 'No command client. Use setCmd prior to calling this function'

  def clearBuffer(self):
    """\brief Zero out the contents of the bundle.

    Calls gBndlClear( gh);

    \return Status
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATclearBuffer(self._Gnode__id)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status
    else:
      raise RuntimeError, 'No command client. Use setCmd prior to calling this function'

  def addChannel(self, channelNo, itemList):
    """Inserts data into a channel

    \param  channelNo The channel number (0 - 15) to insert the chnlData into.
                      The maximum channel number is defined in GNAT/gnat.h as MAX_CHANNEL.
    \param  itemList  A sequence of 32-bit words.
                      The maximum number of words in the array is 5.

    \return           Status

    Usage:
    \code
      data = [0xdeadbeefL, 0xdeadbeefL, 0xdeadbeefL]
      gn.addChannel(channelNo=1, itemList=data)
    \endcode
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATaddChannel(self._Gnode__id, channelNo, itemList)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

  def loadFIFO(self):
    """\brief This is a combination of gBndlGetBndl() and gWritePF16v().

    It transfers the data from the intermediate bundle buffer into the
    playback FIFO.

    \return  Status
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATloadFIFO(self._Gnode__id)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

  def flushPlaybackFIFO(self):
    """\brief This is a combination of gFlushPF() and gEnablePF().

    Flushes the playback FIFO.

    \return Status
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATflushPlaybackFIFO(self._Gnode__id)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

  def flushRecordFIFO(self):
    """\brief This is a combination of gFlushRF() and gEnableRF().

    Flushes the record FIFO.

    \return Status
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATflushRecordFIFO(self._Gnode__id)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

  def writeFIFO(self, data):
    """\brief A wrapper around gWritePF().

    So user could write a single word to the
    FIFO or the user could prepare their own array of words,
    bypassing the bundle/channel interface.

    \param  data   A single or a sequence of 16-bit words
    \return        Status

    Usage:
    \code
      data = [0xa0a0, 0xb0b0, 0xc0c0]
      gn.writeFIFO(data)
      data = 0x1234
      gn.writeFIFO(data)
    \endcode
    """
    if self.__cmdCli is not None:
      if isNumberType(data):
        (userId, status, timestamp) = self.__cmdCli.gGNATwritePF16(self._Gnode__id, data)
      else:
        (userId, status, timestamp) = self.__cmdCli.gGNATwritePF16v(self._Gnode__id, data)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

  def writeFIFO32(self, data):
    """\brief A wrapper around gWritePF()

    So user could write a single word to the
    FIFO or the user could prepare their own array of words,
    bypassing the bundle/channel interface.

    \param data A single or a sequence of 16-bit words

    \return     Status

    Usage:
    \code
      data = [0xa0a0a0a0L, 0xdeadbeefL, 0xc0c0c0c0L]
      gn.writeFIFO32(data)
      data = 0x12345678L
      gn.writeFIFO(data)
    \endcode
    """
    if self.__cmdCli is not None:
      if isNumberType(data):
        (userId, status, timestamp) = self.__cmdCli.gGNATwritePF32(self._Gnode__id, data)
      else:
        (userId, status, timestamp) = self.__cmdCli.gGNATwritePF32v(self._Gnode__id, data)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

  def startPlayback(self):
    """\brief This is a wrapper around gStartPB().

    Starts the playback.

    \return Status

    Usage:
    \code
      gn.startPlayback()
    \endcode
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATstartPlayback(self._Gnode__id)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

  def setLATpMode(self, mode):
    """\brief Sets the running mode of the COMM I/O board based on the boolean
    value of mode.

    When mode is non-zero the mode bit of the COMM I/O
    control register is set to 1, which puts the board in "LATp mode".
    When mode is zero the mode bit is cleared, which puts the board in
    "dumb record FIFO mode".

    \param mode The running mode of the COMM I/O board

    \return     Status

    Usage:
    \code
      gn.setLATpMode(0)
    \endcode
    """
    if self.__cmdCli is not None:
      (userId, status, timestamp) = self.__cmdCli.gGNATsetLATpMode(self._Gnode__id, mode)
      if status != 0:
        if self.__cmdCli.ignoreErrors():
          print "Error:", gutil.LATInterfaceStatus(status)
        else:
          raise gutil.LATInterfaceException(status)
      return status

---