HskRegisters.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 LAT Housekeeping server infrastructure"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T"
__date__     = "07/28/04"
__version__  = "$Revision: 1.2 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC
import logging
from   LATTE.client.gException   import LATInterfaceException

class RegisterInterface(object):
  """Represents a LAT housekeeping register for reading.
  """
  def __init__(self, node, name):
    """\brief RegisterReader constructor

    \param  node:        a gNode (like GAEQ)
    \param  name:        a name  (like env_free_1la)
    """
    
    self.__readOnly = False
    try:
      node.regs.has_key(name)
    except AttributeError, e:
      self.__node = None
    else:
      self.__node = node
      if node.regs[name].isReadOnly():
        self.__readOnly = True

    self.__name          = name
    self.__lastReadValue = None
    self.__log           = logging.getLogger()

  def name(self): return self.__name
    
  def read(self, cachedValue=False):
    """\brief read method
    
    \return the raw value in the register or None
    """
    if cachedValue:
      return self.__lastReadValue
    
    if self.__node:
      try:
        self.__lastReadValue = self.__node.regs[self.__name].get(bypass=1)
      except LATInterfaceException, e:
        self.__lastReadValue=None
        print e
        self.__log.error(e)
    else:
      self.__log.debug("There is no register %s to read.", self.__name)

    return self.__lastReadValue

  def write(self, value):
    """
    writes to the register
    """
    if self.__readOnly:
      self.log.error("Cannot write to a Read Only Register (%s)",
                     self.name)
    if self.__node:
      try:
        self.__node.regs[self.__name].set(value,bypass=1)
      except LATInterfaceException, e:
        #print e
        self.__log.error(e)
    else:
      # If we are running headless, I'll just put this
      # in the cached value variable
      self.__log.debug("There is no register %s to write 0x%x to.",
                     self.name, value)
      self.__lastReadValue=value


class NodeRegisterList(object):
  """
  """
  def __init__(self, node):
    self.__node = node
    
    self.__regMap = {}
    for regKey in node.regs.keys():
      self.__regMap[regKey] = RegisterInterface( node, regKey )
    
  def map(self):
    return self.__regMap
    
    
class AEQHskRegMap:
  """
  """
  regMap = { 
    "env_free_1la" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_1rb" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_2la" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_2lb" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_2ra" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_2rb" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_3la" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_3rb" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_4la" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_4lb" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_4ra" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_free_4rb" : [ "Vdd", "Temperature", "HV1", "HV2" ],
    "env_daq" :      [ "FreeI", "Temperature", "HVI", "DAQV" ]
  }
  def __init__(self):
    pass
  
  def decodeRegister(self, key, regValue):
    """
    decode an AEM register.  Each 16 bit section looks like:
    MBZ[3] Timeout[1] Val[12]
    
    \return a map of parsed values
    """
    keyList = self.regMap[key]
    retMap  = {}
    if ( regValue >> 63 ) & 0x1: # not ready
      for i in range(4): 
        retMap[keyList[i]] = None
    else:
      for i in range(4):
        word    = ( regValue >> (16*i) ) & 0xffff
        timeout = word >> 15 & 0x1
        if timeout:
          value = None
        else:
          value = word & 0x7fff
        retMap[keyList[i]] = value
    return retMap
   

    
    

---