gAEM.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 ACD functional block hierarchy"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/12/21 01:07:55 $").split(' ')[1]
__version__ = "$Revision: 2.17 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import time
import gDb
import gAttr
import LATTE.client.gRegister as gRegister
import LATTE.client.gException as gException

class GAEM(gDb.Gdb):
  """\brief ACD Common Controller.

  Has GAEM specific registers and dataless commands.

  Valid Registers:
  - \c configuration
  - \c common_status
  - \c freeboard_status
  - \c command_response
  - \c trgseq
  - \c power_status
  - \c address
  - \c timeout
  - \c relocation
  - \c response_timeout
  - \c power_up
  - \c power_down
  - \c trigger_statistics

  Dataless Commands:
  - \c cmd_reset

  """
  __attrs = [
    gAttr.GattrReg('configuration',       0, 4),
    gAttr.GattrReg('common_status',       1, 4),
    gAttr.GattrReg('freeboard_status',    2, 4),
    gAttr.GattrReg('command_response',    3, 4),
    gAttr.GattrReg('trgseq',              4, 4),
    gAttr.GattrReg('power_status',        5, 4),
    gAttr.GattrReg('address',             6, 4),
    gAttr.GattrReg('timeout',             7, 4),
    gAttr.GattrReg('relocation',          8, 4),
    gAttr.GattrReg('response_timeout',    9, 4),
    gAttr.GattrReg('power_up',           10, 4),
    gAttr.GattrReg('power_down',         11, 4),
    gAttr.GattrReg('trigger_statistics', 12, 4),
    gAttr.GattrDlc('cmd_reset',           1, 0),
    ]

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

    Assign default values to members
    """
    self.ARC = gDb.Children(self, GARC)
    self.AEQ = None
    flags = {'CmdrspFabric'    : 'On',
             'EventFabric'     : 'On',
             'UsePdu1'         : False,
             'UseRedundantConv': False}
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs, None, flags)

  def read(self, reg):
    return self.cmdrsp('AEM_read', gDb.Lem.ADDR_AEM, reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('AEM_load', gDb.Lem.ADDR_AEM, reg, value)

  def send(self, cmd):
    return self.cmdrsp('AEM_cmd', gDb.Lem.ADDR_AEM, cmd)

  def downARC(self, arcId):
    """\brief Navigate to the GARC indicated by \a childId

    \param  childId The id of the child GARC

    \return         A GARC object instance
    """
    return self.ARC.down(arcId)

  def allARC(self):
    """\brief Navigate to the broadcast GARC

    \return The broadcast GARC object instance
    """
    return self.ARC.all()

  def existsARC(self, arcId):
    """\brief Check if the GARC instance with the id
    \a arcId exists in the schema.

    \param  arcId ACD readout controller id

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.ARC.exists(arcId)

  def downAEQ(self):
    """\brief Navigate to the GAEQ

    \return The GAEQ object instance
    """
    return self.AEQ

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

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

## private:
  def __removeARC(self, arcId):
    self.ARC.remove(arcId)

  def __addARC(self, arcId):
    return self.ARC.add(arcId)

  def __removeAEQ(self):
    self.AEQ = None

  def __addAEQ(self):
    self.AEQ = GAEQ(self.client(), self)
    return self.AEQ

class GAEQ(gDb.Gdb):
  """\brief ACD Environmental Monitors.

  Has GAEQ specific registers and dataless commands.

  Valid Registers:
  - \c env_free_1la
  - \c env_free_1rb
  - \c env_free_2la
  - \c env_free_2lb
  - \c env_free_2ra
  - \c env_free_2rb
  - \c env_free_3la
  - \c env_free_3rb
  - \c env_free_4la
  - \c env_free_4lb
  - \c env_free_4ra
  - \c env_free_4rb
  - \c env_daq

    Pseudo registers:
  - \c env_vdd_xxx
  - \c env_temp_xxx
  - \c env_hv1_xxx
  - \c env_hv2_xxx
  - \c env_dac_digital_3_3i
  - \c env_dac_temp
  - \c env_dac_hv_i
  - \c env_dac_v

  """
  __attrs = [
    # Registers
    gAttr.GattrReg('env_free_1la',       0, 8),
    gAttr.GattrReg('env_free_1rb',       1, 8),
    gAttr.GattrReg('env_free_2la',       2, 8),
    gAttr.GattrReg('env_free_2lb',       3, 8),
    gAttr.GattrReg('env_free_2ra',       4, 8),
    gAttr.GattrReg('env_free_2rb',       5, 8),
    gAttr.GattrReg('env_free_3la',       6, 8),
    gAttr.GattrReg('env_free_3rb',       7, 8),
    gAttr.GattrReg('env_free_4la',       8, 8),
    gAttr.GattrReg('env_free_4lb',       9, 8),
    gAttr.GattrReg('env_free_4ra',      10, 8),
    gAttr.GattrReg('env_free_4rb',      11, 8),
    gAttr.GattrReg('env_daq',           12, 8),
    ]
  __STALE_TMO = 1.0     # Timeout in seconds before considering adcs value stale
  __GAEQ_ENV_VDD_1LA = 20
  __ADCS_BASE = 20

  i = __ADCS_BASE
  for env in ('1la','1rb','2la','2lb','2ra','2rb',
              '3la','3rb','4la','4lb','4ra','4rb'):
    __attrs.append(gAttr.GattrReg('env_vdd_'+env, i, 2))
    i+=1
    __attrs.append(gAttr.GattrReg('env_temp_'+env, i, 2))
    i+=1
    __attrs.append(gAttr.GattrReg('env_hv1_'+env, i, 2))
    i+=1
    __attrs.append(gAttr.GattrReg('env_hv2_'+env, i, 2))
    i+=1
  __attrs.append(gAttr.GattrReg('env_dac_digital_3_3i', 68, 2))
  __attrs.append(gAttr.GattrReg('env_dac_temp', 69, 2))
  __attrs.append(gAttr.GattrReg('env_dac_hv_i', 70, 2))
  __attrs.append(gAttr.GattrReg('env_dac_v', 71, 2))

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

    Assign default values to members
    """
    self.__envs = 13*[(None, 0)]      # [gRegister.Register, time.time()]
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    if reg < GAEQ.__ADCS_BASE:
      rsp = self.cmdrsp('AEM_ENV_read', gDb.Lem.ADDR_AEM, reg, '!I', '!I')
      timestamp = rsp.timestamp()
      status    = rsp.status()
      payloads  = (rsp.payloads()[1], rsp.payloads()[0])
      return gRegister.Register(timestamp, status, payloads, 'II')
    else:
      return self.__fetchReg(reg)

  def load(self, reg, value):
    return self.cmdrsp('AEM_ENV_load', gDb.Lem.ADDR_AEM, reg, value)

  def __fetchReg(self, reg):
    mux   = (reg - GAEQ.__ADCS_BASE) / 4
    which = (reg - GAEQ.__ADCS_BASE) % 4
    now = time.time()
    (rsp, rt) = self.__envs[mux]
    if ((rsp is None) or (now - rt) > GAEQ.__STALE_TMO):
      rsp = self.cmdrsp('AEM_ENV_acquire', gDb.Lem.ADDR_AEM, mux, '!I', '!I')
      notready = (rsp.payloads()[0]>>31) & 1
      tmo = ((rsp.payloads()[0]>>28) & 1) | ((rsp.payloads()[0]>>12) & 1) |\
            ((rsp.payloads()[1]>>28) & 1) | ((rsp.payloads()[1]>>12) & 1)
      if notready:
        status = gException.LATInterfaceStatus.status('OCS_BDADC')
        raise gException.LATInterfaceException(status)
      if tmo:
        status = gException.LATInterfaceStatus.status('OCS_TMOADC')
        raise gException.LATInterfaceException(status)
      self.__envs[mux] = (rsp, now)
    timestamp = rsp.timestamp()
    status    = rsp.status()
    payload   = rsp.payloads()[0] << 32 | rsp.payloads()[1]
    value     = int((payload >> (16 * which)) & 0xfff)
    payloads  = [value]
    return gRegister.Register(timestamp, status, payloads, 'H')

class GARC(gDb.Gdb):
  """\brief ACD Readout Controller.

  Has GARC specific registers and dataless commands.

  Valid Registers:
  - function block 0
    - \c veto_delay
    - \c hvbs
    - \c saa
    - \c use_hv_normal
    - \c use_hv_saa
    - \c hold_delay
    - \c veto_width
    - \c hitmap_width
    - \c hitmap_deadtime
  - function block 1
    - \c look_at_me
    - \c hitmap_delay
    - \c pha_en_0
    - \c veto_en_0
    - \c hld_en_0
    - \c pha_en_1
    - \c veto_en_1
    - \c hld_en_1
    - \c max_pha
  - function block 2
    - \c mode
    - \c status
    - \c last_cmd
    - \c diagnostic
    - \c cmd_reject
    - \c free_id
    - \c garc_version
  - function block 3
    - \c pha_threshold_0
    - \c pha_threshold_1
    - \c pha_threshold_2
    - \c pha_threshold_3
    - \c pha_threshold_4
    - \c pha_threshold_5
    - \c pha_threshold_6
  - function block 4
    - \c pha_threshold_7
    - \c pha_threshold_8
    - \c pha_threshold_9
    - \c pha_threshold_10
    - \c pha_threshold_11
    - \c pha_threshold_12
    - \c pha_threshold_13
  - function block 5
    - \c pha_threshold_14
    - \c pha_threshold_15
    - \c pha_threshold_16
    - \c pha_threshold_17
    - \c adc_tacq

  Dataless Commands
  - \c cmd_reset
  - \c cmd_calstrobe
  - \c cmd_set_hvbs
  - \c cmd_set_hvsaa

  """
  __attrs = [
    # Registers
    # function block 0
    gAttr.GattrReg('veto_delay',         2, 2),
    gAttr.GattrReg('hvbs',               8, 2),
    gAttr.GattrReg('saa',                9, 2),
    gAttr.GattrReg('use_hv_normal',     10, 2),
    gAttr.GattrReg('use_hv_saa',        11, 2),
    gAttr.GattrReg('hold_delay',        12, 2),
    gAttr.GattrReg('veto_width',        13, 2),
    gAttr.GattrReg('hitmap_width',      14, 2),
    gAttr.GattrReg('hitmap_deadtime',   15, 2),
    # function block 1
    gAttr.GattrReg('look_at_me',        20, 2),
    gAttr.GattrReg('hitmap_delay',      24, 2),
    gAttr.GattrReg('pha_en_0',          25, 2),
    gAttr.GattrReg('veto_en_0',         26, 2),
    gAttr.GattrReg('pha_en_1',          28, 2),
    gAttr.GattrReg('veto_en_1',         29, 2),
    gAttr.GattrReg('max_pha',           31, 2),
    # function block 2
    gAttr.GattrReg('mode',              40, 2),
    gAttr.GattrReg('status',            41, 2),
    gAttr.GattrReg('last_cmd',          42, 2),
    gAttr.GattrReg('diagnostic',        43, 2),
    gAttr.GattrReg('cmd_reject',        44, 2),
    gAttr.GattrReg('free_id',           45, 2),
    gAttr.GattrReg('garc_version',      46, 2),
    # function block 3
    gAttr.GattrReg('pha_threshold_0',   56, 2),
    gAttr.GattrReg('pha_threshold_1',   57, 2),
    gAttr.GattrReg('pha_threshold_2',   58, 2),
    gAttr.GattrReg('pha_threshold_3',   59, 2),
    gAttr.GattrReg('pha_threshold_4',   60, 2),
    gAttr.GattrReg('pha_threshold_5',   61, 2),
    gAttr.GattrReg('pha_threshold_6',   62, 2),
    # function block 4
    gAttr.GattrReg('pha_threshold_7',   72, 2),
    gAttr.GattrReg('pha_threshold_8',   73, 2),
    gAttr.GattrReg('pha_threshold_9',   74, 2),
    gAttr.GattrReg('pha_threshold_10',  75, 2),
    gAttr.GattrReg('pha_threshold_11',  76, 2),
    gAttr.GattrReg('pha_threshold_12',  77, 2),
    gAttr.GattrReg('pha_threshold_13',  78, 2),
    # function block 5
    gAttr.GattrReg('pha_threshold_14',  88, 2),
    gAttr.GattrReg('pha_threshold_15',  89, 2),
    gAttr.GattrReg('pha_threshold_16',  90, 2),
    gAttr.GattrReg('pha_threshold_17',  91, 2),
    gAttr.GattrReg('adc_tacq',          92, 2),
    # Dataless Commands
    gAttr.GattrDlc('cmd_reset',          1, 0),
    gAttr.GattrDlc('cmd_calstrobe',      3, 0),
    gAttr.GattrDlc('cmd_set_hvbs',      10, 0),
    gAttr.GattrDlc('cmd_set_hvsaa',     11, 0)
    ]

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

    Assign default values to members
    """
    if id < gDb.Lem.NARCS:
      addr = id
    elif id == gDb.Children.BCASTID:
      addr = gDb.Lem.ARCBCAST
    else:
      raise KeyError("*** gAEM: GARC id %d is invalid" %(id))
    self.AFE = gDb.Children(self, GAFE)
    gDb.Gdb.__init__(self, client, parent, id, self.__attrs, addr)

  def read(self, reg):
    return self.cmdrsp('ARC_read', gDb.Lem.ADDR_AEM, self.addr(), reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('ARC_load', gDb.Lem.ADDR_AEM, self.addr(), reg, value)

  def send(self, cmd):
    return self.cmdrsp('ARC_cmd', gDb.Lem.ADDR_AEM, self.addr(), cmd)

  def downAFE(self, afeId):
    """\brief Navigate to the GAFE indicated by \a childId

    \param  childId The id of the child GAFE

    \return         A GAFE object instance
    """
    return self.AFE.down(afeId)

  def allAFE(self):
    """\brief Navigate to the broadcast GAFE

    \return The broadcast GAFE object instance
    """
    return self.AFE.all()

  def existsAFE(self, afeId):
    """\brief Check if the GAFE instance with the id
    \a afeId exists in the schema.

    \param  afeId ACD readout controller id

    \return       1 if it exists, 0 if it doesn't.
    """
    return self.AFE.exists(afeId)

## private:
  def __removeAFE(self, afeId):
    self.AFE.remove(afeId)

  def __addAFE(self, afeId):
    return self.AFE.add(afeId)


class GAFE(gDb.Gdb):
  """\brief ACD Front-End Controller.

  Has GAFE specific registers and dataless commands.

  Valid Registers:
  - \c configuration
  - \c veto_dac
  - \c hld_dac
  - \c veto_vernier
  - \c bias_dac
  - \c tci_dac
  - \c vers_addr
  - \c write_ctr
  - \c reject_ctr
  - \c loop_ctr
  - \c chip_addr

  """
  __attrs = [
    # Registers
    gAttr.GattrReg('configuration',  0, 2),
    gAttr.GattrReg('veto_dac',       1, 2),
    gAttr.GattrReg('veto_vernier',   2, 2),
    gAttr.GattrReg('hld_dac',        3, 2),
    gAttr.GattrReg('bias_dac',       4, 2),
    gAttr.GattrReg('tci_dac',        5, 2),
    gAttr.GattrReg('vers_addr',      6, 2),
    gAttr.GattrReg('write_ctr',      7, 2),
    gAttr.GattrReg('reject_ctr',     8, 2),
    gAttr.GattrReg('loop_ctr',       9, 2),
    gAttr.GattrReg('chip_addr',     10, 2)
    ]

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

    """
    if id < gDb.Lem.NAFES:
      addr = id
    elif id == gDb.Children.BCASTID:
      addr = gDb.Lem.AFEBCAST
    else:
      raise KeyError("*** gAEM: GAFE id %d is invalid" %(id))
    gDb.Gdb.__init__(self, client, parent, id, self.__attrs, addr)

  def read(self, reg):
    return self.cmdrsp('AFE_read', gDb.Lem.ADDR_AEM, self.up().addr(), self.addr(), reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('AFE_load', gDb.Lem.ADDR_AEM, self.up().addr(), self.addr(), reg, value)

  def send(self, cmd):
    return self.cmdrsp('AFE_cmd', gDb.Lem.ADDR_AEM, self.up().addr(), self.addr(), cmd)

---