def get_timerfd(self, delay, interval=0, close_on_fork=True): fd = linuxfd.timerfd(rtc=True, nonBlocking=True) if close_on_fork: self._close_on_fork_fds.add(fd) fd.settime(delay, 0) return fd
def __init__(self, device, event_loop): self.device = device self.event_loop = event_loop self.joystick = None self.timer = linuxfd.timerfd(rtc=False, nonBlocking=True) self.timer.settime(value=1.0, interval=1.0) self.event_loop.add_reader(self.timer, self._read_timer)
def __init__(self, period_seconds, event_loop, callback): # rtc=False means a monotonic clock for realtime loop as it won't # be adjusted by the system admin self.timer = linuxfd.timerfd(rtc=False, nonBlocking=True) # here we start a timer that will fire in one second, and then # each command period after that self.period_seconds = period_seconds self.callback = callback self.event_loop = event_loop self.timer.settime(value=1.0, interval=self.period_seconds) self.event_loop.add_reader(self.timer, self._read_timer)
def play(device, f): print(f"Using device {device}") p = pyaudio.PyAudio() if device == -1: stream = p.open( format=p.get_format_from_width(f.getsampwidth()), channels=f.getnchannels(), rate=f.getframerate(), output=True, ) else: stream = p.open(format=p.get_format_from_width(f.getsampwidth()), channels=f.getnchannels(), rate=f.getframerate(), output=True, output_device_index=device) data = f.readframes(1024) # wait to start at a specific time # use linuxfd epoll tfd = linuxfd.timerfd(rtc=True, nonBlocking=True, closeOnExec=True) start_time = time.clock_gettime(time.CLOCK_REALTIME) start_time_floor = math.floor(start_time) seconds = start_time_floor % 30 diff = 30 - seconds start_time_floor += diff print(f"Start time {start_time} floor {start_time_floor} sec {seconds}") tfd.settime(value=start_time_floor, interval=0, absolute=True) signal.pthread_sigmask(signal.SIG_SETMASK, {signal.SIGINT}) epl = select.epoll() epl.register(tfd.fileno(), select.EPOLLIN) events = epl.poll(-1) first = True while data != '': stream.write(data) data = f.readframes(1024) if first: signal.pthread_sigmask(signal.SIG_SETMASK, {}) print( f"Starting at time {time.clock_gettime(time.CLOCK_REALTIME)}") first = False
def setup(self): self.request.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.counter = 0 fcntl.fcntl(self.request.fileno(), fcntl.F_SETFL, socket.SOCK_NONBLOCK) fcntl.fcntl(self.request.fileno(), fcntl.F_SETFL, socket.SOCK_CLOEXEC) self.request.setblocking(False) # buat selectors self.sel = selectors.DefaultSelector() self.buffer_echo = b"" # buat timerfd dengan linuxfd self.timer = linuxfd.timerfd(nonBlocking=True, closeOnExec=True)
def main(): command_rate_hz = 50 command_period_seconds = 1.0 / command_rate_hz # rtc=False means a monotonic clock for realtime loop as it won't # be adjusted by the system admin periodic = linuxfd.timerfd(rtc=False, nonBlocking=True) # here we start a timer that will fire in one second, and then # each command period after that periodic.settime(value=1.0, interval=command_period_seconds) logging.basicConfig(stream=sys.stdout, level=logging.INFO) try: can_socket = CANSocket('can0') except OSError as e: sys.stderr.write( f'Could not listen on interface can0\n', ) sys.exit(e.errno) print(f'Listening on can0') loop = asyncio.get_event_loop() radius = (15.0*0.0254)/2.0 # in meters, 15" diameter wheels gear_ratio = 6 poll_pairs = 15 right_motor = HubMotor(radius, gear_ratio, poll_pairs, 7, can_socket) left_motor = HubMotor(radius, gear_ratio, poll_pairs, 9, can_socket) count = [0] def command_loop(): periodic.read() if count[0] % command_rate_hz == 0: logger.info( 'right: %s\nleft: %s', right_motor.get_state(), left_motor.get_state(), ) # right_motor.send_velocity_command(1.0) # left_motor.send_velocity_command(1.0) count[0] += 1 loop.add_reader(can_socket, lambda: can_socket.recv()) loop.add_reader(periodic, command_loop) loop.run_forever()
def __init__(self, period, func, func_args=[], func_kwargs={}, new_thread_for_task=False, epoll_timeout=0.002): self.period = period self.new_thread_for_task = new_thread_for_task # save func info for callback self.func = func self.func_args = func_args self.func_kwargs = func_kwargs # thread needed to trigger func when it's time to run self.shutdown_event = threading.Event() self.thread = threading.Thread(target=self._epoll_thread) # get timerfd & epollfd fds self.tfd = linuxfd.timerfd(rtc=True, nonBlocking=True) self.tfd.settime(self.period, self.period) self.epoll = select.epoll() self.epoll.register(self.tfd.fileno(), select.EPOLLIN) self.epoll_timeout = epoll_timeout
def run(self): if self.rate: tfd = linuxfd.timerfd() tfd.settime(1.0, 1.0 / self.rate) else: tfd = None while True: if tfd: tfd.read() values = self.cb() ts = Timestamp.now(None, self.sequence) sample = Sample(ts, values) sys.stdout.write(str(sample) + '\n') sys.stdout.flush() self.sequence += 1
def main(): command_rate_hz = 100 command_period_seconds = 1.0 / command_rate_hz # rtc=False means a monotonic clock for realtime loop as it won't # be adjusted by the system admin periodic = linuxfd.timerfd(rtc=False, nonBlocking=True) # here we start a timer that will fire in one second, and then # each command period after that periodic.settime(value=1.0, interval=command_period_seconds) logging.basicConfig(stream=sys.stdout, level=logging.INFO) try: can_socket = CANSocket('can0') except OSError as e: sys.stderr.write(f'Could not listen on interface can0\n', ) sys.exit(e.errno) print(f'Listening on can0') loop = asyncio.get_event_loop() config = default_config() right_motor = HubMotor( 'right_motor', config.wheel_radius.value, config.hub_motor_gear_ratio.value, config.hub_motor_poll_pairs.value, 7, can_socket, ) right_motor_aft = HubMotor( 'right_motor_aft', config.wheel_radius.value, config.hub_motor_gear_ratio.value, config.hub_motor_poll_pairs.value, 8, can_socket, ) left_motor = HubMotor( 'left_motor', config.wheel_radius.value, config.hub_motor_gear_ratio.value, config.hub_motor_poll_pairs.value, 9, can_socket, ) left_motor_aft = HubMotor( 'left_motor_aft', config.wheel_radius.value, config.hub_motor_gear_ratio.value, config.hub_motor_poll_pairs.value, 10, can_socket, ) count = [0] def command_loop(): periodic.read() if count[0] % (2 * command_rate_hz) == 0: logger.info( 'right: %s\nleft: %s', MessageToString(right_motor.get_state(), as_one_line=True), MessageToString(left_motor.get_state(), as_one_line=True), ) right_motor.send_velocity_command(0.0) right_motor_aft.send_velocity_command(0.0) left_motor.send_velocity_command(0.0) left_motor_aft.send_velocity_command(0.0) count[0] += 1 loop.add_reader(can_socket, lambda: can_socket.recv()) loop.add_reader(periodic, command_loop) loop.run_forever()
L_UDP = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # Habilitando reuso de la conexión L_UDP.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) # Habilitando modo broadcasting L_UDP.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) L_UDP.bind((HOST, PORT)) print('Escuchando UDP en', (HOST, PORT)) # L_UDP.setblocking(False) events = selectors.EVENT_READ udp_selectorkey = sel.register(L_UDP, events, data=None) request = b'REQUEST\n' sent = L_UDP.sendto(request, ("<broadcast>", PORT)) # Timer anuncios tfd = linuxfd.timerfd(rtc=True, nonBlocking=True) tfd.settime(1, 30) timer_selectorkey = sel.register(tfd.fileno(), selectors.EVENT_READ) # Event loop while True: events = sel.select( timeout=None) # Bloquea hasta que un socket registrado tenga lista I/O for key, mask in events: # Llegó timer if key == timer_selectorkey: announcements.announce_forever.send_announcements( udp_selectorkey.fileobj, PORT) tfd.read()
# sfd = linuxfd.signalfd(signalset={signal.SIGALRM}) signal.pthread_sigmask(signal.SIG_SETMASK, {signal.SIGALRM}) print("\ntesting signalfd (fd={}) with SIGALRM".format(sfd.fileno())) print("guarded signals = {}".format(sfd.signals())) print("starting alarm timer (3 seconds)") signal.alarm(3) value = sfd.read() print("received SIGALRM, signalfd.read() returned:") pprint.pprint(value) signal.alarm(0) # # test timerfd # tfd = linuxfd.timerfd(rtc=True) print("\ntesting timerfd (fd={})".format(sfd.fileno())) print(" {:.2f}: setting timer (value=3,interval=1)".format(time.time())) tfd.settime(3, 1) for i in range(0, 3): value = tfd.read() print(" {:.2f}: received timer event".format(time.time())) time.sleep(0.25) print(" {:.2f}: timer will expire in {:.3f} seconds".format( time.time(), tfd.gettime()[0])) t = time.time() + 5 print(" {:.2f}: setting absolute timer (t={:.2f})".format(time.time(), t)) tfd.settime(t, absolute=True) value = tfd.read() print(" {:.2f}: received timer event".format(time.time()))
break except OSError as err: print(f"socket init: {err}") sock = None if sock is None: print("cannot start server") exit(1) print(f"listening at port {addr[1]}") sock.listen(0) epoll = select.epoll() epoll.register(sock.fileno(), eventmask=select.EPOLLIN) timer = timerfd() timer.settime(1, 1) epoll.register(timer.fileno(), eventmask=select.EPOLLIN) clients = {} while True: epoll_events = epoll.poll(timeout=-1, maxevents=10) for (fd, event_mask) in epoll_events: if fd == sock.fileno(): # new client client_sock, client_addr = sock.accept() print(f"new client {client_addr[0]}:{client_addr[1]}") epoll.register(client_sock.fileno(), eventmask=select.EPOLLIN) clients[client_sock.fileno()] = client_sock
# sfd = linuxfd.signalfd(signalset={signal.SIGALRM}) signal.pthread_sigmask(signal.SIG_SETMASK,{signal.SIGALRM}) print("\ntesting signalfd (fd={}) with SIGALRM".format(sfd.fileno())) print("guarded signals = {}".format(sfd.signals())) print("starting alarm timer (3 seconds)") signal.alarm(3) value = sfd.read() print("received SIGALRM, signalfd.read() returned:") pprint.pprint(value) signal.alarm(0) # # test timerfd # tfd = linuxfd.timerfd(rtc=True) print("\ntesting timerfd (fd={})".format(sfd.fileno())) print(" {:.2f}: setting timer (value=3,interval=1)".format(time.time())) tfd.settime(3,1) for i in range(0,3): value = tfd.read() print(" {:.2f}: received timer event".format(time.time())) time.sleep(0.25) print(" {:.2f}: timer will expire in {:.3f} seconds".format(time.time(),tfd.gettime()[0])) t = time.time()+5 print(" {:.2f}: setting absolute timer (t={:.2f})".format(time.time(),t)) tfd.settime(t,absolute=True) value = tfd.read() print(" {:.2f}: received timer event".format(time.time())) tfd.settime(0,0)