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: 2004/08/25 04:18:27 $").split(' ')[1]
__version__ = "$Revision: 2.9 $"
__release__  = "$Name: P04-06-05 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

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

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

  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.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
    gDb.Gdb.__init__(self, client, parent, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('AEM_CC_read_sync', 'slh', 'LADR_AEM', reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('AEM_CC_load_sync', 'slh', 'LADR_AEM', reg, value)

  def send(self, cmd):
    return self.cmdrsp('AEM_CC_cmd_sync', 'slh', 'LADR_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:
      return self.cmdrsp('AEM_AENV_read_sync', 'slh', 'LADR_AEM', reg, '!Q')
    else:
      return self.__fetchReg(reg)

  def load(self, reg, value):
    return self.cmdrsp('AEM_AENV_load_sync', 'slh', 'LADR_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):
      # Set the mux and cause the ADCs to convert
      self.cmdrsp('AEM_AENV_load_sync', 'slh', 'LADR_AEM', mux, 0)
      # Read the values and timeout information
      rsp = self.cmdrsp('AEM_AENV_read_sync', 'slh', 'LADR_AEM', mux, '!Q')
      self.__envs[mux] = (rsp, now)
    timestamp = rsp.timestamp()
    status    = rsp.status()
    payloads  = [(rsp.value() >> (16 * which)) & 0x0fff]
    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

  \deprecated
  - \c \b rqst_hvbs Use 'hvbs' instead
  - \c \b rqst_hvsaa Use 'saa' instead
  - \c \b hvbs Use 'use_hv_normal' instead
  - \c \b hvsaa Use 'use_hv_saa' instead
  </table>

  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.GattrReg('cmd_reset',          1, 0),
    gAttr.GattrReg('cmd_calstrobe',      3, 0),
    gAttr.GattrReg('cmd_set_hvbs',      10, 0),
    gAttr.GattrReg('cmd_set_hvsaa',     11, 0)
    ]

  BCASTADDR = 0x1f
  NARCS = 12

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

    Assign default values to members
    """
    if id < GARC.NARCS:
      addr = id
    elif id == gDb.Children.BCASTID:
      addr = GARC.BCASTADDR
    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('AEM_GARC_read_sync', 'slh', 'LADR_AEM', self.addr(), reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('AEM_GARC_load_sync', 'slh', 'LADR_AEM', self.addr(), reg, value)

  def send(self, cmd):
    return self.cmdrsp('AEM_GARC_cmd_sync', 'slh', 'LADR_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

  \deprecated
  - \c \b lld_dac Use 'veto_vernier' instead

  """
  __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)
    ]

  BCASTADDR = 0x1f
  NAFES = 18

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

    """
    if id < GAFE.NAFES:
      addr = id
    elif id == gDb.Children.BCASTID:
      addr = GAFE.BCASTADDR
    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('AEM_GAFE_read_sync', 'slh', 'LADR_AEM', self.up().addr(), self.addr(), reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('AEM_GAFE_load_sync', 'slh', 'LADR_AEM', self.up().addr(), self.addr(), reg, value)

  def send(self, cmd):
    return self.cmdrsp('AEM_GAFE_cmd_sync', 'slh', 'LADR_AEM', self.up().addr(), self.addr(), cmd)

---