def _callback(self):
# we've started
self._started = True
# send the code
global have_parallel
if have_parallel:
# send the port code and time it
try:
# Create a parallel port object (locks it exclusively)
self._pport = parallel.Parallel(port=self._port)
start_time = clock.now()
self._pport.setData(self._code_num)
end_time = clock.now()
except: # eventually figure out which errors to catch
sys.stderr.write("\nWARNING: The parallel module could not send pulses,\n" +
"\tso no sync pulsing will be generated.\n\n")
have_parallel = False
self._pport = None
self._pulse_on = None
self._pulse_off = None
self._ended = True
clock.schedule(self.leave)
clock.schedule(self.finalize)
return
# set the pulse time
time_err = (end_time - start_time)/2.
self._pulse_on = event_time(start_time+time_err,
time_err)
# schedule leaving (as soon as this method is done)
clock.schedule(self.leave)
# schedule the off time
if self._width > 0.0:
# we're gonna turn off ourselves
clock.schedule(self._pulse_off_callback,
event_time=self._pulse_on['time']+self._width)
else:
# we're gonna leave it
self._pulse_off = None
# clean up/ close the port
self._pport = None
# so we can finalize now, too
clock.schedule(self.finalize)
self._ended = True
else:
# we can leave and finalize now
self._pulse_on = None
self._pulse_off = None
self._ended = True
clock.schedule(self.leave)
clock.schedule(self.finalize)
def _pulse_off_callback(self, dt):
# turn off the code
start_time = now()
self._pport.setData(0)
end_time = now()
# clean up / close the port
self._pport = None
# set the pulse time
time_err = (end_time - start_time) / 2.
self.pulse_end_time = event_time(start_time + time_err, time_err)
def _pulse_off_callback(self, dt):
# turn off the code
start_time = now()
self._pport.setData(0)
end_time = now()
# clean up / close the port
self._pport = None
# set the pulse time
time_err = (end_time - start_time)/2.
self.pulse_end_time = event_time(start_time+time_err,
time_err)
def blocking_flip(self):
# TODO: use sync events instead!
EventLoop.window.dispatch('on_flip')
# draw a transparent point
glVertexAttribPointer(0, 2, GL_INT, GL_FALSE, 0,
"\x00\x00\x00\x0a\x00\x00\x00\x0a") # Position
glVertexAttrib4f(3, 0.0, 0.0, 0.0, 0.0) # Color
glDrawArrays(GL_POINTS, 0, 1)
# wait for flip and point to draw
glFinish()
# record the time immediately
self.last_flip = event_time(clock.now(), 0.0)
return self.last_flip
def _pulse_off_callback(self):
# turn off the code
start_time = clock.now()
self._pport.setData(0)
end_time = clock.now()
# clean up / close the port
self._pport = None
# set the pulse time
time_err = (end_time - start_time)/2.
self._pulse_off = event_time(start_time+time_err,
time_err)
# let's schedule finalizing
self._ended = True
clock.schedule(self.finalize)
def _pulse_off_callback(self):
# turn off the code
if self._sync_style == "parallel":
start_time = clock.now()
self._sport.setData(0)
end_time = clock.now()
else:
start_time = clock.now()
self._sport.setData("0")
end_time = clock.now()
# clean up / close the port
self._sport = None
# set the pulse time
time_err = (end_time - start_time) / 2.
self._pulse_off = event_time(start_time + time_err, time_err)
# let's schedule finalizing
self._ended = True
clock.schedule(self.finalize)
def _callback(self, dt):
# Convert code if necessary
code = val(self.pulse_code)
if type(code)==str:
if code[0]=="S":
# Use first 4 bits
ncode = int(code[1:])
if ncode < 0 or ncode > 16: ncode = 15
elif code[0]=="R":
# Use last 4 bits
ncode = int(code[1:])
if ncode < 0 or ncode > 16: ncode = 15
ncode = ncode >> 4
else:
# Convert to an integer
ncode = int(code)
else:
ncode = int(code)
# send the code
if have_parallel:
# Create a parallel port object (locks it exclusively)
self._pport = parallel.Parallel(port=self.pulse_port)
# send the port code and time it
start_time = now()
self._pport.setData(ncode)
end_time = now()
# set the pulse time
time_err = (end_time - start_time)/2.
self.pulse_time = event_time(start_time+time_err,
time_err)
# schedule the off time
clock.schedule_once(self._pulse_off_callback, val(self.pulse_duration))
def _callback(self, dt):
# Convert code if necessary
code = val(self.pulse_code)
if type(code) == str:
if code[0] == "S":
# Use first 4 bits
ncode = int(code[1:])
if ncode < 0 or ncode > 16: ncode = 15
elif code[0] == "R":
# Use last 4 bits
ncode = int(code[1:])
if ncode < 0 or ncode > 16: ncode = 15
ncode = ncode >> 4
else:
# Convert to an integer
ncode = int(code)
else:
ncode = int(code)
# send the code
if have_parallel:
# Create a parallel port object (locks it exclusively)
self._pport = parallel.Parallel(port=self.pulse_port)
# send the port code and time it
start_time = now()
self._pport.setData(ncode)
end_time = now()
# set the pulse time
time_err = (end_time - start_time) / 2.
self.pulse_time = event_time(start_time + time_err, time_err)
# schedule the off time
clock.schedule_once(self._pulse_off_callback,
val(self.pulse_duration))
def _callback(self):
# we've started
self._started = True
# Pull in the global variables
global PI
global SI
if PI or SI:
# send the port code and time it
try:
if self._sync_style == "parallel":
# Create a parallel port object
# from the global variable (locks it exclusively)
self._sport = PI(address=self._port)
start_time = clock.now()
self._sport.setData(self._code_num)
end_time = clock.now()
elif self._sync_style == "serial":
self._sport = SI(address=self._port)
start_time = clock.now()
self._sport.setData(self._code_num)
end_time = clock.now()
except: # eventually figure out which errors to catch
sys.stderr.write(
"\nWARNING: The sync module could not send pulses,\n" +
"\tso no sync pulsing will be generated.\n\n")
PI = None
self._pport = None
self._pulse_on = None
self._pulse_off = None
self._ended = True
clock.schedule(self.leave)
clock.schedule(self.finalize)
return
# set the pulse time
time_err = (end_time - start_time) / 2.
self._pulse_on = event_time(start_time + time_err, time_err)
# schedule leaving (as soon as this method is done)
clock.schedule(self.leave)
# schedule the off time
if self._width > 0.0:
# we're gonna turn off ourselves
clock.schedule(self._pulse_off_callback,
event_time=self._pulse_on['time'] + self._width)
else:
# we're gonna leave it
self._pulse_off = None
# clean up/ close the port
self._sport = None
# so we can finalize now, too
clock.schedule(self.finalize)
self._ended = True
else:
# we can leave and finalize now
self._pulse_on = None
self._pulse_off = None
self._ended = True
clock.schedule(self.leave)
clock.schedule(self.finalize)
def _idle_callback(self, event_loop):
# record the time range
self._new_time = clock.now()
time_err = (self._new_time - self._last_time) / 2.0
self.event_time = event_time(self._last_time + time_err, time_err)
# call any of our scheduled events that are ready
clock.tick()
# see if we're ready for video
ready_for_video = ((self._new_time - self.last_flip["time"]) >=
(self.flip_interval - FLIP_TIME_MARGIN))
# see if the kivy clock needs a tick
# throttled by flip interval
ready_for_kivy_tick = ready_for_video and (
self._new_time - self._last_kivy_tick >= self.flip_interval)
# prepare for every video to be drawn on the next flip
need_draw = False
for video in self.video_queue:
if (not video.drawn
and ((self.pending_flip_time is None and self._new_time >=
(video.flip_time - (self.flip_interval / 2.0)))
or video.flip_time == self.pending_flip_time)):
# prepare that video change
video.update_cb()
need_draw = True
video.drawn = True
# save the pending time so all other changes
# for that time will also run
self.pending_flip_time = video.flip_time
else:
# either none are ready or the remaining are
# for a subsequent flip
break
# do a kivy tick if we're going to be drawing or enough time
# has passed (see above)
# but only tick and draw once before a flip
do_kivy_tick = ready_for_kivy_tick or need_draw
if do_kivy_tick:
# tick the kivy clock
_kivy_clock.tick()
self._last_kivy_tick = self._new_time
# dispatch input events
event_loop.dispatch_input()
# process the builder and check for kivy draws
if do_kivy_tick:
Builder.sync()
_kivy_clock.tick_draw()
Builder.sync()
kivy_needs_draw = EventLoop.window.canvas.needs_redraw or need_draw
# print (_kivy_clock.get_fps(),
# _kivy_clock.get_rfps(), self._new_time)
else:
kivy_needs_draw = False
# dispatch draw if necessary
if kivy_needs_draw:
EventLoop.window.dispatch('on_draw')
# handle video and flips
if ready_for_video:
# we need flip if kivy needs one
need_flip = kivy_needs_draw and self.pending_flip_time is None
flip_time_callbacks = []
for video in self.video_queue:
if video.drawn and video.flip_time == self.pending_flip_time:
# a smile video change is ready, so we need flip
need_flip = True
# append the flip time callback
if video.flip_time_cb is not None:
flip_time_callbacks.append(video.flip_time_cb)
# mark that video as flipped (it's gonna be)
video.flipped = True
else:
# no more of the videos could match, so break
break
# remove any video change that's gonna be flipped
while len(self.video_queue) and self.video_queue[0].flipped:
del self.video_queue[0]
# do flip if necessary
if need_flip:
# test if blocking or non-blocking flip
# do a blocking if:
# 1) Forcing a blocking flip_interval
# OR
# 2) We have a specific flip callback request and we
# are not forcing a non-blocking flip
if self.force_blocking_flip or \
(len(flip_time_callbacks) and
not self.force_nonblocking_flip):
# print "BLOCKING FLIP!"
self.blocking_flip()
else:
# non-blocking flip
# print "FLIP!"
EventLoop.window.dispatch('on_flip')
self.last_flip = event_time(clock.now(), 0.0)
# still may need to update flip_time_callbacks
# even though they may be wrong for non-blocking flips
for cb in flip_time_callbacks:
cb(self.last_flip)
# tell refs that last_flip updated
self.exp._screen._set_last_flip(self.last_flip)
# no longer pending flip
self.pending_flip_time = None
# save the time
self._last_time = self._new_time
# exit if experiment done
if not self.exp._root_executor._active:
if self.exp._root_executor._enter_time:
# stop if we're not active, but we have an enter time
self.stop()
# give time to other threads
clock.usleep(IDLE_USLEEP)
def _callback(self, dt):
# play the sound
self._snd.out()
self.sound_start = event_time(now())
def _callback(self, dt):
self._fader.play()
self.sound_start = event_time(now())
def _callback(self, dt):
# play the sound
self._snd.out()
self.sound_start = event_time(now())
def _callback(self, dt):
self._fader.play()
self.sound_start = event_time(now())
def _callback(self, dt):
self._rec = pyo.Record(
pyo.Input(), filename=self.filepath, chnls=2, fileformat=0,
sampletype=1, buffering=16)
self.rec_start = event_time(now())
pyo.Clean_objects(self.duration, self._rec).start()
