hTestEnv.py

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

__facility__ = "Online"
__abstract__ = "Example TKR test application"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "11/21/2002"
__version__  = "$Revision: 1.2 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import threading
from   sihippo       import *
from   time          import sleep, time
import logging       as     log

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

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

  def getName(self):
    return __name__

  def setup(self):
    log.debug("userApplication.setup()")
    if self.gui is None:
      self.__arg = userArgText()
    else:
      self.__arg = self.gui.createGUI(userArgument, self.gui, 'test1', 1)
    
    self.gui.execGUImethod(self.__initHippo)

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


  def startRun(self):
    log.debug("userApplication.startRun()")
    self.__cmdSynchQuit = False
    caption = "Enter number of data groups to read"
    if self.gui is None:
      cnt = self.__arg.getValue(caption)
    else:
      cnt = self.gui.execGUImethod(self.__arg.getValue, caption)
      
    # The user pressed 'Cancel'
    if cnt is None:  return -1
    self.__cnt = cnt

    self.gui.execGUImethod(self.__initPlots)        
    
    # A state transition can be rejected by not returning None
    return None

  def stopRun(self):
    self.__cmdSynchQuit = True

    # The STOP_RUN transition can not be rejected

  def stop (self):
    return self.stopRun()
    
  def teardown(self):
    log.debug("userApplication.teardown()")    
    # Allow the C++ object to be deleted   
    if self.gui 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"
    ###print "userApplication.process()"

  #def __commandSynch(self, count):
  def commandSynch(self):
    "Method called by the command synchronization task"
    cnt = 0
    count = self.__cnt
    tic = self.lat.TEM[0].TIC
    while cnt < count and not self.__cmdSynchQuit:
      cnt = cnt + 1
      volts = tic.adc_tem_digital_3_3v
      amps = tic.adc_tem_digital_3_3i
      self.__nt.addRow([cnt, volts])
      self.__nt2.addRow([cnt, amps])
      sleep(.1)

    # 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.rc is not None:
        self.rc.doStop()
    

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

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

  def __initHippo(self):
    label1 = ['Time', 'TEM Voltage']
    label2 = ['Time', 'TEM Current']
    ntc = NTupleController.instance()
    self.__nt = ntc.createCircularBuffer(2)
    self.__nt2 = ntc.createCircularBuffer(2)
    self.__nt.setLabels(label1)    
    self.__nt2.setLabels(label2)    
    self.__nt.setTitle('GTIC Test')
    self.__nt2.setTitle('GTIC Test2')
    self.__nt.reserve(100)    
    self.__nt2.reserve(100)    
    if __name__ == "__main__":
      app = QApplication ( sys.argv )
      self.__canvas = CanvasWindow()
      self.__canvas.show()
    else:
      wc = WindowController.instance()
      self.__canvas = wc.currentCanvas()

    dc = DisplayController.instance()

  def __initPlots(self):
    self.__canvas.clear()
    
    self.__nt.clear()
    self.__nt2.clear()

    #self.__nt.setIntervalCount ( 500 )
    #self.__nt2.setIntervalCount ( 100 )
    dc = DisplayController.instance()
    self.__hist = dc.createDisplay('Strip Chart',self.__nt,['Time', 'TEM Voltage'])
    self.__hist2 = dc.createDisplay('Strip Chart',self.__nt2,['Time', 'TEM Current'])
    self.__canvas.addDisplay(self.__hist)
    self.__canvas.addDisplay(self.__hist2)    
    self.__hist.setRange ( 'y', 2660, 2680 )
    self.__hist2.setRange ( 'y', 200, 300 )
    #self.__canvas.setIntervalEnabled ( 1 )
    self.__canvas.show()      

if __name__ == "__main__":
  ua = userApplication(None, 321, 0)
  ua.rcSetup('../repos/simpleTEMSchema.xml')
  ua.rcStartRun()
  ua.wait()
  ua.rcStopRun()
  ua.rcTeardown()
  raw_input("Press any key to end")

# History:
#     $Log: hTestEnv.py,v $
#     Revision 1.2  2004/08/18 18:00:15  stuvi
#     Updated for LATTE 4.
#     All hippo functions go through the Qt GUI bridge now.
#
#     Revision 1.1  2004/08/07 02:14:33  stuvi
#     no message
#
#     Revision 1.8  2004/04/17 02:22:17  stuvi
#     Various Hippo related fixes
#     Added teardown() to delete the C++ object for the userArgument
#
#     Revision 1.7  2004/04/08 00:32:39  stuvi
#     Modularized hippodraw code.
#     Changed tuples to circular buffer.
#
#     Revision 1.6  2004/03/10 22:24:50  panetta
#     Upgraded trigger interface.
#     Removed dependencies on self.glt.
#
#     Revision 1.5  2004/02/24 02:13:34  stuvi
#     Changes for long transition support.
#
#     Revision 1.4  2003/07/17 00:01:35  stuvi
#     no message
#
#     Revision 1.3  2003/03/31 19:28:53  stuvi
#     Fixed name
#
#     Revision 1.2  2003/03/26 21:59:36  stuvi
#     Fixed standalone mode
#
#     Revision 1.1  2003/03/11 21:20:54  stuvi
#     Moved from RunControl directory
#
#     Revision 1.3  2003/02/06 05:20:22  claus
#     Added resume; StopRun bug fix
#
#     Revision 1.2  2003/01/16 02:38:25  stuvi
#     Removed extra stuff
#
#     Revision 1.1  2002/12/10 00:59:16  stuvi
#     Runcontrol example that uses Hippo. Currently it doesn't work in GUI mode.
#
#     Revision 1.4  2002/12/02 17:17:09  claus
#     Added provision to allow application to run stand-alone
#
#     Revision 1.3  2002/11/28 02:02:04  claus
#     Shuffled constructor arguments
#
#     Revision 1.2  2002/11/27 23:49:27  claus
#     Initialize semaphore with zero count
#
#     Revision 1.1  2002/11/27 05:02:48  claus
#     Initial version of Run Control
#

---