def install(self): micropython.alloc_emergency_exception_buf(100) self.screen.running = True uos.dupterm(self) self.poller.init(period=10, mode=Timer.ONE_SHOT, callback=self.schedule_poll_ref)
def stop(self): if self.sw_client: self.sw_client.close() uos.dupterm_notify(self.sw_client.socket) # deactivate dupterm uos.dupterm(None) self.sw_client = None
def stop(): global server_socket, last_client_socket uos.dupterm(None) if server_socket: server_socket.close() if last_client_socket: last_client_socket.close()
def main(): try: uos.dupterm(None, 1) # disable REPL on UART(0) uart = machine.UART(0) uart.init(115200, timeout=3000, bits=8, parity=None, stop=1, rxbuf=128) while True: if uart.any(): hostMsg = uart.readline() if hostMsg is not None: strMsg = hostMsg.decode().strip('\r\n') if '\x03' in strMsg: raise Exception('Cto repl') elif strMsg == '\x00': raise Exception('STOP code') else: for i in range(len(strMsg)): led.off() time.sleep(0.05) led.on() time.sleep(0.1) uart.write(strMsg+'\n') except Exception as err: uart.write('Exception was raised') led.on() finally: uos.dupterm(machine.UART(0, 115200), 1)
def stop(): global listen_s, client_s uos.dupterm(None) if client_s: client_s.close() if listen_s: listen_s.close()
def accept_conn(listen_sock): global client_s, key, cert, websslrepl cl, remote_addr = listen_sock.accept() prev = uos.dupterm(None) uos.dupterm(prev) if prev: print("\nConcurrent WebREPL connection from", remote_addr, "rejected") cl.close() return print("\nWebREPL connection from:", remote_addr) client_s = cl if websslrepl: if hasattr(uos, 'dupterm_notify'): cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify) cl = ssl.wrap_socket(cl, server_side=True, key=key, cert=cert) wss_helper.server_handshake(cl, ssl=True) else: websocket_helper.server_handshake(cl) ws = uwebsocket.websocket(cl, True) ws = _webrepl._webrepl(ws) cl.setblocking(False) # notify REPL on socket incoming data (ESP32/ESP8266-only) if not websslrepl: if hasattr(uos, 'dupterm_notify'): cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify) uos.dupterm(ws)
def gps_deinit(serial, logger, message, indicator_led): """ De-initialises GPS serial bus, initialises terminal output and prints message to the terminal :param serial: GPS serial bus :type serial: UART object :param logger: status logger :type logger: LoggerFactory object :param message: message to display after terminal output was enabled :type message: str :param indicator_led: Timer for led indicator :type indicator_led: Timer object """ # turn off GPS via turning off transistor GPS_transistor.value(0) # de-initialise GPS serial serial.deinit() # re-initialise terminal out terminal = UART(0, 115200) uos.dupterm(terminal) indicator_led.cancel() # print any important messages concerning the gps if message is not False: logger.info(message) logger.info("Turning GPS off - Terminal output enabled")
def run(): lcd = GpioLcd(rs_pin=Pin(16), enable_pin=Pin(5), d4_pin=Pin(14), d5_pin=Pin(12), d6_pin=Pin(13), d7_pin=Pin(15), num_lines=2, num_columns=16) lcd.clear() new_term = None while True: # dupterm allows us to use TX/RX for the sds011 read, then restore TX/RX to the web REPL. old_term = uos.dupterm(new_term, 1) # Read the two measurements from the SDS011. readings = sds011.read(1) new_term = uos.dupterm(old_term, 1) if readings is not None: pm25, pm10 = readings lcd.move_to(0, 0) message = "PM2.5 %3d ug/m3\nPM10 %4d ug/m3" % (pm25, pm10) lcd.putstr(message) print(message) sleep(1)
def gps_init(logger): """ De-initialises terminal output, and opens serial for the GPS :param logger: status logger :type logger: LoggerFactory object :return: serial, chrono, inidcator_led :rtype: UART object, Chrono object, Alarm object """ logger.info( "Turning GPS on - Terminal output is disabled until GPS finishes") uos.dupterm(None) # deinit terminal output on serial bus 0 # turn GPS module on via transistor GPS_transistor.value(1) # set up serial input for gps signals serial = UART(0, baudrate=9600, pins=('P22', 'P21')) # Tx, Rx chrono = Timer.Chrono() chrono.start() indicator_led = Timer.Alarm(blink_led, s=1.6, arg=(0x000055, 0.4, False), periodic=True) return serial, chrono, indicator_led
def crepl(self, msg): self.rec_msg = self.decrypt_hex(msg) self.buff_out = io.StringIO(500) try: self.wrepl = uos.dupterm(self.buff_out, 0) self.resp_msg = eval(self.rec_msg) # self.buff_crepl = uos.dupterm(self.wrepl, 0) if self.resp_msg is None: self.message_out = self.buff_out.getvalue() self.buff_crepl = uos.dupterm(self.wrepl, 0) if self.message_out == '': gc.collect() return None else: return self.encrypt_hex(self.message_out) else: self.buff_crepl = uos.dupterm(self.wrepl, 0) return self.encrypt_hex(str(self.resp_msg)) except Exception as e: try: # self.buff_crepl = uos.dupterm(self.wrepl, 0) exec(self.rec_msg, self.gbls) self.message_out = self.buff_out.getvalue() self.buff_crepl = uos.dupterm(self.wrepl, 0) if self.message_out == '': gc.collect() return None else: return self.encrypt_hex(self.message_out) except Exception as e: self.buff_crepl = uos.dupterm(self.wrepl, 0) sys.print_exception(e, self.err_buff) self.resp_msg = self.err_buff.getvalue() self.err_buff.seek(0) return self.encrypt_hex(self.resp_msg)
def stop(): global listen_s, client_s uos.dupterm(None) for ls in listen_s: ls.close() for cl in client_s: cl.close()
def watcher(self, data): d = self.wrapper.get_buffer() if d != "": self.ins_text(lv.LABEL_POS.LAST, d) if not self.running: uos.dupterm(None) self.task.set_repeat_count(0) if self.done_cb: self.done_cb()
def wlan_disconnect(self): if not self._sta.active(): return if not self._ap.isconnected(): import uos prev = uos.dupterm(None) uos.dupterm(prev) assert prev is None, 'Active webrepl on this connection. Use webrepl.stop() first.' self._sta.active(False)
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 stop_client(t=None): # allow random parameter for being scheduled global _crypt_socket, _flush_timer uos.dupterm(None) if _crypt_socket: _crypt_socket.close() _crypt_socket = None print("\nnetrepl: Connection closed.\n") if _flush_timer: _flush_timer.deinit()
def accept_ws(listen_sock): global client_s cl, remote_addr = listen_sock.accept() client_s.append(cl) websocket_helper.server_handshake(cl) ws = websocket.websocket(cl, True) cl.setblocking(False) cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify) uos.dupterm(ws)
def measure_start(): uos.dupterm(None, 1) uart = UART(0) uart.init(115200) step = 0 while step < 100: print(uart.readline()) step += 1 utime.sleep_ms(200)
def handleSerialLine(inputLine): global running if inputLine == "exit": uart.write("stopping: \n\r") uos.dupterm(uart, 1) running = False return uart.write(inputLine) uart.write("\n\rKO\n\r")
def execute(cmd): mystdout = uio.StringIO() err = '' uos.dupterm(mystdout, 1) try: exec(cmd) except Exception as e: err = get_traceback(e) uos.dupterm(None) return (mystdout.getvalue() + err)
def accept_conn(listen_sock): global client_s cl, remote_addr = listen_sock.accept() client_s = cl websocket_helper.server_handshake(cl) ws = websocket.websocket(cl, True) cl.setblocking(False) # notify REPL on socket incoming data cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify) uos.dupterm(ws) print("WebREPL connected\n>>> ", end="")
def manage(*args): global client_s try: if client_s and client_s.fileno() == -1: client_s = None uos.dupterm(None) except: pass try: accept_conn(listen_s) except: pass
def handleMQTTclient(): global client global running try: reply = client.check_msg() if reply is not None: client.publish(topic_pub, "{\"msg\":\"OK\"}") print("Reply:" + reply) except OSError as e: uos.dupterm(uart, 1) print("Exception in main loop ", e) running = False
def run(self, code, done_cb=None): self.done_cb = done_cb # start wrapper to catch script output self.wrapper = self.Wrapper() uos.dupterm(self.wrapper) # run script in background self.running = True _thread.start_new_thread(self.execute, (code, )) # start task to read text from wrapper and display it in label self.task = lv.task_create(self.watcher, 100, lv.TASK_PRIO.MID, None)
def mainLoop(): try: uos.dupterm(None, 1) # disable REPL on UART(0) control = Controller(btnGap=200, uart=US100UART(UART(0))) while True: control.monitorButton() control.update() control.show() utime.sleep_ms(200) except Exception as e: print(e) finally: uos.dupterm(UART(0, 115200), 1)
def accept_conn(listen_sock): global client_s cl, remote_addr = listen_sock.accept() prev = uos.dupterm(None) uos.dupterm(prev) if prev: print("\nConcurrent WebREPL connection from", remote_addr, "rejected") cl.close() return print("\nWebREPL connection from:", remote_addr) client_s = cl websocket_helper.server_handshake(cl) ws = websocket.websocket(cl, True) ws = _webrepl._webrepl(ws) cl.setblocking(False) uos.dupterm(ws)
def accept_conn(listen_sock): global client_s cl, remote_addr = listen_sock.accept() if uos.dupterm(): print("\nConcurrent WebREPL connection from", remote_addr, "rejected") cl.close() return print("\nWebREPL connection from:", remote_addr) client_s = cl websocket_helper.server_handshake(cl) ws = websocket.websocket(cl, True) ws = _webrepl._webrepl(ws) cl.setblocking(False) # notify REPL on socket incoming data cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify) uos.dupterm(ws)
def accept_telnet_connect(telnet_server): global last_client_socket if last_client_socket: uos.dupterm(None) last_client_socket.close() last_client_socket,remote_addr=telnet_server.accept() #print("Telnet connection from:",remote_addr) log_connection(remote_addr) last_client_socket.setblocking(False) last_client_socket.setsockopt(socket.SOL_SOCKET,20,uos.dupterm_notify) last_client_socket.sendall(bytes([255,252,34])) last_client_socket.sendall(bytes([255,251,1])) uos.dupterm(TelnetWrapper(last_client_socket)) from main import welcome welcome() del welcome
def accept_conn(listen_sock): global client_s cl, remote_addr = listen_sock.accept() prev = uos.dupterm(None) uos.dupterm(prev) if prev: print("\nConcurrent telnet connection from", remote_addr, "rejected") cl.close() return print("\ntelnet connection from:", remote_addr) client_s = cl cl.setblocking(False) # notify REPL on socket incoming data (ESP32/ESP8266-only) if hasattr(uos, "dupterm_notify"): cl.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify) uos.dupterm(TelnetWrapper(cl))
def accept_telnet_connect(telnet_server): global last_client_socket if last_client_socket: # close any previous clients uos.dupterm(None) last_client_socket.close() last_client_socket, remote_addr = telnet_server.accept() print("Telnet connection from:", remote_addr) last_client_socket.setblocking(False) last_client_socket.setsockopt(socket.SOL_SOCKET, 20, uos.dupterm_notify) last_client_socket.sendall(bytes([255, 252, 34])) # dont allow line mode last_client_socket.sendall(bytes([255, 251, 1])) # turn off local echo uos.dupterm(TelnetWrapper(last_client_socket))
def gps_init(logger): logger.info("Turning GPS on - Terminal output is disabled until GPS finishes") uos.dupterm(None) # deinit terminal output on serial bus 0 # turn GPS module on via transistor GPS_transistor.value(1) # set up serial input for gps signals serial = UART(0, baudrate=9600, pins=('P22', 'P21')) # Tx, Rx chrono = Timer.Chrono() chrono.start() indicator_led = Timer.Alarm(blink_led, s=1.6, arg=(0x000055, 0.4, False), periodic=True) return serial, chrono, indicator_led
def _initialize_console(self): """ Initialize the console redirection for the event loop """ from .console import RedisStream self.console = RedisStream( redis=self.redis_connection, redis_key=self.console_key, heartbeat_key=self.heartbeat_key ) if sys.platform not in [ 'WiPy', 'linux' ]: # Dupterm is currently broken on wipy and unix from uos import dupterm dupterm(self.console) self.clear_keys() self.console.clear() if sys.platform.lower() in ['wipy']: import network self.redis_connection.execute_command('SET', self.console_key, network.WLAN().ifconfig()[0])
def setup(): check_bootsec() print("Performing initial setup") wifi() uos.VfsFat.mkfs(bdev) vfs = uos.VfsFat(bdev) uos.mount(vfs, '/') with open("boot.py", "w") as f: f.write("""\ # This file is executed on every boot (including wake-boot from deepsleep) #import esp #esp.osdebug(None) import uos, machine uos.dupterm(machine.UART(0, 115200), 1) import gc #import webrepl #webrepl.start() gc.collect() """) return vfs