gXBR.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 XBR functional block"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/07/21 15:13:17 $").split(' ')[1]
__version__ = "$Revision: 2.18 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC

import gSchemaConfig

import gDb
import gAttr
import gGLT
import logging as log
from   LATTE.client import gLog
from   LATTE.client import gRegister

class GXBRD(gDb.Gdb):
  """\brief Tower controller node Record

  Valid Registers:
  - \c dac_tem_voltage
  - \c dac_tkr_analog_2_5
  - \c dac_tkr_digital_2_5
  - \c dac_tkr_cal_analog
  - \c dac_cal_digital_3_3
  - \c path_cmd_resp_reset
  - \c path_trigger
  - \c path_event
  - \c evt_flow_ctrl

  Dataless commands:
  - \c cmd_tem_hw_reset
  """
  __regs = [
    # Registers
    gAttr.GattrReg('dac_tem_voltage',     0, 2),
    gAttr.GattrReg('dac_tkr_analog_2_5',  1, 2),
    gAttr.GattrReg('dac_tkr_digital_2_5', 2, 2),
    gAttr.GattrReg('dac_tkr_cal_analog',  3, 2),
    gAttr.GattrReg('dac_cal_digital_3_3', 4, 2),
    gAttr.GattrReg('path_cmd_resp_reset', 5, 2),
    gAttr.GattrReg('path_trigger',        6, 2),
    gAttr.GattrReg('path_event',          7, 2),
    gAttr.GattrReg('evt_flow_ctrl',       8, 2, gAttr.REG_WRITE_ONLY),
    # Dataless commands
    gAttr.GattrDlc('cmd_tem_hw_reset',    0, 0, gAttr.REG_WRITE_ONLY)
    ]

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

    Assign default values to members
    """
    self.GLT = None
    self.TWR = gDb.Children(self, GTWR)
    self.__schemaComments            = []
    self.__schemaName                = ''
    self.__configComments            = []
    self.__configName                = ''
    self.__configVersion             = ''
    self.__includeFiles              = []
    self.__declarations              = None
    self.__configurations            = {}
    self.__opaque                    = {}
    self.__serialnos                 = {}
    self.__excludes                  = {}    
    gDb.Gdb.__init__(self, client, None, 0, self.__regs)

  def read(self, reg):
    if reg in (7,8):
      log.error("gXBRD.GXBRD:read(): Register no longer available")
      gLog.logStack()
      return gRegister.Register(0, 0, [0], 'H')
    else:
      return self.cmdrsp('ggXBRDread', reg, '!H')

  def load(self, reg, value):
    if reg in (7,8):
      log.error("gXBRD.GXBRD:load(): Register no longer available")
      gLog.logStack()
      return gRegister.Register(0, 0, [0], 'H')
    else:
      return self.cmdrsp('ggXBRDload', reg, value)

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

  def readSchema(self, name):
    self.GLT = None
    self.TWR = gDb.Children(self, GTWR)
    return gSchemaConfig.readSchema(self, name)

  def readConfig(self, cfgFileName):
    return gSchemaConfig.readConfig(self, cfgFileName)

  def applyConfig(self, seq=None):
    gSchemaConfig.applyConfig(self, seq)

  def getConfigurations(self):
    """\brief Get list of configurations.

    Return a list of configuration tuples where
    each tuple contains the configDOM, configName and configRelease.

    \return Configuration tuple list.
    """
    return self.__configurations

  def getDeclarations(self):
    """\brief Get list of declarations.

    Return a list of declarations

    \return Declarations.
    """
    return self.__declarations

  def downGLT(self):
    """\brief Navigate to the GGLT

    \return The GGLT object instance
    """
    return self.GLT

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

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

  def downTWR(self, twrId):
    """\brief Navigate to the GTWR indicated by \a childId

    \param  childId The id of the child tower
    \return         A GTWR object instance
    """
    return self.TWR.down(twrId)

  def existsTWR(self, twrId):
    """\brief Check if the GTWR instance with the id \a twrId
    exists in the schema.

    \param  twrId Tower id
    \return       1 if it exists, 0 if it doesn't.
    """
    return self.TWR.exists(twrId)

## private:
  def __removeGLT(self):
    self.GLT = None

  def __addGLT(self):
    self.GLT = gGLT.GGLT(self.client(), self)
    return self.GLT

  def __removeTWR(self, twrId):
    self.TWR.remove(twrId)

  def __addTWR(self, twrId):
    return self.TWR.add(twrId)


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

  Valid Registers:
  - \c adc_ps_temp_0
  - \c adc_ps_temp_1
  - \c adc_tem_temp_0
  - \c adc_tem_temp_1
  - \c adc_tem_voltage_0
  - \c adc_tem_voltage_1
  """
  __regs = [
    # Registers
    gAttr.GattrReg('adc_ps_temp_0',     0, 4),
    gAttr.GattrReg('adc_ps_temp_1',     1, 4),
    gAttr.GattrReg('adc_tem_temp_0',    2, 4),
    gAttr.GattrReg('adc_tem_temp_1',    3, 4),
    gAttr.GattrReg('adc_tem_voltage_0', 4, 4),
    gAttr.GattrReg('adc_tem_voltage_1', 5, 4)
    ]

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

    Assign default values to members
    """
    gDb.Gdb.__init__(self, client, parent, id, self.__regs)

  def read(self, reg):
    return self.cmdrsp('ggTWRread', self.up().addr(), reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('ggTWRload', self.up().addr(), reg, value)

---