testTrgParityError.py

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

__facility__ = "Online"
__abstract__ = "Test application for inducing and detecting event errors"
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/03/22"
__version__  = "$Revision: 1.1 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import threading
import logging       as     log

from   LATTE.runcontrol.rcTransitions import rcTransitions
from   LATTE.runcontrol.ArgumentImpl  import ArgumentImpl

from support.SimpleGasuExample   import *
from support.MiniGLTExample      import *


#  Example application implementation.
#  Note that the name of the class must be userApplication.
#  Look at rcTransitions for names of other transition methods that can be used.
class userApplication(rcTransitions):
  "Implmentation class for a user application"
  def __init__(self, gui, userId, debug):
    rcTransitions.__init__(self, gui, userId, debug)
    log.debug("userApplication.__init__()")
    self.__eventSem    = threading.Semaphore(0)
    self.__cmdSynchSem = threading.Semaphore(0)
    self.__tpe = 0
    self.__pkte = 0
    
  def getName(self):
    return __name__

  def setup(self):
    log.debug("userApplication.setup()")

    # Get a TEM instance
    if self.lat.TEMcnt() == 1:
      tem = self.lat.TEM[self.lat.TEM.keys()[0]]
    elif self.lat.TEMcnt() > 1:
      tem = self.lat.TEM.all()
    else:
      log.fatal("No TEM(s) found in the schema")
      return -1

    # reset the TEM since we are going to modify DATA_MASKS
    tem.CMD_RESET = 1

    # clear TEM stats reg
    tem.COMMAND_RESPONSE = 0

    # clear TEM status reg
    tem.STATUS = 0

    # enable CAL, disable TKR, no diag #  0x10FF for diag
    tem.DATA_MASKS = 0x00FF

    # TEM config reg # set TEM timeout
    tem.CONFIGURATION = 0

    #status = gTEMread( __GT, temId, TEM_REG_CONFIGURATION, &payload);
    #printf("tem config reg = 0x%08x\n", payload);

    # enable output in our GCCCs
    # broadcast load of GCCC_REG_CONFIGURATION

    bcast_ccc = tem.allCCC()
    bcast_ccc.CONFIGURATION = 0x80000000L

    #  disable all GCRCs in all GCCCs via broadcast # GCCC_REG_LAYER_MASK_0, GCCC_REG_LAYER_MASK_1
    bcast_ccc.LAYER_MASK_0 = 0xFFFFFFFFL
    bcast_ccc.LAYER_MASK_1 = 0xFFFFFFFFL
    ccc2 = tem.downCCC(2) # O$GCCC_02
    ccc2.LAYER_MASK_1 = 0x3BFD3FFF

    # large timeouts for all GCCCs
    # broadcast load of GCCC_REG_EVENT_TIMEOUTS
    bcast_ccc.EVENT_TIMEOUTS = 0x0
    #status = gGCCCread( __GT, temId, 1, GCCC_REG_EVENT_TIMEOUTS, &payload);
    #printf("gccc register event timeouts = 0x%08x\n", payload);

    # Two choices for the trigger, GEM and MiniGLT
    if self.lat.existsGEM():
      self.trigger( SimpleGasuExample() )
    else:
      self.trigger( MiniGLTExample() )

    # A state transition can be rejected by not returning None
    return None

  def startRun(self):
    log.debug("userApplication.startRun()")

    self.__cnt = 5

    # Spawn a thread to synchronize commands with events
    # This must happen after triggers are enabled
    self.__cmdSynchQuit = False

    # reset internal variables
    self.__tpe = 0
    self.__pkte = 0
    
    # A state transition can be rejected by not returning None
    return None

  def stopRun(self):

    # Success is defined if we found one and only one trigger parity error
    # and one and only one packet error
    if self.__tpe == 1 & self.__pkte == 1:
      log.info("Setting completion status = SUCCESS")
      self.setCompletionStatus(self.COMPL_STATUS_SUCCESS)
    else:
      log.info("Setting completion status = FAILED")
      self.setCompletionStatus(self.COMPL_STATUS_FAILED)
    self.__cmdSynchQuit = True
    self.__eventSem.release()

    # The STOP_RUN transition can not be rejected

  def resume(self):
    # Issue self trigger to make up for the one that was lost during PAUSE
    self.trigger().solicit()

    return None

  def stop(self):
    return self.stopRun()

  def process(self, (status, buffer)):
    "Method called back for each data event taken"
    ###log.debug("userApplication.process()")

    evtCli = self.evtCli

    if status != 0:
      if evtCli.isGGLTStatus():
        log.error("GGLT_STATUS=%d %s" % (evtCli.getGGLTStatus(), evtCli.getGGLTStatusStr()))
      elif not evtCli.checkOnlineStatus(status, self.evtCli.PLAYBACK_ERROR):
        log.error("EVENT ERROR= 0x%x %s" % (status, evtCli.getOnlineStatusStr()))
      self.__eventSem.release()
      return

    try:
      # In the future this event may contain additional data
      if evtCli.isSweepEvent(): return
    except:
      # Event summary word inaccessible, handle the bad event here
      import gutil
      gutil.logException()
      return

    if evtCli.isTrgParityErrorEvent():
      log.debug( "Found a trigger parity error")
      self.__tpe += 1
    elif evtCli.isPacketErrorEvent():
      log.debug( "Found a packet error")
      self.__pkte += 1
    else:
      log.debug( "Found a normal event")
    # Get next event triggered
    self.__eventSem.release()

  def commandSynch(self):
    "Method called by the command synchronization task"
    import time
    trigger  = self.trigger()
    eventSem = self.__eventSem

    # Drain the semaphore release count
    # Handles the case when the stop run release collided with a trigger release
    while eventSem.acquire(0):  pass

    t0  = time.time()

    # Compensate for the extra CMD_SELF_TRIGGER below
    cnt   = 1
    count = self.__cnt

    # bitmask in GEM config to cause trigger parity error
    TPE = 0x20
    # bitmask in GEM config to cause packet error  (suppress bit)
    PKTE = 0x40

    # Wait for START_RUN to enable triggers
    trigger.waitForMaskEnable()

    # take one normal event
    trigger.solicit()                   # Issue an internal trigger
    eventSem.acquire()                  # Wait for the event to be processed

    # Cause a trigger parity error for GEM event
    trigger.disable()
    gemc = trigger.GEM().GEMC
    gemcfg = gemc.CONFIGURATION
    gemcfg |= TPE
    gemc.configuration = gemcfg
    trigger.enable()

    trigger.solicit()                   # Issue an internal trigger
    eventSem.acquire()                  # Wait for the event to be processed

    # Reset the GEM to remove the trigger parity error bit.
    trigger.disable()
    gemc = trigger.GEM().GEMC
    gemcfg = gemc.CONFIGURATION
    gemcfg &= ~TPE
    gemc.configuration = gemcfg
    trigger.enable()

    # Cause a packet error for GEM event
    trigger.disable()
    gemc = trigger.GEM().GEMC
    gemcfg = gemc.CONFIGURATION
    gemcfg |= PKTE
    gemc.configuration = gemcfg
    trigger.enable()

    trigger.solicit()                   # Issue an internal trigger
    eventSem.acquire()                  # Wait for the event to be processed

    # Reset the GEM to remove the suppression bit.
    trigger.disable()
    gemc = trigger.GEM().GEMC
    gemcfg = gemc.CONFIGURATION
    gemcfg &= ~PKTE
    gemc.configuration = gemcfg
    trigger.enable()

    # take one normal event
    trigger.solicit()                   # Issue an internal trigger
    eventSem.acquire()                  # Wait for the event to be processed

    # Get out of waiting when in standalone mode
    self.sync()

    # execute the GUI functions for stopRun, just in case
    if not self.__cmdSynchQuit and not self.isRunFromSuite():
      if self.gui is not None:
        self.gui.doStopRun()

  def wait(self):
    self.__cmdSynchSem.acquire()

  def sync(self):
    if __name__ == "__main__" or self.isRunFromSuite():
      self.__cmdSynchSem.release()


# Standalone mode:
if __name__ == "__main__":
  import os
  log.basicConfig()
  log.getLogger("").setLevel(log.DEBUG)
  ua = userApplication(None, 321, 1)
  ua.rcSetup(os.path.join(os.environ['ONLINE_ROOT'], 'repos/simpleTemSchema.xml'))
  ua.rcStartRun()
  ua.wait()
  ua.rcStopRun()
  ua.rcTeardown()

---