84c614e729
This patch makes the following configuration changes: - MICROPY_FSUSERMOUNT is disabled, removing old mounting infrastructure - MICROPY_VFS is enabled, giving new VFS sub-system - MICROPY_VFS_FAT is enabled, giving uos.VfsFat type - MICROPY_FATFS_OO is enabled, to use new ooFatFs lib, R0.12b User facing API should be almost unchanged. Most notable changes are removal of os.mkfs (use os.VfsFat.mkfs instead) and pyb.mount doesn't allow unmounting by passing None as the device.
642 lines
19 KiB
C
642 lines
19 KiB
C
/*
|
|
* This file is part of the Micro Python project, http://micropython.org/
|
|
*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
|
*
|
|
* 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 <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "py/nlr.h"
|
|
#include "py/lexer.h"
|
|
#include "py/parse.h"
|
|
#include "py/obj.h"
|
|
#include "py/runtime.h"
|
|
#include "py/stackctrl.h"
|
|
#include "py/gc.h"
|
|
#include "py/mphal.h"
|
|
|
|
#include "lib/utils/pyexec.h"
|
|
#include "lib/oofatfs/ff.h"
|
|
#include "extmod/vfs.h"
|
|
#include "extmod/fsusermount.h"
|
|
|
|
#include "systick.h"
|
|
#include "pendsv.h"
|
|
#include "gccollect.h"
|
|
#include "readline.h"
|
|
#include "modmachine.h"
|
|
#include "i2c.h"
|
|
#include "spi.h"
|
|
#include "uart.h"
|
|
#include "timer.h"
|
|
#include "led.h"
|
|
#include "pin.h"
|
|
#include "extint.h"
|
|
#include "usrsw.h"
|
|
#include "usb.h"
|
|
#include "rtc.h"
|
|
#include "storage.h"
|
|
#include "sdcard.h"
|
|
#include "rng.h"
|
|
#include "accel.h"
|
|
#include "servo.h"
|
|
#include "dac.h"
|
|
#include "can.h"
|
|
#include "modnetwork.h"
|
|
|
|
void SystemClock_Config(void);
|
|
|
|
fs_user_mount_t fs_user_mount_flash;
|
|
mp_vfs_mount_t mp_vfs_mount_flash;
|
|
|
|
void flash_error(int n) {
|
|
for (int i = 0; i < n; i++) {
|
|
led_state(PYB_LED_R1, 1);
|
|
led_state(PYB_LED_R2, 0);
|
|
HAL_Delay(250);
|
|
led_state(PYB_LED_R1, 0);
|
|
led_state(PYB_LED_R2, 1);
|
|
HAL_Delay(250);
|
|
}
|
|
led_state(PYB_LED_R2, 0);
|
|
}
|
|
|
|
void NORETURN __fatal_error(const char *msg) {
|
|
for (volatile uint delay = 0; delay < 10000000; delay++) {
|
|
}
|
|
led_state(1, 1);
|
|
led_state(2, 1);
|
|
led_state(3, 1);
|
|
led_state(4, 1);
|
|
mp_hal_stdout_tx_strn("\nFATAL ERROR:\n", 14);
|
|
mp_hal_stdout_tx_strn(msg, strlen(msg));
|
|
for (uint i = 0;;) {
|
|
led_toggle(((i++) & 3) + 1);
|
|
for (volatile uint delay = 0; delay < 10000000; delay++) {
|
|
}
|
|
if (i >= 16) {
|
|
// to conserve power
|
|
__WFI();
|
|
}
|
|
}
|
|
}
|
|
|
|
void nlr_jump_fail(void *val) {
|
|
printf("FATAL: uncaught exception %p\n", val);
|
|
mp_obj_print_exception(&mp_plat_print, (mp_obj_t)val);
|
|
__fatal_error("");
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
|
|
(void)func;
|
|
printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
|
|
__fatal_error("");
|
|
}
|
|
#endif
|
|
|
|
STATIC mp_obj_t pyb_main(mp_uint_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
|
|
static const mp_arg_t allowed_args[] = {
|
|
{ MP_QSTR_opt, MP_ARG_INT, {.u_int = 0} }
|
|
};
|
|
|
|
if (MP_OBJ_IS_STR(pos_args[0])) {
|
|
MP_STATE_PORT(pyb_config_main) = pos_args[0];
|
|
|
|
// parse args
|
|
mp_arg_val_t args[MP_ARRAY_SIZE(allowed_args)];
|
|
mp_arg_parse_all(n_args - 1, pos_args + 1, kw_args, MP_ARRAY_SIZE(allowed_args), allowed_args, args);
|
|
MP_STATE_VM(mp_optimise_value) = args[0].u_int;
|
|
}
|
|
return mp_const_none;
|
|
}
|
|
MP_DEFINE_CONST_FUN_OBJ_KW(pyb_main_obj, 1, pyb_main);
|
|
|
|
static const char fresh_boot_py[] =
|
|
"# boot.py -- run on boot-up\r\n"
|
|
"# can run arbitrary Python, but best to keep it minimal\r\n"
|
|
"\r\n"
|
|
"import machine\r\n"
|
|
"import pyb\r\n"
|
|
"#pyb.main('main.py') # main script to run after this one\r\n"
|
|
"#pyb.usb_mode('VCP+MSC') # act as a serial and a storage device\r\n"
|
|
"#pyb.usb_mode('VCP+HID') # act as a serial device and a mouse\r\n"
|
|
;
|
|
|
|
static const char fresh_main_py[] =
|
|
"# main.py -- put your code here!\r\n"
|
|
;
|
|
|
|
static const char fresh_pybcdc_inf[] =
|
|
#include "genhdr/pybcdc_inf.h"
|
|
;
|
|
|
|
static const char fresh_readme_txt[] =
|
|
"This is a MicroPython board\r\n"
|
|
"\r\n"
|
|
"You can get started right away by writing your Python code in 'main.py'.\r\n"
|
|
"\r\n"
|
|
"For a serial prompt:\r\n"
|
|
" - Windows: you need to go to 'Device manager', right click on the unknown device,\r\n"
|
|
" then update the driver software, using the 'pybcdc.inf' file found on this drive.\r\n"
|
|
" Then use a terminal program like Hyperterminal or putty.\r\n"
|
|
" - Mac OS X: use the command: screen /dev/tty.usbmodem*\r\n"
|
|
" - Linux: use the command: screen /dev/ttyACM0\r\n"
|
|
"\r\n"
|
|
"Please visit http://micropython.org/help/ for further help.\r\n"
|
|
;
|
|
|
|
// avoid inlining to avoid stack usage within main()
|
|
MP_NOINLINE STATIC void init_flash_fs(uint reset_mode) {
|
|
// init the vfs object
|
|
fs_user_mount_t *vfs_fat = &fs_user_mount_flash;
|
|
vfs_fat->str = NULL;
|
|
vfs_fat->len = 0;
|
|
vfs_fat->flags = 0;
|
|
pyb_flash_init_vfs(vfs_fat);
|
|
|
|
// try to mount the flash
|
|
FRESULT res = f_mount(&vfs_fat->fatfs);
|
|
|
|
if (reset_mode == 3 || res == FR_NO_FILESYSTEM) {
|
|
// no filesystem, or asked to reset it, so create a fresh one
|
|
|
|
// LED on to indicate creation of LFS
|
|
led_state(PYB_LED_R2, 1);
|
|
uint32_t start_tick = HAL_GetTick();
|
|
|
|
uint8_t working_buf[_MAX_SS];
|
|
res = f_mkfs(&vfs_fat->fatfs, FM_FAT, 0, working_buf, sizeof(working_buf));
|
|
if (res == FR_OK) {
|
|
// success creating fresh LFS
|
|
} else {
|
|
printf("PYB: can't create flash filesystem\n");
|
|
return;
|
|
}
|
|
|
|
// set label
|
|
f_setlabel(&vfs_fat->fatfs, "pybflash");
|
|
|
|
// create empty main.py
|
|
FIL fp;
|
|
f_open(&vfs_fat->fatfs, &fp, "/main.py", FA_WRITE | FA_CREATE_ALWAYS);
|
|
UINT n;
|
|
f_write(&fp, fresh_main_py, sizeof(fresh_main_py) - 1 /* don't count null terminator */, &n);
|
|
// TODO check we could write n bytes
|
|
f_close(&fp);
|
|
|
|
// create .inf driver file
|
|
f_open(&vfs_fat->fatfs, &fp, "/pybcdc.inf", FA_WRITE | FA_CREATE_ALWAYS);
|
|
f_write(&fp, fresh_pybcdc_inf, sizeof(fresh_pybcdc_inf) - 1 /* don't count null terminator */, &n);
|
|
f_close(&fp);
|
|
|
|
// create readme file
|
|
f_open(&vfs_fat->fatfs, &fp, "/README.txt", FA_WRITE | FA_CREATE_ALWAYS);
|
|
f_write(&fp, fresh_readme_txt, sizeof(fresh_readme_txt) - 1 /* don't count null terminator */, &n);
|
|
f_close(&fp);
|
|
|
|
// keep LED on for at least 200ms
|
|
sys_tick_wait_at_least(start_tick, 200);
|
|
led_state(PYB_LED_R2, 0);
|
|
} else if (res == FR_OK) {
|
|
// mount sucessful
|
|
} else {
|
|
printf("PYB: can't mount flash\n");
|
|
return;
|
|
}
|
|
|
|
// mount the flash device (there should be no other devices mounted at this point)
|
|
mp_vfs_mount_t *vfs = &mp_vfs_mount_flash;
|
|
vfs->str = "/flash";
|
|
vfs->len = 6;
|
|
vfs->obj = MP_OBJ_FROM_PTR(vfs_fat);
|
|
vfs->next = NULL;
|
|
MP_STATE_VM(vfs_mount_table) = vfs;
|
|
|
|
// The current directory is used as the boot up directory.
|
|
// It is set to the internal flash filesystem by default.
|
|
MP_STATE_PORT(vfs_cur) = vfs;
|
|
|
|
// Make sure we have a /flash/boot.py. Create it if needed.
|
|
FILINFO fno;
|
|
res = f_stat(&vfs_fat->fatfs, "/boot.py", &fno);
|
|
if (res != FR_OK) {
|
|
// doesn't exist, create fresh file
|
|
|
|
// LED on to indicate creation of boot.py
|
|
led_state(PYB_LED_R2, 1);
|
|
uint32_t start_tick = HAL_GetTick();
|
|
|
|
FIL fp;
|
|
f_open(&vfs_fat->fatfs, &fp, "/flash/boot.py", FA_WRITE | FA_CREATE_ALWAYS);
|
|
UINT n;
|
|
f_write(&fp, fresh_boot_py, sizeof(fresh_boot_py) - 1 /* don't count null terminator */, &n);
|
|
// TODO check we could write n bytes
|
|
f_close(&fp);
|
|
|
|
// keep LED on for at least 200ms
|
|
sys_tick_wait_at_least(start_tick, 200);
|
|
led_state(PYB_LED_R2, 0);
|
|
}
|
|
}
|
|
|
|
STATIC uint update_reset_mode(uint reset_mode) {
|
|
#if MICROPY_HW_HAS_SWITCH
|
|
if (switch_get()) {
|
|
|
|
// The original method used on the pyboard is appropriate if you have 2
|
|
// or more LEDs.
|
|
#if defined(MICROPY_HW_LED2)
|
|
for (uint i = 0; i < 3000; i++) {
|
|
if (!switch_get()) {
|
|
break;
|
|
}
|
|
HAL_Delay(20);
|
|
if (i % 30 == 29) {
|
|
if (++reset_mode > 3) {
|
|
reset_mode = 1;
|
|
}
|
|
led_state(2, reset_mode & 1);
|
|
led_state(3, reset_mode & 2);
|
|
led_state(4, reset_mode & 4);
|
|
}
|
|
}
|
|
// flash the selected reset mode
|
|
for (uint i = 0; i < 6; i++) {
|
|
led_state(2, 0);
|
|
led_state(3, 0);
|
|
led_state(4, 0);
|
|
HAL_Delay(50);
|
|
led_state(2, reset_mode & 1);
|
|
led_state(3, reset_mode & 2);
|
|
led_state(4, reset_mode & 4);
|
|
HAL_Delay(50);
|
|
}
|
|
HAL_Delay(400);
|
|
|
|
#elif defined(MICROPY_HW_LED1)
|
|
|
|
// For boards with only a single LED, we'll flash that LED the
|
|
// appropriate number of times, with a pause between each one
|
|
for (uint i = 0; i < 10; i++) {
|
|
led_state(1, 0);
|
|
for (uint j = 0; j < reset_mode; j++) {
|
|
if (!switch_get()) {
|
|
break;
|
|
}
|
|
led_state(1, 1);
|
|
HAL_Delay(100);
|
|
led_state(1, 0);
|
|
HAL_Delay(200);
|
|
}
|
|
HAL_Delay(400);
|
|
if (!switch_get()) {
|
|
break;
|
|
}
|
|
if (++reset_mode > 3) {
|
|
reset_mode = 1;
|
|
}
|
|
}
|
|
// Flash the selected reset mode
|
|
for (uint i = 0; i < 2; i++) {
|
|
for (uint j = 0; j < reset_mode; j++) {
|
|
led_state(1, 1);
|
|
HAL_Delay(100);
|
|
led_state(1, 0);
|
|
HAL_Delay(200);
|
|
}
|
|
HAL_Delay(400);
|
|
}
|
|
#else
|
|
#error Need a reset mode update method
|
|
#endif
|
|
}
|
|
#endif
|
|
return reset_mode;
|
|
}
|
|
|
|
int main(void) {
|
|
// TODO disable JTAG
|
|
|
|
// 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();
|
|
mp_stack_set_limit((char*)&_ram_end - (char*)&_heap_end - 1024);
|
|
|
|
/* STM32F4xx HAL library initialization:
|
|
- Configure the Flash prefetch, instruction and Data caches
|
|
- Configure the Systick to generate an interrupt each 1 msec
|
|
- Set NVIC Group Priority to 4
|
|
- Global MSP (MCU Support Package) initialization
|
|
*/
|
|
HAL_Init();
|
|
|
|
// set the system clock to be HSE
|
|
SystemClock_Config();
|
|
|
|
// enable GPIO clocks
|
|
__GPIOA_CLK_ENABLE();
|
|
__GPIOB_CLK_ENABLE();
|
|
__GPIOC_CLK_ENABLE();
|
|
__GPIOD_CLK_ENABLE();
|
|
|
|
#if defined(MCU_SERIES_F4) || defined(MCU_SERIES_F7)
|
|
#if defined(__HAL_RCC_DTCMRAMEN_CLK_ENABLE)
|
|
// The STM32F746 doesn't really have CCM memory, but it does have DTCM,
|
|
// which behaves more or less like normal SRAM.
|
|
__HAL_RCC_DTCMRAMEN_CLK_ENABLE();
|
|
#elif defined(CCMDATARAM_BASE)
|
|
// enable the CCM RAM
|
|
__HAL_RCC_CCMDATARAMEN_CLK_ENABLE();
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(MICROPY_BOARD_EARLY_INIT)
|
|
MICROPY_BOARD_EARLY_INIT();
|
|
#endif
|
|
|
|
// basic sub-system init
|
|
pendsv_init();
|
|
led_init();
|
|
#if MICROPY_HW_HAS_SWITCH
|
|
switch_init0();
|
|
#endif
|
|
|
|
#if defined(USE_DEVICE_MODE)
|
|
// default to internal flash being the usb medium
|
|
pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_FLASH;
|
|
#endif
|
|
|
|
int first_soft_reset = true;
|
|
|
|
soft_reset:
|
|
|
|
// check if user switch held to select the reset mode
|
|
#if defined(MICROPY_HW_LED2)
|
|
led_state(1, 0);
|
|
led_state(2, 1);
|
|
#else
|
|
led_state(1, 1);
|
|
led_state(2, 0);
|
|
#endif
|
|
led_state(3, 0);
|
|
led_state(4, 0);
|
|
uint reset_mode = update_reset_mode(1);
|
|
|
|
machine_init();
|
|
|
|
#if MICROPY_HW_ENABLE_RTC
|
|
if (first_soft_reset) {
|
|
rtc_init_start(false);
|
|
}
|
|
#endif
|
|
|
|
// more sub-system init
|
|
#if MICROPY_HW_HAS_SDCARD
|
|
if (first_soft_reset) {
|
|
sdcard_init();
|
|
}
|
|
#endif
|
|
if (first_soft_reset) {
|
|
storage_init();
|
|
}
|
|
|
|
// GC init
|
|
gc_init(&_heap_start, &_heap_end);
|
|
|
|
// Micro Python init
|
|
mp_init();
|
|
mp_obj_list_init(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_flash));
|
|
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_flash_slash_lib));
|
|
mp_obj_list_init(mp_sys_argv, 0);
|
|
|
|
// Initialise low-level sub-systems. Here we need to very basic things like
|
|
// zeroing out memory and resetting any of the sub-systems. Following this
|
|
// we can run Python scripts (eg boot.py), but anything that is configurable
|
|
// by boot.py must be set after boot.py is run.
|
|
|
|
readline_init0();
|
|
pin_init0();
|
|
extint_init0();
|
|
timer_init0();
|
|
uart_init0();
|
|
|
|
// Define MICROPY_HW_UART_REPL to be PYB_UART_6 and define
|
|
// MICROPY_HW_UART_REPL_BAUD in your mpconfigboard.h file if you want a
|
|
// REPL on a hardware UART as well as on USB VCP
|
|
#if defined(MICROPY_HW_UART_REPL)
|
|
{
|
|
mp_obj_t args[2] = {
|
|
MP_OBJ_NEW_SMALL_INT(MICROPY_HW_UART_REPL),
|
|
MP_OBJ_NEW_SMALL_INT(MICROPY_HW_UART_REPL_BAUD),
|
|
};
|
|
MP_STATE_PORT(pyb_stdio_uart) = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args);
|
|
}
|
|
#else
|
|
MP_STATE_PORT(pyb_stdio_uart) = NULL;
|
|
#endif
|
|
|
|
#if MICROPY_HW_ENABLE_CAN
|
|
can_init0();
|
|
#endif
|
|
|
|
#if MICROPY_HW_ENABLE_RNG
|
|
rng_init0();
|
|
#endif
|
|
|
|
i2c_init0();
|
|
spi_init0();
|
|
pyb_usb_init0();
|
|
|
|
// Initialise the local flash filesystem.
|
|
// Create it if needed, mount in on /flash, and set it as current dir.
|
|
init_flash_fs(reset_mode);
|
|
|
|
#if MICROPY_HW_HAS_SDCARD
|
|
// if an SD card is present then mount it on /sd/
|
|
if (sdcard_is_present()) {
|
|
// create vfs object
|
|
fs_user_mount_t *vfs_fat = m_new_obj_maybe(fs_user_mount_t);
|
|
mp_vfs_mount_t *vfs = m_new_obj_maybe(mp_vfs_mount_t);
|
|
if (vfs == NULL || vfs_fat == NULL) {
|
|
goto no_mem_for_sd;
|
|
}
|
|
vfs_fat->str = NULL;
|
|
vfs_fat->len = 0;
|
|
vfs_fat->flags = FSUSER_FREE_OBJ;
|
|
sdcard_init_vfs(vfs_fat);
|
|
|
|
FRESULT res = f_mount(&vfs_fat->fatfs);
|
|
if (res != FR_OK) {
|
|
printf("PYB: can't mount SD card\n");
|
|
m_del_obj(fs_user_mount_t, vfs_fat);
|
|
m_del_obj(mp_vfs_mount_t, vfs);
|
|
} else {
|
|
// mount the sd device after the internal flash
|
|
vfs->str = "/sd";
|
|
vfs->len = 3;
|
|
vfs->obj = MP_OBJ_FROM_PTR(vfs_fat);
|
|
vfs->next = NULL;
|
|
MP_STATE_VM(vfs_mount_table)->next = vfs;
|
|
|
|
// TODO these should go before the /flash entries in the path
|
|
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd));
|
|
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_sd_slash_lib));
|
|
|
|
if (first_soft_reset) {
|
|
// use SD card as medium for the USB MSD
|
|
#if defined(USE_DEVICE_MODE)
|
|
pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_SDCARD;
|
|
#endif
|
|
}
|
|
|
|
#if defined(USE_DEVICE_MODE)
|
|
// only use SD card as current directory if that's what the USB medium is
|
|
if (pyb_usb_storage_medium == PYB_USB_STORAGE_MEDIUM_SDCARD)
|
|
#endif
|
|
{
|
|
// use SD card as current directory
|
|
MP_STATE_PORT(vfs_cur) = vfs;
|
|
}
|
|
}
|
|
no_mem_for_sd:;
|
|
}
|
|
#endif
|
|
|
|
// reset config variables; they should be set by boot.py
|
|
MP_STATE_PORT(pyb_config_main) = MP_OBJ_NULL;
|
|
|
|
// run boot.py, if it exists
|
|
// TODO perhaps have pyb.reboot([bootpy]) function to soft-reboot and execute custom boot.py
|
|
if (reset_mode == 1 || reset_mode == 3) {
|
|
const char *boot_py = "boot.py";
|
|
mp_import_stat_t stat = mp_import_stat(boot_py);
|
|
if (stat == MP_IMPORT_STAT_FILE) {
|
|
int ret = pyexec_file(boot_py);
|
|
if (ret & PYEXEC_FORCED_EXIT) {
|
|
goto soft_reset_exit;
|
|
}
|
|
if (!ret) {
|
|
flash_error(4);
|
|
}
|
|
}
|
|
}
|
|
|
|
// turn boot-up LEDs off
|
|
#if !defined(MICROPY_HW_LED2)
|
|
// If there is only one LED on the board then it's used to signal boot-up
|
|
// and so we turn it off here. Otherwise LED(1) is used to indicate dirty
|
|
// flash cache and so we shouldn't change its state.
|
|
led_state(1, 0);
|
|
#endif
|
|
led_state(2, 0);
|
|
led_state(3, 0);
|
|
led_state(4, 0);
|
|
|
|
// Now we initialise sub-systems that need configuration from boot.py,
|
|
// or whose initialisation can be safely deferred until after running
|
|
// boot.py.
|
|
|
|
#if defined(USE_DEVICE_MODE)
|
|
// init USB device to default setting if it was not already configured
|
|
if (!(pyb_usb_flags & PYB_USB_FLAG_USB_MODE_CALLED)) {
|
|
pyb_usb_dev_init(USBD_VID, USBD_PID_CDC_MSC, USBD_MODE_CDC_MSC, NULL);
|
|
}
|
|
#endif
|
|
|
|
#if MICROPY_HW_HAS_MMA7660
|
|
// MMA accel: init and reset
|
|
accel_init();
|
|
#endif
|
|
|
|
#if MICROPY_HW_ENABLE_SERVO
|
|
// servo
|
|
servo_init();
|
|
#endif
|
|
|
|
#if MICROPY_HW_ENABLE_DAC
|
|
// DAC
|
|
dac_init();
|
|
#endif
|
|
|
|
#if MICROPY_PY_NETWORK
|
|
mod_network_init();
|
|
#endif
|
|
|
|
// At this point everything is fully configured and initialised.
|
|
|
|
// Run the main script from the current directory.
|
|
if ((reset_mode == 1 || reset_mode == 3) && pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
|
|
const char *main_py;
|
|
if (MP_STATE_PORT(pyb_config_main) == MP_OBJ_NULL) {
|
|
main_py = "main.py";
|
|
} else {
|
|
main_py = mp_obj_str_get_str(MP_STATE_PORT(pyb_config_main));
|
|
}
|
|
mp_import_stat_t stat = mp_import_stat(main_py);
|
|
if (stat == MP_IMPORT_STAT_FILE) {
|
|
int ret = pyexec_file(main_py);
|
|
if (ret & PYEXEC_FORCED_EXIT) {
|
|
goto soft_reset_exit;
|
|
}
|
|
if (!ret) {
|
|
flash_error(3);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Main script is finished, so now go into REPL mode.
|
|
// The REPL mode can change, or it can request a soft reset.
|
|
for (;;) {
|
|
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
|
|
if (pyexec_raw_repl() != 0) {
|
|
break;
|
|
}
|
|
} else {
|
|
if (pyexec_friendly_repl() != 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
soft_reset_exit:
|
|
|
|
// soft reset
|
|
|
|
printf("PYB: sync filesystems\n");
|
|
storage_flush();
|
|
|
|
printf("PYB: soft reboot\n");
|
|
timer_deinit();
|
|
uart_deinit();
|
|
#if MICROPY_HW_ENABLE_CAN
|
|
can_deinit();
|
|
#endif
|
|
|
|
first_soft_reset = false;
|
|
goto soft_reset;
|
|
}
|