def auto_acquire_running(self):
from sleep import sleep
while not self.auto_acquire_running_cancelled:
sleep(10)
if self.auto_acquire:
if not self.acquiring_waveforms:
self.acquiring_waveforms = True
def running(self):
info("Starting IOC...")
from CAServer import casget, casput, casdel, casmonitor
from time import time
from sleep import sleep
for name in self.PV_names:
PV_name = self.PV_name(name)
casmonitor(PV_name, callback=self.monitor)
while not self.running_cancelled:
t = time()
for name in self.PV_names:
if time() - self.last_updated(name) > self.update_period(name):
PV_name = self.PV_name(name)
value = getattr(self.object, name)
##info("%s=%r" % (PV_name,value))
casput(PV_name, self.transform(name, value), update=False)
self.set_update_time(name)
if not self.running_cancelled:
sleep(t + self.min_update_period - time())
for name in self.names:
PV_name = self.PV_name(name)
casdel(PV_name)
def monitoring_trace_count(self):
"""Watch trace directory for new files"""
while self.monitoring_trace_count_allowed and not self.monitoring_trace_count_cancelled:
directory = self.trace_directory
from os.path import exists
from time import sleep
if not exists(directory): sleep(1)
else:
# http://timgolden.me.uk/python/win32_how_do_i/watch_directory_for_changes.html
import os
import win32file, win32con
ACTIONS = {
1: "Created",
2: "Deleted",
3: "Updated",
4: "Renamed from something",
5: "Renamed to something"
}
FILE_LIST_DIRECTORY = 0x0001
hDir = win32file.CreateFile(
directory,
FILE_LIST_DIRECTORY,
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE
| win32con.FILE_SHARE_DELETE,
None,
win32con.OPEN_EXISTING,
win32con.FILE_FLAG_BACKUP_SEMANTICS,
None,
)
while self.monitoring_trace_count_allowed and not self.monitoring_trace_count_cancelled:
# ReadDirectoryChangesW takes a previously-created handle to a
# directory, a buffer size for results, a flag to indicate whether
# to watch subtrees and a filter of what changes to notify.
#
# Need to up the buffer size to be sure of picking up all events when
# a large number of files were deleted at once.
results = win32file.ReadDirectoryChangesW(
hDir,
1024,
True,
win32con.FILE_NOTIFY_CHANGE_FILE_NAME
| win32con.FILE_NOTIFY_CHANGE_DIR_NAME
| win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES
| win32con.FILE_NOTIFY_CHANGE_SIZE
| win32con.FILE_NOTIFY_CHANGE_LAST_WRITE
| win32con.FILE_NOTIFY_CHANGE_SECURITY,
None,
None,
)
for action_code, filename in results:
action = ACTIONS.get(action_code, "Unknown")
if action != "Deleted":
debug("%s: %s" % (filename, action))
if action == "Updated":
self.trace_counts_handle(filename)
if action == "Created":
self.__trace_directory_size__ += 1
if action == "Deleted":
self.__trace_directory_size__ -= 1
def task(name):
print(name, 1)
yield sleep(1)
print(name, 2)
yield sleep(2)
print(name, 3)
yield sleep(3)
def __migrate_files__(source_files, destination_files):
"""Copy each file in the list 'source_files' to the corresponding file
in 'destination_files' and remove the source.
source_files: list of strings
destination_files: list of strings"""
from time import sleep
from os.path import dirname
directory = dirname(source_files[0]) if len(source_files) > 0 else ""
global migrate_directory
migrate_directory = directory
copied = [False] * len(source_files)
while directory == migrate_directory and not all(copied):
for i in range(0, len(source_files)):
if copied[i]: continue
if not exists(source_files[i]):
sleep(1)
break # Copying caught up with collection.
copy(source_files[i], destination_files[i])
if exists(destination_files[i]): copied[i] = True
# Make one last attempt after acquisition finished.
for i in range(0, len(source_files)):
if not copied[i]:
copy(source_files[i], destination_files[i])
if exists(destination_files[i]): copied[i] = True
# Clean up.
for i in range(0, len(source_files)):
if copied[i]: remove(source_files[i])
from os import rmdir
rmdir(directory)
def auto_synchronize_running(self):
from sleep import sleep
while not self.auto_synchronize_running_cancelled:
sleep(10)
if self.auto_synchronize:
if self.monitoring_timing:
if not self.trace_count_synchronized:
self.trace_count_synchronized = True
def peridiocally_reset_dcm(wait_time=60):
while True:
try:
reset_dcm()
sleep(wait_time)
except KeyboardInterrupt:
timing_system.clk_shift_reset.count = 0
break
def save_traces_forever(self):
from time import sleep
while self.__save_traces_running__:
try:
self.save_traces_once()
except Exception, msg:
error("%s\n%s", msg, traceback.print_exc())
sleep(0.1)
def timescan(counters=[],waiting_time=1,averaging_time=0,total_time=1e1000,
logfile=None):
"""Monitor a counter or list of counters at a regular time interval.
If "waiting_time" is not specified that interval is 1 second.
"counters" can be either a single counter or list of counters (in square backets).
If "total_time" is given, the scan is ended after the specified number of seconds.
Otherwise, it is ended on keyboard interrupt (Control-C).
"""
if not isinstance(counters,list): counters = [counters]
nc = len(counters)
if logfile != None: logfile = file(logfile,"w")
# Write scan header
line = "#date\ttime/s\t"
for i in range(0,nc):
if hasattr(counters[i],"name"): line += counters[i].name
else: line += "\tcount"
if hasattr(counters[i],"unit") and counters[i].unit != "":
line += "/"+counters[i].unit
line += "\t"
line.strip("\t")
#print line # commented on Feb 28 2018, Valentyn
if logfile != None: logfile.write(line+"\n"); logfile.flush()
counts = range(0,nc)
n = 0
start = time()
while time() < start + total_time:
try:
t = time()
# Acquire scan point
if averaging_time == 0:
for i in range(0,nc): counts[i] = counters[i].value
else:
for i in range(0,nc):
if hasattr(counters[i],"count_time"): counters[i].count_time = averaging_time
for i in range(0,nc):
if hasattr(counters[i],"start"): counters[i].start()
sleep(averaging_time)
for i in range(0,nc):
if hasattr(counters[i],"stop"): counters[i].stop()
for i in range(0,nc):
if hasattr(counters[i],"average"): counts[i] = counters[i].average
else: counts[i] = counters[i].value
# Write scan record
line = datestring(t)+"\t"+str(t-start)+"\t"
for i in range(0,nc): line += str(counts[i])+"\t"
line.strip("\t")
print line
if logfile != None: logfile.write(line+"\n"); logfile.flush()
n = n+1
dt = n*waiting_time - (time()-start)
while dt>0:
sleep (min(dt,0.1))
dt = n*waiting_time - (time()-start)
except KeyboardInterrupt: break
def __query__(self, command, count=None):
"""Send a command to the controller and return the reply"""
from time import time
from sleep import sleep
sleep(self.last_reply_time + self.wait_time - time())
self.write(command)
reply = self.read(count=count)
self.last_reply_time = time()
return reply
def peridiocally_interrupt_clock():
while True:
try:
clksrc.state = 'RJ45:1'
sleep(4)
clksrc.state = 'RF IN'
sleep(60 - 4)
except KeyboardInterrupt:
break
clksrc.state = 'RF IN'
def MyMainLoop():
import wx
from time import sleep
if not hasattr(wx,"app"): wx.app = wx.App(False)
evtloop = wx.GUIEventLoop()
wx.EventLoop.SetActive(evtloop)
while True:
while evtloop.Pending(): evtloop.Dispatch()
evtloop.ProcessIdle()
update_plots()
sleep(0.1)
def ramping(self):
from time_string import date_time
info("Ramp start time: %s" % date_time(self.start_time))
from time import time, sleep
for (t, T) in zip(self.times, self.temperatures):
dt = self.start_time + t - time()
if dt > 0:
sleep(dt)
self.VAL = T
if self.ramping_cancelled: break
info("Ramp ended")
def peridiocally_reset_dcm(wait_time=20):
while True:
try:
count = timing_system.clk_shift.count
timing_system.clk_shift.count = count + 1
sleep(0.05)
timing_system.clk_shift.count = count
sleep(wait_time)
except KeyboardInterrupt:
timing_system.clk_shift.count = count
break
def sleep_or_exit(interval=0.5):
# todo: do this better - check button multiple times and sleep for only a short while
if buttons.is_triggered(tilda.Buttons.BTN_Menu):
clean_up()
launcher = "launcher"
try:
with open("default_launcher.txt", "r") as dl:
launcher = dl.readline()
except OSError:
pass
App(launcher).boot()
sleep.sleep(interval)
def run():
setT.value = Temp_array[0]
sleep(Time_array[0])
setT.value = Temp_array[1]
sleep(Time_array[1])
for i in range(0,T_repeat):
setT.value = Temp_array[2]
sleep(Time_array[2])
setT.value = Temp_array[1]
sleep(Time_array[3])
setT.value = Temp_array[0]
sleep(Time_array[4])
def record_temperature():
from sample_frozen_optical2 import sample_frozen_optical as sfo
from numpy import zeros
try:
l = 0
while True:
record_T_once(l)
l += 1
sleep(0.3)
except KeyboardInterrupt:
pass
def motor_test(dvalue=0.01):
from time import time
value = motorZ.value
motorZ.value = value + dvalue
t1 = time()
while motorZ.value != round(value + dvalue, 3):
sleep(0.01)
t2 = time()
motorZ.value = value
while motorZ.value != value:
sleep(0.01)
t3 = time()
print(t2 - t1, t3 - t2)
def check_laser_loop():
from sleep import sleep
import traceback
info("Initializing...")
try:
while True:
try:
check_laser()
except Exception, msg:
error("%s" % msg)
traceback.print_exc()
sleep(3)
except KeyboardInterrupt:
pass
def monitor(self):
"""Keep generating reports"""
import autoreload
from sleep import sleep
from sys import stdout
try:
while True:
report = "\n\n" + self.report + "\n"
report += "[Updating in 10 s... Control-C to end]"
stdout.write(report)
sleep(10)
except KeyboardInterrupt:
pass
stdout.write("\n\n")
def record():
try:
i = 0
while True:
filename = template % (time(), i, "M")
print("%s" % basename(filename))
camere_Microscope.save_image(filename)
filename = template % (time(), i, "W")
print("%s" % basename(filename))
camera_WideField.save_image(filename)
i += 1
sleep(delay)
except KeyboardInterrupt:
pass
def finish(text):
parts = text.split()
# sleep
pretty_time = parts[0]
# jitter
if len(parts) > 1:
jitter = int(parts[1])
else:
jitter = 30
for bid in bids:
aggressor.btask(bid, 'sl {} {}'.format(pretty_time, jitter))
sleep.sleep(bid, pretty_time, jitter)
def update_once(self):
from CAServer import casput
from numpy import isfinite, isnan, nan
from time import time
from sleep import sleep
t = time()
online = oasis_chiller_driver.online
if online:
if online and not self.was_online:
info("Reading configuration...")
casput(self.prefix + ".COMM", oasis_chiller_driver.COMM)
casput(self.prefix + ".VAL", oasis_chiller_driver.VAL)
casput(self.prefix + ".RBV", oasis_chiller_driver.RBV)
casput(self.prefix + ".fault_code",
oasis_chiller_driver.fault_code)
casput(self.prefix + ".faults", oasis_chiller_driver.faults)
casput(self.prefix + ".LLM", oasis_chiller_driver.LLM)
casput(self.prefix + ".HLM", oasis_chiller_driver.HLM)
casput(self.prefix + ".P1", oasis_chiller_driver.P1)
casput(self.prefix + ".I1", oasis_chiller_driver.I1)
casput(self.prefix + ".D1", oasis_chiller_driver.D1)
casput(self.prefix + ".P2", oasis_chiller_driver.P2)
casput(self.prefix + ".I2", oasis_chiller_driver.I2)
casput(self.prefix + ".D2", oasis_chiller_driver.D2)
casput(self.prefix + ".SCANT", nan)
casput(self.prefix + ".processID",
value=os.getpid(),
update=False)
casput(self.prefix + ".computer_name",
value=computer_name,
update=False)
if len(self.command_queue) > 0:
attr, value = self.command_queue.popleft()
setattr(oasis_chiller_driver, attr, value)
value = getattr(oasis_chiller_driver, attr)
else:
attr = self.next_poll_property
value = getattr(oasis_chiller_driver, attr)
casput(self.prefix + "." + attr, value)
casput(self.prefix + ".SCANT",
time() - t) # post actual scan time for diagnostics
else:
sleep(1)
self.was_online = online
def running(self):
info("Starting IOC: Prefix: %s ..." % self.prefix)
from CAServer import casget, casput, casdel
from time import time
from sleep import sleep
self.monitors_setup()
while not self.running_cancelled:
t = time()
for name in self.property_names:
if time() - self.last_updated(name) > self.update_period(name):
PV_name = self.prefix + name.upper()
value = getattr(self, name)
##info("Update: %s=%r" % (PV_name,value))
casput(PV_name, value, update=False)
self.set_update_time(name)
if not self.running_cancelled:
sleep(t + self.min_update_period - time())
casdel(self.prefix)
def record(camera_name='MicroscopeCamera'):
camera1 = Camera('MicroscopeCamera')
camera1.acquiring = True
camera2 = Camera('WideFieldCamera')
#camera2.ip_address = '164.54.161.34:2001'
camera2.acquiring = True
try:
i = 0
while True:
ins = 0
filename = template % ("Microscope/", time(), i, int(ins),
temperature.value)
print("%s" % basename(filename))
camera1.save_image(filename)
filename = template % ("WideField/", time(), i, int(ins),
temperature.value)
print("%s" % basename(filename))
camera2.save_image(filename)
i += 1
sleep(delay)
except KeyboardInterrupt:
pass
def run():
t0 = time()
T0 = nan
f = file("logfiles/temperature_controller.log", "wb")
s = "#time[s]\tT[C]\tI[A]\tU[V]\tTC[C]"
print(s)
f.write(s + "\n")
try:
while True:
TC = thermocouple.T
TIU = temperature_controller.TIU
if TIU is not None and TC is not None:
T, I, U = TIU
t = time()
if T != T0:
s = "%s\t%g\t%g\t%g\t%g" % (t - t0, T, I, U, TC)
print(s)
f.write(s + "\n")
T0 = T
sleep(0.2)
except KeyboardInterrupt:
pass
def display_room(beginning):
room = beginning
if room == "start":
clear()
room = start()
display_room(room)
elif room == "initial_room":
clear()
room = initial_room()
display_room(room)
elif room == "cabin":
clear()
room = cabin()
display_room(room)
elif room == "outside":
clear()
room = outside()
display_room(room)
elif room == "garden":
clear()
room = garden()
display_room(room)
elif room == "woods":
clear()
room = woods()
display_room(room)
elif room == "fire":
clear()
room = fire()
display_room(room)
elif room == "upstairs":
clear()
room = upstairs()
display_room(room)
elif room == "sleep":
clear()
room = sleep()
display_room(room)
elif room == "end":
clear()
print("Ok, goodbye!")
def run(self):
"""Run EPICS IOC"""
from CAServer import casput, casmonitor, casdel
from numpy import isfinite, nan
from time import time
from sleep import sleep
self.running = True
casput(self.prefix + ".SCAN", self.SCAN)
casput(self.prefix + ".DESC", "State")
casput(self.prefix + ".EGU", "")
# Monitor client-writable PVs.
casmonitor(self.prefix + ".SCAN", callback=self.monitor)
casmonitor(self.prefix + ".VAL", callback=self.monitor)
was_online = False
while self.running:
if self.SCAN > 0 and isfinite(self.SCAN):
SCAN = self.SCAN
online = Ramsey_RF_driver.online
if online:
if online and not was_online:
info("Reading configuration...")
casput(self.prefix + ".COMM", Ramsey_RF_driver.COMM)
casput(self.prefix + ".SCANT", nan)
t = time()
casput(self.prefix + ".VAL", float(Ramsey_RF_driver.VAL))
sleep(t + 1.0 * SCAN - time())
casput(self.prefix + ".SCANT",
time() - t) # post actual scan time for diagnostics
else:
casput(self.prefix + ".VAL", nan)
sleep(SCAN)
was_online = online
else:
casput(self.prefix + ".SCANT", nan)
sleep(0.1)
casdel(self.prefix)
def Sleep(self, request, context):
response = sleep_pb2.Seconds()
response.value = sleep.sleep(request.value)
return response
def test_output_state():
for name in timing_system.output_names:
timing_system.register(name + "_enable").count = 0
timing_system.register(name + "_state").count = 1
sleep(0.5)
timing_system.register(name + "_state").count = 0
def task(name):
print(name, 1)
yield sleep(1)
print(name, 2)
yield sleep(2)
print(name, 3)
def long_add(x, y, duration=1):
yield sleep(duration)
return x + y
def task(name):
print(name, 1)
sleep(1)
print(name, 2)
sleep(2)
print(name, 3)
import signal import sys import time from subprocess import Popen from sleep import sleep sleep.flush_queue() worker_command = [sys.executable, '-m', 'thoonktasks.worker', 'examples.sleep'] # Send task once sleep(3) # Start worker worker = Popen(worker_command) time.sleep(2) # Stop worker before task finished worker.send_signal(signal.SIGINT) # Wait for worker to exit worker.wait() # Start a new worker worker = Popen(worker_command) # Task is still in queue time.sleep(4) # Stop worker
def sleep(self, secs):
log.debug("Sleeping %f seconds" % secs)
sleep.sleep(secs)
