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 = {}