FEpowerUp.py

#!/usr/local/bin/python
#
#                               Copyright 2002
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "Front End power up / power down routines"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/02/11 03:58:33 $").split(' ')[1]
__version__  = "$Revision: 2.16 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from time import sleep
import           sys
import           logging as log

from LATTE.client.gException import LATInterfaceException

class FEpowerUp(object):
  def __init__(self, acdPowerUp=None, temPowerUp=None):
    self.acdPowerUp = acdPowerUp
    self.temPowerUp = temPowerUp
    self.__nominal  = 0x800

  def initialize(self, lat, xbrd):
    self.lat        = lat
    self.xbrd       = xbrd

  def setAcdPowerUp(self, acdPowerUp):
    self.acdPowerUp = acdPowerUp

  def setTemPowerUp(self, temPowerUp):
    self.temPowerUp = temPowerUp

  def up(self):
    # Power up TEM(s)
    activeTEMs = self.getActiveTEMs(self.lat)
    #for (temId, tem) in activeTEMs.items():
    #  if self.temPowerUp is None or temId in self.temPowerUp:
    #    # turn off front ends
    #    tic = tem.TIC
    #    if self.temPowerUp is None:
    #      tic.POWER_SUPPLY = 0x0
    #    else:
    #      powerSupply = tic.POWER_SUPPLY
    #      if powerSupply & self.temPowerUp[temId] != 0:
    #        powerSupply &= ~self.temPowerUp[temId]
    #        tic.POWER_SUPPLY = powerSupply

    xbrd = self.xbrd
    if xbrd is not None:
      # set all margin DACs to "middle" values
      # ggDACload() take the following values:
      #   0x000 - maximum voltage
      #   0x800 - nominal
      #   0xFFF - minimum voltage

      # Adjust TKR Analog 2.5v
      margin = 0x800
      if margin != self.__nominal:
        log.warn("dac_tkr_analog_2_5 is being set to 0x%03x" % margin)
      xbrd.dac_tkr_analog_2_5 = margin

      # Adjust TKR Digital 2.5v
      margin = 0x800
      if margin != self.__nominal:
        log.warn("dac_tkr_digital_2_5 is being set to 0x%03x" % margin)
      xbrd.dac_tkr_digital_2_5 = margin

      # Adjust TKR Analog 1.5v _and_ CAL Analog 3.3v
      margin = 0x800
      if margin != self.__nominal:
        log.warn("dac_tkr_cal_analog is being set to 0x%03x" % margin)
      xbrd.dac_tkr_cal_analog = margin

      # Adjust CAL Digital 3.3v
      margin = 0x800
      if margin != self.__nominal:
        log.warn("dac_cal_digital_3_3 is being set to 0x%03x" % margin)
      xbrd.dac_cal_digital_3_3 = margin

      # Adjust TEM Digital 3.3v
      margin = 0x800
      if margin != self.__nominal:
        log.warn("dac_tem_voltage is being set to 0x%03x" % margin)
      xbrd.dac_tem_voltage = margin

      ##
      ##  HIGH VOLTAGES for TKR and CAL
      ##  Disable by default
      ##
      ##  Note:  These take different values then ggDACload()
      ##
      ##    0x4000 - 0 V
      ##    0x5000 - plus half scale
      ##    0x5FFE - plus full scale
      ##

      # Adjust TKR High Voltage
      #tic.tkr_biasdac = 0x4000

      # Adjust CAL High Voltage
      #tic.cal_biasdac = 0x5000

    for (temId, tem) in activeTEMs.items():
      # turn on TKR and/or CAL front ends
      if self.temPowerUp is None or temId in self.temPowerUp:
        tic = tem.TIC
        if self.temPowerUp is None:
          tic.POWER_SUPPLY = 0x3
        else:
          powerSupply = tic.POWER_SUPPLY
          if powerSupply | self.temPowerUp[temId] != powerSupply:
            tkrPowerUp = 0
            if self.temPowerUp[temId] & 1 == 1 and powerSupply & 1 == 0:
              # TKR power up requested
              tkrPowerUp = 1
              if tem.allTCC() is None:
                msg = "Broadcast TCC needs to be defined in the schema for TKR power up"
                log.error(msg)
                raise RuntimeError, msg
            tic.POWER_SUPPLY = powerSupply | self.temPowerUp[temId]
            # We don't want to reset the TEM since it causes events
            # to be triggered
            #tem.CMD_RESET = 1
            if tkrPowerUp:
              sleep(1.0)
              tem.allTCC().CMD_RESET = 1

    # Power up AEM
    aem = self.lat.AEM
    if not self.isAEMactive(aem):
      aem = None
    else:
      for (arcId, arc) in aem.ARC.items():
        if self.acdPowerUp is None or arcId in self.acdPowerUp:
          aem.power_down = arcId
          aem.power_up = arcId
          sleep(1.5)  # Gotta wait 1.5 seconds before *any* read can work.
          arc.look_at_me = 0xeb90
    return self.checkPower(aem, activeTEMs)

  def down(self):
    # Power down TEM
    activeTEMs = self.getActiveTEMs(self.lat)
    for (temId, tem) in activeTEMs.items():
      if self.temPowerUp is None or temId in self.temPowerUp:
        # turn off CAL and/or TKR front ends
        tic = tem.TIC
        if self.temPowerUp is None:
          tic.POWER_SUPPLY = 0x0
        else:
          powerSupply = tic.POWER_SUPPLY
          if powerSupply & ~self.temPowerUp[temId] != powerSupply:
            tic.POWER_SUPPLY = powerSupply & ~self.temPowerUp[temId]

    xbrd = self.xbrd

    if xbrd is not None:
      # set all margin DACs to "middle" values (as per Leonid's request)

      # Adjust TKR Analog 2.5v
      xbrd.dac_tkr_analog_2_5 = self.__nominal

      # Adjust TKR Digital 2.5v
      xbrd.dac_tkr_digital_2_5 = self.__nominal

      # Adjust TKR Analog 1.5v _and_ CAL Analog 3.3v
      xbrd.dac_tkr_cal_analog = self.__nominal

      # Adjust CAL Digital 3.3v
      xbrd.dac_cal_digital_3_3 = self.__nominal

      # Adjust TEM Digital 3.3v
      xbrd.dac_tem_voltage = self.__nominal

    # Power down AEM
    aem = self.lat.AEM
    if not self.isAEMactive(aem):
      aem = None
    else:
      for arcId in aem.ARC:
        if self.acdPowerUp is None or arcId in self.acdPowerUp:
          try:
            arc = aem.ARC[arcId]
            for mode in (0xF8F, 0xFF1): # Enable HVBS 1 and then HVBS 2
              arc.mode &= mode
              hvbs = arc.hvbs
              while hvbs > 0:
                hvbs -= 200 # Ramp-down in 200 DAC step decrements
                if hvbs >= 0:
                  arc.hvbs = hvbs
                else:
                  arc.hvbs = 0
                arc.cmd_set_hvbs = 1
                sleep(1)
          except LATInterfaceException:
            if sys.exc_info()[1].errstr()[0] in ('LCB_RTOERR', 'LCBD_RTOERR') \
                and self.lat.getDeclarations()['options']['ignorehardwaretimeouts']:
              pass
            else:
              raise LATInterfaceException(sys.exc_info()[1].status)
          aem.power_down = arcId
    return self.checkPower(aem, activeTEMs)

  def getActiveTEMs(self, lat):
    activeTEMs = {}
    if lat.TEMcnt() > 0:
      for (temId, tem) in lat.TEM.items():
        try:
          tem.configuration # Check to see if this TEM really exists
          activeTEMs[temId] = tem
        except LATInterfaceException:
          if sys.exc_info()[1].errstr()[0] in ('LCB_RTOERR', 'LCBD_RTOERR') \
              and lat.getDeclarations()['options']['ignorehardwaretimeouts']:
            continue
          else:
            raise LATInterfaceException(sys.exc_info()[1].status)
    return activeTEMs

  def isAEMactive(self, aem):
    if aem is None:
      return False
    else:
      try:
        aem.configuration # Check to see if the AEM really exists
      except LATInterfaceException:
        if sys.exc_info()[1].errstr()[0] in ('LCB_RTOERR', 'LCBD_RTOERR') \
            and aem.up().getDeclarations()['options']['ignorehardwaretimeouts']:
          return False
        else:
          raise LATInterfaceException(sys.exc_info()[1].status)
    return True

  def refreshPowerStatus(self):
    activeTEMs = self.getActiveTEMs(self.lat)
    aem = self.lat.AEM
    if not self.isAEMactive(aem):
      aem = None
    return self.checkPower(aem, activeTEMs)

  def checkPower(self, aem, activeTEMs):
    aemPowerCheck = []
    calPowerCheck = []
    tkrPowerCheck = []

    # Prepare feedback as to which CAL & TKR front ends were really turned on
    for (temId, tem) in activeTEMs.items():
      tic = tem.TIC
      powerSupply = tic.POWER_SUPPLY
      if powerSupply & 1:
        tkrPowerCheck.append(temId)
      if powerSupply & 2:
        calPowerCheck.append(temId)

    if aem is not None:
      # Prepare feedback as to which free-boards were really turned on
      powerStatus = aem.power_status
      for i in range(12):
        if powerStatus & (1 << i):
          aemPowerCheck.append(i)
    return (aemPowerCheck, calPowerCheck, tkrPowerCheck)

---