def __init__(self): import machine self.disconnectWLAN() self.original_term = os.dupterm() os.dupterm(None) # disconnect the current serial port connection self.serial = machine.UART(0, 115200) self.poll = select.poll() self.poll.register(self.serial, select.POLLIN) self.write = self.serial.write
Add a Terminal widget, bind it to Virtual Pin V5. Run the App (green triangle in the upper right corner). Don't forget to change WIFI_SSID, WIFI_AUTH and BLYNK_AUTH ;) """ import BlynkLib from network import WLAN import os WIFI_SSID = 'YOUR_WIFI' WIFI_AUTH = (WLAN.WPA2,'YOUR_PASS') BLYNK_AUTH = 'YOUR_AUTH_TOKEN' # connect to WiFi wifi = WLAN(mode=WLAN.STA) wifi.connect(WIFI_SSID, auth=WIFI_AUTH) while not wifi.isconnected(): pass print('IP address:', wifi.ifconfig()[0]) # initialize Blynk blynk = BlynkLib.Blynk(BLYNK_AUTH) term = blynk.repl(5) os.dupterm(term) # start Blynk (this call should never return) blynk.run()
from machine import UART import time import os os.dupterm(None) repl_u = UART(0, baudrate=921600, timeout_chars=10) if 'FiPy' in os.uname().sysname: lte_u = UART(1, baudrate=921600, pins=('P20', 'P18', 'P19', 'P17'), timeout_chars=10) else: lte_u = UART(1, baudrate=921600, pins=('P5', 'P98', 'P7', 'P99'), timeout_chars=10) while True: if repl_u.any(): lte_u.write(repl_u.read()) if lte_u.any(): repl_u.write(lte_u.read()) time.sleep_ms(2)
def shutdown(self): """Shut down Terminal and UART0 interface.""" os.dupterm(None) self.deinit()
def destroy(self): os.dupterm(self.original_term)
# stop battery manangement if 112 in i2c.scan(): i2c.mem_write(0, 112, 0) # sync filesystem os.sync() time.sleep_ms(300) finally: # disable power pwr.off() time.sleep_ms(300) # will never reach here for led in leds: led.toggle() pyb.ExtInt(pyb.Pin('B1'), pyb.ExtInt.IRQ_FALLING, pyb.Pin.PULL_NONE, pwrcb) # configure usb from start if you want, # otherwise will be configured after PIN # pyb.usb_mode("VCP+MSC") # debug mode with USB and mounted storages from start # pyb.usb_mode("VCP") # debug mode with USB from start # disable at start pyb.usb_mode(None) os.dupterm(None, 0) os.dupterm(None, 1) # inject version and i2c to platform module import platform platform.version = version platform.i2c = i2c
def enable_console_on_serial(): """Enable REPL on USB serial connection""" global uart uart = UART(0, 115200) os.dupterm(uart)
def set_usb_mode(dev=False, usb=False): if simulator: print("dev:", dev, ", usb:", usb) # now get correct mode if usb and not dev: pyb.usb_mode("VCP") if not simulator: os.dupterm(None, 0) os.dupterm(None, 1) elif usb and dev: pyb.usb_mode("VCP+MSC") if not simulator: # duplicate repl to stlink # as usb is busy for communication os.dupterm(stlk, 0) os.dupterm(None, 1) elif not usb and dev: pyb.usb_mode("VCP+MSC") usb = pyb.USB_VCP() if not simulator: os.dupterm(None, 0) os.dupterm(usb, 1) else: pyb.usb_mode(None) if not simulator: os.dupterm(None, 0) os.dupterm(None, 1)
def start(): uart = BLEUART(name="upy-repl") stream = BLEUARTStream(uart) os.dupterm(stream)
Downloads, docs, tutorials: http://www.blynk.cc Sketch generator: http://examples.blynk.cc Blynk community: http://community.blynk.cc Social networks: http://www.fb.com/blynkapp http://twitter.com/blynk_app This example shows how to turn a Terminal widget into the REPL console. In your Blynk App project: Add a Terminal widget, bind it to Virtual Pin V5. Run the App (green triangle in the upper right corner). """ import BlynkLib import os BLYNK_AUTH = 'YourAuthToken' def hello(): print('Welcome!') # initialize Blynk blynk = BlynkLib.Blynk(BLYNK_AUTH) term = blynk.repl(5) os.dupterm(term) # start Blynk (this call should never return) blynk.run()
# REPL duplication on UART0 for serial connection from machine import UART import os usb = UART(0, 115200) os.dupterm(usb) # Disable heartbeat LED from pycom import heartbeat heartbeat(False) # Disable WiFi radio from pycom import wifi_on_boot wifi_on_boot(False)
def start(): ble = bluetooth.BLE() uart = BLEUART(ble, name="mpy-repl") stream = BLEUARTStream(uart) os.dupterm(stream)
def stop(): if self._repl_task: self._repl_task.cancel() self._repl_task = None self.mqclient = None os.dupterm(None)
def switch_ssl_repl(self): print('>>> ') self.wrepl = os.dupterm(self.cli_soc, 0)
# boot.py -- run on boot-up # can run arbitrary Python, but best to keep it minimal # Copy config.example.py to config.py and modify to your needs first! import config import machine #from machine import UART from os import dupterm uart = machine.UART(0, 115200) dupterm(uart) if machine.reset_cause() != machine.SOFT_RESET: from network import WLAN wifi = WLAN() wifi.mode(WLAN.STA) ssids = wifi.scan() found = False for net in ssids: print("Checking %s" % net.ssid) if net.ssid == config.HOME_SSID: print("Found %s!" % net.ssid) wifi.connect(config.HOME_SSID, auth=(WLAN.WPA, config.HOME_PASSWORD)) found = True break if not found: print("No eligible WiFi found.") wifi.mode(WLAN.AP)
def switch_wrepl(self): print('>>> ') self.cli_soc = os.dupterm(self.wrepl, 0)
# poweroff on button press pwrcb = lambda e: pwr.off() pyb.ExtInt(pyb.Pin('B1'), pyb.ExtInt.IRQ_FALLING, pyb.Pin.PULL_NONE, pwrcb) import platform # uncomment this lines if you want to override DEV_ENABLED # platform.DEV_ENABLED = True # platform.USB_ENABLED = True # set up usb mode if platform.USB_ENABLED and platform.DEV_ENABLED: pyb.usb_mode('CDC+MSC') elif platform.USB_ENABLED: pyb.usb_mode('CDC') elif platform.DEV_ENABLED: pyb.usb_mode('MSC') else: pyb.usb_mode(None) if platform.DEV_ENABLED: repl = pyb.UART('YB',115200) # redirect REPL to STLINK UART os.dupterm(repl,0) if platform.USB_ENABLED: # unconnect REPL from USB os.dupterm(None, 1) # uncomment this line to get interactive access over REPL # pyb.main('repl.py')
def configure_uart(): uart = machine.UART(0, 115200) os.dupterm(uart)
from machine import Pin, UART uart1 = UART(1, baudrate=115200, tx=17, rx=18) #uart1.init(115200, bits=8, parity=None, stop=1) def test(): import time for i in range(50): time.sleep(0.1) uart1.write('hello world!') print(uart1.read(uart1.any())) import os os.dupterm(uart1) print(os)
def enable_terminal(self): self.__terminal_enabled = True os.dupterm(self.__terminal)
# boot.py -- run on boot-up # can run arbitrary Python, but best to keep it minimal from machine import UART from network import WLAN from os import dupterm from time import sleep_ms # enable the UART on the USB-to-serial port uart = UART(0, baudrate=115200) # duplicate the terminal on the UART dupterm(uart) print('UART initialised!') import settings # login to the local network print('Initialising WLAN in station mode...', end=' ') wlan = WLAN(mode=WLAN.STA) print('done.\nConnecting to WiFi network...', end='') wlan.ifconfig(config='dhcp') AUTH = (WLAN.WPA2, settings.wifiKey) wlan.connect(ssid= settings.SSID, auth=AUTH) while not wlan.isconnected(): sleep_ms(500) print('.', end='') print(' done.\n') # print ip, mask, gateway, dns = wlan.ifconfig() print('IP address: ', ip) print('Netmask: ', mask)
def stop(self): os.dupterm(None) if self.client_s: self.client_s.close() if self.listen_s: self.listen_s.close()
import ili9341 from machine import Pin, SPI spi = SPI(1, baudrate=40000000, polarity=0, phase=0) display = ili9341.ILI9341(spi, cs=Pin(15), dc=Pin(16), rst=None, width=320, height=240) import ili9341_fb fb = ili9341_fb.Ili9341Framebuffer(display) import ps2 ps2.init(clock=5, data=0) from fbconsole import FBConsole console = FBConsole(fb) import os os.dupterm(console) def cls(): console.cls() def on(): console.on() def off(): console.off()
# can run arbitrary Python, but best to keep it minimal import os import machine from network import WLAN # disable LED matrix first latch = machine.Pin('GP13', mode=machine.Pin.OUT) latch.value(0) spi = machine.SPI(0, mode=machine.SPI.MASTER, bits=32, pins=('GP14', 'GP16', 'GP15')) spi.write(b'\x00\x00\x00\x00') latch.value(1) # repl on serial os.dupterm(machine.UART(0, 115200)) # now wifi wlan = WLAN() if machine.reset_cause() != machine.SOFT_RESET: wlan.init(WLAN.STA) wlan.ifconfig(config=('192.168.1.254', '255.255.255.0', '192.168.1.1', '192.168.1.1')) if not wlan.isconnected(): # change the line below to match your network ssid, security and password wlan.connect('XXX', auth=(WLAN.WPA2, 'XXX'), timeout=5000) while not wlan.isconnected(): machine.idle()
def __init__(self, aPort, aSpeed): # diasable terminal echo to uart os.dupterm(None, aPort) self.uart = machine.UART(aPort) self.uart.init(9600, timeout=1000)
from machine import UART import machine import os uart = UART(0, baudrate=115200) os.dupterm(uart) machine.main('main.py')
# (c) 2019-2020 Andreas Motl <*****@*****.**> # (c) 2019-2020 Jan Hoffmann <*****@*****.**> # (c) 2019-2020 Richard Pobering <*****@*****.**> # # License: GNU Affero General Public License, Version 3 # # Documentation: https://terkin.org # # Have fun! # Required to receive logging output when freezing the firmware. try: import os from machine import UART os.dupterm(UART(0, 115200)) except: pass # Global reference to Bootloader object. bootloader = None if __name__ == '__main__': import sys print('[boot.py] INFO: Python module search path is:', sys.path) # Extend module search path. print('[boot.py] INFO: Universal MicroPython Application Loader (umal)') from umal import MicroPythonBootloader
from machine import Pin import os import time mch = os.uname().machine if 'LaunchPad' in mch: uart_id_range = range(0, 2) uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]] elif 'WiPy' in mch: uart_id_range = range(0, 2) uart_pins = [[('GP12', 'GP13'), ('GP12', 'GP13', 'GP7', 'GP6')], [('GP16', 'GP17'), ('GP16', 'GP17', 'GP7', 'GP6')]] else: raise Exception('Board not supported!') # just in case we have the repl duplicated on any of the uarts os.dupterm(None) for uart_id in uart_id_range: uart = UART(uart_id, 38400) print(uart) uart.init(57600, 8, None, 1, pins=uart_pins[uart_id][0]) uart.init(baudrate=9600, stop=2, parity=UART.EVEN, pins=uart_pins[uart_id][1]) uart.init(baudrate=115200, parity=UART.ODD, stop=0, pins=uart_pins[uart_id][0]) uart = UART(baudrate=1000000) uart.sendbreak() uart = UART(baudrate=1000000) uart = UART() print(uart) uart = UART(baudrate=38400, pins=('GP12', 'GP13')) print(uart)
def enable_expansion_usb_uart(): uart = UART(0, 115200) os.dupterm(uart)
# Copyright 2021 FMR LLC <*****@*****.**> # SPDX-License-Identifer: MIT # boot.py -- run on boot-up # can run arbitrary Python, but best to keep it minimal import machine import pyb pyb.country('US') # ISO 3166-1 Alpha-2 code, eg US, GB, DE, AU #pyb.main('main.py') # main script to run after this one #pyb.usb_mode('VCP+MSC') # act as a serial and a storage device #pyb.usb_mode('VCP+HID') # act as a serial device and a mouse # move this to boot.py import os, pyb stlk = pyb.UART("YB", 9600) os.dupterm(stlk, 0) os.dupterm(None, 1) # end
# boot.py -- run on boot-up # can run arbitrary Python, but best to keep it minimal # setup UART on USB import micropython micropython.alloc_emergency_exception_buf(100) from machine import UART import os uart = UART(0, baudrate=115200) os.dupterm(uart) print ('UART initialised') #uart.irq(trigger=UART.RX_ANY, wake=machine.IDLE) from machine import Pin from machine import Timer led_out = Pin('GP16', mode=Pin.OUT) tim = Timer(1, mode=Timer.PERIODIC) tim_a = tim.channel(Timer.A, freq=5) # The slowest frequency the timer can run at is 5Hz # so we divide the frequency down to toggle the LED # BUT the callback function doesn't appear to have been developed # Worth trying again as it is now included in the documentation tim_a.irq(handler=lambda t:led_out.toggle(), trigger=Timer.TIMEOUT) # Toggle LED on Timer interrupt #btn_in = Pin('GP17', mode=Pin.IN, pull=Pin.PULL_UP) # Connect to my WiFi
# REPL duplication on UART0 for serial connection from machine import UART import os uart0 = UART(0, 115200) os.dupterm(uart0) # Disable heartbeat LED from pycom import heartbeat heartbeat(False) # Disable WiFi radio from pycom import wifi_on_boot wifi_on_boot(False)