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 stop():
global listen_s, client_s
uos.dupterm(None)
if client_s:
client_s.close()
if listen_s:
listen_s.close()
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 server_socket, last_client_socket
uos.dupterm(None)
if server_socket:
server_socket.close()
if last_client_socket:
last_client_socket.close()
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_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 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 _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
