/* * 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 #include #include "extmod/vfs.h" #include "extmod/vfs_fat.h" #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" #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" #include "supervisor/shared/reload.h" #include "supervisor/shared/safe_mode.h" #include "supervisor/shared/stack.h" #include "supervisor/shared/status_leds.h" #include "supervisor/shared/tick.h" #include "supervisor/shared/traceback.h" #include "supervisor/shared/translate.h" #include "supervisor/shared/workflow.h" #include "supervisor/usb.h" #include "supervisor/workflow.h" #include "supervisor/shared/external_flash/external_flash.h" #include "shared-bindings/microcontroller/__init__.h" #include "shared-bindings/microcontroller/Processor.h" #include "shared-bindings/supervisor/Runtime.h" #if CIRCUITPY_ALARM #include "shared-bindings/alarm/__init__.h" #endif #if CIRCUITPY_ATEXIT #include "shared-module/atexit/__init__.h" #endif #if CIRCUITPY_BLEIO #include "shared-bindings/_bleio/__init__.h" #include "supervisor/shared/bluetooth/bluetooth.h" #endif #if CIRCUITPY_BOARD #include "shared-module/board/__init__.h" #endif #if CIRCUITPY_CANIO #include "common-hal/canio/CAN.h" #endif #if CIRCUITPY_DISPLAYIO #include "shared-module/displayio/__init__.h" #endif #if CIRCUITPY_KEYPAD #include "shared-module/keypad/__init__.h" #endif #if CIRCUITPY_MEMORYMONITOR #include "shared-module/memorymonitor/__init__.h" #endif #if CIRCUITPY_USB_HID #include "shared-module/usb_hid/__init__.h" #endif #if CIRCUITPY_WIFI #include "shared-bindings/wifi/__init__.h" #endif #if CIRCUITPY_BOOT_COUNTER #include "shared-bindings/nvm/ByteArray.h" uint8_t value_out = 0; #endif #if MICROPY_ENABLE_PYSTACK static size_t PLACE_IN_DTCM_BSS(_pystack[CIRCUITPY_PYSTACK_SIZE / sizeof(size_t)]); #endif static void reset_devices(void) { #if CIRCUITPY_BLEIO_HCI bleio_reset(); #endif } STATIC void start_mp(supervisor_allocation *heap, bool first_run) { 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); } #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(); } #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 mp_pystack_init(_pystack, _pystack + (sizeof(_pystack) / sizeof(size_t))); #endif #if MICROPY_ENABLE_GC 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); #if CIRCUITPY_ALARM // Record which alarm woke us up, if any. An object may be created so the heap must be functional. // There is no alarm if this is not the first time code.py or the REPL has been run. shared_alarm_save_wake_alarm(first_run ? common_hal_alarm_create_wake_alarm() : mp_const_none); // Reset alarm module only after we retrieved the wakeup alarm. alarm_reset(); #endif } 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 usb_background(); #endif gc_deinit(); } #define STRING_LIST(...) {__VA_ARGS__, ""} // 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) { for (int i = 0; filenames[i] != (char *)""; i++) { mp_import_stat_t stat = mp_import_stat(filenames[i]); if (stat == MP_IMPORT_STAT_FILE) { return filenames[i]; } } return NULL; } STATIC bool maybe_run_list(const char *const *filenames, pyexec_result_t *exec_result) { const char *filename = first_existing_file_in_list(filenames); if (filename == NULL) { return false; } mp_hal_stdout_tx_str(filename); serial_write_compressed(translate(" output:\n")); pyexec_file(filename, exec_result); #if CIRCUITPY_ATEXIT shared_module_atexit_execute(exec_result); #endif return true; } STATIC void count_strn(void *data, const char *str, size_t len) { *(size_t *)data += len; } STATIC void cleanup_after_vm(supervisor_allocation *heap, 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; 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); ((char *)prev_traceback_allocation->ptr)[traceback_len] = '\0'; } } else { prev_traceback_allocation = NULL; } } // Reset port-independent devices, like CIRCUITPY_BLEIO_HCI. reset_devices(); #if CIRCUITPY_ATEXIT atexit_reset(); #endif // Turn off the display and flush the filesystem before the heap disappears. #if CIRCUITPY_DISPLAYIO reset_displays(); #endif #if CIRCUITPY_MEMORYMONITOR memorymonitor_reset(); #endif // Disable user related BLE state that uses the micropython heap. #if CIRCUITPY_BLEIO bleio_user_reset(); #endif #if CIRCUITPY_CANIO common_hal_canio_reset(); #endif #if CIRCUITPY_KEYPAD keypad_reset(); #endif // reset_board_buses() first because it may release pins from the never_reset state, so that // reset_port() can reset them. #if CIRCUITPY_BOARD reset_board_buses(); #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(); free_memory(heap); supervisor_move_memory(); } STATIC void print_code_py_status_message(safe_mode_t safe_mode) { 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")); } else { serial_write_compressed(translate("Auto-reload is off.\n")); } if (safe_mode != NO_SAFE_MODE) { serial_write_compressed(translate("Running in safe mode! Not running saved code.\n")); } } STATIC bool run_code_py(safe_mode_t safe_mode, bool first_run, bool *simulate_reset) { bool serial_connected_at_start = serial_connected(); bool printed_safe_mode_message = false; #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 pyexec_result_t result; result.return_code = 0; result.exception = MP_OBJ_NULL; result.exception_line = 0; bool skip_repl = false; 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. if (safe_mode == NO_SAFE_MODE) { stack_resize(); filesystem_flush(); } if (safe_mode == NO_SAFE_MODE && !autoreload_pending()) { static const char *const supported_filenames[] = STRING_LIST( "code.txt", "code.py", "main.py", "main.txt"); #if CIRCUITPY_FULL_BUILD static const char *const double_extension_filenames[] = STRING_LIST( "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 supervisor_allocation *heap = allocate_remaining_memory(); // Prepare the VM state. Includes an alarm check/reset for sleep. start_mp(heap, first_run); #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 *)next_code_allocation->ptr)->options &= ~SUPERVISOR_NEXT_CODE_OPT_NEWLY_SET; next_code_options = ((next_code_info_t *)next_code_allocation->ptr)->options; if (((next_code_info_t *)next_code_allocation->ptr)->filename[0] != '\0') { const char *next_list[] = {((next_code_info_t *)next_code_allocation->ptr)->filename, ""}; // This is where the user's python code is actually executed: found_main = maybe_run_list(next_list, &result); if (!found_main) { serial_write(((next_code_info_t *)next_code_allocation->ptr)->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, &result); // If that didn't work, double check the extensions #if CIRCUITPY_FULL_BUILD if (!found_main) { found_main = maybe_run_list(double_extension_filenames, &result); if (found_main) { serial_write_compressed(translate("WARNING: Your code filename has two extensions\n")); } } #else (void)found_main; #endif } // Print done before resetting everything so that we get the message over // BLE before it is reset and we have a delay before reconnect. if ((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")); } // Finished executing python code. Cleanup includes filesystem flush and a board reset. cleanup_after_vm(heap, result.exception); // 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; } if (result.return_code & PYEXEC_RELOAD) { next_code_stickiness_situation |= SUPERVISOR_NEXT_CODE_OPT_STICKY_ON_RELOAD; // 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; } } else if (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; skip_wait = true; } } else { next_code_stickiness_situation |= SUPERVISOR_NEXT_CODE_OPT_STICKY_ON_ERROR; // 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 && !(result.return_code & PYEXEC_DEEP_SLEEP)) { skip_repl = true; skip_wait = true; } } if (result.return_code & PYEXEC_FORCED_EXIT) { skip_repl = false; skip_wait = true; } } // Program has finished running. bool printed_press_any_key = false; #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 if (result.return_code & PYEXEC_DEEP_SLEEP) { color = BLACK; blink_count = 0; } else #endif if (result.return_code != PYEXEC_EXCEPTION) { if (safe_mode == NO_SAFE_MODE) { 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; #endif // This loop is waits after code completes. It waits for fake sleeps to // finish, user input or autoreloads. #if CIRCUITPY_ALARM bool fake_sleeping = false; #endif while (!skip_wait) { RUN_BACKGROUND_TASKS; // 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()) { // Skip REPL if reload was requested. skip_repl = serial_read() == CHAR_CTRL_D; if (skip_repl) { 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 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) { 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")); printed_press_any_key = true; } if (!serial_connected()) { serial_connected_at_start = false; printed_press_any_key = false; } // Sleep until our next interrupt. #if CIRCUITPY_ALARM if (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 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); #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(); // 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; STATIC void __attribute__ ((noinline)) run_boot_py(safe_mode_t safe_mode) { // If not in safe mode, run boot before initing USB and capture output in a file. // There is USB setup to do even if boot.py is not actually run. const bool ok_to_run = filesystem_present() && safe_mode == NO_SAFE_MODE && MP_STATE_VM(vfs_mount_table) != NULL; static const char *const boot_py_filenames[] = STRING_LIST("boot.py", "boot.txt"); // Do USB setup even if boot.py is not run. supervisor_allocation *heap = allocate_remaining_memory(); // true means this is the first set of VM's after a hard reset. start_mp(heap, true); #if CIRCUITPY_USB // Set up default USB values after boot.py VM starts but before running boot.py. usb_set_defaults(); #endif pyexec_result_t result = {0, MP_OBJ_NULL, 0}; if (ok_to_run) { #ifdef CIRCUITPY_BOOT_OUTPUT_FILE 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); bool found_boot = maybe_run_list(boot_py_filenames, &result); (void)found_boot; #ifdef CIRCUITPY_BOOT_OUTPUT_FILE // Get the base filesystem. fs_user_mount_t *vfs = (fs_user_mount_t *)MP_STATE_VM(vfs_mount_table)->obj; FATFS *fs = &vfs->fatfs; boot_output = NULL; 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; 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 } 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 } #if CIRCUITPY_USB // 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); #endif cleanup_after_vm(heap, result.exception); #if CIRCUITPY_USB // Now give back the data we saved from the heap going away. usb_return_boot_py_data(usb_boot_py_data, size); #endif } STATIC int run_repl(bool first_run) { int exit_code = PYEXEC_FORCED_EXIT; stack_resize(); filesystem_flush(); supervisor_allocation *heap = allocate_remaining_memory(); start_mp(heap, first_run); #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) { exit_code = pyexec_raw_repl(); } else { exit_code = pyexec_friendly_repl(); } #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 cleanup_after_vm(heap, MP_OBJ_SENTINEL); #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) { // initialise the cpu and peripherals safe_mode_t 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 // Wait briefly to give a reset window where we'll enter safe mode after the reset. if (safe_mode == NO_SAFE_MODE) { safe_mode = wait_for_safe_mode_reset(); } stack_init(); #if CIRCUITPY_BLEIO // Early init so that a reset press can cause BLE public advertising. supervisor_bluetooth_init(); #endif // Start the debug serial serial_early_init(); #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(); #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. // Check whether CIRCUITPY is available. No need to reset to get safe mode // since we haven't run user code yet. if (!filesystem_init(safe_mode == NO_SAFE_MODE, false)) { safe_mode = NO_CIRCUITPY; } // displays init after filesystem, since they could share the flash SPI board_init(); // Reset everything and prep MicroPython to run boot.py. reset_port(); // Port-independent devices, like CIRCUITPY_BLEIO_HCI. reset_devices(); reset_board(); // This is first time we are running CircuitPython after a reset or power-up. supervisor_set_run_reason(RUN_REASON_STARTUP); // If not in safe mode turn on autoreload by default but before boot.py in case it wants to change it. if (safe_mode == NO_SAFE_MODE) { autoreload_enable(); } // By default our internal flash is readonly to local python code and // writable over USB. Set it here so that boot.py can change it. filesystem_set_internal_concurrent_write_protection(true); filesystem_set_internal_writable_by_usb(CIRCUITPY_USB == 1); run_boot_py(safe_mode); // Start USB after giving boot.py a chance to tweak behavior. #if CIRCUITPY_USB // Setup USB connection after heap is available. // It needs the heap to build descriptors. usb_init(); #endif // Set up any other serial connection. serial_init(); #if CIRCUITPY_BLEIO bleio_reset(); supervisor_bluetooth_enable_workflow(); supervisor_start_bluetooth(); #endif // Boot script is finished, so now go into REPL or run code.py. int exit_code = PYEXEC_FORCED_EXIT; bool skip_repl = true; bool first_run = true; bool simulate_reset; for (;;) { simulate_reset = false; if (!skip_repl) { exit_code = run_repl(first_run); supervisor_set_run_reason(RUN_REASON_REPL_RELOAD); } if (exit_code == PYEXEC_FORCED_EXIT) { if (!first_run) { serial_write_compressed(translate("soft reboot\n")); } if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) { skip_repl = run_code_py(safe_mode, first_run, &simulate_reset); } else { skip_repl = false; } } else if (exit_code != 0) { break; } // Either the REPL or code.py has run and finished. // 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. first_run = simulate_reset; } 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. gc_collect_root((void **)&MP_STATE_VM(vfs_mount_table), sizeof(mp_vfs_mount_t) / sizeof(mp_uint_t)); background_callback_gc_collect(); #if CIRCUITPY_ALARM common_hal_alarm_gc_collect(); #endif #if CIRCUITPY_ATEXIT atexit_gc_collect(); #endif #if CIRCUITPY_DISPLAYIO displayio_gc_collect(); #endif #if CIRCUITPY_BLEIO common_hal_bleio_gc_collect(); #endif #if CIRCUITPY_USB_HID usb_hid_gc_collect(); #endif #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) { reset_into_safe_mode(MICROPY_NLR_JUMP_FAIL); while (true) { } } #ifndef NDEBUG static void NORETURN __fatal_error(const char *msg) { reset_into_safe_mode(MICROPY_FATAL_ERROR); while (true) { } } void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) { mp_printf(&mp_plat_print, "Assertion '%s' failed, at file %s:%d\n", expr, file, line); __fatal_error("Assertion failed"); } #endif