gGLT.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 GLT functional block"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/02/02 00:42:04 $").split(' ')[1]
__version__ = "$Revision: 2.7 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

from threading import Event

from gDb import Gdb
import gAttr
import LATTE.client.gBits as gBits

class GGLT(Gdb):
  """\brief Global Trigger

  Has GGLT specific registers and dataless commands.

  Valid Registers:
  - \c mask
  - \c busy_disable
  - \c ext_cal_strobe
  - \c ext_tack
  - \c counter_mask
  - \c counter
  - \c ext_clk_out_enable

  Dataless Commands:
  - \c cmd_reset
  - \c cmd_self_trigger

  <a name="option_fields"></a>
  Options Register Bit Fields:
  - \c parity
  - \c tag
  - \c event_number

  <a name="conf_fields"></a>
  Configuration Register Bit Fields:
  - \c destination
  - \c marker
  - \c tack
  - \c zero_suppress
  - \c four_range_readout
  - \c cal_strobe

  Mask Register Bit Fields:
  - \c internal_trg
  - \c external_trg
  - \c cal_low
  - \c cal_high
  - \c three_in_a_row
  - \c acd_veto_00
  - \c acd_veto_01
  - \c acd_veto_02
  - \c acd_veto_03
  - \c acd_veto_04
  - \c acd_veto_05
  - \c acd_veto_06
  - \c acd_veto_07
  - \c acd_veto_08
  - \c acd_veto_09
  - \c acd_veto_10
  - \c acd_veto_11
  - \c acd_veto_12
  - \c acd_veto_13
  - \c acd_veto_14
  - \c acd_veto_15
  - \c acd_veto_16
  - \c acd_veto_17
  - \c acd_cno

  """
  __attrs = [
      # Registers
      gAttr.GattrRaw('mask',                1,  4),
      gAttr.GattrRaw('busy_disable',        3,  2),
      gAttr.GattrRaw('ext_cal_strobe',      4,  2),
      gAttr.GattrRaw('ext_tack',            5,  2),
      gAttr.GattrRaw('counter_mask',        6,  4),
      gAttr.GattrRaw('counter',             7,  4),
      gAttr.GattrRaw('ext_clk_out_enable',  8,  4),
      # Dataless Commands
      gAttr.GattrDlc('cmd_reset',           9,  0),
      gAttr.GattrDlc('cmd_self_trigger',   10,  0),
      # Bit fields
      gAttr.GattrRaw('parity',             11,  2),
      gAttr.GattrRaw('tag',                12,  2),
      gAttr.GattrRaw('event_number',       13,  2),
      gAttr.GattrRaw('destination',        14,  2),
      gAttr.GattrRaw('marker',             15,  2),
      gAttr.GattrRaw('tack',               16,  2),
      gAttr.GattrRaw('zero_suppress',      17,  2),
      gAttr.GattrRaw('four_range_readout', 18,  2),
      gAttr.GattrRaw('cal_strobe',         19,  2)
      ]

  __mask_BF = [
      ('internal_trg',     0,  1),
      ('external_trg',     1,  2),
      ('cal_low',          2,  3),
      ('cal_high',         3,  4),
      ('three_in_a_row',   4,  5),
      ('acd_veto_00',      5,  6),
      ('acd_veto_01',      6,  7),
      ('acd_veto_02',      7,  8),
      ('acd_veto_03',      8,  9),
      ('acd_veto_04',      9, 10),
      ('acd_veto_05',     10, 11),
      ('acd_veto_06',     11, 12),
      ('acd_veto_07',     12, 13),
      ('acd_veto_08',     13, 14),
      ('acd_veto_09',     14, 15),
      ('acd_veto_10',     15, 16),
      ('acd_veto_11',     16, 17),
      ('acd_veto_12',     17, 18),
      ('acd_veto_13',     18, 19),
      ('acd_veto_14',     19, 20),
      ('acd_veto_15',     20, 21),
      ('acd_veto_16',     21, 22),
      ('acd_veto_17',     22, 23),
      ('acd_cno',         23, 24)
      ]

  __TRG_DISABLE_MASK = 0xFFFFFFFFL

  __EPU_ADDR = 0x20

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

    Assign default values to members
    """
    self.__dirtyMask = 0
    self.__saveMask = None
    self.__bitsMask = 0xFFFFFFFFL
    self.__triggersEnabled = Event()
    self.__enableTime = None
    self.__disableTime = None
    self.__gltMode = 1
    self.__destinationOverride = 0
    self.__lcbAddr = None
    Gdb.__init__(self, client, parent, 0, self.__attrs)

  def getEPUaddr(self):
    # Hard code EPU_ADDR to 0x20 to work with the Caligula FSW release
    return GGLT.__EPU_ADDR

  def read(self, reg):
    return self.cmdrsp('ggGLTread', reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('ggGLTload', reg, value)

  def send(self, cmd):
    return self.cmdrsp('ggGLTcmd', cmd)

  def initialize(self):
    if self.__gltMode == 1:
      # We need to find which bits are enabled
      self.refreshMask()
      #self.regs['mask'].set(self, GGLT.__TRG_DISABLE_MASK) # Revisit: Why next?
      Gdb.__setattr__(self, 'mask', GGLT.__TRG_DISABLE_MASK)
      self.__bitsMask = Gdb.__getattr__(self, 'mask')
      Gdb.__setattr__(self, 'mask', int(self.__saveMask))
    if self.__lcbAddr is None:
      self.__lcbAddr = self.getEPUaddr()
    if self.__destinationOverride == 0:
      Gdb.__setattr__(self, 'destination', self.__lcbAddr)

  def waitForMaskEnable(self, tmo = None):
    """\brief Waits until the enableMask() method is called.

    This is usually needed by non-self-triggering scripts where
    the _commandSynch thread needs to wait until RunControl
    actually enables the mask before continuing.

    \param tmo  Optional parameter giving the wait timeout in seconds
    """
    self.__triggersEnabled.wait(tmo)

  def enableMask(self):
    """\brief Commits the mask value to hardware.

    \return The value of the dirty flag before the commit is made.
    """
    if self.__gltMode == 1:
      if self.__dirtyMask:
        if int(self.__saveMask) == GGLT.__TRG_DISABLE_MASK:
          self.__triggersEnabled.clear()
          Gdb.__setattr__(self, 'mask', int(self.__saveMask))
          self.__disableTime = self.regs['mask'].getTimeStamp()
        else:
          Gdb.__setattr__(self, 'mask', int(self.__saveMask))
          self.__enableTime = self.regs['mask'].getTimeStamp()
          self.__triggersEnabled.set()
        self.__dirtyMask = 0
        return 1
      else:
        return 0
    else:
      return 0

  def disableMask(self):
    """\brief Disables all trigger masks but doesn't change the cached mask value.

    This way when the triggers are enabled again, the old setting can be applied.
    """
    #Note: This method should not modify the cached value.
    if self.__gltMode == 1:
      self.__dirtyMask = 1
      self.__triggersEnabled.clear()
      Gdb.__setattr__(self, 'mask', GGLT.__TRG_DISABLE_MASK)
      self.__disableTime = self.regs['mask'].getTimeStamp()

  def triggersDisabled(self):
    """\brief Check if the triggers are disabled.

    \return True  if triggers are disabled,
            False if triggers are disabled.
    """
    return not self.__triggersEnabled.isSet()

  def isMaskDirty(self):
    """\brief Return the mask dirty flag.

    \return Mask dirty flag.
    """
    return self.__dirtyMask

  def refreshMask(self):
    """\brief Refreshes the cached value of the mask from the hardware.
    """
    self.__saveMask = gBits.bf(Gdb.__getattr__(self, 'mask'))

  def getEnableTime(self):
    """\brief Returns the VxWorks timestamp at the time the triggers are enabled.

    \return Trigger enable time
    """
    return self.__enableTime

  def getDisableTime(self):
    """\brief Returns the VxWorks timestamp at the time the triggers are disabled.

    \return Trigger disable time
    """
    return self.__disableTime

  def setDestinationOverride(self, override):
    """\brief Sets the flag to determine whether the user should be able to
    override the destination value.

    \param override 0=Destination is supplied as the LCB address as returned by CmdCli.getLcbAddr()
                    1=The user supplied destination value takes effect
    """
    self.__destinationOverride = override
    if override == 0:
      Gdb.__setattr__(self, 'destination', self.__lcbAddr)


## private:

  def __setGLTmode(self, mode):
    """Controls the GLT behaviour

    \param mode If set to 0 the GLT behaves in immediate mode
                meaning the trigger mask settings take effect
                immediately.
                If set to 1 then the settings are stored in a
                cached variable and the script needs to call
                enableMask() and/or disableMask() to commit
                the changes from the cache to the hardware.
    """
    self.__gltMode = mode

  def __getGLTmode(self):
    """Retrieves the current GLT mode

    \return Current GLT mode
    """
    return self.__gltMode

  def __getattr__(self, attribute):
    attr = attribute.lower()
    if attr == 'mask' and self.__gltMode == 1:
      return int(self.__saveMask)
    else:
      for (bitField, fromBit, toBit) in self.__mask_BF:
        if attr == bitField:
          if self.__gltMode == 1:
            return self.__saveMask[fromBit:toBit]
          else:
            mask = gBits.bf(Gdb.__getattr__(self, 'mask'))
            return mask[fromBit:toBit]
    return Gdb.__getattr__(self, attribute)

  def __setattr__(self, attribute, value):
    attr = attribute.lower()
    if attr == 'mask' and self.__gltMode == 1:
      self.__dirtyMask = 1
      self.__saveMask = gBits.bf(value & self.__bitsMask)
      return
    elif attr == 'cmd_self_trigger':
      pass
    elif attr == 'destination':
      if not self.__destinationOverride:
        return
    else:
      for (bitField, fromBit, toBit) in self.__mask_BF:
        if attr == bitField:
          if self.__gltMode == 1:
            newVal = gBits.bf(0)
            newVal[fromBit:toBit] = value
            if (int(newVal) | self.__bitsMask) == self.__bitsMask:
              self.__dirtyMask = 1
              self.__saveMask[fromBit:toBit] = value
          else:
            mask = gBits.bf(Gdb.__getattr__(self, 'mask'))
            mask[fromBit:toBit] = value
            Gdb.__setattr__(self, 'mask', int(mask))
          return
    Gdb.__setattr__(self, attribute, value)

---