circuitpython/main.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1171 lines
41 KiB
C
Raw Normal View History

/*
* This file is part of the MicroPython project, http://micropython.org/
*
* The MIT License (MIT)
*
* Copyright (c) 2016-2017 Scott Shawcroft for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdint.h>
#include <string.h>
#include "extmod/vfs.h"
#include "extmod/vfs_fat.h"
2018-05-03 23:43:02 -04:00
#include "genhdr/mpversion.h"
#include "py/nlr.h"
#include "py/compile.h"
#include "py/frozenmod.h"
#include "py/mphal.h"
#include "py/runtime.h"
#include "py/repl.h"
#include "py/gc.h"
#include "py/stackctrl.h"
Merge tag 'v1.17' into merge-1.17 F-strings, new machine.I2S class, ESP32-C3 support and LEGO_HUB_NO6 board This release of MicroPython adds support for f-strings (PEP-498), with a few limitations compared to normal Python. F-strings are essentially syntactic sugar for "".format() and make formatting strings a lot more convenient. Other improvements to the core runtime include pretty printing OSError when it has two arguments (an errno code and a string), scheduling of KeyboardInterrupt on the main thread, and support for a single argument to the optimised form of StopIteration. In the machine module a new I2S class has been added, with support for esp32 and stm32 ports. This provides a consistent API for transmit and receive of audio data in blocking, non-blocking and asyncio-based operation. Also, the json module has support for the "separators" argument in the dump and dumps functions, and framebuf now includes a way to blit between frame buffers of different formats using a palette. A new, portable machine.bitstream function is also added which can output a stream of bits with configurable timing, and is used as the basis for driving WS2812 LEDs in a common way across ports. There has been some restructuring of the repository directory layout, with all third-party code now in the lib/ directory. And a new top-level directory shared/ has been added with first-party code that was previously in lib/ moved there. The docs have seen further improvement with enhancements and additions to the rp2 parts, as well as a new quick reference for the zephyr port. The terms master/slave have been replaced with controller/peripheral, mainly relating to I2C and SPI usage. And u-module references have been replaced with just the module name without the u-prefix to help clear up the intended usage of modules in MicroPython. For the esp8266 and esp32 ports, hidden networks are now included in WLAN scan results. On the esp32 the RMT class is enhanced with idle_level and write_pulses modes. There is initial support for ESP32-C3 chips with GENERIC_C3 and GENERIC_C3_USB boards. The javascript port has had its Makefile and garbage collector implementation reworked so it compiles and runs with latest the Emscripten using asyncify. The mimxrt port sees the addition of hardware I2C and SPI support, as well as some additional methods to the machine module. There is also support for Hyperflash chips. The nrf port now has full VFS storage support, enables source-line on traceback, and has .mpy features consistent with other ports. For the rp2 port there is now more configurability for boards, and more boards added. The stm32 port has a new LEGO_HUB_NO6 board definition with detailed information how to get this LEGO Hub running stock MicroPython. There is also now support to change the CPU frequency on STM32WB MCUs. And USBD_xxx descriptor options have been renamed to MICROPY_HW_USB_xxx. Thanks to everyone who contributed to this release: Amir Gonnen, Andrew Scheller, Bryan Tong Minh, Chris Wilson, Damien George, Daniel Mizyrycki, David Lechner, David P, Fernando, finefoot, Frank Pilhofer, Glenn Ruben Bakke, iabdalkader, Jeff Epler, Jim Mussared, Jonathan Hogg, Josh Klar, Josh Lloyd, Julia Hathaway, Krzysztof Adamski, Matúš Olekšák, Michael Weiss, Michel Bouwmans, Mike Causer, Mike Teachman, Ned Konz, NitiKaur, oclyke, Patrick Van Oosterwijck, Peter Hinch, Peter Züger, Philipp Ebensberger, robert-hh, Roberto Colistete Jr, Sashkoiv, Seon Rozenblum, Tobias Thyrrestrup, Tom McDermott, Will Sowerbutts, Yonatan Goldschmidt. What follows is a detailed list of changes, generated from the git commit history, and organised into sections. Main components =============== all: - fix signed shifts and NULL access errors from -fsanitize=undefined - update to point to files in new shared/ directory py core: - mpstate: make exceptions thread-local - mpstate: schedule KeyboardInterrupt on main thread - mperrno: add MP_ECANCELED error code - makeqstrdefs.py: don't include .h files explicitly in preprocessing - mark unused arguments from bytecode decoding macros - objexcept: pretty print OSError also when it has 2 arguments - makeversionhdr: add --tags arg to git describe - vm: simplify handling of MP_OBJ_STOP_ITERATION in yield-from opcode - objexcept: make mp_obj_exception_get_value support subclassed excs - support single argument to optimised MP_OBJ_STOP_ITERATION - introduce and use mp_raise_type_arg helper - modsys: optimise sys.exit for code size by using exception helpers - objexcept: make mp_obj_new_exception_arg1 inline - obj: fix formatting of comment for mp_obj_is_integer - emitnative: reuse need_reg_all func in need_stack_settled - emitnative: ensure stack settling is safe mid-branch - runtime: fix bool unary op for subclasses of native types - builtinimport: fix condition for including do_execute_raw_code() - mkrules: automatically build mpy-cross if it doesn't exist - implement partial PEP-498 (f-string) support - lexer: clear fstring_args vstr on lexer free - mkrules.mk: do submodule sync in "make submodules" extmod: - btstack: add missing call to mp_bluetooth_hci_uart_deinit - btstack: check that BLE is active before performing operations - uasyncio: get addr and bind server socket before creating task - axtls-include: add axtls_os_port.h to customise axTLS - update for move of crypto-algorithms, re1.5, uzlib to lib - moduselect: conditionally compile select() - nimble: fix leak in l2cap_send if send-while-stalled - btstack/btstack.mk: use -Wno-implicit-fallthrough, not =0 - utime: always invoke mp_hal_delay_ms when >= to 0ms - modbluetooth: clamp MTU values to 32->UINT16_MAX - nimble: allow modbluetooth binding to hook "sent HCI packet" - nimble: add "memory stalling" mechanism for l2cap_send - uasyncio: in open_connection use address info in socket creation - modujson: add support for dump/dumps separators keyword-argument - modlwip: fix close and clean up of UDP and raw sockets - modbluetooth: add send_update arg to gatts_write - add machine.bitstream - modframebuf: enable blit between different formats via a palette lib: - tinyusb: update to version 0.10.1 - pico-sdk: update to version 1.2.0 - utils/stdout_helpers: make mp_hal_stdout_tx_strn_cooked efficient - axtls: switch to repo at micropython/axtls - axtls: update to latest axtls 2.1.5 wih additional commits - re1.5: move re1.5 code from extmod to lib - uzlib: move uzlib code from extmod to lib - crypto-algorithms: move crypto-algorithms code from extmod to lib - update README's based on contents of these dirs drivers: - neopixel: add common machine.bitstream-based neopixel module - neopixel: optimize fill() for speed - neopixel: reduce code size of driver - cyw43: fix cyw43_deinit so it can be called many times in a row - cyw43: make wifi join fail if interface is not active mpy-cross: - disable stack check when building with Emscripten Support components ================== docs: - library: document new esp32.RMT features and fix wait_done - library: warn that ustruct doesn't handle spaces in format strings - esp8266/tutorial: change flash mode from dio to dout - replace master/slave with controller/peripheral in I2C and SPI - rp2: enhance quickref and change image to Pico pinout - rp2: update general section to give a brief technical overview - library/utime.rst: clarify behaviour and precision of sleep ms/us - library/uasyncio.rst: document stream readexactly() method - library/machine.I2S.rst: fix use of sd pin in examples - zephyr: add quick reference for the Zephyr port - library/zephyr: add libraries specific to the Zephyr port - templates: add unix and zephyr quickref links to top-index - rename ufoo.rst to foo.rst - replace ufoo with foo in all docs - library/index.rst: clarify module naming and purpose - library/builtins.rst: add module title - library/network.rst: simplify socket import - add docs for machine.bitstream and neopixel module - library: fix usage of :term: for frozen module reference - esp8266: use monospace for software tools - reference: mention that slicing a memoryview causes allocation examples: no changes specific to this component/port tests: - extmod: make uasyncio_heaplock test more deterministic - cpydiff/modules_struct_whitespace_in_format: run black - extmod/ujson: add tests for dump/dumps separators argument - run-multitests.py: add broadcast and wait facility - multi_bluetooth/ble_subscribe.py: add test for subscription - extmod/vfs_fat_finaliser.py: ensure alloc at never-used GC blocks - basics: split f-string debug printing to separate file with .exp - pybnative: make while.py test run on boards without pyb.delay tools: - autobuild: add scripts to build release firmware - remove obsolete build-stm-latest.sh script - ci.sh: run apt-get update in ci_powerpc_setup - makemanifest.py: allow passing flags to mpy-tool.py - autobuild: add mimxrt port to build scripts for nightly builds - pyboard.py: add cmd-line option to make soft reset configurable - mpremote: swap order of PID and VID in connect-list output - ci.sh: build unix dev variant as part of macOS CI - ci.sh: build GENERIC_C3 board as part of esp32 CI - autobuild: use separate IDF version to build newer esp32 SoCs - autobuild: add FeatherS2 and TinyS2 to esp32 auto builds - mpremote: add seek whence for mounted files - mpremote: raise OSError on unsupported RemoteFile.seek - autobuild: add the MIMXRT1050_EVKB board to the daily builds - ci.sh: add mpy-cross build to nrf port - codeformat.py: include ports/nrf/modules/nrf in code formatting - gen-cpydiff.py: don't rename foo to ufoo in diff output - autobuild: add auto build for Silicognition wESP32 - mpremote: fix connect-list in case VID/PID are None - mpremote: add "devs" shortcut for "connect list" - mpremote: remove support for pyb.USB_VCP in/out specialisation - autobuild: don't use "-B" for make, it's already a fresh build - pyboard.py: move --no-exclusive/--soft-reset out of mutex group - pyboard.py: make --no-follow use same variable as --follow - pyboard.py: add --exclusive to match --no-exclusive - pyboard.py: make --no-soft-reset consistent with other args - uncrustify: force 1 newline at end of file - mpremote: bump version to 0.0.6 CI: - workflows: add workflow to build and test javascript port - workflows: switch from Coveralls to Codecov - workflows: switch from lcov to gcov - workflows: add workflow to build and test unix dev variant The ports ========= all ports: - use common mp_hal_stdout_tx_strn_cooked instead of custom one - update for move of crypto-algorithms, uzlib to lib - rename USBD_VID/PID config macros to MICROPY_HW_USB_VID/PID bare-arm port: no changes specific to this component/port cc3200 port: no changes specific to this component/port esp8266 port: - add __len__ to NeoPixel driver to support iterating - Makefile: add more libm files to build - include hidden networks in WLAN.scan results - replace esp.neopixel with machine.bitstream - remove dead code for end_ticks in machine_bitstream esp32 port: - boards/sdkconfig.base: disable MEMPROT_FEATURE to alloc from IRAM - add __len__ to NeoPixel driver to support iterating - main: allow MICROPY_DIR to be overridden - esp32_rmt: fix RMT looping in newer IDF versions - esp32_rmt: enhance RMT with idle_level and write_pulses modes - add new machine.I2S class for I2S protocol support - machine_spi: calculate actual attained baudrate - machine_hw_spi: use a 2 item SPI queue for long transfers - machine_dac: add MICROPY_PY_MACHINE_DAC option, enable by default - machine_i2s: add MICROPY_PY_MACHINE_I2S option, enable by default - fix use of mp_int_t, size_t and uintptr_t - add initial support for ESP32C3 SoCs - boards/GENERIC_C3: add generic C3-based board - modmachine: release the GIL in machine.idle() - mphalport: always yield at least once in delay_ms - machine_uart: add flow kw-arg to enable hardware flow control - boards: add Silicognition wESP32 board configuration - mpconfigport.h: enable reverse and inplace special methods - include hidden networks in WLAN.scan results - makeimg.py: get bootloader and partition offset from sdkconfig - enable MICROPY_PY_FSTRINGS by default - machine_hw_spi: release GIL during transfers - machine_pin: make check for non-output pins respect chip variant - replace esp.neopixel with machine.bitstream - remove dead code for end_ticks in machine_bitstream - boards: add GENERIC_C3_USB board with USB serial/JTAG support javascript port: - rework Makefile and GC so it works with latest Emscripten - Makefile: suppress compiler errors from array bounds - Makefile: change variable to EXPORTED_RUNTIME_METHODS mimxrt port: - move calc_weekday helper function to timeutils - machine_spi: add the SPI class to the machine module - moduos: seed the PRNG on boot using the TRNG - boards: set vfs partition start to 1 MBbyte - main: skip running main.py if boot.py failed - main: extend the information returned by help() - mimxrt_flash: remove commented-out code - modmachine: add a few minor methods to the machine module - machine_led: use mp_raise_msg_varg helper - machine_i2c: add hardware-based machine.I2C to machine module - add support for Hyperflash chips - boards: add support for the MIMXRT1050_EVKB board - machine_pin: implement ioctl for Pin minimal port: - Makefile: add support for building with user C modules nrf port: - modules: replace master/slave with controller/peripheral in SPI - boards/common.ld: calculate unused flash region - modules/nrf: add new nrf module with flash block device - drivers: add support for using flash block device with SoftDevice - mpconfigport.h: expose nrf module when MICROPY_PY_NRF is set - README: update README.md to reflect internal file systems - mpconfigport.h: tune FAT FS configuration - Makefile: add _fs_size linker script override from make - modules/uos: allow a board to configure MICROPY_VFS_FAT/LFS1/LFS2 - mpconfigport.h: enable MICROPY_PY_IO_FILEIO when an FS is enabled - qstrdefsport.h: add entries for in-built FS mount points - main: add auto mount and auto format hook for internal flash FS - boards: enable needed features for FAT/LFS1/LFS2 - facilitate use of freeze manifest - boards: set FROZEN_MANIFEST blank when SD present on nrf51 targets - modules/scripts: add file system formatting script - Makefile: set default manifest file for all targets - mphalport: add dummy function for mp_hal_time_ns() - boards: enable MICROPY_VFS_LFS2 for all target boards - modules/uos: add ilistdir to uos module - modules/nrf: add function to enable/disable DCDC - enable source line on tracebacks - set .mpy features consistent with documentation and other ports pic16bit port: no changes specific to this component/port powerpc port: no changes specific to this component/port qemu-arm port: no changes specific to this component/port rp2 port: - use 0=Monday datetime convention in RTC - machine_rtc: in RTC.datetime, compute weekday automatically - CMakeLists.txt: suppress compiler errors for pico-sdk and tinyusb - tusb_config.h: set CFG_TUD_CDC_EP_BUFSIZE to 256 - machine_uart: add hardware flow control support - machine_uart: allow overriding default machine UART pins - machine_i2c: allow boards to configure I2C pins using new macros - machine_spi: allow boards to configure SPI pins using new macros - machine_uart: fix poll ioctl to also check hardware FIFO - machine_uart: fix read when FIFO has chars but ringbuf doesn't - tusb_port: allow boards to configure USB VID and PID - boards/ADAFRUIT_FEATHER_RP2040: configure custom VID/PID - boards/ADAFRUIT_FEATHER_RP2040: configure I2C/SPI default pins - boards/SPARKFUN_PROMICRO: configure UART/I2C/SPI default pins - boards/SPARKFUN_THINGPLUS: configure I2C/SPI default pins - boards: add Adafruit ItsyBitsy RP2040 - boards: add Adafruit QT Py RP2040 - boards: add Pimoroni Pico LiPo 4MB - boards: add Pimoroni Pico LiPo 16MB - boards: add Pimoroni Tiny 2040 - CMakeLists.txt: allow a board's cmake to set the manifest path - enable MICROPY_PY_FSTRINGS by default - Makefile: add "submodules" target, to match other ports - rp2_flash: disable IRQs while calling flash_erase/program - CMakeLists.txt: add option to enable double tap reset to bootrom - mpconfigport.h: allow boards to add root pointers samd port: - add support for building with user C modules stm32 port: - softtimer: add soft_timer_reinsert() helper function - mpbthciport: change from systick to soft-timer for BT scheduling - provide a custom BTstack runloop that integrates with soft timer - usb: make irq's default trigger enable all events - boardctrl: skip running main.py if boot.py had an error - sdio: fix undefined reference to DMA stream on H7 - dma: add DMAMUX configuration for H7 to fix dma_nohal_init - main: call mp_deinit() at end of main - adc: allow using ADC12 and ADC3 for H7 - adc: define the ADC instance used for internal channels - adc: simplify and generalise how pin_adcX table is defined - add new machine.I2S class for I2S protocol support - boards/NUCLEO_F446RE: fix I2C1 pin assignment to match datasheet - replace master/slave with controller/peripheral in I2C and SPI - systick: always POLL_HOOK when delaying for milliseconds - sdram: make SDRAM test cache aware, and optional failure with msg - boards/NUCLEO_F446RE: enable CAN bus support - boards: add support for SparkFun STM32 MicroMod Processor board - uart: fix LPUART1 baudrate set/get - uart: support low baudrates on LPUART1 - boards/STM32F429DISC: set correct UART2 pins and add UART3/6 - boards/NUCLEO_F439ZI: add board definition for NUCLEO_F439ZI - boards/LEGO_HUB_NO6: add board definition for LEGO_HUB_NO6 - Makefile: update to only pull in used Bluetooth library - README.md: update supported MCUs, and submodule and mboot use - usbd_desc: rename USBD_xxx descriptor opts to MICROPY_HW_USB_xxx - usbd_cdc_interface: rename USBD_CDC_xx opts to MICROPY_HW_USB_xx - powerctrl: support changing frequency on WB MCUs - boards/NUCLEO_H743ZI2: add modified version of NUCLEO_H743ZI - mbedtls: fix compile warning about uninitialized val - enable MICROPY_PY_FSTRINGS by default - add implementation of machine.bitstream - Makefile: allow GIT_SUBMODULES and LIBS to be extended - stm32_it: support TIM17 IRQs on WB MCUs - disable computed goto on constrained boards - storage: make extended-block-device more configurable - boards/LEGO_HUB_NO6: change SPI flash storage to use hardware SPI - boards/LEGO_HUB_NO6: skip first 1MiB of SPI flash for storage - boards/LEGO_HUB_NO6: add make commands to backup/restore firmware teensy port: no changes specific to this component/port unix port: - modffi: add option to lock GC in callback, and cfun access - Makefile: add back LIB_SRC_C to list of object files - variants: enable help and help("modules") on standard and dev - Makefile: disable error compression on arm-linux-gnueabi-gcc windows port: - Makefile: add .exe extension to executables name - appveyor: update to VS 2017 and use Python 3.8 for build/test zephyr port: - machine_spi: add support for hardware SPI
2021-10-14 15:38:41 -04:00
#include "shared/readline/readline.h"
#include "shared/runtime/pyexec.h"
#include "background.h"
#include "mpconfigboard.h"
#include "supervisor/background_callback.h"
#include "supervisor/board.h"
#include "supervisor/cpu.h"
#include "supervisor/filesystem.h"
#include "supervisor/memory.h"
#include "supervisor/port.h"
#include "supervisor/serial.h"
2022-03-11 13:29:20 -05:00
#include "supervisor/shared/reload.h"
#include "supervisor/shared/safe_mode.h"
2018-07-25 08:06:30 -04:00
#include "supervisor/shared/stack.h"
#include "supervisor/shared/status_leds.h"
#include "supervisor/shared/tick.h"
#include "supervisor/shared/traceback.h"
2022-05-27 15:59:54 -04:00
#include "supervisor/shared/translate/translate.h"
2020-11-19 17:47:12 -05:00
#include "supervisor/shared/workflow.h"
2020-09-30 01:45:02 -04:00
#include "supervisor/usb.h"
#include "supervisor/workflow.h"
2022-04-18 10:09:36 -04:00
#include "supervisor/shared/external_flash/external_flash.h"
2020-09-30 01:45:02 -04:00
#include "shared-bindings/microcontroller/__init__.h"
2020-11-22 19:10:09 -05:00
#include "shared-bindings/microcontroller/Processor.h"
#include "shared-bindings/supervisor/Runtime.h"
2020-11-19 15:43:39 -05:00
#if CIRCUITPY_ALARM
#include "shared-bindings/alarm/__init__.h"
#endif
2021-07-29 23:06:24 -04:00
#if CIRCUITPY_ATEXIT
#include "shared-module/atexit/__init__.h"
#endif
2021-02-15 20:06:18 -05:00
#if CIRCUITPY_BLEIO
#include "shared-bindings/_bleio/__init__.h"
2021-06-25 17:58:32 -04:00
#include "supervisor/shared/bluetooth/bluetooth.h"
2021-02-15 20:06:18 -05:00
#endif
#if CIRCUITPY_BOARD
#include "shared-module/board/__init__.h"
#endif
#if CIRCUITPY_CANIO
#include "common-hal/canio/CAN.h"
#endif
2019-07-22 12:58:28 -04:00
#if CIRCUITPY_DISPLAYIO
#include "shared-module/displayio/__init__.h"
#endif
2021-06-14 20:54:43 -04:00
#if CIRCUITPY_KEYPAD
#include "shared-module/keypad/__init__.h"
#endif
2020-07-16 22:01:43 -04:00
#if CIRCUITPY_MEMORYMONITOR
#include "shared-module/memorymonitor/__init__.h"
#endif
#if CIRCUITPY_SOCKETPOOL
#include "shared-bindings/socketpool/__init__.h"
#endif
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
#include "supervisor/shared/status_bar.h"
#endif
2021-04-27 14:37:36 -04:00
#if CIRCUITPY_USB_HID
#include "shared-module/usb_hid/__init__.h"
#endif
2020-12-07 11:06:33 -05:00
#if CIRCUITPY_WIFI
#include "shared-bindings/wifi/__init__.h"
#endif
#if CIRCUITPY_BOOT_COUNTER
#include "shared-bindings/nvm/ByteArray.h"
2021-09-10 15:43:04 -04:00
uint8_t value_out = 0;
#endif
2023-02-15 15:27:37 -05:00
#if MICROPY_ENABLE_PYSTACK && CIRCUITPY_OS_GETENV
#include "shared-module/os/__init__.h"
#endif
static void reset_devices(void) {
2021-11-08 09:21:43 -05:00
#if CIRCUITPY_BLEIO_HCI
bleio_reset();
2021-11-08 09:21:43 -05:00
#endif
}
2023-02-16 16:10:11 -05:00
#if MICROPY_ENABLE_PYSTACK
2023-02-17 10:40:55 -05:00
STATIC supervisor_allocation *allocate_pystack(safe_mode_t safe_mode) {
2023-02-15 15:27:37 -05:00
mp_int_t pystack_size = CIRCUITPY_PYSTACK_SIZE;
2023-02-16 16:10:11 -05:00
#if CIRCUITPY_OS_GETENV && CIRCUITPY_SETTABLE_PYSTACK
2023-02-15 15:27:37 -05:00
// Fetch value if exists from settings.toml
2023-02-15 14:54:53 -05:00
// Leaves size to build default on any failure
2023-02-17 10:40:55 -05:00
if (safe_mode == SAFE_MODE_NONE || safe_mode == SAFE_MODE_USER) {
(void)common_hal_os_getenv_int("CIRCUITPY_PYSTACK_SIZE", &pystack_size);
// Check if value is valid
pystack_size = pystack_size - pystack_size % sizeof(size_t); // Round down to multiple of 4.
2023-02-18 16:56:06 -05:00
if ((pystack_size < 384) || (pystack_size > 900000)) {
2023-02-17 10:40:55 -05:00
serial_write_compressed(translate("\nInvalid CIRCUITPY_PYSTACK_SIZE\n\n\r"));
pystack_size = CIRCUITPY_PYSTACK_SIZE; // Reset
}
2023-02-15 14:54:53 -05:00
}
#endif
2023-02-16 16:10:11 -05:00
supervisor_allocation *pystack = allocate_memory(pystack_size, false, false);
if (pystack == NULL) {
serial_write_compressed(translate("\nInvalid CIRCUITPY_PYSTACK_SIZE\n\n\r"));
pystack = allocate_memory(CIRCUITPY_PYSTACK_SIZE, false, false);
2023-02-15 16:15:21 -05:00
}
2023-02-16 16:10:11 -05:00
return pystack;
2023-02-15 14:54:53 -05:00
}
2023-02-16 16:10:11 -05:00
#endif
2023-02-15 14:54:53 -05:00
2023-02-16 16:10:11 -05:00
STATIC void start_mp(supervisor_allocation *heap, supervisor_allocation *pystack) {
supervisor_workflow_reset();
// Stack limit should be less than real stack size, so we have a chance
// to recover from limit hit. (Limit is measured in bytes.)
mp_stack_ctrl_init();
if (stack_get_bottom() != NULL) {
mp_stack_set_limit(stack_get_length() - 1024);
}
2021-11-08 09:21:43 -05:00
#if MICROPY_MAX_STACK_USAGE
// _ezero (same as _ebss) is an int, so start 4 bytes above it.
if (stack_get_bottom() != NULL) {
mp_stack_set_bottom(stack_get_bottom());
mp_stack_fill_with_sentinel();
}
2021-11-08 09:21:43 -05:00
#endif
// Sync the file systems in case any used RAM from the GC to cache. As soon
// as we re-init the GC all bets are off on the cache.
filesystem_flush();
// Clear the readline history. It references the heap we're about to destroy.
readline_init0();
#if MICROPY_ENABLE_PYSTACK
2023-02-16 16:10:11 -05:00
mp_pystack_init(pystack->ptr, pystack->ptr + get_allocation_length(pystack) / sizeof(size_t));
#endif
#if MICROPY_ENABLE_GC
2023-02-16 16:10:11 -05:00
gc_init(heap->ptr, heap->ptr + get_allocation_length(heap) / 4);
#endif
mp_init();
mp_obj_list_init((mp_obj_list_t *)mp_sys_path, 0);
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_));
#if MICROPY_MODULE_FROZEN
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__dot_frozen));
#endif
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_lib));
mp_obj_list_init((mp_obj_list_t *)mp_sys_argv, 0);
}
STATIC void stop_mp(void) {
#if MICROPY_VFS
mp_vfs_mount_t *vfs = MP_STATE_VM(vfs_mount_table);
// Unmount all heap allocated vfs mounts.
while (gc_nbytes(vfs) > 0) {
vfs = vfs->next;
}
MP_STATE_VM(vfs_mount_table) = vfs;
MP_STATE_VM(vfs_cur) = vfs;
#endif
background_callback_reset();
#if CIRCUITPY_USB
2021-02-04 22:15:32 -05:00
usb_background();
#endif
gc_deinit();
}
2022-08-02 20:01:41 -04:00
STATIC const char *_current_executing_filename = NULL;
STATIC pyexec_result_t _exec_result = {0, MP_OBJ_NULL, 0};
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
2022-08-02 20:01:41 -04:00
void supervisor_execution_status(void) {
mp_obj_exception_t *exception = MP_OBJ_TO_PTR(_exec_result.exception);
if (_current_executing_filename != NULL) {
2022-08-02 20:01:41 -04:00
serial_write(_current_executing_filename);
} else if ((_exec_result.return_code & PYEXEC_EXCEPTION) != 0 &&
_exec_result.exception_line > 0 &&
exception != NULL) {
2022-08-09 13:42:20 -04:00
mp_printf(&mp_plat_print, "%d@%s %q", _exec_result.exception_line, _exec_result.exception_filename, exception->base.type->name);
} else {
serial_write_compressed(translate("Done"));
2022-08-02 20:01:41 -04:00
}
}
2022-08-28 21:55:13 -04:00
#endif
2022-08-02 20:01:41 -04:00
2018-05-03 23:43:02 -04:00
// Look for the first file that exists in the list of filenames, using mp_import_stat().
// Return its index. If no file found, return -1.
STATIC const char *first_existing_file_in_list(const char *const *filenames, size_t n_filenames) {
for (size_t i = 0; i < n_filenames; i++) {
mp_import_stat_t stat = mp_import_stat(filenames[i]);
2018-05-03 23:43:02 -04:00
if (stat == MP_IMPORT_STAT_FILE) {
2018-05-04 08:28:05 -04:00
return filenames[i];
}
}
2018-05-04 08:28:05 -04:00
return NULL;
2018-05-03 23:43:02 -04:00
}
STATIC bool maybe_run_list(const char *const *filenames, size_t n_filenames) {
2022-08-02 20:01:41 -04:00
_exec_result.return_code = 0;
_exec_result.exception = MP_OBJ_NULL;
_exec_result.exception_line = 0;
_current_executing_filename = first_existing_file_in_list(filenames, n_filenames);
2022-08-02 20:01:41 -04:00
if (_current_executing_filename == NULL) {
2018-05-03 23:43:02 -04:00
return false;
}
2022-08-02 20:01:41 -04:00
mp_hal_stdout_tx_str(_current_executing_filename);
2021-08-23 21:00:34 -04:00
serial_write_compressed(translate(" output:\n"));
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_update();
#endif
2022-08-02 20:01:41 -04:00
pyexec_file(_current_executing_filename, &_exec_result);
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_ATEXIT
2022-08-02 20:01:41 -04:00
shared_module_atexit_execute(&_exec_result);
#endif
2022-08-28 21:55:13 -04:00
_current_executing_filename = NULL;
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_update();
#endif
2018-05-03 23:43:02 -04:00
return true;
}
STATIC void count_strn(void *data, const char *str, size_t len) {
2021-11-08 09:21:43 -05:00
*(size_t *)data += len;
}
2023-02-16 16:10:11 -05:00
STATIC void cleanup_after_vm(supervisor_allocation *heap, supervisor_allocation *pystack, mp_obj_t exception) {
// Get the traceback of any exception from this run off the heap.
// MP_OBJ_SENTINEL means "this run does not contribute to traceback storage, don't touch it"
// MP_OBJ_NULL (=0) means "this run completed successfully, clear any stored traceback"
if (exception != MP_OBJ_SENTINEL) {
free_memory(prev_traceback_allocation);
// ReloadException is exempt from traceback printing in pyexec_file(), so treat it as "no
// traceback" here too.
if (exception && exception != MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_reload_exception))) {
size_t traceback_len = 0;
mp_print_t print_count = {&traceback_len, count_strn};
mp_obj_print_exception(&print_count, exception);
prev_traceback_allocation = allocate_memory(align32_size(traceback_len + 1), false, true);
// Empirically, this never fails in practice - even when the heap is totally filled up
// with single-block-sized objects referenced by a root pointer, exiting the VM frees
// up several hundred bytes, sufficient for the traceback (which tends to be shortened
// because there wasn't memory for the full one). There may be convoluted ways of
// making it fail, but at this point I believe they are not worth spending code on.
if (prev_traceback_allocation != NULL) {
vstr_t vstr;
2021-11-08 09:21:43 -05:00
vstr_init_fixed_buf(&vstr, traceback_len, (char *)prev_traceback_allocation->ptr);
mp_print_t print = {&vstr, (mp_print_strn_t)vstr_add_strn};
mp_obj_print_exception(&print, exception);
2021-11-08 09:21:43 -05:00
((char *)prev_traceback_allocation->ptr)[traceback_len] = '\0';
}
2021-11-08 09:21:43 -05:00
} else {
prev_traceback_allocation = NULL;
}
}
// Reset port-independent devices, like CIRCUITPY_BLEIO_HCI.
reset_devices();
2021-07-29 23:06:24 -04:00
#if CIRCUITPY_ATEXIT
atexit_reset();
#endif
2020-12-09 10:52:18 -05:00
// Turn off the display and flush the filesystem before the heap disappears.
#if CIRCUITPY_DISPLAYIO
reset_displays();
#endif
2021-06-14 20:54:43 -04:00
2020-07-16 22:01:43 -04:00
#if CIRCUITPY_MEMORYMONITOR
memorymonitor_reset();
#endif
2021-06-14 20:54:43 -04:00
// Disable user related BLE state that uses the micropython heap.
#if CIRCUITPY_BLEIO
bleio_user_reset();
#endif
2020-09-16 13:18:55 -04:00
#if CIRCUITPY_CANIO
common_hal_canio_reset();
#endif
2021-06-14 20:54:43 -04:00
#if CIRCUITPY_KEYPAD
keypad_reset();
#endif
// Close user-initiated sockets.
#if CIRCUITPY_SOCKETPOOL
socketpool_user_reset();
#endif
// Turn off user initiated WiFi connections.
#if CIRCUITPY_WIFI
wifi_user_reset();
#endif
// reset_board_buses() first because it may release pins from the never_reset state, so that
// reset_port() can reset them.
2019-07-24 14:21:27 -04:00
#if CIRCUITPY_BOARD
reset_board_buses();
2019-07-24 14:21:27 -04:00
#endif
reset_port();
reset_board();
// Free the heap last because other modules may reference heap memory and need to shut down.
filesystem_flush();
stop_mp();
2023-02-16 16:10:11 -05:00
free_memory(heap);
2023-02-15 17:45:41 -05:00
#if MICROPY_ENABLE_PYSTACK
2023-02-16 16:10:11 -05:00
free_memory(pystack);
2023-02-15 17:45:41 -05:00
#endif
supervisor_move_memory();
// Let the workflows know we've reset in case they want to restart.
supervisor_workflow_reset();
}
STATIC void print_code_py_status_message(safe_mode_t safe_mode) {
2020-10-07 14:23:08 -04:00
if (autoreload_is_enabled()) {
serial_write_compressed(
translate("Auto-reload is on. Simply save files over USB to run them or enter REPL to disable.\n"));
2020-10-07 14:23:08 -04:00
} else {
serial_write_compressed(translate("Auto-reload is off.\n"));
}
2023-02-11 23:50:20 -05:00
if (safe_mode != SAFE_MODE_NONE) {
serial_write_compressed(translate("Running in safe mode! Not running saved code.\n"));
2020-10-07 14:23:08 -04:00
}
}
2023-02-15 14:54:53 -05:00
STATIC bool run_code_py(safe_mode_t safe_mode, bool *simulate_reset) {
bool serial_connected_at_start = serial_connected();
bool printed_safe_mode_message = false;
2019-10-20 23:50:12 -04:00
#if CIRCUITPY_AUTORELOAD_DELAY_MS > 0
if (serial_connected_at_start) {
serial_write("\r\n");
print_code_py_status_message(safe_mode);
print_safe_mode_message(safe_mode);
printed_safe_mode_message = true;
}
#endif
bool skip_repl = false;
2021-06-20 16:57:20 -04:00
bool skip_wait = false;
bool found_main = false;
uint8_t next_code_options = 0;
// Collects stickiness bits that apply in the current situation.
uint8_t next_code_stickiness_situation = SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET;
// Do the filesystem flush check before reload in case another write comes
// in while we're doing the flush.
2023-02-11 23:50:20 -05:00
if (safe_mode == SAFE_MODE_NONE) {
stack_resize();
filesystem_flush();
}
2023-02-11 23:50:20 -05:00
if (safe_mode == SAFE_MODE_NONE && !autoreload_pending()) {
static const char *const supported_filenames[] = {
"code.txt", "code.py", "main.py", "main.txt"
};
#if CIRCUITPY_FULL_BUILD
static const char *const double_extension_filenames[] = {
"code.txt.py", "code.py.txt", "code.txt.txt","code.py.py",
"main.txt.py", "main.py.txt", "main.txt.txt","main.py.py"
};
#endif
2023-02-16 17:52:13 -05:00
supervisor_allocation *pystack = NULL;
2023-02-16 16:10:11 -05:00
#if MICROPY_ENABLE_PYSTACK
2023-02-17 10:40:55 -05:00
pystack = allocate_pystack(safe_mode);
2023-02-16 16:10:11 -05:00
#endif
supervisor_allocation *heap = allocate_remaining_memory();
start_mp(heap, pystack);
2020-12-11 08:10:26 -05:00
2021-04-28 23:48:26 -04:00
#if CIRCUITPY_USB
usb_setup_with_vm();
#endif
// Check if a different run file has been allocated
if (next_code_allocation) {
next_code_info_t *info = ((next_code_info_t *)next_code_allocation->ptr);
info->options &= ~SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET;
next_code_options = info->options;
if (info->filename[0] != '\0') {
// This is where the user's python code is actually executed:
const char *const filenames[] = { info->filename };
found_main = maybe_run_list(filenames, MP_ARRAY_SIZE(filenames));
if (!found_main) {
serial_write(info->filename);
serial_write_compressed(translate(" not found.\n"));
}
}
}
// Otherwise, default to the standard list of filenames
if (!found_main) {
// This is where the user's python code is actually executed:
found_main = maybe_run_list(supported_filenames, MP_ARRAY_SIZE(supported_filenames));
// If that didn't work, double check the extensions
#if CIRCUITPY_FULL_BUILD
2021-11-08 09:21:43 -05:00
if (!found_main) {
found_main = maybe_run_list(double_extension_filenames, MP_ARRAY_SIZE(double_extension_filenames));
if (found_main) {
serial_write_compressed(translate("WARNING: Your code filename has two extensions\n"));
}
}
#else
2021-11-08 09:21:43 -05:00
(void)found_main;
#endif
}
2020-12-01 20:01:14 -05:00
// Print done before resetting everything so that we get the message over
// BLE before it is reset and we have a delay before reconnect.
2022-08-02 20:01:41 -04:00
if ((_exec_result.return_code & PYEXEC_RELOAD) && supervisor_get_run_reason() == RUN_REASON_AUTO_RELOAD) {
serial_write_compressed(translate("\nCode stopped by auto-reload. Reloading soon.\n"));
} else {
serial_write_compressed(translate("\nCode done running.\n"));
}
2022-03-11 13:29:20 -05:00
// Finished executing python code. Cleanup includes filesystem flush and a board reset.
2023-02-16 16:10:11 -05:00
cleanup_after_vm(heap, pystack, _exec_result.exception);
_exec_result.exception = NULL;
// If a new next code file was set, that is a reason to keep it (obviously). Stuff this into
// the options because it can be treated like any other reason-for-stickiness bit. The
// source is different though: it comes from the options that will apply to the next run,
// while the rest of next_code_options is what applied to this run.
if (next_code_allocation != NULL &&
(((next_code_info_t *)next_code_allocation->ptr)->options & SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET)) {
next_code_options |= SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET;
}
2022-08-02 20:01:41 -04:00
if (_exec_result.return_code & PYEXEC_RELOAD) {
next_code_stickiness_situation |= SUPERVISOR_NEXT_CODE_OPT_STICKY_ON_RELOAD;
2022-03-17 13:36:45 -04:00
// Reload immediately unless the reload is due to autoreload. In that
// case, we wait below to see if any other writes occur.
if (supervisor_get_run_reason() != RUN_REASON_AUTO_RELOAD) {
skip_repl = true;
skip_wait = true;
}
2022-08-02 20:01:41 -04:00
} else if (_exec_result.return_code == 0) {
next_code_stickiness_situation |= SUPERVISOR_NEXT_CODE_OPT_STICKY_ON_SUCCESS;
if (next_code_options & SUPERVISOR_NEXT_CODE_OPT_RELOAD_ON_SUCCESS) {
skip_repl = true;
2021-06-20 16:57:20 -04:00
skip_wait = true;
}
} else {
next_code_stickiness_situation |= SUPERVISOR_NEXT_CODE_OPT_STICKY_ON_ERROR;
2021-06-20 17:20:47 -04:00
// Deep sleep cannot be skipped
// TODO: settings in deep sleep should persist, using a new sleep memory API
if (next_code_options & SUPERVISOR_NEXT_CODE_OPT_RELOAD_ON_ERROR
2022-08-02 20:01:41 -04:00
&& !(_exec_result.return_code & PYEXEC_DEEP_SLEEP)) {
skip_repl = true;
2021-06-20 16:57:20 -04:00
skip_wait = true;
}
}
2022-08-02 20:01:41 -04:00
if (_exec_result.return_code & PYEXEC_FORCED_EXIT) {
skip_repl = false;
2021-06-20 16:57:20 -04:00
skip_wait = true;
}
}
// Program has finished running.
2021-01-20 21:40:53 -05:00
bool printed_press_any_key = false;
2019-08-21 16:18:43 -04:00
#if CIRCUITPY_DISPLAYIO
size_t time_to_epaper_refresh = 1;
#endif
// Setup LED blinks.
#if CIRCUITPY_STATUS_LED
uint32_t color;
uint8_t blink_count;
bool led_active = false;
#if CIRCUITPY_ALARM
2022-08-02 20:01:41 -04:00
if (_exec_result.return_code & PYEXEC_DEEP_SLEEP) {
color = BLACK;
blink_count = 0;
} else
#endif
2022-08-02 20:01:41 -04:00
if (_exec_result.return_code != PYEXEC_EXCEPTION) {
2023-02-11 23:50:20 -05:00
if (safe_mode == SAFE_MODE_NONE) {
color = ALL_DONE;
blink_count = ALL_DONE_BLINKS;
} else {
color = SAFE_MODE;
blink_count = SAFE_MODE_BLINKS;
}
} else {
color = EXCEPTION;
blink_count = EXCEPTION_BLINKS;
}
size_t pattern_start = supervisor_ticks_ms32();
size_t single_blink_time = (OFF_ON_RATIO + 1) * BLINK_TIME_MS;
size_t blink_time = single_blink_time * blink_count;
size_t total_time = blink_time + LED_SLEEP_TIME_MS;
2019-08-21 16:18:43 -04:00
#endif
// This loop is waits after code completes. It waits for fake sleeps to
// finish, user input or autoreloads.
#if CIRCUITPY_ALARM
2021-03-27 13:16:12 -04:00
bool fake_sleeping = false;
#endif
2021-06-20 16:57:20 -04:00
while (!skip_wait) {
RUN_BACKGROUND_TASKS;
2022-03-11 13:29:20 -05:00
// If a reload was requested by the supervisor or autoreload, return.
if (autoreload_ready()) {
next_code_stickiness_situation |= SUPERVISOR_NEXT_CODE_OPT_STICKY_ON_RELOAD;
// Should the STICKY_ON_SUCCESS and STICKY_ON_ERROR bits be cleared in
// next_code_stickiness_situation? I can see arguments either way, but I'm deciding
// "no" for now, mainly because it's a bit less code. At this point, we have both a
// success or error and a reload, so let's have both of the respective options take
// effect (in OR combination).
skip_repl = true;
// We're kicking off the autoreload process so reset now. If any
// other reloads trigger after this, then we'll want another wait
// period.
autoreload_reset();
break;
}
// If interrupted by keyboard, return
if (serial_connected() && serial_bytes_available() && !autoreload_pending()) {
// Skip REPL if reload was requested.
skip_repl = serial_read() == CHAR_CTRL_D;
if (skip_repl) {
2020-11-22 19:10:09 -05:00
supervisor_set_run_reason(RUN_REASON_REPL_RELOAD);
}
break;
}
// Check for a deep sleep alarm and restart the VM. This can happen if
// an alarm alerts faster than our USB delay or if we pretended to deep
// sleep.
#if CIRCUITPY_ALARM
2021-03-27 13:16:12 -04:00
if (fake_sleeping && common_hal_alarm_woken_from_sleep()) {
serial_write_compressed(translate("Woken up by alarm.\n"));
supervisor_set_run_reason(RUN_REASON_STARTUP);
skip_repl = true;
break;
}
#endif
// If messages haven't been printed yet, print them
if (!printed_press_any_key && serial_connected() && !autoreload_pending()) {
if (!serial_connected_at_start) {
2020-10-07 14:23:08 -04:00
print_code_py_status_message(safe_mode);
}
if (!printed_safe_mode_message) {
print_safe_mode_message(safe_mode);
printed_safe_mode_message = true;
}
serial_write("\r\n");
serial_write_compressed(translate("Press any key to enter the REPL. Use CTRL-D to reload.\n"));
2021-01-20 21:40:53 -05:00
printed_press_any_key = true;
}
2021-01-20 21:40:53 -05:00
if (!serial_connected()) {
serial_connected_at_start = false;
2021-01-20 21:40:53 -05:00
printed_press_any_key = false;
}
// Sleep until our next interrupt.
#if CIRCUITPY_ALARM
2022-08-02 20:01:41 -04:00
if (_exec_result.return_code & PYEXEC_DEEP_SLEEP) {
const bool awoke_from_true_deep_sleep =
common_hal_mcu_processor_get_reset_reason() == RESET_REASON_DEEP_SLEEP_ALARM;
if (fake_sleeping) {
// This waits until a pretend deep sleep alarm occurs. They are set
// during common_hal_alarm_set_deep_sleep_alarms. On some platforms
// it may also return due to another interrupt, that's why we check
// for deep sleep alarms above. If it wasn't a deep sleep alarm,
// then we'll idle here again.
common_hal_alarm_pretending_deep_sleep();
}
// The first time we go into a deep sleep, make sure we have been awake long enough
// for USB to connect (enumeration delay), or for the BLE workflow to start.
// We wait CIRCUITPY_WORKFLOW_CONNECTION_SLEEP_DELAY seconds after a restart.
// But if we woke up from a real deep sleep, don't wait for connection. The user will need to
// do a hard reset to get out of the real deep sleep.
else if (awoke_from_true_deep_sleep ||
port_get_raw_ticks(NULL) > CIRCUITPY_WORKFLOW_CONNECTION_SLEEP_DELAY * 1024) {
// OK to start sleeping, real or fake.
#if CIRCUITPY_DISPLAYIO
common_hal_displayio_release_displays();
#endif
status_led_deinit();
deinit_rxtx_leds();
board_deinit();
// Continue with true deep sleep even if workflow is available.
if (awoke_from_true_deep_sleep || !supervisor_workflow_active()) {
// Enter true deep sleep. When we wake up we'll be back at the
// top of main(), not in this loop.
common_hal_alarm_enter_deep_sleep();
// Does not return.
} else {
serial_write_compressed(
translate("Pretending to deep sleep until alarm, CTRL-C or file write.\n"));
fake_sleeping = true;
}
} else {
// Loop while checking the time. We can't idle because we don't want to override a
// time alarm set for the deep sleep.
}
} else
#endif
{
// Refresh the ePaper display if we have one. That way it'll show an error message.
#if CIRCUITPY_DISPLAYIO
if (time_to_epaper_refresh > 0) {
time_to_epaper_refresh = maybe_refresh_epaperdisplay();
}
#if !CIRCUITPY_STATUS_LED
2021-11-08 09:21:43 -05:00
port_interrupt_after_ticks(time_to_epaper_refresh);
#endif
#endif
#if CIRCUITPY_STATUS_LED
uint32_t tick_diff = supervisor_ticks_ms32() - pattern_start;
// By default, don't sleep.
size_t time_to_next_change = 0;
if (tick_diff < blink_time) {
uint32_t blink_diff = tick_diff % (single_blink_time);
if (blink_diff >= BLINK_TIME_MS) {
if (led_active) {
new_status_color(BLACK);
status_led_deinit();
led_active = false;
}
time_to_next_change = single_blink_time - blink_diff;
} else {
if (!led_active) {
status_led_init();
new_status_color(color);
led_active = true;
}
time_to_next_change = BLINK_TIME_MS - blink_diff;
}
} else if (tick_diff > total_time) {
pattern_start = supervisor_ticks_ms32();
} else {
if (led_active) {
new_status_color(BLACK);
status_led_deinit();
led_active = false;
}
time_to_next_change = total_time - tick_diff;
}
#if CIRCUITPY_DISPLAYIO
if (time_to_epaper_refresh > 0 && time_to_next_change > 0) {
time_to_next_change = MIN(time_to_next_change, time_to_epaper_refresh);
}
#endif
// time_to_next_change is in ms and ticks are slightly shorter so
// we'll undersleep just a little. It shouldn't matter.
port_interrupt_after_ticks(time_to_next_change);
2021-03-27 14:08:44 -04:00
#endif
port_idle_until_interrupt();
}
}
// Done waiting, start the board back up.
// We delay resetting BLE until after the wait in case we're transferring
// more files over.
#if CIRCUITPY_BLEIO
bleio_reset();
#endif
// free code allocation if unused
if ((next_code_options & next_code_stickiness_situation) == 0) {
free_memory(next_code_allocation);
next_code_allocation = NULL;
}
#if CIRCUITPY_STATUS_LED
if (led_active) {
new_status_color(BLACK);
status_led_deinit();
}
#endif
#if CIRCUITPY_ALARM
if (fake_sleeping) {
board_init();
2021-12-21 21:48:36 -05:00
// Pretend that the next run is the first run, as if we were reset.
*simulate_reset = true;
}
#endif
return skip_repl;
}
vstr_t *boot_output;
2023-02-11 23:50:20 -05:00
#if CIRCUITPY_SAFEMODE_PY
STATIC void __attribute__ ((noinline)) run_safemode_py(safe_mode_t safe_mode) {
// Don't run if we aren't in safe mode or we won't be able to find safemode.py.
// Also don't run if it's a user-initiated safemode (pressing button(s) during boot),
// since that's deliberate.
if (safe_mode == SAFE_MODE_NONE || safe_mode == SAFE_MODE_USER || !filesystem_present()) {
2023-02-11 23:50:20 -05:00
return;
}
2023-02-16 17:52:13 -05:00
supervisor_allocation *pystack = NULL;
#if MICROPY_ENABLE_PYSTACK
2023-02-17 10:40:55 -05:00
pystack = allocate_pystack(safe_mode);
2023-02-16 17:52:13 -05:00
#endif
2023-02-11 23:50:20 -05:00
supervisor_allocation *heap = allocate_remaining_memory();
2023-02-16 17:52:13 -05:00
start_mp(heap, pystack);
2023-02-11 23:50:20 -05:00
static const char *const safemode_py_filenames[] = {"safemode.py", "safemode.txt"};
maybe_run_list(safemode_py_filenames, MP_ARRAY_SIZE(safemode_py_filenames));
// If safemode.py itself caused an error, change the safe_mode state to indicate that.
if (_exec_result.exception != MP_OBJ_NULL &&
_exec_result.exception != MP_OBJ_SENTINEL) {
set_safe_mode(SAFE_MODE_SAFEMODE_PY_ERROR);
}
2023-02-16 17:52:13 -05:00
cleanup_after_vm(heap, pystack, _exec_result.exception);
2023-02-11 23:50:20 -05:00
_exec_result.exception = NULL;
}
#endif
2023-02-15 15:00:52 -05:00
STATIC void __attribute__ ((noinline)) run_boot_py(safe_mode_t safe_mode) {
2023-02-11 23:50:20 -05:00
if (safe_mode == SAFE_MODE_NO_HEAP) {
return;
}
2021-05-08 11:03:05 -04:00
// If not in safe mode, run boot before initing USB and capture output in a file.
2018-05-03 23:43:02 -04:00
2021-05-08 11:03:05 -04:00
// There is USB setup to do even if boot.py is not actually run.
const bool ok_to_run = filesystem_present()
2023-02-11 23:50:20 -05:00
&& safe_mode == SAFE_MODE_NONE
2021-05-08 11:03:05 -04:00
&& MP_STATE_VM(vfs_mount_table) != NULL;
static const char *const boot_py_filenames[] = {"boot.py", "boot.txt"};
2021-05-08 11:03:05 -04:00
// Do USB setup even if boot.py is not run.
2023-02-16 17:52:13 -05:00
supervisor_allocation *pystack = NULL;
2023-02-16 16:10:11 -05:00
#if MICROPY_ENABLE_PYSTACK
2023-02-17 10:40:55 -05:00
pystack = allocate_pystack(safe_mode);
2023-02-16 16:10:11 -05:00
#endif
supervisor_allocation *heap = allocate_remaining_memory();
start_mp(heap, pystack);
2021-05-08 11:03:05 -04:00
2021-11-08 09:21:43 -05:00
#if CIRCUITPY_USB
2021-05-08 11:03:05 -04:00
// Set up default USB values after boot.py VM starts but before running boot.py.
usb_set_defaults();
2021-11-08 09:21:43 -05:00
#endif
2021-04-28 13:00:44 -04:00
if (ok_to_run) {
#ifdef CIRCUITPY_BOOT_OUTPUT_FILE
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
// Turn off status bar updates when writing out to boot_out.txt.
supervisor_status_bar_suspend();
#endif
vstr_t boot_text;
vstr_init(&boot_text, 512);
boot_output = &boot_text;
#endif
// Write version info
mp_printf(&mp_plat_print, "%s\nBoard ID:%s\n", MICROPY_FULL_VERSION_INFO, CIRCUITPY_BOARD_ID);
#if CIRCUITPY_MICROCONTROLLER && COMMON_HAL_MCU_PROCESSOR_UID_LENGTH > 0
uint8_t raw_id[COMMON_HAL_MCU_PROCESSOR_UID_LENGTH];
common_hal_mcu_processor_get_uid(raw_id);
2022-10-09 19:22:39 -04:00
mp_cprintf(&mp_plat_print, translate("UID:"));
for (size_t i = 0; i < COMMON_HAL_MCU_PROCESSOR_UID_LENGTH; i++) {
mp_cprintf(&mp_plat_print, translate("%02X"), raw_id[i]);
}
mp_printf(&mp_plat_print, "\n");
port_boot_info();
#endif
bool found_boot = maybe_run_list(boot_py_filenames, MP_ARRAY_SIZE(boot_py_filenames));
2021-11-08 09:21:43 -05:00
(void)found_boot;
#ifdef CIRCUITPY_BOOT_OUTPUT_FILE
// Get the base filesystem.
2021-11-08 09:21:43 -05:00
fs_user_mount_t *vfs = (fs_user_mount_t *)MP_STATE_VM(vfs_mount_table)->obj;
FATFS *fs = &vfs->fatfs;
boot_output = NULL;
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_resume();
#endif
bool write_boot_output = true;
FIL boot_output_file;
if (f_open(fs, &boot_output_file, CIRCUITPY_BOOT_OUTPUT_FILE, FA_READ) == FR_OK) {
char *file_contents = m_new(char, boot_text.alloc);
UINT chars_read;
2021-11-08 09:21:43 -05:00
if (f_read(&boot_output_file, file_contents, 1 + boot_text.len, &chars_read) == FR_OK) {
write_boot_output =
(chars_read != boot_text.len) || (memcmp(boot_text.buf, file_contents, chars_read) != 0);
}
// no need to f_close the file
2018-05-03 23:43:02 -04:00
}
if (write_boot_output) {
// Wait 1 second before opening CIRCUITPY_BOOT_OUTPUT_FILE for write,
// in case power is momentary or will fail shortly due to, say a low, battery.
mp_hal_delay_ms(1000);
// USB isn't up, so we can write the file.
// operating at the oofatfs (f_open) layer means the usb concurrent write permission
// is not even checked!
f_open(fs, &boot_output_file, CIRCUITPY_BOOT_OUTPUT_FILE, FA_WRITE | FA_CREATE_ALWAYS);
UINT chars_written;
f_write(&boot_output_file, boot_text.buf, boot_text.len, &chars_written);
f_close(&boot_output_file);
filesystem_flush();
}
#endif
}
2021-11-08 09:21:43 -05:00
#if CIRCUITPY_USB
2021-05-08 11:03:05 -04:00
// Some data needs to be carried over from the USB settings in boot.py
// to the next VM, while the heap is still available.
// Its size can vary, so save it temporarily on the stack,
// and then when the heap goes away, copy it in into a
// storage_allocation.
size_t size = usb_boot_py_data_size();
uint8_t usb_boot_py_data[size];
usb_get_boot_py_data(usb_boot_py_data, size);
2021-11-08 09:21:43 -05:00
#endif
2021-04-28 23:48:26 -04:00
port_post_boot_py(true);
2023-02-16 16:10:11 -05:00
cleanup_after_vm(heap, pystack, _exec_result.exception);
_exec_result.exception = NULL;
2021-04-28 23:48:26 -04:00
port_post_boot_py(false);
2021-11-08 09:21:43 -05:00
#if CIRCUITPY_USB
2021-05-08 11:03:05 -04:00
// Now give back the data we saved from the heap going away.
usb_return_boot_py_data(usb_boot_py_data, size);
2021-11-08 09:21:43 -05:00
#endif
}
2023-02-17 10:40:55 -05:00
STATIC int run_repl(safe_mode_t safe_mode) {
int exit_code = PYEXEC_FORCED_EXIT;
2018-07-25 08:06:30 -04:00
stack_resize();
filesystem_flush();
2023-02-16 17:52:13 -05:00
supervisor_allocation *pystack = NULL;
2023-02-16 16:10:11 -05:00
#if MICROPY_ENABLE_PYSTACK
2023-02-17 10:40:55 -05:00
pystack = allocate_pystack(safe_mode);
2023-02-16 16:10:11 -05:00
#endif
supervisor_allocation *heap = allocate_remaining_memory();
start_mp(heap, pystack);
2021-04-28 23:48:26 -04:00
#if CIRCUITPY_USB
usb_setup_with_vm();
#endif
autoreload_suspend(AUTORELOAD_SUSPEND_REPL);
// Set the status LED to the REPL color before running the REPL. For
// NeoPixels and DotStars this will be sticky but for PWM or single LED it
// won't. This simplifies pin sharing because they won't be in use when
// actually in the REPL.
#if CIRCUITPY_STATUS_LED
status_led_init();
new_status_color(REPL_RUNNING);
status_led_deinit();
#endif
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_suspend();
#endif
exit_code = pyexec_raw_repl();
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_resume();
#endif
} else {
_current_executing_filename = "REPL";
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_update();
#endif
exit_code = pyexec_friendly_repl();
_current_executing_filename = NULL;
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_update();
#endif
}
#if CIRCUITPY_ATEXIT
pyexec_result_t result;
shared_module_atexit_execute(&result);
if (result.return_code == PYEXEC_DEEP_SLEEP) {
exit_code = PYEXEC_DEEP_SLEEP;
}
#endif
2023-02-16 16:10:11 -05:00
cleanup_after_vm(heap, pystack, MP_OBJ_SENTINEL);
// Also reset bleio. The above call omits it in case workflows should continue. In this case,
// we're switching straight to another VM so we want to reset.
#if CIRCUITPY_BLEIO
bleio_reset();
#endif
2021-05-18 14:32:45 -04:00
#if CIRCUITPY_STATUS_LED
status_led_init();
new_status_color(BLACK);
status_led_deinit();
#endif
autoreload_resume(AUTORELOAD_SUSPEND_REPL);
return exit_code;
}
int __attribute__((used)) main(void) {
2023-02-10 15:45:25 -05:00
// initialise the cpu and peripherals
2023-02-11 23:50:20 -05:00
set_safe_mode(port_init());
// Turn on RX and TX LEDs if we have them.
init_rxtx_leds();
#if CIRCUITPY_BOOT_COUNTER
// Increment counter before possibly entering safe mode
common_hal_nvm_bytearray_get_bytes(&common_hal_mcu_nvm_obj,0,1,&value_out);
++value_out;
common_hal_nvm_bytearray_set_bytes(&common_hal_mcu_nvm_obj,0,&value_out,1);
#endif
// Start the debug serial
serial_early_init();
// Wait briefly to give a reset window where we'll enter safe mode after the reset.
2023-02-11 23:50:20 -05:00
if (get_safe_mode() == SAFE_MODE_NONE) {
set_safe_mode(wait_for_safe_mode_reset());
}
stack_init();
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_init();
#endif
#if CIRCUITPY_BLEIO
// Early init so that a reset press can cause BLE public advertising.
supervisor_bluetooth_init();
#endif
2022-04-18 10:59:30 -04:00
#if !INTERNAL_FLASH_FILESYSTEM
// Set up anything that might need to get done before we try to use SPI flash
// This is needed for some boards where flash relies on GPIO setup to work
external_flash_setup();
2022-04-18 10:59:30 -04:00
#endif
// Create a new filesystem only if we're not in a safe mode.
// A power brownout here could make it appear as if there's
// no SPI flash filesystem, and we might erase the existing one.
2022-01-06 17:36:16 -05:00
// Check whether CIRCUITPY is available. No need to reset to get safe mode
// since we haven't run user code yet.
2023-02-11 23:50:20 -05:00
if (!filesystem_init(get_safe_mode() == SAFE_MODE_NONE, false)) {
set_safe_mode(SAFE_MODE_NO_CIRCUITPY);
}
2022-10-27 22:42:04 -04:00
#if CIRCUITPY_ALARM
// Record which alarm woke us up, if any.
// common_hal_alarm_record_wake_alarm() should return a static, non-heap object
shared_alarm_save_wake_alarm(common_hal_alarm_record_wake_alarm());
2022-10-29 16:26:36 -04:00
// Then reset the alarm system. It's not reset in reset_port(), because that's also called
// on VM teardown, which would clear any alarm setup.
alarm_reset();
2022-10-27 22:42:04 -04:00
#endif
// Reset everything and prep MicroPython to run boot.py.
reset_port();
// Port-independent devices, like CIRCUITPY_BLEIO_HCI.
reset_devices();
reset_board();
// displays init after filesystem, since they could share the flash SPI
board_init();
2020-11-22 19:10:09 -05:00
// This is first time we are running CircuitPython after a reset or power-up.
supervisor_set_run_reason(RUN_REASON_STARTUP);
2020-10-07 12:45:05 -04:00
// If not in safe mode turn on autoreload by default but before boot.py in case it wants to change it.
2023-02-11 23:50:20 -05:00
if (get_safe_mode() == SAFE_MODE_NONE) {
2020-10-07 12:45:05 -04:00
autoreload_enable();
}
// By default our internal flash is readonly to local python code and
2023-02-11 23:50:20 -05:00
// writable over USB. Set it here so that safemode.py or boot.py can change it.
filesystem_set_internal_concurrent_write_protection(true);
filesystem_set_internal_writable_by_usb(CIRCUITPY_USB == 1);
2023-02-11 23:50:20 -05:00
#if CIRCUITPY_SAFEMODE_PY
// Run safemode.py if we ARE in safe mode.
// If safemode.py does not do a hard reset, and exits normally, we will continue on
// and report the safe mode as usual.
run_safemode_py(get_safe_mode());
#endif
run_boot_py(get_safe_mode());
supervisor_workflow_start();
2022-08-28 21:55:13 -04:00
#if CIRCUITPY_STATUS_BAR
supervisor_status_bar_request_update(true);
2022-08-28 21:55:13 -04:00
#endif
2021-12-21 21:48:36 -05:00
// Boot script is finished, so now go into REPL or run code.py.
int exit_code = PYEXEC_FORCED_EXIT;
bool skip_repl = true;
2022-10-27 22:42:04 -04:00
bool simulate_reset = true;
for (;;) {
if (!skip_repl) {
2023-02-17 10:40:55 -05:00
exit_code = run_repl(get_safe_mode());
supervisor_set_run_reason(RUN_REASON_REPL_RELOAD);
}
if (exit_code == PYEXEC_FORCED_EXIT) {
2022-10-27 22:42:04 -04:00
if (!simulate_reset) {
serial_write_compressed(translate("soft reboot\n"));
}
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
2022-10-29 16:26:36 -04:00
// If code.py did a fake deep sleep, pretend that we
// are running code.py for the first time after a hard
// reset. This will preserve any alarm information.
2023-02-11 23:50:20 -05:00
skip_repl = run_code_py(get_safe_mode(), &simulate_reset);
} else {
2021-11-22 16:45:28 -05:00
skip_repl = false;
}
} else if (exit_code != 0) {
break;
}
2021-12-21 21:48:36 -05:00
2022-10-29 16:26:36 -04:00
#if CIRCUITPY_ALARM
shared_alarm_save_wake_alarm(simulate_reset ? common_hal_alarm_record_wake_alarm() : mp_const_none);
alarm_reset();
#endif
}
mp_deinit();
return 0;
}
void gc_collect(void) {
gc_collect_start();
mp_uint_t regs[10];
mp_uint_t sp = cpu_get_regs_and_sp(regs);
// This collects root pointers from the VFS mount table. Some of them may
// have lost their references in the VM even though they are mounted.
2021-11-08 09:21:43 -05:00
gc_collect_root((void **)&MP_STATE_VM(vfs_mount_table), sizeof(mp_vfs_mount_t) / sizeof(mp_uint_t));
2019-06-06 17:49:32 -04:00
background_callback_gc_collect();
2020-12-22 10:06:43 -05:00
#if CIRCUITPY_ALARM
common_hal_alarm_gc_collect();
#endif
#if CIRCUITPY_ATEXIT
atexit_gc_collect();
#endif
2019-06-06 17:49:32 -04:00
#if CIRCUITPY_DISPLAYIO
displayio_gc_collect();
#endif
#if CIRCUITPY_BLEIO
common_hal_bleio_gc_collect();
#endif
2021-04-28 23:48:26 -04:00
#if CIRCUITPY_USB_HID
usb_hid_gc_collect();
#endif
2020-12-07 11:06:33 -05:00
#if CIRCUITPY_WIFI
common_hal_wifi_gc_collect();
#endif
// This naively collects all object references from an approximate stack
// range.
gc_collect_root((void **)sp, ((mp_uint_t)port_stack_get_top() - sp) / sizeof(mp_uint_t));
gc_collect_end();
}
void NORETURN nlr_jump_fail(void *val) {
2023-02-11 23:50:20 -05:00
reset_into_safe_mode(SAFE_MODE_NLR_JUMP_FAIL);
2021-11-08 09:21:43 -05:00
while (true) {
}
}
#ifndef NDEBUG
static void NORETURN __fatal_error(const char *msg) {
2023-02-11 23:50:20 -05:00
reset_into_safe_mode(SAFE_MODE_HARD_FAULT);
2021-11-08 09:21:43 -05:00
while (true) {
}
}
void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
2018-08-31 17:46:03 -04:00
mp_printf(&mp_plat_print, "Assertion '%s' failed, at file %s:%d\n", expr, file, line);
__fatal_error("Assertion failed");
}
#endif