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 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 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 _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 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 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)