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)