Python Time类代码示例

  def run(self):
    #--ref to: http://www.codeproject.com/Articles/36459/PID-process-control-a-Cruise-Control-example

    lastTs=Time.currentTime();
    previousError=0;
    integral=0;
    Kp=1.2;
    Ki=0.003;
    Kd=1;
    pV=0.0;
    noise=0.0;
    while(not self.done_):
      self.lock_.acquire();

      tS=Time.currentTime();
      dT=tS-lastTs;
      error=self.pRef_-self.pResponse_;
      integral=integral+error*dT;
      derivative=(error-previousError)/dT;
      output=Kp*error+Ki*integral+Kd*derivative;
      previousError=error;
      pV=pV+(output*0.20)-(pV*0.10)+noise;
      dP=pV*dT;
      self.pResponse_ = self.pResponse_+dP;
      lastTs=tS;

#     self.pResponse_ = self.pResponse_ + dP;
      self.D_.append((Time.currentTime(),self.pResponse_));

      self.lock_.release();
      time.sleep(ControlLoopCycle);

    def startDose(doseLength, waitTime):
        if(shouldDose == True):
            doseLock = True
            t0 = Utility.currentTimeMillis()
            
            #set dig output pin to start dosing 
            try:
                ik.interfaceKit.setOutputState(0, 1)
            except PhidgetException as e:
                doseLock = False 
                ik.interfaceKit.setOutputState(0, 0)
                print("Phidget Exception %i: %s" % (e.code, e.details))
                print("Exiting....")
                exit(1)

            print("setting dig output to 1")

            # dose until the dose time is met or something else releases the lock 
            while((Utility.currentTimeMillis() - t0) < timeToDose * 1000 or doseLock != True):    
                Time.sleep(0.1)
             
            try:
                ik.interfaceKit.setOutputState(0, 0)
                doseLock = False
                print("dosed for %i second out put changed to 0" % (timeToDose))
            except PhidgetException as e:
                doseLock = False
                print("Phidget Exception %i: %s" % (e.code, e.details))
                print("Exiting....")
                exit(1)
            doseLock = False

def misc_setup(rps):
	"""Set default change ownership flag, umask, relay regexps"""
	os.umask(077)
	Time.setcurtime(Globals.current_time)
	SetConnections.UpdateGlobal("client_conn", Globals.local_connection)
	Globals.postset_regexp('no_compression_regexp',
						   Globals.no_compression_regexp_string)
	for conn in Globals.connections:
		conn.robust.install_signal_handlers()
		conn.Hardlink.initialize_dictionaries()

 def validate(self):
     if self.number == 0 or self.begin == '' or self.end == '' or self.text is None: return False
     zbegin = re.split('\W+', self.begin)
     zend = re.split('\W+', self.end)
     self.time_begin = Time(int(zbegin[0]), int(zbegin[1]), int(zbegin[2]), int(zbegin[3]))
     self.time_end = Time(int(zend[0]), int(zend[1]), int(zend[2]), int(zend[3]))
     self.set_mt()
     del self.begin
     del self.end
     return True

	def manageTime(self):
		t=Time()
		if self.clock==None:
			self.clock=ClockThread(t.getCurrentTime(),self.pool.getTime())#obtiene el tiempo actual
			self.connect(self.clock,SIGNAL("timeOver()"),self.timeEnding)
		else:
			self.clock.setStartTime(t.getCurrentTime())

		#manda a ejecutar un hilo que consultara el tiempo
		self.clock.start()

	def manageTime(self):
		t=Time()#este objeto permite extraer el tiempo actual del sistema
		if self.clock==None:
			#se envia al hilo el tiempo actual y el maximo tiempo de espera
			self.clock=ClockThread(t.getCurrentTime(),self.pool.getTime())#obtiene el tiempo actual
			self.connect(self.clock,SIGNAL("timeOver()"),self.timeEnding)
		else:
			self.clock.setMaxTime(self.pool.getTime())
			self.clock.setStartTime(t.getCurrentTime())
		#manda a ejecutar un hilo que consultara el tiempo
		self.clock.start()

 def get_timestats_string(self):
     """Return portion of statistics string dealing with time"""
     timelist = []
     if self.StartTime is not None:
         timelist.append("StartTime %.2f (%s)\n" % (self.StartTime, Time.timetopretty(self.StartTime)))
     if self.EndTime is not None:
         timelist.append("EndTime %.2f (%s)\n" % (self.EndTime, Time.timetopretty(self.EndTime)))
     if self.ElapsedTime or (self.StartTime is not None and self.EndTime is not None):
         if self.ElapsedTime is None:
             self.ElapsedTime = self.EndTime - self.StartTime
         timelist.append("ElapsedTime %.2f (%s)\n" % (self.ElapsedTime, Time.inttopretty(self.ElapsedTime)))
     return "".join(timelist)

def Compare(compare_type, src_rp, dest_rp, compare_time = None):
	"""Compare metadata in src_rp with metadata of backup session

	Prints to stdout whenever a file in the src_rp directory has
	different metadata than what is recorded in the metadata for the
	appropriate session.

	Session time is read from restore_timestr if compare_time is None.

	"""
	global return_val
	dest_rp = require_root_set(dest_rp, 1)
	if not compare_time:
		try: compare_time = Time.genstrtotime(restore_timestr)
		except Time.TimeException, exc: Log.FatalError(str(exc))

	mirror_rp = restore_root.new_index(restore_index)
	inc_rp = Globals.rbdir.append_path("increments", restore_index)
	backup_set_select(src_rp) # Sets source rorp iterator
	if compare_type == "compare": compare_func = compare.Compare
	elif compare_type == "compare-hash": compare_func = compare.Compare_hash
	else:
		assert compare_type == "compare-full", compare_type
		compare_func = compare.Compare_full
	return_val = compare_func(src_rp, mirror_rp, inc_rp, compare_time)

def yield_metadata():
	"""Iterate rorps from metadata file, if any are available"""
	metadata.SetManager()
	metadata_iter = metadata.ManagerObj.GetAtTime(regress_time)
	if metadata_iter: return metadata_iter
	log.Log.FatalError("No metadata for time %s (%s) found,\ncannot regress"
					   % (Time.timetopretty(regress_time), regress_time))

	def triple_to_line(triple):
		"""Convert triple to display string"""
		time, size, cum_size = triple
		return "%24s   %13s   %15s" % \
			   (Time.timetopretty(time),
				stat_obj.get_byte_summary_string(size),
				stat_obj.get_byte_summary_string(cum_size))

def describe_incs_human(incs, mirror_time, mirrorrp):
	"""Return a string describing all the the root increments"""
	incpairs = [(inc.getinctime(), inc) for inc in incs]
	incpairs.sort()

	result = ["Found %d increments:" % len(incpairs)]
	if Globals.chars_to_quote:
		for time, inc in incpairs:
			result.append("    %s   %s" %
						  (FilenameMapping.unquote(inc.dirsplit()[1]),
						   Time.timetopretty(time)))
	else:
		for time, inc in incpairs:
			result.append("    %s   %s" %
						  (inc.dirsplit()[1], Time.timetopretty(time)))
	result.append("Current mirror: %s" % Time.timetopretty(mirror_time))
	return "\n".join(result)

	def _writer_helper(self, prefix, flatfileclass, typestr, time):
		"""Used in the get_xx_writer functions, returns a writer class"""
		if time is None: timestr = Time.curtimestr
		else: timestr = Time.timetostring(time)		
		filename = '%s.%s.%s' % (prefix, timestr, typestr)
		rp = Globals.rbdir.append(filename)
		assert not rp.lstat(), "File %s already exists!" % (rp.path,)
		assert rp.isincfile()
		return flatfileclass(rp, 'w', callback = self.add_incrp)

def ListAtTime(rp):
	"""List files in archive under rp that are present at restoretime"""
	rp = require_root_set(rp, 1)
	try: rest_time = Time.genstrtotime(restore_timestr)
	except Time.TimeException, exc: Log.FatalError(str(exc))
	mirror_rp = restore_root.new_index(restore_index)
	inc_rp = mirror_rp.append_path("increments", restore_index)
	for rorp in rp.conn.restore.ListAtTime(mirror_rp, inc_rp, rest_time):
		print rorp.get_indexpath()

def ListChangedSince(rp):
	"""List all the files under rp that have changed since restoretime"""
	rp = require_root_set(rp, 1)
	try: rest_time = Time.genstrtotime(restore_timestr)
	except Time.TimeException, exc: Log.FatalError(str(exc))
	mirror_rp = restore_root.new_index(restore_index)
	inc_rp = mirror_rp.append_path("increments", restore_index)
	for rorp in rp.conn.restore.ListChangedSince(mirror_rp, inc_rp, rest_time):
		# This is a hack, see restore.ListChangedSince for rationale
		print rorp.index[0]

def Backup(rpin, rpout):
	"""Backup, possibly incrementally, src_path to dest_path."""
	global incdir
	SetConnections.BackupInitConnections(rpin.conn, rpout.conn)
	backup_check_dirs(rpin, rpout)
	backup_set_rbdir(rpin, rpout)
	rpout.conn.fs_abilities.backup_set_globals(rpin, force)
	if Globals.chars_to_quote: rpout = backup_quoted_rpaths(rpout)
	init_user_group_mapping(rpout.conn)
	backup_final_init(rpout)
	backup_set_select(rpin)
	backup_warn_if_infinite_regress(rpin, rpout)
	if prevtime:
		Time.setprevtime(prevtime)
		rpout.conn.Main.backup_touch_curmirror_local(rpin, rpout)
		backup.Mirror_and_increment(rpin, rpout, incdir)
		rpout.conn.Main.backup_remove_curmirror_local()
	else:
		backup.Mirror(rpin, rpout)
		rpout.conn.Main.backup_touch_curmirror_local(rpin, rpout)