sweepRejectTest.py

#!/usr/local/bin/python
#
#  sweepRejectTest.py
#      Test code to test what happens when sweeps never appear in RC.
#      Sweeps are disabled by reimplementing the shut() method.
#      DO NOT use this code as a basis for any user code.  --Jim
#
#
#
#                               Copyright 2004
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#




__facility__ = "Online"
__abstract__ = "Application to test Bad or Timed out SWEEP events."
__author__   = "J. Panetta <panetta@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/03/21 17:58:11 $").split(' ')[1]
__version__  = "$Revision: 1.2 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import            threading
import logging as log
import            time

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

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


#  This class puts up a GUI for inputting a value of some sort.  It is used by
#  the userApplication example to get the number of self triggers to take.
class userArgument(ArgumentImpl):
  "GUI for getting the user to input some sort of value."
  def __init__(self, parent = None, name = None, modal = 0, fl = 0):
    ArgumentImpl.__init__(self, parent, name, modal, fl)
    self.__value = 0
    self.setCaption("Hello world!")

  def OKButtonClicked(self):
    self.__value = int(self.ArgumentList.text().latin1())
    self.close()

  def CancelButtonClicked(self):
    self.__value = None
    self.close()

  def getValue(self, caption):
    self.setCaption(caption)
    self.show()
    self.exec_loop()
    return self.__value

class userArgText(object):
  "Text user interface for getting the user to input some sort of value"
  def __init__(self):
    pass

  def getValue(self, caption):
    return int(raw_input("%s: " % (caption)))


#  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, rc, userId, debug):
    rcTransitions.__init__(self, rc, userId, debug)
    log.debug("userApplication.__init__()")
    self.__eventSem    = threading.Semaphore(0)
    self.__cmdSynchSem = threading.Semaphore(0)

  def getName(self):
    return __name__

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

    if self.rc is None:
      self.__arg = userArgText()
    else:
      self.__arg = self.rc.createGUI(userArgument, self.rc, 'test1', 1)

    # 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

    # clear TEM stats reg
    tem.COMMAND_RESPONSE = 0

    # clear TEM status reg
    tem.STATUS = 0

    # 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
    ccc0 = tem.downCCC(0) # O$GCCC_00
    ccc0.LAYER_MASK_0 = 0xFFFF0000L
    ccc0.LAYER_MASK_1 = 0xFFFF000FL
    ccc2 = tem.downCCC(2) # O$GCCC_02
    ccc2.LAYER_MASK_0 = 0xFFFF0000L
    ccc2.LAYER_MASK_1 = 0xFFFF0000L

    # large timeouts for all GCCCs
    # broadcast load of GCCC_REG_EVENT_TIMEOUTS
    bcast_ccc.EVENT_TIMEOUTS = 0x0

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

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

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

    caption = "Enter number of triggers to take"
    if self.rc is None:
      cnt = self.__arg.getValue(caption)
    else:
      cnt = self.rc.execGUImethod(self.__arg.getValue, caption)

    # The user pressed 'Cancel'
    if cnt is None:  return -1
    self.__cnt = cnt

    if self.rc is not None:
      self.getParameterVerifier().add(caption, cnt)

    # Spawn a thread to synchronize commands with events
    self.__cmdSynchQuit = False

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

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

    if self.getBadEvents() == 0 and self.getErrorEvents() == 0:
      self.setCompletionStatus(self.COMPL_STATUS_PASSED)
    else:
      self.setCompletionStatus(self.COMPL_STATUS_FAILED)

    self.__cmdSynchQuit = True
    self.__eventSem.release()

    # The STOP_RUN transition can not be rejected

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

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

    return None

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

    return self.stopRun()

  def teardown(self):
    log.debug("userApplication.teardown()")
    # Allow the C++ object to be deleted
    if self.rc is not None and self.__arg is not None:
      self.__arg.deleteLater()

  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
      log.exception("")
      return


    # 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

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

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

    t1 = trigger.getEnableTime()        # get the last trigger enable time from GLT
    while cnt < count and not self.__cmdSynchQuit:
      cnt += 1
      trigger.solicit()                 # Issue an internal trigger
      time.sleep(.0001)
      eventSem.acquire()                # Wait for the event to be processed

    t2 = trigger.getTimeStamp()                 # Get the last trigger timestamp

    if t1 is None:
      t1 = t0
    if t2 is None:
      t2 = time.time()
    dT = t2 - t1
    if dT == 0.0:  dT = 0.000001
    log.info("%s processed %d events in %.3f seconds = %.1f events/second" % \
             (self.getName(), self.evtCnt, dT, self.evtCnt/dT))

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

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

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

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

from LATTE.trigger.rcTrgGem     import *
from LATTE.trigger.rcTrgMiniGLT import *
class BadGasuExample(SimpleGasuExample):
  """\brief BadGasuExample
  """
  def __init__(self):
    """\brief BadGasuExample constructor
    """
    SimpleGasuExample.__init__(self)
  def shut(self, sweepEvent, progress = None):
    """Re-implementation of the shut function to NEVER send a sweep

    NEVER EVER EVER use this code in a real trigger system.  --Jim Panetta
    This code is only to test a particular bug in sweep timeouts.
    """

    gemw = self.GEM().GEMW
    gemsc = self.GEM().GEMSC

    #0) determine whether we are enabled or not
    if gemw.WINDOW_OPEN_MASK != 0:
      enabled = True
    else:
      enabled = False

    #1) disable triggers
    goodSolicit  = self.solicit
    # self.solicit = self.__falseSolicit
    self.disable()
    sweepEvent.clear()

    #2) Replace contents of all schedulers with solicited with (Engine) f
    #   Doing it by hand
    oldSched = [ gemsc.CONDITIONS_40_47,
                 gemsc.CONDITIONS_48_4F,
                 gemsc.CONDITIONS_50_57,
                 gemsc.CONDITIONS_58_5F,
                 gemsc.CONDITIONS_60_67,
                 gemsc.CONDITIONS_68_6F,
                 gemsc.CONDITIONS_70_77,
                 gemsc.CONDITIONS_78_7F ]
    scheduler = ( 0xffffffffL )               # Everything's f!
    gemsc.CONDITIONS_40_47 = scheduler
    gemsc.CONDITIONS_48_4F = scheduler
    gemsc.CONDITIONS_50_57 = scheduler
    gemsc.CONDITIONS_58_5F = scheduler
    gemsc.CONDITIONS_60_67 = scheduler
    gemsc.CONDITIONS_68_6F = scheduler
    gemsc.CONDITIONS_70_77 = scheduler
    gemsc.CONDITIONS_78_7F = scheduler

    #2.5) Wait until we don't have progress
    if progress is not None:
      while True:
        if progress() == 0:
          break
        time.sleep(.5)
        # print "waiting for progress"

    #3) Change conditions to be solicit only, solicit a trigger
    gemw.WINDOW_OPEN_MASK = TrgGem._TrgGem__SOLICIT_MASK
    # self.GEM().downGEMC().CMD_TRIGGER = 1

    #4) Block until the sweep is detected by rcTransitions then disable triggers
    tmo = self._rcTrgGem__SWEEP_TMO
    while (tmo > 0.0):
      if sweepEvent.isSet():  break
      sweepEvent.wait(0.50)
      if progress is not None:
        if progress() != 0:
          tmo = self._rcTrgGem__SWEEP_TMO
          continue
      tmo -= 0.50
    if tmo <= 0:
      sweepEvent.set()
      logging.fatal("Trigger sweep timed out before all events were drained")
      return False

    self.disable()

    #5) Put the original contents of schedulers back
    gemsc.CONDITIONS_40_47 = oldSched[0]
    gemsc.CONDITIONS_48_4F = oldSched[1]
    gemsc.CONDITIONS_50_57 = oldSched[2]
    gemsc.CONDITIONS_58_5F = oldSched[3]
    gemsc.CONDITIONS_60_67 = oldSched[4]
    gemsc.CONDITIONS_68_6F = oldSched[5]
    gemsc.CONDITIONS_70_77 = oldSched[6]
    gemsc.CONDITIONS_78_7F = oldSched[7]

    #6) Put the trigger conditions back.
    if enabled:
      self.enable()
    self.solicit = goodSolicit

    return True


class BadGLTExample(MiniGLTExample):
  """\brief MiniTower example interface to MiniGLT
  """
  def __init__(self):
    """\brief AcdTriggerExample constructor
    """
    MiniGLTExample.__init__(self)
  def shut(self, sweepEvent, progress = None):
    """Re-implementation of the shut function to NEVER send a sweep

    NEVER EVER EVER use this code in a real trigger system.  --Jim Panetta
    This code is only to test a particular bug in sweep timeouts.
    """

    glt = self.GLT()

    #0) disable triggers
    if not glt.triggersDisabled():
      enabled = True
    else:
      enabled = False
    goodSolicit  = self.solicit
    # self.solicit = self.__falseSolicit

    self.disable()
    sweepEvent.clear()

    #1) Set up marker logic
    mask           = glt.MASK           # Cache Mask, CalStrobe and Tack
    calStrobe      = glt.CAL_STROBE
    tack           = glt.TACK
    zeroSuppress   = glt.ZERO_SUPPRESS
    fourRange      = glt.FOUR_RANGE_READOUT
    marker         = glt.MARKER

    glt.MASK       = TrgMiniGLT._TrgMiniGLT__SOLICIT_MASK # Enable internal trigger only
    glt.MARKER     = rcTrgMiniGLT._rcTrgMiniGLT__SWEEP_MARKER          # Signal that we're sweeping
    glt.CAL_STROBE = 0                  # Don't inject charge
    glt.TACK       = 1                  # Force a readout
    glt.ZERO_SUPPRESS       = 1         # Yes to zero suppression
    glt.FOUR_RANGE_READOUT  = 0         # No to four range readout

    #2) enable and solicit
    glt.enableMask()
    self.waitForMaskEnable()
    # self.GLT().CMD_SELF_TRIGGER = 1     # Solicit a trigger

    #3) Block until the sweep is detected by rcTransitions then disable triggers
    tmo = self._rcTrgMiniGLT__SWEEP_TMO
    while (tmo > 0.0):
      if sweepEvent.isSet():  break
      sweepEvent.wait(0.5)
      if progress is not None:
        if progress() != 0:
          tmo = self._rcTrgMiniGLT__SWEEP_TMO
          continue
      tmo -= 0.5
    if tmo <= 0:
      sweepEvent.set()
      logging.fatal("Trigger sweep timed out before all events were drained")
      return False
    self.disable()

    #4) Put the original contents of scheduler 0x40 back, and put the TAM back
    glt.CAL_STROBE         = calStrobe
    glt.TACK               = tack
    glt.MARKER             = marker
    glt.ZERO_SUPPRESS      = zeroSuppress
    glt.FOUR_RANGE_READOUT = fourRange
    glt.MASK               = mask

    #5) Put the trigger conditions back
    if enabled:
      glt.enableMask()
    self.solicit = goodSolicit

    return True

---