gGEM.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 GEM functional block"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/06/15 17:45:10 $").split(' ')[1]
__version__ = "$Revision: 2.19 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import gDb
import gAttr

class GGEM(gDb.Gdb):
  """\brief GGEM node.

  """
  __attrs = []

  __EPU_ADDR = 0x20

  def __init__(self, client, parent):
    """\brief Initialize child objects.

    """
    self.GEMC    = None
    self.GEMMG   = None
    self.GEMST   = None
    self.GEMSC   = None
    self.GEMVG   = None
    self.GEMIE   = None
    self.GEMW    = None
    flags = {'CmdrspFabric'    : 'On',
             'EventFabric'     : 'On'}
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs, None, flags)

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

  def downGEMC(self):
    """\brief Navigate to the GGEMC node

    \return         The GGEMC object instance
    """
    return self.GEMC

  def existsGEMC(self):
    """\brief Check if the GGEMC instance exists in the schema.

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.GEMC != None

  def downGEMMG(self):
    """\brief Navigate to the GGEMMG node

    \return         The GGEMMG object instance
    """
    return self.GEMMG

  def existsGEMMG(self):
    """\brief Check if the GGEMMG instance exists in the schema.

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.GEMMG != None

  def downGEMST(self):
    """\brief Navigate to the GGEMST node

    \return         The GGEMST object instance
    """
    return self.GEMST

  def existsGEMST(self):
    """\brief Check if the GGEMST instance exists in the schema.

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.GEMST != None

  def downGEMSC(self):
    """\brief Navigate to the GGEMSC node

    \return         The GGEMSC object instance
    """
    return self.GEMSC

  def existsGEMSC(self):
    """\brief Check if the GGEMSC instance exists in the schema.

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.GEMSC != None

  def downGEMVG(self):
    """\brief Navigate to the GGEMVG node

    \return         The GGEMVG object instance
    """
    return self.GEMVG

  def existsGEMVG(self):
    """\brief Check if the GGEMVG instance exists in the schema.

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.GEMVG != None

  def downGEMIE(self):
    """\brief Navigate to the GGEMIE node

    \return         The GGEMIE object instance
    """
    return self.GEMIE

  def existsGEMIE(self):
    """\brief Check if the GGEMIE instance exists in the schema.

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.GEMIE != None

  def downGEMW(self):
    """\brief Navigate to the GGEMW node

    \return         The GGEMW object instance
    """
    return self.GEMW

  def existsGEMW(self):
    """\brief Check if the GGEMW instance exists in the schema.

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.GEMW != None

## private:

  def __removeGEMC(self):
    self.GEMC = None

  def __addGEMC(self):
    ggemc = GGEMC(self.client(), self)
    self.GEMC = ggemc
    return ggemc

  def __removeGEMMG(self):
    self.GEMMG = None

  def __addGEMMG(self):
    ggemmg = GGEMMG(self.client(), self)
    self.GEMMG = ggemmg
    return ggemmg

  def __removeGEMST(self):
    self.GEMST = None

  def __addGEMST(self):
    ggemst = GGEMST(self.client(), self)
    self.GEMST = ggemst
    return ggemst

  def __removeGEMSC(self):
    self.GEMSC = None

  def __addGEMSC(self):
    ggemsc = GGEMSC(self.client(), self)
    self.GEMSC = ggemsc
    return ggemsc

  def __removeGEMVG(self):
    self.GEMVG = None

  def __addGEMVG(self):
    ggemvg = GGEMVG(self.client(), self)
    self.GEMVG = ggemvg
    return ggemvg

  def __removeGEMIE(self):
    self.GEMIE = None

  def __addGEMIE(self):
    ggemie = GGEMIE(self.client(), self)
    self.GEMIE = ggemie
    return ggemie

  def __removeGEMW(self):
    self.GEMW = None

  def __addGEMW(self):
    ggemw = GGEMW(self.client(), self)
    self.GEMW = ggemw
    return ggemw


class GGEMC(gDb.Gdb):
  """\brief GEMC sub-node of GGEM (controller).

  Has GGEMC specific registers and dataless commands.

  Valid Registers:
  - \c configuration
  - \c address
  - \c periodic_mode
  - \c periodic_limits
  - \c periodic_rate
  - \c sequence
  - \c cr_statistics
  - \c event_statistics
  - \c delay_ext_trg

  Dataless Commands:
  - \c cmd_nop
  - \c cmd_reset
  - \c cmd_trigger

  """
  __attrs = [
    # Registers
    gAttr.GattrRaw('configuration',    0, 4),
    gAttr.GattrRaw('address',          1, 4),
    gAttr.GattrRaw('periodic_mode',    3, 4),
    gAttr.GattrRaw('periodic_limits',  4, 4),
    gAttr.GattrRaw('periodic_rate',    5, 4),
    gAttr.GattrRaw('sequence',         6, 4),
    gAttr.GattrRaw('cr_statistics',    7, 4),
    gAttr.GattrRaw('event_statistics', 8, 4),
    gAttr.GattrRaw('delay_ext_trg',    9, 4),
    # Dataless Commands
    gAttr.GattrDlc('cmd_nop',          0, 0),
    gAttr.GattrDlc('cmd_reset',        1, 0),
    gAttr.GattrDlc('cmd_trigger',      2, 0),
    ]

  def __init__(self, client, parent):
    """\brief Initialize valid registers as Gattrs
    """
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('GEM_read', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_CC, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('GEM_load', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_CC, reg, value)

  def send(self, cmd):
    return self.cmdrsp('GEM_cmd', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_CC, cmd)


class GGEMMG(gDb.Gdb):
  """\brief GEMMG sub-node of GGEM (TAM generator).

  Has GGEMMG specific registers and dataless commands.

  Valid Registers:
  - \c engine_0
  - \c engine_1
  - \c engine_2
  - \c engine_3
  - \c engine_4
  - \c engine_5
  - \c engine_6
  - \c engine_7
  - \c engine_8
  - \c engine_9
  - \c engine_a
  - \c engine_b
  - \c engine_c
  - \c engine_d
  - \c engine_e
  - \c engine_f

  """
  __attrs = [
    # Registers
    gAttr.GattrRaw('engine_0',    0, 4),
    gAttr.GattrRaw('engine_1',    1, 4),
    gAttr.GattrRaw('engine_2',    2, 4),
    gAttr.GattrRaw('engine_3',    3, 4),
    gAttr.GattrRaw('engine_4',    4, 4),
    gAttr.GattrRaw('engine_5',    5, 4),
    gAttr.GattrRaw('engine_6',    6, 4),
    gAttr.GattrRaw('engine_7',    7, 4),
    gAttr.GattrRaw('engine_8',    8, 4),
    gAttr.GattrRaw('engine_9',    9, 4),
    gAttr.GattrRaw('engine_a',   10, 4),
    gAttr.GattrRaw('engine_b',   11, 4),
    gAttr.GattrRaw('engine_c',   12, 4),
    gAttr.GattrRaw('engine_d',   13, 4),
    gAttr.GattrRaw('engine_e',   14, 4),
    gAttr.GattrRaw('engine_f',   15, 4),
    ]

  def __init__(self, client, parent):
    """\brief Initialize valid registers as Gattrs.
    """
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('GEM_read', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_TAM, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('GEM_load', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_TAM, reg, value)


class GGEMST(gDb.Gdb):
  """\brief GEMST sub-node of GGEM (statistics).

  Has GGEMST specific registers and dataless commands.

  Valid Registers:
  - \c livetime
  - \c prescaled
  - \c discarded
  - \c sent
  - \c tile_counters
  - \c tile_0
  - \c tile_1
  - \c cno_counters
  - \c cno_0
  - \c cno_1
  - \c one_pps
  - \c timebase
  - \c deadzone

  \deprecated
  - \c \b missed Use 'deadzone' instead

  """
  __attrs = [
    # Registers
    gAttr.GattrRaw('livetime',        0, 4),
    gAttr.GattrRaw('prescaled',       1, 4),
    gAttr.GattrRaw('discarded',       2, 4),
    gAttr.GattrRaw('sent',            3, 4),
    gAttr.GattrRaw('tile_counters',   4, 4),
    gAttr.GattrRaw('tile_0',          5, 4),
    gAttr.GattrRaw('tile_1',          6, 4),
    gAttr.GattrRaw('cno_counters',    7, 4),
    gAttr.GattrRaw('cno_0',           8, 4),
    gAttr.GattrRaw('cno_1',           9, 4),
    gAttr.GattrRaw('one_pps',        10, 4),
    gAttr.GattrRaw('timebase',       11, 4),
    gAttr.GattrRegDepr('missed',     12, 4), # Deprecated: use deadzone
    gAttr.GattrRaw('deadzone',       12, 4),
    ]

  def __init__(self, client, parent):
    """\brief Initialize valid registers as Gattrs.
    """
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('GEM_read', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_STAT, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('GEM_load', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_STAT, reg, value)

  def send(self, cmd):
    return self.cmdrsp('GEM_cmd', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_STAT, cmd)

  def extCtrEnable(self, reg):
    """\brief Enable the specified pseudo counter.
    By default all pseudo counters are disabled.

    \param reg Register id of the pseudo counter.
               Can be retrieved by calling gemst.regs['regname'].id().
    \return A Response object
    """
    return self.cmdrsp('GEM_stat_enable', reg)

  def extCtrDisable(self, reg):
    """\brief Disable the specified pseudo counter.
    By default all pseudo counters are disabled.

    \param reg Register id of the pseudo counter.
               Can be retrieved by calling gemst.regs['regname'].id().
    \return A Response object
    """
    return self.cmdrsp('GEM_stat_disable', reg)

  def extCtrLoopEnable(self):
    """\brief Enable the update loop that updates all
    counter pseudoregisters.

    \return A Response object
    """
    return self.cmdrsp('GEM_stat_loop_enable')

  def extCtrLoopDisable(self):
    """\brief Disable the update loop that updates all
    counter pseudoregisters.

    \return A Response object
    """
    return self.cmdrsp('GEM_stat_loop_disable')

  def extCtrSetLoopDelay(self, delay):
    """\brief Set the update loop interval for
    counter pseudoregisters.

    \param Set the pseudo counter update loop delay
           in 1/60 second ticks. The default is 30 (2 Hz).

    \return A Response object
    """
    return self.cmdrsp('GEM_stat_loop_delay', delay)

  def extCtrRead(self, reg):
    """\brief Read the specified pseudocounter

    \param reg Register id of the pseudo counter.
               Can be retrieved by calling gemst.regs['regname'].id().
    \return (value, timestamp) pair
    """
    return self.cmdrsp('GEM_stat_read', reg, '!Q', '!Q')

  def extCtrClear(self):
    """\brief Clear the pseudocounters
    """
    return self.cmdrsp('GEM_stat_clear')

  def extCtrClearStatus(self):
    """\brief Read the pseudocounter statuses
    """
    return self.cmdrsp('GEM_stat_clear_status')



class GGEMSC(gDb.Gdb):
  """\brief GEMSC sub-node of GGEM (scheduler).

  Has GGEMSC specific registers and dataless commands.

  Valid Registers:
  - \c conditions_00_07
  - \c conditions_08_0f
  - \c conditions_10_17
  - \c conditions_18_1f
  - \c conditions_20_27
  - \c conditions_28_2f
  - \c conditions_30_37
  - \c conditions_38_3f
  - \c conditions_40_47
  - \c conditions_48_4f
  - \c conditions_50_57
  - \c conditions_58_5f
  - \c conditions_60_67
  - \c conditions_68_6f
  - \c conditions_70_77
  - \c conditions_78_7f
  - \c conditions_80_87
  - \c conditions_88_8f
  - \c conditions_90_97
  - \c conditions_98_9f
  - \c conditions_a0_a7
  - \c conditions_a8_af
  - \c conditions_b0_b7
  - \c conditions_b8_bf
  - \c conditions_c0_c7
  - \c conditions_c8_cf
  - \c conditions_d0_d7
  - \c conditions_d8_df
  - \c conditions_e0_e7
  - \c conditions_e8_ef
  - \c conditions_f0_f7
  - \c conditions_f8_ff

  """
  __attrs = [
    # Registers
    gAttr.GattrRaw('conditions_00_07', 0x00, 4),
    gAttr.GattrRaw('conditions_08_0f', 0x01, 4),
    gAttr.GattrRaw('conditions_10_17', 0x02, 4),
    gAttr.GattrRaw('conditions_18_1f', 0x03, 4),
    gAttr.GattrRaw('conditions_20_27', 0x04, 4),
    gAttr.GattrRaw('conditions_28_2f', 0x05, 4),
    gAttr.GattrRaw('conditions_30_37', 0x06, 4),
    gAttr.GattrRaw('conditions_38_3f', 0x07, 4),
    gAttr.GattrRaw('conditions_40_47', 0x08, 4),
    gAttr.GattrRaw('conditions_48_4f', 0x09, 4),
    gAttr.GattrRaw('conditions_50_57', 0x0a, 4),
    gAttr.GattrRaw('conditions_58_5f', 0x0b, 4),
    gAttr.GattrRaw('conditions_60_67', 0x0c, 4),
    gAttr.GattrRaw('conditions_68_6f', 0x0d, 4),
    gAttr.GattrRaw('conditions_70_77', 0x0e, 4),
    gAttr.GattrRaw('conditions_78_7f', 0x0f, 4),
    gAttr.GattrRaw('conditions_80_87', 0x10, 4),
    gAttr.GattrRaw('conditions_88_8f', 0x11, 4),
    gAttr.GattrRaw('conditions_90_97', 0x12, 4),
    gAttr.GattrRaw('conditions_98_9f', 0x13, 4),
    gAttr.GattrRaw('conditions_a0_a7', 0x14, 4),
    gAttr.GattrRaw('conditions_a8_af', 0x15, 4),
    gAttr.GattrRaw('conditions_b0_b7', 0x16, 4),
    gAttr.GattrRaw('conditions_b8_bf', 0x17, 4),
    gAttr.GattrRaw('conditions_c0_c7', 0x18, 4),
    gAttr.GattrRaw('conditions_c8_cf', 0x19, 4),
    gAttr.GattrRaw('conditions_d0_d7', 0x1a, 4),
    gAttr.GattrRaw('conditions_d8_df', 0x1b, 4),
    gAttr.GattrRaw('conditions_e0_e7', 0x1c, 4),
    gAttr.GattrRaw('conditions_e8_ef', 0x1d, 4),
    gAttr.GattrRaw('conditions_f0_f7', 0x1e, 4),
    gAttr.GattrRaw('conditions_f8_ff', 0x1f, 4),
    ]

  def __init__(self, client, parent):
    """\brief Initialize valid registers as Gattrs.
    """
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('GEM_read', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_SCHD, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('GEM_load', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_SCHD, reg, value)


class GGEMVG(gDb.Gdb):
  """\brief GEMVG sub-node of GGEM (ROI generator).

  Has GGEMVG specific registers and dataless commands.

  Valid Registers:

  - \c ROI_00, ROI_01, ROI_02,...,ROI_53

  """
  __attrs = []
  # Registers
  for i in range(54):
    __attrs.append(gAttr.GattrRaw('ROI_%02d' % i, i, 4))

  def __init__(self, client, parent):
    """\brief Initialize valid registers as Gattrs.
    """
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('GEM_read', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_ROI, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('GEM_load', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_ROI, reg, value)


class GGEMIE(gDb.Gdb):
  """\brief GEMIE sub-node of GGEM (input enables).

  Has GGEMIE specific registers and dataless commands.

  Valid Registers:
  - \c towers_0_3
  - \c towers_4_7
  - \c towers_8_11
  - \c towers_12_15
  - \c acd_cno
  - \c tiles_000_013
  - \c tiles_014_032
  - \c tiles_033_NA3
  - \c tiles_100_113
  - \c tiles_114_NA5
  - \c tiles_200_213
  - \c tiles_214_NA7
  - \c tiles_300_313
  - \c tiles_314_NA9
  - \c tiles_400_413
  - \c tiles_414_NA1
  - \c tiles_500_NA10
  - \c tower_busy
  - \c external

  """
  __attrs = [
    # Registers
    gAttr.GattrRaw('external',       18, 4), # Specified first to support
                                             # older GASUs. See __commit() in
                                             # trigger.TrgGem for more information.
    gAttr.GattrRaw('towers_0_3',      0, 4),
    gAttr.GattrRaw('towers_4_7',      1, 4),
    gAttr.GattrRaw('towers_8_11',     2, 4),
    gAttr.GattrRaw('towers_12_15',    3, 4),
    gAttr.GattrRaw('acd_cno',         4, 4),
    gAttr.GattrRaw('tiles_000_013',   5, 4),
    gAttr.GattrRaw('tiles_014_032',   6, 4),
    gAttr.GattrRaw('tiles_033_NA3',   7, 4),
    gAttr.GattrRaw('tiles_100_113',   8, 4),
    gAttr.GattrRaw('tiles_114_NA5',   9, 4),
    gAttr.GattrRaw('tiles_200_213',  10, 4),
    gAttr.GattrRaw('tiles_214_NA7',  11, 4),
    gAttr.GattrRaw('tiles_300_313',  12, 4),
    gAttr.GattrRaw('tiles_314_NA9',  13, 4),
    gAttr.GattrRaw('tiles_400_413',  14, 4),
    gAttr.GattrRaw('tiles_414_NA1',  15, 4),
    gAttr.GattrRaw('tiles_500_NA10', 16, 4),
    gAttr.GattrRaw('tower_busy',     17, 4),
    ]

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

    """
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('GEM_read', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_IE, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('GEM_load', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_IE, reg, value)


class GGEMW(gDb.Gdb):
  """\brief GEMW sub-node of GGEM.

  Has GGEMW specific registers.

  Valid Registers:
  - \c window_width
  - \c window_open_mask
  """
  __attrs = [
    # Registers
    gAttr.GattrRaw('window_width',      0, 4),
    gAttr.GattrRaw('window_open_mask',  1, 4),
    ]

  def __init__(self, client, parent):
    """\brief Initialize valid registers as Gattrs.
    """
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('GEM_read', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_WIN, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('GEM_load', gDb.Lem.ADDR_GEM, gDb.Lem.GEM_WIN, reg, value)

---