hTestStrip.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.1 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

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

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

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, gui, userId, debug):
    rcTransitions.__init__(self, gui, userId, debug)
    log.debug("userApplication.__init__()")
    self.phase = 0.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)    
        
    #self.hippoDisplay = threading.Thread(None, self.initHippo, 'HippoDisplay', ())
    #self.hippoDisplay.start()

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

  def stopRun(self):
    self._cmdSynchQuit = True
    #self.__canvas.savePlotAsImage(self.__hist, "c:/temp/plot.jpg")
    #self.__canvas.savePlotAsImage(self.__hist2, "c:/temp/plot2.jpg")

    # 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):
    "Method called by the command synchronization task"
    count = self.__cnt
    cnt = 0    
    while cnt < count and not self._cmdSynchQuit:
      if self.phase > math.pi - 0.0001: self.phase = 0.0
      cnt = cnt + 1
      volts = math.sin(self.phase) * (-1.0 +2.0*random.random())
      amps  = 0.8 - (2.0 * self.phase/math.pi) +0.4*random.random()
      self.__nt.addRow([cnt, volts])
      self.__nt2.addRow([cnt, amps])
      sleep(.1)
      self.phase += math.pi*0.02

  def wait(self):
    pass

  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()
    else:
      wc = WindowController.instance()
      self.__canvas = wc.currentCanvas()

    #hist.setRange ( 'y', 2660, 2680 )
    #hist2.setRange ( 'y', 200, 300 )
    
  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.__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: hTestStrip.py,v $
#     Revision 1.1  2004/08/18 18:00:15  stuvi
#     Updated for LATTE 4.
#     All hippo functions go through the Qt GUI bridge now.
#
#     Revision 1.9  2004/05/03 21:19:47  stuvi
#     Moved non-Runcontrol scripts to the support directory and modified imports accordingly.
#
#     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/07 23:28:29  stuvi
#     Modularized hippodraw code.
#
#     Revision 1.6  2004/03/31 01:03:21  stuvi
#     Fixed so that it works with the new trigger interface.
#
#     Revision 1.5  2004/03/10 22:24:50  panetta
#     Upgraded trigger interface.
#     Removed dependencies on self.glt.
#
#     Revision 1.4  2004/02/24 02:13:34  stuvi
#     Changes for long transition support.
#
#     Revision 1.3  2003/07/17 00:01:35  stuvi
#     no message
#
#     Revision 1.2  2003/03/31 19:28:53  stuvi
#     Fixed name
#
#     Revision 1.1  2003/03/11 21:20:54  stuvi
#     Moved from RunControl directory
#
#     Revision 1.2  2003/02/06 05:20:22  claus
#     Added resume; StopRun bug fix
#
#     Revision 1.1  2003/01/10 01:41:52  stuvi
#     Example strip chart example for hippo
#
#     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
#

---