HskRetriever.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.9 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC
import time

from LATTE.monitoring.Retriever    import Retriever
from LATTE.monitoring.Trendable    import Trendable
from LATTE.database.gLAT           import GLAT

class HskLatRetriever(Retriever):
  """Fully populated LAT retriever.
     Should get all available LAT housekeeping quantities and trend them.
  """
  def __init__(self, glat):
    Retriever.__init__(self)
    from LATTE.monitoring.TrendMaps    import GLATTrendMap
    self.__trendMap = GLATTrendMap(glat)
    # Deal with GEBM TEM multiplexer...
    self.__mux = []
    for i in range(16):
      self.__mux.append('LHKETEM%XRS'%i)
    
  def retrievePacket(self):
    packet = []
    timestamp = time.time()  # time() returns seconds since epoch, UTC
    for key in self.__trendMap.mapKeys():
      atuple = self.__trendMap.mapGet(key)
      if atuple is not None:
        node, attr = atuple
        if node is not None and attr != '':
          try:
            if key in self.__mux:   # have a GEBM TEM multiplexer...
              muxes = node.downEBMC().tem_statistics
              mux0 = ( muxes      ) & 0xf 
              mux1 = ( muxes >> 4 ) & 0xf
              tem = self.__mux.index(key)
              if tem == mux0:
                value = node.downEBMST().regs['receive_tem_mux0'].get(bypass=1)
              elif tem == mux1:
                value = node.downEBMST().regs['receive_tem_mux1'].get(bypass=1)
              else:
                value = 0
            else:
              value = node.regs[attr.lower()].get(bypass=1)
          except Exception, e:
            # print e
            value = None
          packet.append( Trendable( key, timestamp, { 'Raw Value' : value } ) )
    return packet

class HskTestRetriever(Retriever):
  """ Test HskRetriever
  """
  def __init__(self, glat):
    self.__monitorList={}
    from HskRegisters import NodeRegisterList
    
    AEQ = glat.downAEM().downAEQ()
    self.__monitorList["AEQ"] = NodeRegisterList(AEQ)
    from LATTE.monitoring.HskRegisters import AEQHskRegMap
    self.__hskMap = AEQHskRegMap()
    
  def retrievePacket(self): 
    packet=[]
    timestamp = time.time()  # time() returns seconds since epoch, UTC
    
    for reg in self.__monitorList["AEQ"].map().values():
      reg.write(self.aeqBuildDummy(timestamp))
      parsed = self.__hskMap.decodeRegister(reg.name(), reg.read())
      for key in parsed:
        tName = reg.name() + ":" + key
        packet.append( Trendable(tName, timestamp, {'Raw Value' : parsed[key]}) )
    
    return packet

  def aeqBuildDummy(self,timestamp):
    import math
    ret = 0L
    for i in range(2):
      word = long( math.fabs(math.sin( (timestamp*math.pi)/(i*12+12) )) * 0xfff)
      ret |= word << (16*i)
    return ret
  

---