PeriodicTask.py

Go to the documentation of this file.

#!/usr/bin/env python
# -*- coding: euc-jp -*-




import threading
import time
import OpenRTM_aist


class PeriodicTask(OpenRTM_aist.Task):
  """
  """

  
  def __init__(self):
    OpenRTM_aist.Task.__init__(self)
    self._period         = OpenRTM_aist.TimeValue(0.0)
    self._nowait         = False
    self._func           = 0
    self._deleteInDtor   = True
    self._alive          = self.alive_t(False)
    self._suspend        = self.suspend_t(False)

    # variables for execution time measurement
    self._execMeasure    = False
    self._execCount      = 0
    self._execCountMax   = 10
    self._execStat       = self.statistics_t()
    self._execTime       = OpenRTM_aist.TimeMeasure()

    # variables for period time measurement
    self._periodMeasure  = False
    self._periodCount    = 0
    self._periodCountMax = 10
    self._periodStat     = self.statistics_t()
    self._periodTime     = OpenRTM_aist.TimeMeasure()

    return

    
  
  def __del__(self, Task=OpenRTM_aist.Task):
    self.finalize()
    self.wait()
    Task.__del__(self)
    return
  
    
  
  def activate(self):
    guard = OpenRTM_aist.ScopedLock(self._alive.mutex)
    if not self._func:
      return

    if self._alive.value:
      return

    self._alive.value = True
    OpenRTM_aist.Task.activate(self)
    return


  
  def finalize(self):
    guard = OpenRTM_aist.ScopedLock(self._alive.mutex)
    self._alive.value = False

    self._suspend.cond.acquire()
    self._suspend.suspend = False
    self._suspend.cond.notify()
    self._suspend.cond.release()
    return


  
  def suspend(self):
    self._suspend.cond.acquire()
    self._suspend.suspend = True
    self._suspend.cond.release()
    return 0
    

  
  def resume(self):
    self._periodTime.reset()
    self._execTime.reset()
    self._suspend.cond.acquire()
    self._suspend.suspend = False
    self._suspend.cond.notify()
    self._suspend.cond.release()
    return 0


  
  def signal(self):
    self._suspend.cond.acquire()
    self._suspend.cond.notify()
    self._suspend.cond.release()
    return


  
  def setTask(self, func, delete_in_dtor = True):
    if not func:
      return False

    self._deleteInDtor = delete_in_dtor
    self._func = func
    return True

  
  
  def setPeriod(self, period):
    if type(period) == float:
      self._period = OpenRTM_aist.TimeValue(period)
    else:
      self._period = period
    
    if self._period.sec() == 0 and self._period.usec() == 0:
      self._nowait = True
      return

    self._nowait = False
    return


  
  def executionMeasure(self, value):
    self._execMeasure = value
    return

    
  
  def executionMeasureCount(self, n):
    self._execCountMax = n
    return
    

  
  def periodicMeasure(self, value):
    self._periodMeasure = value
    return

  
  def periodicMeasureCount(self, n):
    self._periodCountMax = n
    return


  
  def getExecStat(self):
    guard = OpenRTM_aist.ScopedLock(self._execStat.mutex)
    return self._execStat.stat
    
    
  
  def getPeriodStat(self):
    guard = OpenRTM_aist.ScopedLock(self._periodStat.mutex)
    return self._periodStat.stat
    

  ## virtual int svc();
  def svc(self):

    while self._alive.value: # needs lock?
      if self._periodMeasure:
        self._periodTime.tack()
        
      # wait if suspended
      self._suspend.cond.acquire()
      if self._suspend.suspend:
        self._suspend.cond.wait()
        # break if finalized
        if not self._alive.value:
          self._suspend.cond.release()
          return 0
      self._suspend.cond.release()
          
      if self._periodMeasure:
        self._periodTime.tick()

      # task execution
      if self._execMeasure:
        self._execTime.tick()

      self._func()
      if self._execMeasure:
        self._execTime.tack()

      # wait for next period
      self.updateExecStat()
      self.sleep()
      self.updatePeriodStat()


    return 0
        
        
  ## virtual void sleep();
  def sleep(self):
    if self._nowait:
      return

    sleep_sec = self._period - self._execTime.interval()

    if sleep_sec.toDouble() < 0:
      return

    time.sleep(sleep_sec.toDouble())
    return


  ## virtual void updateExecStat();
  def updateExecStat(self):
    if self._execCount > self._execCountMax:
      guard = OpenRTM_aist.ScopedLock(self._execStat.mutex)
      self._execStat.stat = self._execTime.getStatistics()
      self._execCount = 0

    self._execCount += 1
    return


  ## virtual void updatePeriodStat();
  def updatePeriodStat(self):
    if self._periodCount > self._periodCountMax:
      guard = OpenRTM_aist.ScopedLock(self._periodStat.mutex)
      self._periodStat.stat = self._periodTime.getStatistics()
      self_periodCount = 0

    self._periodCount += 1
    return


  # alive flag
  class alive_t:
    def __init__(self, val):
      self.value = val
      self.mutex = threading.RLock()
      return

  # suspend flag
  class suspend_t:
    def __init__(self, sus):
      self.suspend = sus
      self.mutex = threading.RLock()
      self.cond = threading.Condition(self.mutex)
      return

      
  # time measurement statistics struct
  class statistics_t:
    def __init__(self):
      self.stat = OpenRTM_aist.TimeMeasure.Statistics()
      self.mutex = threading.RLock()