def cancel(self):
"""Cancel the timer"""
with self._cancel_lock:
if self._canceled:
return
self._canceled = True
e = os.write(self._fd, Timeout._ONE)
os.check_error(e)
def timer_delete(tid):
try:
r = timer_delete_(tid)
# print("timer_delete", r, uos.errno())
os.check_error(r)
except OSError:
e = uos.errno()
if e != errno.EINVAL:
raise(e)
def poll(self, timeout=-1):
s = bytearray(self.evbuf)
n = epoll_wait(self.epfd, s, 1, timeout)
os.check_error(n)
res = []
if n > 0:
vals = struct.unpack(epoll_event, s)
res.append((vals[1], vals[0]))
return res
def poll(self, timeout=-1):
s = bytearray(self.evbuf)
n = epoll_wait(self.epfd, s, 1, timeout)
os.check_error(n)
res = []
if n > 0:
vals = struct.unpack(epoll_event, s)
res.append((vals[1], vals[0]))
return res
def timer_settime(tid, hz):
period = 1000000000 // hz
new_val = new(itimerspec_t)
new_val.it_value.tv_nsec = period
new_val.it_interval.tv_nsec = period
#print("new_val:", bytes(new_val))
old_val = new(itimerspec_t)
#print(new_val, old_val)
r = timer_settime_(tid, 0, new_val, old_val)
os.check_error(r)
def timer_settime(tid, hz):
period = 1000000000 // hz
new_val = new(itimerspec_t)
new_val.it_value.tv_nsec = period
new_val.it_interval.tv_nsec = period
# print("new_val:", bytes(new_val))
old_val = new(itimerspec_t)
# print(new_val, old_val)
r = timer_settime_(tid, 0, new_val, old_val)
os.check_error(r)
def timer_create(sig_id):
sev = new(sigevent_t)
# print(sev)
sev.sigev_notify = SIGEV_SIGNAL
sev.sigev_signo = SIGRTMIN + sig_id
timerid = array.array("P", [0])
r = timer_create_(CLOCK_MONOTONIC, sev, timerid)
os.check_error(r)
# print("timerid", hex(timerid[0]))
return timerid[0]
def timer_create(sig_id):
sev = new(sigevent_t)
#print(sev)
sev.sigev_notify = _SIGEV_SIGNAL
sev.sigev_signo = SIGRTMIN + sig_id
timerid = array.array('P', [0])
r = timer_create_(_CLOCK_MONOTONIC, sev, timerid)
os.check_error(r)
# print("timerid", hex(timerid[0]))
return timerid[0]
def fcntl(fd, op, arg=0):
if type(arg) is int:
r = fcntl_l(fd, op, arg)
os.check_error(r)
return r
else:
r = fcntl_s(fd, op, arg)
os.check_error(r)
# TODO: Not compliant. CPython says that arg should be immutable,
# and possibly mutated buffer is returned.
return r
def ioctl(fd, op, arg=0, mut=False):
if type(arg) is int:
r = ioctl_l(fd, op, arg)
os.check_error(r)
return r
else:
# TODO
assert mut
r = ioctl_s(fd, op, arg)
os.check_error(r)
return r
def fcntl(fd, op, arg=0):
if type(arg) is int:
r = fcntl_l(fd, op, arg)
os.check_error(r)
return r
else:
r = fcntl_s(fd, op, arg)
os.check_error(r)
# TODO: Not compliant. CPython says that arg should be immutable,
# and possibly mutated buffer is returned.
return r
def ioctl(fd, op, arg=0, mut=False):
if type(arg) is int:
r = ioctl_l(fd, op, arg)
os.check_error(r)
return r
else:
# TODO
assert mut
r = ioctl_s(fd, op, arg)
os.check_error(r)
return r
def register(self, fd, eventmask=EPOLLIN|EPOLLPRI|EPOLLOUT, retval=None):
"retval is extension to stdlib, value to use in results from .poll()."
if retval is None:
retval = fd
s = struct.pack(epoll_event, eventmask, retval)
r = epoll_ctl(self.epfd, EPOLL_CTL_ADD, fd, s)
if r == -1 and os.errno_.get() == errno.EEXIST:
r = epoll_ctl(self.epfd, EPOLL_CTL_MOD, fd, s)
os.check_error(r)
# We must keep reference to retval, or it may be GCed. And we must
# keep mapping from fd to retval to be able to get rid of retval reference.
self.registry[fd] = retval
def register(self, fd, eventmask=EPOLLIN|EPOLLPRI|EPOLLOUT, retval=None):
"retval is extension to stdlib, value to use in results from .poll()."
if retval is None:
retval = fd
s = struct.pack(epoll_event, eventmask, retval)
r = epoll_ctl(self.epfd, EPOLL_CTL_ADD, fd, s)
if r == -1 and os.errno_.get() == errno.EEXIST:
r = epoll_ctl(self.epfd, EPOLL_CTL_MOD, fd, s)
os.check_error(r)
# We must keep reference to retval, or it may be GCed. And we must
# keep mapping from fd to retval to be able to get rid of retval reference.
self.registry[fd] = retval
def __init__(self, interval, func, repeat=False):
self._fd = _eventfd(0, _EFD_CLOEXEC)
os.check_error(self._fd)
self._poll = poll()
self._poll.register(self._fd, POLLIN)
self._interval = interval
self._func = func
self._repeat = repeat
# _cancel_lock protects access to _canceled
self._cancel_lock = _thread.allocate_lock()
self._canceled = False
# _wait_lock is used for synchronization
self._wait_lock = _thread.allocate_lock()
def timer_settime(tid, period, mode):
"""
period in milisecond
"""
period = _MILISECOND * period
new_val = new(itimerspec_t)
new_val.it_value.tv_nsec = period
if mode == _PERIODIC:
new_val.it_interval.tv_nsec = period
#print("new_val:", bytes(new_val))
old_val = new(itimerspec_t)
#print("old_val:", bytes(old_val))
#print(new_val, old_val)
r = timer_settime_(tid, 0, new_val, old_val)
os.check_error(r)
def poll(self, timeout=-1):
s = bytearray(self.evbuf)
while True:
n = epoll_wait(self.epfd, s, 1, timeout)
if not os.check_error(n):
break
# TODO: what about timeout value?
res = []
if n > 0:
vals = struct.unpack(epoll_event, s)
res.append((vals[1], vals[0]))
return res
def poll(self, timeout=-1):
s = bytearray(self.evbuf)
while True:
n = epoll_wait(self.epfd, s, 1, timeout)
if not os.check_error(n):
break
# TODO: what about timeout value?
res = []
if n > 0:
vals = struct.unpack(epoll_event, s)
res.append((vals[1], vals[0]))
return res
def _run(self):
try:
data = bytearray(8)
while True:
try:
events = self._poll.poll(int(self._interval * 1000))
except OSError as err:
# TODO: implement PEP 475 in micropython so we don't have
# to check for EINTR
if err.args[0] == EINTR:
continue
raise
for fd, ev in events:
e = os.read_(fd, data, 8)
os.check_error(e)
with self._cancel_lock:
if self._canceled:
break
self._canceled = True
self._func()
if not self._repeat:
break
finally:
self._wait_lock.release()
def poll_ms(self, timeout=-1):
s = bytearray(self.evbuf)
if timeout >= 0:
deadline = utime.ticks_add(utime.ticks_ms(), timeout)
while True:
n = epoll_wait(self.epfd, s, 1, timeout)
if not os.check_error(n):
break
if timeout >= 0:
timeout = utime.ticks_diff(deadline, utime.ticks_ms())
if timeout < 0:
n = 0
break
res = []
if n > 0:
vals = struct.unpack(epoll_event, s)
res.append((vals[1], vals[0]))
return res
def poll_ms(self, timeout=-1):
s = bytearray(self.evbuf)
if timeout >= 0:
deadline = utime.ticks_add(utime.ticks_ms(), timeout)
while True:
n = epoll_wait(self.epfd, s, 1, timeout)
if not os.check_error(n):
break
if timeout >= 0:
timeout = utime.ticks_diff(deadline, utime.ticks_ms())
if timeout < 0:
n = 0
break
res = []
if n > 0:
vals = struct.unpack(epoll_event, s)
res.append((vals[1], vals[0]))
return res
def epoll(sizehint=4):
fd = epoll_create(sizehint)
os.check_error(fd)
return Epoll(fd)
def unregister(self, fd):
# Pass dummy event structure, to workaround kernel bug
r = epoll_ctl(self.epfd, EPOLL_CTL_DEL, fd, self.evbuf)
os.check_error(r)
del self.registry[fd]
def timer_disarm(tid):
no_val = new(itimerspec_t)
r = timer_settime_(tid, 0, no_val, no_val)
os.check_error(r)
def epoll(sizehint=4):
fd = epoll_create(sizehint)
os.check_error(fd)
return Epoll(fd)
def unregister(self, fd):
# Pass dummy event structure, to workaround kernel bug
r = epoll_ctl(self.epfd, EPOLL_CTL_DEL, fd, self.evbuf)
os.check_error(r)
del self.registry[fd]
def mmap(fd, sz, flags, prot, access=None, offset=0):
ptr = mmap_(None, sz, prot, flags, fd, offset)
os.check_error(ptr)
return uctypes.bytearray_at(ptr, sz)
