def connect(self, clean_session=True):
self.sock = socket.socket()
self.poller_r = uselect.poll()
self.poller_r.register(self.sock, uselect.POLLIN)
self.poller_w = uselect.poll()
self.poller_w.register(self.sock, uselect.POLLOUT)
addr = socket.getaddrinfo(self.server, self.port)[0][-1]
self.sock.connect(addr)
if self.ssl:
import ussl
self.sock = ussl.wrap_socket(self.sock, **self.ssl_params)
premsg = bytearray(b"\x10\0\0\0\0\0")
msg = bytearray(b"\0\x04MQTT\x04\0\0\0")
sz = 10 + 2 + len(self.client_id)
msg[7] = bool(clean_session) << 1
# Clean session = True, remove current session
if bool(clean_session):
self.rcv_pids.clear()
if self.user is not None:
sz += 2 + len(self.user)
msg[7] |= 1 << 7 # User Name Flag
if self.pswd is not None:
sz += 2 + len(self.pswd)
msg[7] |= 1 << 6 # # Password Flag
if self.keepalive:
assert self.keepalive < 65536
msg[8] |= self.keepalive >> 8
msg[9] |= self.keepalive & 0x00FF
if self.lw_topic:
sz += 2 + len(self.lw_topic) + 2 + len(self.lw_msg)
msg[7] |= 0x4 | (self.lw_qos & 0x1) << 3 | (self.lw_qos & 0x2) << 3
msg[7] |= self.lw_retain << 5
plen = self._varlen_encode(sz, premsg, 1)
self._write(premsg, plen)
self._write(msg)
self._send_str(self.client_id)
if self.lw_topic:
self._send_str(self.lw_topic)
self._send_str(self.lw_msg)
if self.user is not None:
self._send_str(self.user)
if self.pswd is not None:
self._send_str(self.pswd)
resp = self._read(4)
if not (resp[0] == 0x20 and resp[1] == 0x02):
raise MQTTException(29)
if resp[3] != 0:
if 1 <= resp[3] <= 5:
raise MQTTException(20 + resp[3])
else:
raise MQTTException(20, resp[3])
self.last_cpacket = ticks_ms()
return resp[2] & 1
def connect(A, clean_session=True):
E = clean_session
A.sock = socket.socket()
G = socket.getaddrinfo(A.server, A.port)[0][-1]
A.sock.connect(G)
if A.ssl:
import ussl
A.sock = ussl.wrap_socket(A.sock, **A.ssl_params)
A.poller_r = uselect.poll()
A.poller_r.register(A.sock, uselect.POLLIN)
A.poller_w = uselect.poll()
A.poller_w.register(A.sock, uselect.POLLOUT)
F = bytearray(b'\x10\x00\x00\x00\x00\x00')
B = bytearray(b'\x00\x04MQTT\x04\x00\x00\x00')
D = 10 + 2 + len(A.client_id)
B[7] = bool(E) << 1
if bool(E): A.rcv_pids.clear()
if A.user is not None:
D += 2 + len(A.user)
B[7] |= 1 << 7
if A.pswd is not None:
D += 2 + len(A.pswd)
B[7] |= 1 << 6
if A.keepalive:
assert A.keepalive < 65536
B[8] |= A.keepalive >> 8
B[9] |= A.keepalive & 255
if A.lw_topic:
D += 2 + len(A.lw_topic) + 2 + len(A.lw_msg)
B[7] |= 4 | (A.lw_qos & 1) << 3 | (A.lw_qos & 2) << 3
B[7] |= A.lw_retain << 5
H = A._varlen_encode(D, F, 1)
A._write(F, H)
A._write(B)
A._send_str(A.client_id)
if A.lw_topic:
A._send_str(A.lw_topic)
A._send_str(A.lw_msg)
if A.user is not None:
A._send_str(A.user)
if A.pswd is not None: A._send_str(A.pswd)
C = A._read(4)
if not (C[0] == 32 and C[1] == 2): raise MQTTException(29)
if C[3] != 0:
if 1 <= C[3] <= 5: raise MQTTException(20 + C[3])
else: raise MQTTException(20, C[3])
A.last_cpacket = ticks_ms()
return C[2] & 1
def _set_socket_timeout(self, timeout):
if getattr(self._socket, 'settimeout', None):
self._socket.settimeout(timeout)
else:
p = select.poll()
p.register(self._socket)
p.poll(int(timeout * 1000))
def __init__(self):
self.brightness = 0
self.mode = Mode.CLOCK
self.sta_if = network.WLAN(network.STA_IF)
self.credentials = Creds().load()
self.settings = Settings().load()
routes = {
b"/": b"./index.html",
b"/connect": self.connect,
b"/action/color": self.set_color,
b"/action/clock/display": self.display_clock,
b"/action/brightness/more": self.brightness_more,
b"/action/brightness/less": self.brightness_less,
b"/action/scoreboard/display": self.display_scoreboard,
b"/action/scoreboard/green/more": self.scoreboard_green_more,
b"/action/scoreboard/green/less": self.scoreboard_green_less,
b"/action/scoreboard/red/more": self.scoreboard_red_more,
b"/action/scoreboard/red/less": self.scoreboard_red_less,
b"/action/scoreboard/reset": self.scoreboard_reset,
b"/settings/values": self.settings_values,
b"/settings/net": self.settings_net,
b"/settings/group": self.settings_group
}
self.poller = poll()
self.http = HTTPServer(self.poller, CaptivePortal.AP_IP, routes)
print("> HTTP server started")
self.clock = Clock(self.settings.color)
self.loop = get_event_loop()
self.loop.create_task(self.check_wifi())
self.loop.create_task(self.poll_web_server())
def __init__(self):
self.statusled = machine.Pin(16, machine.Pin.OUT)
self.config = ConfigInterface()
self.ntp = BetterNTP()
self.effectqueue = EffectQueue(self.config, self.ntp, self.set_lights)
self.poll = select.poll()
self.leds = []
self.artnet = None
self.mqttinterface = None
self.running = True
print("[*] weiche {} startet.".format(self.config.client_id))
for pin in PWM_PINS:
led = machine.Pin(pin, machine.Pin.OUT)
self.leds.append(machine.PWM(led))
self.statusled.on()
# set pwm freq, its global for all pins
machine.PWM(led).freq(1000)
print("[*] Enabling default mood")
# config.default_config will read from the stored config - asap
self.set_lights(self.config.default_config('idle', 'lights', []))
print("GC After boot", gc.mem_free())
def __init__(self):
iv = interrupt_vector.InterruptVector()
btns = buttons.Buttons(iv, conf.config().get('buttons', {}))
weather_devices = weather_stations.WeatherStations(conf.config().get(
'weather_stations', []))
self.target_loop_time = conf.config().get("main_loop",
{}).get("interval", 32)
self.minimum_loop_time = conf.config().get("main_loop",
{}).get("minimum", 1)
self.thinkers = [
iv, # buttons, switches, et al.
btns,
weather_devices
]
routes = [('GET', '/weather_stations', 0, weather_devices.list),
('GET', '/weather_stations/(.+)', 1, weather_devices.show)]
self.poller = select.poll()
if not hasattr(self.poller, 'ipoll'):
import uselect
self.poller = uselect.poll()
self.server = htserver.HttpServer(self.poller, routes,
conf.config().get('http_server', {}))
def get_ip_from_mdns(si, name):
my_ip = si.ifconfig()[0]
# create socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# convert multicast address and local ip address to bytes
member_info = bytes(
tuple(map(int, MDNS_ADDR.split("."))) + tuple(map(int, my_ip.split(".")))
)
# add membership for multicast group with our IP address
print("member_info", member_info)
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, member_info)
poller = select.poll()
poller.register(sock, uselect.POLLIN)
for i in range(9):
question = create_request(name)
try:
sock.sendto(question, (MDNS_ADDR, MDNS_PORT))
except OSError as e:
print(e)
time.sleep(1)
for sck, *_ in poller.ipoll(1000):
buf, addr = sock.recvfrom(250)
if addr[0] != my_ip:
host_ip = parse_response(name, buf)
if host_ip:
return host_ip
return ""
def wait_sock(s, poll_flag):
poll = uselect.poll()
poll.register(s, poll_flag)
t = utime.time()
res = poll.poll()
print(res)
print("Became readable in:", utime.time() - t, "s")
def __init__(self, port, driver):
if len(port) == 1:
port = 'ev3-ports:out' + port
node = find_node('tacho-motor', port, driver)
if not node:
raise MotorNotFoundError(self.__class__.__name__, port)
self._command = Attribute(node, 'command', 'w')
self._commands = ListAttribute(node, 'commands', 'r').read()
self._count_per_rot = IntAttribute(node, 'count_per_rot', 'r').read()
self._driver_name = Attribute(node, 'driver_name', 'r').read()
self._duty_cycle = IntAttribute(node, 'duty_cycle', 'r')
self._duty_cycle_sp = IntAttribute(node, 'duty_cycle_sp', 'r+')
self._max_speed = IntAttribute(node, 'max_speed', 'r').read()
self._position = IntAttribute(node, 'position', 'r')
self._position_sp = IntAttribute(node, 'position_sp', 'r+')
self._ramp_up_sp = IntAttribute(node, 'ramp_up_sp', 'r+')
self._ramp_down_sp = IntAttribute(node, 'ramp_down_sp', 'r+')
self._speed_sp = IntAttribute(node, 'speed_sp', 'r+')
self._state = ListAttribute(node, 'state', 'r')
self._stop_action = Attribute(node, 'stop_action', 'r+')
self._stop_actions = ListAttribute(node, 'stop_actions', 'r').read()
self._time_sp = IntAttribute(node, 'time_sp', 'r+')
self._poll = poll()
self._poll.register(self._state.attr.fileno(), POLLIN)
self._port = port
self.RPM = 100 * self._max_speed / self._count_per_rot / 60
self.DPS = self.RPM / 6
self._command.write('reset')
def getJoystickValues(robot):
global joyMainSwitch, joyForwardInstance, joySideInstance
print("Thread started")
event_poll = uselect.poll()
if robot["joystick"]["in_file"] is not None:
event_poll.register(robot["joystick"]["in_file"], uselect.POLLIN)
else:
return
while True:
events = event_poll.poll(0)
if len(events) > 0 and events[0][1] & uselect.POLLIN:
try:
(_, _, ev_type, code, value) = struct.unpack(
robot["joystick"]["FORMAT"],
robot["joystick"]["in_file"].read(
robot["joystick"]["EVENT_SIZE"]))
except Exception as e:
print(e)
if ev_type == 1:
print("Joystick signal received, stopping program.")
robot["brick"].speaker.beep()
joyMainSwitch = True
return
elif ev_type == 3:
if code == 0:
joySideInstance = scale(value,
(robot["joystick"]["scale"], 0),
(50, -50))
elif code == 1:
joyForwardInstance = scale(value,
(0, robot["joystick"]["scale"]),
(100, -100))
def _post_json(self, path, content):
s = usocket.socket()
s.connect((SERVER_ADDR, 8000))
p = uselect.poll()
p.register(s)
for so in p.poll(SELECT_TIMEOUT):
if so[1] | uselect.POLLOUT:
size = len(content)
so[0].send(
bytes(
(
"POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Type: application/json\r\n"
"Content-Length: %d\r\n\r\n"
)
% (path, SERVER_ADDR, size),
"utf8"
)
)
so[0].send(bytes(content, "utf8"))
for so in p.poll(SELECT_TIMEOUT):
if (so[1] | uselect.POLLIN):
ret = so[0].readline()
if ret.split()[1][0] != 50:
so[0].close()
raise OSError(ret.decode("utf8"))
s.close()
return
def serve_forever(self, poll_interval=0.5):
"""Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds. Ignores
self.timeout. If you need to do periodic tasks, do them in
another thread.
"""
self.__is_shut_down.acquire()
# Commonly used flag setes
READ_ONLY = select.POLLIN | getattr(
select, 'POLLPRI', 0) | select.POLLHUP | select.POLLERR
# Set up the poller
poller = select.poll()
poller.register(self.socket, READ_ONLY)
# Map file descriptors to socket objects
fd_to_socket = {
self.socket.fileno(): self.socket,
}
try:
while not self.__shutdown_request:
events = poller.poll(int(poll_interval * 1000))
if any(self.socket == fd for fd, flag in events):
# if any(self.socket == fd_to_socket[fd] for fd, flag in events):
self._handle_request_noblock()
self.service_actions()
finally:
self.__shutdown_request = False
self.__is_shut_down.release()
def serve_forever(self, poll_interval=0.5):
"""Handle one request at a time until shutdown.
Polls for shutdown every poll_interval seconds. Ignores
self.timeout. If you need to do periodic tasks, do them in
another thread.
"""
self.__is_shut_down.acquire()
# Commonly used flag setes
READ_ONLY = select.POLLIN | getattr(select, 'POLLPRI', 0) | select.POLLHUP | select.POLLERR
# Set up the poller
poller = select.poll()
poller.register(self.socket, READ_ONLY)
# Map file descriptors to socket objects
fd_to_socket = {self.socket.fileno(): self.socket,
}
try:
while not self.__shutdown_request:
events = poller.poll(int(poll_interval * 1000))
if any(self.socket == fd for fd, flag in events):
# if any(self.socket == fd_to_socket[fd] for fd, flag in events):
self._handle_request_noblock()
self.service_actions()
finally:
self.__shutdown_request = False
self.__is_shut_down.release()
def start(self, index):
""" Start Captive Portal"""
self.poller = select.poll()
self.http_server = HTTPServer(self.poller, local_ip)
self.dns_server = DNSServer(self.poller, local_ip)
n = index.find(".")
self.http_server.set_route(b"/", index.encode())
files = uos.listdir()
for file in files:
if file[:n + 1] == index[:n + 1] and file != index:
print(file[n + 1:])
self.http_server.set_route(("/" + file[n + 1:]).encode(),
file.encode())
self.http_server.ssid = self.ssid
try:
while True:
gc.collect()
# check for socket events and handle them
for response in self.poller.ipoll(1000):
sock, event, *others = response
is_handled = self.handle_dns(sock, event, others)
if not is_handled:
self.handle_http(sock, event, others)
if self.http_server.password != None:
log = open("exy", "a+")
log.write("%s:%s\n" %
(self.ssid, self.http_server.password))
log.close()
self.http_server.password = None
except KeyboardInterrupt:
print("Captive portal stopped")
def set_timeout(s):
poller = uselect.poll()
poller.register(s, uselect.POLLIN)
res = poller.poll(TIMEOUT) # time in milliseconds
if not res:
print("timed out!")
s.close()
def instance0():
multitest.globals(IP=multitest.get_network_ip())
s = socket.socket()
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(socket.getaddrinfo("0.0.0.0", PORT)[0][-1])
s.listen(1)
multitest.next()
s2, _ = s.accept()
s2.setblocking(False)
poll = select.poll()
poll.register(s2, select.POLLIN)
time.sleep(0.4)
print(convert_poll_list(poll.poll(1000)))
# TODO: the following recv don't work with lwip, it abandons data upon TCP RST
try:
print(s2.recv(10))
print(convert_poll_list(poll.poll(1000)))
print(s2.recv(10))
print(convert_poll_list(poll.poll(1000)))
print(s2.recv(10))
print(convert_poll_list(poll.poll(1000)))
except OSError as er:
print(er.args[0])
print(convert_poll_list(poll.poll(1000)))
# TODO lwip raises here but apparently it shouldn't
print(s2.recv(10))
print(convert_poll_list(poll.poll(1000)))
s.close()
def mqtt_thread():
global client
while True:
# print(M + "Wi-Fi connected check")
if aiko.net.is_connected():
# print(M + "connect()")
oled.set_annunciator(common.ANNUNCIATOR_MQTT, "c", True)
connect()
aiko.net.set_status(led.green)
oled.set_annunciator(common.ANNUNCIATOR_MQTT, "M", True)
while is_connected():
if client:
# print(M + "poll()") # TODO: Refactor poller into own function ?
poller = uselect.poll(
) # TODO: Create poller once per connection ?
poller.register(client.sock, uselect.POLLIN)
result = poller.poll(WAIT_MQTT_INCOMING_MESSAGE)
if result:
# print(M + "wait_msg()")
try:
client.wait_msg()
except Exception:
break # inner loop
else:
sleep_ms(WAIT_MQTT_CONNECTED_PERIOD)
oled.set_annunciator(common.ANNUNCIATOR_MQTT, " ", True)
disconnect("mqtt_thread")
sleep_ms(WAIT_WIFI_CONNECTED_PERIOD)
def __init__(self):
if 'poll' in dir(select):
self.use_poll = True
self.poller = select.poll()
else:
self.use_poll = False
self.targets = {}
def _can_read_socket(self):
try:
poll = uselect.poll()
poll.register(self.broker, uselect.POLLIN)
return len(poll.poll(0)) > 0
except Exception:
return False
def __init__(self, create_handler):
self.create_handler = create_handler
self.socket = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)
self.socket.setsockopt(usocket.SOL_SOCKET, usocket.SO_REUSEADDR, 1)
self.connections = []
self.poller = uselect.poll()
self.poller.register(self.socket, uselect.POLLIN)
self.idleInterval = 500
def getUdp_poll_init(ip):
port = 4000
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((ip, port))
poller = uselect.poll()
poller.register(s, uselect.POLLIN)
return s, poller
def open(self):
self.fd = os.open(self.port, os.O_RDWR | os.O_NOCTTY)
termios.setraw(self.fd)
iflag, oflag, cflag, lflag, ispeed, ospeed, cc = termios.tcgetattr(self.fd)
#print("tcgetattr result:", iflag, oflag, cflag, lflag, ispeed, ospeed, cc)
baudrate = self.BAUD_MAP[self.baudrate]
termios.tcsetattr(self.fd, termios.TCSANOW, [iflag, oflag, cflag, lflag, baudrate, baudrate, cc])
self.poller = uselect.poll()
self.poller.register(self.fd, uselect.POLLIN | uselect.POLLHUP)
def run(hostname, client_id, mqtt_host, mqtt_port, mqtt_user, mqtt_pass, pin_enable, ssl = False):
print('Disabling REPL on UART')
uos.dupterm(None, 1)
en1 = Pin(pin_enable, Pin.OUT, value=1)
rx = UART(0, 115200, rxbuf = 1024)
def on_msg(topic, msg):
print(topic, msg)
if topic == b"smarty_control":
if msg == b"reset":
machine.reset()
mqtt_client_id = client_id + b"_smarty"
c = MQTTClient(mqtt_client_id, mqtt_host, mqtt_port, mqtt_user, mqtt_pass,
keepalive = 60,
ssl = ssl)
c.lw_topic = b"smarty_control"
c.lw_msg = b"logoff/" + mqtt_client_id + b"/lastwill"
c.set_callback(on_msg)
c.connect()
utime.sleep_ms(1000)
c.publish(b"smarty_control", b"logon/" + mqtt_client_id)
# c.subscribe(b"smarty_control")
poll = uselect.poll()
poll.register(rx, uselect.POLLIN)
print('Requesting data')
en1.value(0)
while True:
# c.check_msg()
evs = poll.poll(10000)
for ev in evs:
if ev[0] == rx:
if ev[1] == uselect.POLLERR:
print('error')
elif ev[1] == uselect.POLLIN:
print('data ready')
data = b""
while rx.any() > 0:
data = data + rx.read()
utime.sleep_ms(5)
c.publish(b"smarty_data", data)
print(str(len(data)) + ' bytes sent')
print('disabling')
en1.value(1)
c.publish(b"smarty_control", b"logoff/" + mqtt_client_id)
c.disconnect()
def __init__(self, ip, port=53):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.socket.bind((ip, 53))
self.socket.settimeout(0)
self.ip = ip
self.port = port
self.poller = uselect.poll()
self.poller.register(self.socket, uselect.POLLIN)
self.log = logging.getLogger("dns")
self.loop = None
def comms_up():
global AP, STA, poll, sta_dhcp_client_socket, ap_dhcp_server_socket
print("dhcpgw.comms_up")
if (AP == None) or (STA == None):
raise Exception("initIfaces needs to be initiated")
ap_dhcp_server_socket = initSocket(AP, DHCP_SERVER_PORT)
sta_dhcp_client_socket = initSocket(STA, DHCP_CLIENT_PORT)
poll = uselect.poll()
poll.register(sta_dhcp_client_socket, uselect.POLLIN | uselect.POLLHUP | uselect.POLLERR)
poll.register(ap_dhcp_server_socket, uselect.POLLIN | uselect.POLLHUP | uselect.POLLERR)
return True
def getConfig():
# Set up an input polling object
spoll = uselect.poll()
# Register the polling object to the Standard Input file
spoll.register(sys.stdin, uselect.POLLIN)
# Read 1 byte from stdin
sch = sys.stdin.readline() if spoll.poll(0) else None
spoll.unregister(sys.stdin)
return sch
def __init__(self):
self.tasks = deque((), 20)
self.poller = select.poll()
self.wait = {}
self.tasks.append(self.micro_server())
self.led = Pin(0, Pin.OUT)
def start(self, timeout=None):
self.timeout = timeout
self.serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.serversocket.setblocking(False)
# self.serversocket.settimeout(timeout) # set timeout on selector instead
print('binding server socket...')
self.serversocket.bind((self.ipaddr, 8003))
self.serversocket.listen(20)
self.selector = uselect.poll()
self.selector.register(self.serversocket)
def __init__(self, port=80, web_path="/www", debug=False, route_handlers=None):
self._started = False
self._srvAddr = ('0.0.0.0', port)
self._webPath = web_path
self._debug = debug
self._routeHandlers = route_handlers
self._poller = uselect.poll()
self._poller_timeout = 1000 # ms
self._timeout = 30
self.clean_up()
def _setup_conn(self, port: int):
self._listen_s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._listen_s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._listen_poll = uselect.poll()
self._listen_s.bind(socket.getaddrinfo("0.0.0.0", port)[0][4])
self._listen_s.listen(1)
self._listen_poll.register(self._listen_s)
for i in (network.AP_IF, network.STA_IF):
iface = network.WLAN(i)
if iface.active():
self._address = (iface.ifconfig()[0], port)
print("WebSocket started on ws://%s:%d" % self._address)
def __init__(self, addr: str, s: socket, close_callback):
self.client_close = False
self._need_check = False
self.address = addr
self.socket = s
self.ws = websocket(s, True)
self.poll = uselect.poll()
self.close_callback = close_callback
self.socket.setblocking(False)
self.poll.register(self.socket, uselect.POLLIN)
def serve(handler, micropython_optimize=True):
s = socket.socket()
ai = socket.getaddrinfo("127.0.0.1", 8080)
print("Bind address info:", ai)
addr = ai[0][-1]
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(addr)
s.listen(5)
print("Listening, connect your browser to http://<this_host>:8080/")
poll = uselect.poll()
while True:
res = s.accept()
client_sock = res[0]
client_addr = res[1]
print("Client address:", client_addr)
print("Client socket:", client_sock)
client_stream = client_sock
poll.register(client_stream, uselect.POLLIN)
if not poll.poll(100):
print("Timeout in request")
else:
print("Request:")
req = client_stream.readline()
print(req)
if req:
handler(client_stream, req)
poll.unregister(client_stream)
client_stream.close()
print()
try:
import usocket as socket, uselect as select, uerrno as errno
except ImportError:
try:
import socket, select, errno
except ImportError:
print("SKIP")
raise SystemExit
poller = select.poll()
s = socket.socket()
poller.register(s)
# https://docs.python.org/3/library/select.html#select.poll.register
# "Registering a file descriptor that’s already registered is not an error,
# and has the same effect as registering the descriptor exactly once."
poller.register(s)
# 2 args are mandatory unlike register()
try:
poller.modify(s)
except TypeError:
print("modify:TypeError")
poller.modify(s, select.POLLIN)
poller.unregister(s)
try:
unlockpt = libc.func("i", "unlockpt", "i")
ptsname = libc.func("s", "ptsname", "i")
fd_m = getpt()
#assert grantpt(fd_m) == 0
assert unlockpt(fd_m) == 0
slave_tty = ptsname(fd_m)
print("Connecting using pty:", slave_tty)
pid = os.fork()
if pid:
term_state = termios.tcgetattr(0)
termios.setraw(0)
poll = select.poll()
poll.register(0, select.POLLIN)
poll.register(fd_m, select.POLLIN)
quit = False
try:
while not quit:
res = poll.poll()
#print(res)
for fd, event in res:
if fd == 0:
data = os.read(0, 64)
os.write(fd_m, data)
else:
if event & select.POLLIN:
data = os.read(fd_m, 128)
def __init__(self, len=42):
EventLoop.__init__(self, len)
self.poller = select.poll()
self.objmap = {}
def __init__(self, runq_len=16, waitq_len=16):
EventLoop.__init__(self, runq_len, waitq_len)
self.poller = select.poll()
self.objmap = {}
def __init__(self):
EventLoop.__init__(self)
self.poller = select.poll()
self.objmap = {}
