STATIC void mp_reset(void) {
mp_stack_set_top((void*)0x40000000);
mp_stack_set_limit(8192);
mp_hal_init();
gc_init(heap, heap + sizeof(heap));
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_lib));
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_));
mp_obj_list_init(mp_sys_argv, 0);
#if MICROPY_VFS_FAT
memset(MP_STATE_PORT(fs_user_mount), 0, sizeof(MP_STATE_PORT(fs_user_mount)));
#endif
MP_STATE_PORT(mp_kbd_exception) = mp_obj_new_exception(&mp_type_KeyboardInterrupt);
MP_STATE_PORT(term_obj) = MP_OBJ_NULL;
MP_STATE_PORT(dupterm_arr_obj) = MP_OBJ_NULL;
pin_init0();
readline_init0();
dupterm_task_init();
#if MICROPY_MODULE_FROZEN
pyexec_frozen_module("_boot.py");
pyexec_file("boot.py");
pyexec_file("main.py");
#endif
}
STATIC void mp_reset(void) {
mp_stack_set_top((void*)0x40000000);
mp_stack_set_limit(8192);
mp_hal_init();
gc_init(heap, heap + sizeof(heap));
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_slash_lib));
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_flash));
mp_obj_list_init(mp_sys_argv, 0);
MP_STATE_PORT(term_obj) = MP_OBJ_NULL;
MP_STATE_PORT(dupterm_arr_obj) = MP_OBJ_NULL;
#if MICROPY_EMIT_XTENSA || MICROPY_EMIT_INLINE_XTENSA
extern void esp_native_code_init(void);
esp_native_code_init();
#endif
pin_init0();
readline_init0();
dupterm_task_init();
#if MICROPY_MODULE_FROZEN
pyexec_frozen_module("_boot.py");
pyexec_file("boot.py");
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
pyexec_file("main.py");
}
#endif
}
void mp_run(void) {
int stack_dummy;
stack_top = (char*)&stack_dummy;
mp_stack_ctrl_init();
mp_stack_set_limit(1800); // stack is 2k
// allocate the heap statically in the bss
static uint32_t heap[9820 / 4];
gc_init(heap, (uint8_t*)heap + sizeof(heap));
/*
// allocate the heap using system malloc
extern void *malloc(int);
void *mheap = malloc(2000);
gc_init(mheap, (byte*)mheap + 2000);
*/
/*
// allocate the heap statically (will clash with BLE)
gc_init((void*)0x20000100, (void*)0x20002000);
*/
mp_init();
mp_hal_init();
readline_init0();
microbit_init();
if (APPENDED_SCRIPT->header[0] == 'M' && APPENDED_SCRIPT->header[1] == 'P') {
// run appended script
do_strn(APPENDED_SCRIPT->str, APPENDED_SCRIPT->len);
} else if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
// from microbit import *
mp_import_all(mp_import_name(MP_QSTR_microbit, mp_const_empty_tuple, MP_OBJ_NEW_SMALL_INT(0)));
}
for (;;) {
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
if (pyexec_raw_repl() != 0) {
break;
}
} else {
if (pyexec_friendly_repl() != 0) {
break;
}
}
}
mp_hal_stdout_tx_str("soft reboot\r\n");
memset(&MP_STATE_PORT(async_data)[0], 0, sizeof(MP_STATE_PORT(async_data)));
MP_STATE_PORT(async_music_data) = NULL;
mp_deinit();
}
void mp_task(void *pvParameter) {
volatile uint32_t sp = (uint32_t)get_sp();
#if MICROPY_PY_THREAD
mp_thread_init(&mp_task_stack[0], MP_TASK_STACK_LEN);
#endif
uart_init();
soft_reset:
// initialise the stack pointer for the main thread
mp_stack_set_top((void *)sp);
mp_stack_set_limit(MP_TASK_STACK_SIZE - 1024);
gc_init(mp_task_heap, mp_task_heap + sizeof(mp_task_heap));
mp_init();
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_));
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_lib));
mp_obj_list_init(mp_sys_argv, 0);
readline_init0();
// initialise peripherals
machine_pins_init();
// run boot-up scripts
pyexec_frozen_module("_boot.py");
pyexec_file("boot.py");
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
pyexec_file("main.py");
}
for (;;) {
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
if (pyexec_raw_repl() != 0) {
break;
}
} else {
if (pyexec_friendly_repl() != 0) {
break;
}
}
}
#if MICROPY_PY_THREAD
mp_thread_deinit();
#endif
mp_hal_stdout_tx_str("PYB: soft reboot\r\n");
// deinitialise peripherals
machine_pins_deinit();
mp_deinit();
fflush(stdout);
goto soft_reset;
}
int main(int argc, char **argv) {
// init the CPU and the peripherals
cpu_init();
led_init();
switch_init();
uart_init();
soft_reset:
// flash green led for 150ms to indicate boot
led_state(1, 0);
led_state(2, 0);
led_state(3, 1);
mp_hal_delay_ms(150);
led_state(3, 0);
// init MicroPython runtime
int stack_dummy;
MP_STATE_THREAD(stack_top) = (char*)&stack_dummy;
gc_init(heap, heap + sizeof(heap));
mp_init();
mp_hal_init();
readline_init0();
// REPL loop
for (;;) {
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
if (pyexec_raw_repl() != 0) {
break;
}
} else {
if (pyexec_friendly_repl() != 0) {
break;
}
}
}
printf("PYB: soft reboot\n");
mp_deinit();
goto soft_reset;
}
STATIC void mp_reset(void) {
mp_stack_set_top((void*)0x40000000);
mp_stack_set_limit(8192);
mp_hal_init();
gc_init(heap, heap + sizeof(heap));
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_lib));
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_));
mp_obj_list_init(mp_sys_argv, 0);
#if MICROPY_EMIT_XTENSA || MICROPY_EMIT_INLINE_XTENSA
extern void esp_native_code_init(void);
esp_native_code_init();
#endif
pin_init0();
readline_init0();
dupterm_task_init();
// Activate UART(0) on dupterm slot 1 for the REPL
{
mp_obj_t args[2];
args[0] = MP_OBJ_NEW_SMALL_INT(0);
args[1] = MP_OBJ_NEW_SMALL_INT(115200);
args[0] = pyb_uart_type.make_new(&pyb_uart_type, 2, 0, args);
args[1] = MP_OBJ_NEW_SMALL_INT(1);
extern mp_obj_t os_dupterm(size_t n_args, const mp_obj_t *args);
os_dupterm(2, args);
}
#if MICROPY_MODULE_FROZEN
pyexec_frozen_module("_boot.py");
pyexec_file_if_exists("boot.py");
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
pyexec_file_if_exists("main.py");
}
#endif
}
void TASK_Micropython (void *pvParameters) {
// initialize the garbage collector with the top of our stack
uint32_t sp = gc_helper_get_sp();
gc_collect_init (sp);
bool safeboot = false;
mptask_pre_init();
#ifndef DEBUG
safeboot = PRCMGetSpecialBit(PRCM_SAFE_BOOT_BIT);
#endif
soft_reset:
// GC init
gc_init(&_boot, &_eheap);
// MicroPython init
mp_init();
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_init(mp_sys_argv, 0);
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
// execute all basic initializations
mpexception_init0();
mp_irq_init0();
pyb_sleep_init0();
pin_init0();
mperror_init0();
uart_init0();
timer_init0();
readline_init0();
mod_network_init0();
moduos_init0();
rng_init0();
pybsleep_reset_cause_t rstcause = pyb_sleep_get_reset_cause();
if (rstcause < PYB_SLP_SOFT_RESET) {
if (rstcause == PYB_SLP_HIB_RESET) {
// when waking up from hibernate we just want
// to enable simplelink and leave it as is
wlan_first_start();
}
else {
// only if not comming out of hibernate or a soft reset
mptask_enter_ap_mode();
}
// enable telnet and ftp
servers_start();
}
// initialize the serial flash file system
mptask_init_sflash_filesystem();
// append the flash paths to the system path
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));
// reset config variables; they should be set by boot.py
MP_STATE_PORT(machine_config_main) = MP_OBJ_NULL;
if (!safeboot) {
// run boot.py
int ret = pyexec_file("boot.py");
if (ret & PYEXEC_FORCED_EXIT) {
goto soft_reset_exit;
}
if (!ret) {
// flash the system led
mperror_signal_error();
}
}
// now we initialise sub-systems that need configuration from boot.py,
// or whose initialisation can be safely deferred until after running
// boot.py.
// at this point everything is fully configured and initialised.
if (!safeboot) {
// run the main script from the current directory.
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
const char *main_py;
if (MP_STATE_PORT(machine_config_main) == MP_OBJ_NULL) {
main_py = "main.py";
} else {
main_py = mp_obj_str_get_str(MP_STATE_PORT(machine_config_main));
}
int ret = pyexec_file(main_py);
if (ret & PYEXEC_FORCED_EXIT) {
goto soft_reset_exit;
}
if (!ret) {
// flash the system led
mperror_signal_error();
}
}
}
// 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
pyb_sleep_signal_soft_reset();
mp_printf(&mp_plat_print, "PYB: soft reboot\n");
// disable all callbacks to avoid undefined behaviour
// when coming out of a soft reset
mp_irq_disable_all();
// cancel the RTC alarm which might be running independent of the irq state
pyb_rtc_disable_alarm();
// flush the serial flash buffer
sflash_disk_flush();
// clean-up the user socket space
modusocket_close_all_user_sockets();
// wait for pending transactions to complete
mp_hal_delay_ms(20);
goto soft_reset;
}
void TASK_Micropython (void *pvParameters) {
// initialize the garbage collector with the top of our stack
uint32_t sp = gc_helper_get_sp();
gc_collect_init (sp);
bool safeboot = false;
mptask_pre_init();
#ifndef DEBUG
safeboot = PRCMGetSpecialBit(PRCM_SAFE_BOOT_BIT);
#endif
soft_reset:
// GC init
gc_init(&_boot, &_eheap);
// MicroPython init
mp_init();
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_init(mp_sys_argv, 0);
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_)); // current dir (or base dir of the script)
// execute all basic initializations
mpexception_init0();
mpcallback_init0();
pybsleep_init0();
mperror_init0();
uart_init0();
pin_init0();
timer_init0();
readline_init0();
mod_network_init0();
#if MICROPY_HW_ENABLE_RNG
rng_init0();
#endif
#ifdef LAUNCHXL
// configure the stdio uart pins with the correct alternate functions
// param 3 ("mode") is DON'T CARE" for AFs others than GPIO
pin_config ((pin_obj_t *)&MICROPY_STDIO_UART_TX_PIN, MICROPY_STDIO_UART_TX_PIN_AF, 0, PIN_TYPE_STD_PU, PIN_STRENGTH_2MA);
pin_config ((pin_obj_t *)&MICROPY_STDIO_UART_RX_PIN, MICROPY_STDIO_UART_RX_PIN_AF, 0, PIN_TYPE_STD_PU, PIN_STRENGTH_2MA);
// instantiate the stdio uart
mp_obj_t args[2] = {
mp_obj_new_int(MICROPY_STDIO_UART),
mp_obj_new_int(MICROPY_STDIO_UART_BAUD),
};
pyb_stdio_uart = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args);
// create a callback for the uart, in order to enable the rx interrupts
uart_callback_new (pyb_stdio_uart, mp_const_none, MICROPY_STDIO_UART_RX_BUF_SIZE, INT_PRIORITY_LVL_3);
#else
pyb_stdio_uart = MP_OBJ_NULL;
#endif
pybsleep_reset_cause_t rstcause = pybsleep_get_reset_cause();
if (rstcause < PYB_SLP_SOFT_RESET) {
if (rstcause == PYB_SLP_HIB_RESET) {
// when waking up from hibernate we just want
// to enable simplelink and leave it as is
wlan_first_start();
}
else {
// only if not comming out of hibernate or a soft reset
mptask_enter_ap_mode();
}
// enable telnet and ftp
servers_start();
}
// initialize the serial flash file system
mptask_init_sflash_filesystem();
// append the flash paths to the system path
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));
// reset config variables; they should be set by boot.py
MP_STATE_PORT(pyb_config_main) = MP_OBJ_NULL;
if (!safeboot) {
// run boot.py
int ret = pyexec_file("boot.py");
if (ret & PYEXEC_FORCED_EXIT) {
goto soft_reset_exit;
}
if (!ret) {
// flash the system led
mperror_signal_error();
}
}
// now we initialise sub-systems that need configuration from boot.py,
// or whose initialisation can be safely deferred until after running
// boot.py.
// at this point everything is fully configured and initialised.
if (!safeboot) {
// run the main script from the current directory.
if (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));
}
int ret = pyexec_file(main_py);
if (ret & PYEXEC_FORCED_EXIT) {
goto soft_reset_exit;
}
if (!ret) {
// flash the system led
mperror_signal_error();
}
}
}
// 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
pybsleep_signal_soft_reset();
mp_printf(&mp_plat_print, "PYB: soft reboot\n");
// disable all peripherals that could trigger a callback
pyb_rtc_callback_disable(NULL);
timer_disable_all();
uart_disable_all();
// flush the serial flash buffer
sflash_disk_flush();
// clean-up the user socket space
modusocket_close_all_user_sockets();
#if MICROPY_HW_HAS_SDCARD
pybsd_disable();
#endif
// wait for pending transactions to complete
HAL_Delay(20);
goto soft_reset;
}
void mp_task(void *pvParameter) {
volatile uint32_t sp = (uint32_t)get_sp();
#if MICROPY_PY_THREAD
mp_thread_init(&mp_task_stack[0], MP_TASK_STACK_LEN);
#endif
uart_init();
// Allocate the uPy heap using malloc and get the largest available region
size_t mp_task_heap_size = heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
void *mp_task_heap = malloc(mp_task_heap_size);
soft_reset:
// initialise the stack pointer for the main thread
mp_stack_set_top((void *)sp);
mp_stack_set_limit(MP_TASK_STACK_SIZE - 1024);
gc_init(mp_task_heap, mp_task_heap + mp_task_heap_size);
mp_init();
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR_));
mp_obj_list_append(mp_sys_path, MP_OBJ_NEW_QSTR(MP_QSTR__slash_lib));
mp_obj_list_init(mp_sys_argv, 0);
readline_init0();
// initialise peripherals
machine_pins_init();
// run boot-up scripts
pyexec_frozen_module("_boot.py");
pyexec_file("boot.py");
if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
pyexec_file("main.py");
}
for (;;) {
if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
vprintf_like_t vprintf_log = esp_log_set_vprintf(vprintf_null);
if (pyexec_raw_repl() != 0) {
break;
}
esp_log_set_vprintf(vprintf_log);
} else {
if (pyexec_friendly_repl() != 0) {
break;
}
}
}
#if MICROPY_PY_THREAD
mp_thread_deinit();
#endif
gc_sweep_all();
mp_hal_stdout_tx_str("PYB: soft reboot\r\n");
// deinitialise peripherals
machine_pins_deinit();
usocket_events_deinit();
mp_deinit();
fflush(stdout);
goto soft_reset;
}
int main(void)
{
// Stack limit should be less than real stack size, so we
// had chance to recover from limit hit.
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();
// basic sub-system init
pendsv_init();
timer_tim3_init();
led_init();
soft_reset:
// check if user switch held to select the reset mode
led_state(LED_RED, 1);
led_state(LED_GREEN, 1);
led_state(LED_BLUE, 1);
#if MICROPY_HW_ENABLE_RTC
rtc_init();
#endif
// GC init
gc_init(&_heap_start, &_heap_end);
// Micro Python init
mp_init();
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_init(mp_sys_argv, 0);
readline_init0();
pin_init0();
extint_init0();
timer_init0();
rng_init0();
i2c_init0();
spi_init0();
uart_init0();
pyb_usb_init0();
usbdbg_init();
if (sensor_init() != 0) {
__fatal_error("Failed to init sensor");
}
/* Export functions to the global python namespace */
mp_store_global(qstr_from_str("randint"), (mp_obj_t)&py_randint_obj);
mp_store_global(qstr_from_str("cpu_freq"), (mp_obj_t)&py_cpu_freq_obj);
mp_store_global(qstr_from_str("Image"), (mp_obj_t)&py_image_load_image_obj);
mp_store_global(qstr_from_str("HaarCascade"), (mp_obj_t)&py_image_load_cascade_obj);
mp_store_global(qstr_from_str("FreakDesc"), (mp_obj_t)&py_image_load_descriptor_obj);
mp_store_global(qstr_from_str("FreakDescSave"), (mp_obj_t)&py_image_save_descriptor_obj);
mp_store_global(qstr_from_str("LBPDesc"), (mp_obj_t)&py_image_load_lbp_obj);
mp_store_global(qstr_from_str("vcp_is_connected"), (mp_obj_t)&py_vcp_is_connected_obj);
if (sdcard_is_present()) {
sdcard_init();
FRESULT res = f_mount(&fatfs, "1:", 1);
if (res != FR_OK) {
__fatal_error("could not mount SD\n");
}
// Set CWD and USB medium to SD
f_chdrive("1:");
pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_SDCARD;
} else {
storage_init();
// try to mount the flash
FRESULT res = f_mount(&fatfs, "0:", 1);
if (res == FR_NO_FILESYSTEM) {
// create a fresh fs
make_flash_fs();
} else if (res != FR_OK) {
__fatal_error("could not access LFS\n");
}
// Set CWD and USB medium to flash
f_chdrive("0:");
pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_FLASH;
}
// turn boot-up LEDs off
led_state(LED_RED, 0);
led_state(LED_GREEN, 0);
led_state(LED_BLUE, 0);
// 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);
}
// Run the main script from the current directory.
FRESULT res = f_stat("main.py", NULL);
if (res == FR_OK) {
if (!pyexec_file("main.py")) {
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
flash_error(3);
nlr_pop();
}
}
}
// Enter REPL
nlr_buf_t nlr;
for (;;) {
if (nlr_push(&nlr) == 0) {
while (usbdbg_script_ready()) {
nlr_buf_t nlr;
vstr_t *script_buf = usbdbg_get_script();
// clear script flag
usbdbg_clr_script();
// execute the script
if (nlr_push(&nlr) == 0) {
pyexec_push_scope();
// parse and compile script
mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_,
vstr_str(script_buf), vstr_len(script_buf), 0);
mp_parse_node_t pn = mp_parse(lex, MP_PARSE_FILE_INPUT);
mp_obj_t script = mp_compile(pn, lex->source_name, MP_EMIT_OPT_NONE, false);
// execute the script
mp_call_function_0(script);
nlr_pop();
} else {
mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
}
pyexec_pop_scope();
}
// clear script flag
usbdbg_clr_script();
// no script run REPL
pyexec_friendly_repl();
nlr_pop();
}
}
printf("PYB: sync filesystems\n");
storage_flush();
printf("PYB: soft reboot\n");
goto soft_reset;
}
int main(void)
{
FRESULT f_res;
int sensor_init_ret;
// Stack limit should be less than real stack size, so we
// had chance to recover from limit hit.
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();
// basic sub-system init
pendsv_init();
timer_tim3_init();
led_init();
soft_reset:
// check if user switch held to select the reset mode
led_state(LED_RED, 1);
led_state(LED_GREEN, 1);
led_state(LED_BLUE, 1);
#if MICROPY_HW_ENABLE_RTC
rtc_init();
#endif
// GC init
gc_init(&_heap_start, &_heap_end);
// Micro Python init
mp_init();
mp_obj_list_init(mp_sys_path, 0);
mp_obj_list_init(mp_sys_argv, 0);
readline_init0();
pin_init0();
extint_init0();
timer_init0();
rng_init0();
i2c_init0();
spi_init0();
uart_init0();
pyb_usb_init0();
usbdbg_init();
sensor_init_ret = sensor_init();
/* Export functions to the global python namespace */
mp_store_global(qstr_from_str("randint"), (mp_obj_t)&py_randint_obj);
mp_store_global(qstr_from_str("cpu_freq"), (mp_obj_t)&py_cpu_freq_obj);
mp_store_global(qstr_from_str("vcp_is_connected"), (mp_obj_t)&py_vcp_is_connected_obj);
if (sdcard_is_present()) {
sdcard_init();
FRESULT res = f_mount(&fatfs, "1:", 1);
if (res != FR_OK) {
__fatal_error("could not mount SD\n");
}
// Set CWD and USB medium to SD
f_chdrive("1:");
pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_SDCARD;
} else {
storage_init();
// try to mount the flash
FRESULT res = f_mount(&fatfs, "0:", 1);
if (res == FR_NO_FILESYSTEM) {
// create a fresh fs
make_flash_fs();
} else if (res != FR_OK) {
__fatal_error("could not access LFS\n");
}
// Set CWD and USB medium to flash
f_chdrive("0:");
pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_FLASH;
}
// turn boot-up LEDs off
led_state(LED_RED, 0);
led_state(LED_GREEN, 0);
led_state(LED_BLUE, 0);
// 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);
}
// check sensor init result
if (sensor_init_ret != 0) {
char buf[512];
snprintf(buf, sizeof(buf), "Failed to init sensor, error:%d", sensor_init_ret);
__fatal_error(buf);
}
// Run self tests the first time only
f_res = f_stat("selftest.py", NULL);
if (f_res == FR_OK) {
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
// Parse, compile and execute the self-tests script.
pyexec_file("selftest.py");
nlr_pop();
} else {
// Get the exception message. TODO: might be a hack.
mp_obj_str_t *str = mp_obj_exception_get_value((mp_obj_t)nlr.ret_val);
// If any of the self-tests fail log the exception message
// and loop forever. Note: IDE exceptions will not be caught.
__fatal_error((const char*) str->data);
}
// Success: remove self tests script and flush cache
f_unlink("selftest.py");
storage_flush();
}
// Run the main script from the current directory.
f_res = f_stat("main.py", NULL);
if (f_res == FR_OK) {
nlr_buf_t nlr;
if (nlr_push(&nlr) == 0) {
// Parse, compile and execute the main script.
pyexec_file("main.py");
nlr_pop();
} else {
mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
if (nlr_push(&nlr) == 0) {
flash_error(3);
nlr_pop();
}// if this gets interrupted again ignore it.
}
}
// Enter REPL
nlr_buf_t nlr;
for (;;) {
if (nlr_push(&nlr) == 0) {
while (usbdbg_script_ready()) {
nlr_buf_t nlr;
vstr_t *script_buf = usbdbg_get_script();
// clear debugging flags
usbdbg_clear_flags();
// re-init MP
mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
mp_init();
MICROPY_END_ATOMIC_SECTION(atomic_state);
// execute the script
if (nlr_push(&nlr) == 0) {
// parse, compile and execute script
pyexec_str(script_buf);
nlr_pop();
} else {
mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
}
}
// clear debugging flags
usbdbg_clear_flags();
// re-init MP
mp_uint_t atomic_state = MICROPY_BEGIN_ATOMIC_SECTION();
mp_init();
MICROPY_END_ATOMIC_SECTION(atomic_state);
// no script run REPL
pyexec_friendly_repl();
nlr_pop();
}
}
printf("PYB: sync filesystems\n");
storage_flush();
printf("PYB: soft reboot\n");
goto soft_reset;
}
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_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();
// enable the CCM RAM
__CCMDATARAMEN_CLK_ENABLE();
#if 0
#if defined(NETDUINO_PLUS_2)
{
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
#if MICROPY_HW_HAS_SDCARD
// Turn on the power enable for the sdcard (PB1)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_WriteBit(GPIOB, GPIO_Pin_1, Bit_SET);
#endif
// Turn on the power for the 5V on the expansion header (PB2)
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_WriteBit(GPIOB, GPIO_Pin_2, Bit_SET);
}
#endif
#endif
// basic sub-system init
pendsv_init();
timer_tim3_init();
led_init();
#if MICROPY_HW_HAS_SWITCH
switch_init0();
#endif
int first_soft_reset = true;
soft_reset:
// check if user switch held to select the reset mode
led_state(1, 0);
led_state(2, 1);
led_state(3, 0);
led_state(4, 0);
uint reset_mode = 1;
#if MICROPY_HW_HAS_SWITCH
if (switch_get()) {
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);
}
#endif
#if MICROPY_HW_ENABLE_RTC
if (first_soft_reset) {
rtc_init();
}
#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);
// Change #if 0 to #if 1 if you want REPL on UART_6 (or another uart)
// as well as on USB VCP
#if 0
{
mp_obj_t args[2] = {
MP_OBJ_NEW_SMALL_INT(PYB_UART_6),
MP_OBJ_NEW_SMALL_INT(115200),
};
pyb_stdio_uart = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args);
}
#else
pyb_stdio_uart = NULL;
#endif
// 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();
#if MICROPY_HW_ENABLE_RNG
rng_init0();
#endif
i2c_init0();
spi_init0();
pyb_usb_init0();
// Initialise the local flash filesystem.
// Create it if needed, and mount in on /flash.
{
// try to mount the flash
FRESULT res = f_mount(&fatfs0, "/flash", 1);
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();
res = f_mkfs("/flash", 0, 0);
if (res == FR_OK) {
// success creating fresh LFS
} else {
__fatal_error("could not create LFS");
}
// set label
f_setlabel("/flash/pybflash");
// create empty main.py
FIL fp;
f_open(&fp, "/flash/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(&fp, "/flash/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(&fp, "/flash/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 {
__fatal_error("could not access LFS");
}
}
// The current directory is used as the boot up directory.
// It is set to the internal flash filesystem by default.
f_chdrive("/flash");
// Make sure we have a /flash/boot.py. Create it if needed.
{
FILINFO fno;
#if _USE_LFN
fno.lfname = NULL;
fno.lfsize = 0;
#endif
FRESULT res = f_stat("/flash/boot.py", &fno);
if (res == FR_OK) {
if (fno.fattrib & AM_DIR) {
// exists as a directory
// TODO handle this case
// see http://elm-chan.org/fsw/ff/img/app2.c for a "rm -rf" implementation
} else {
// exists as a file, good!
}
} else {
// 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(&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);
}
}
#if defined(USE_DEVICE_MODE)
usb_storage_medium_t usb_medium = USB_STORAGE_MEDIUM_FLASH;
#endif
#if MICROPY_HW_HAS_SDCARD
// if an SD card is present then mount it on /sd/
if (sdcard_is_present()) {
FRESULT res = f_mount(&fatfs1, "/sd", 1);
if (res != FR_OK) {
printf("[SD] could not mount SD card\n");
} else {
// use SD card as current directory
f_chdrive("/sd");
// 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)
usb_medium = USB_STORAGE_MEDIUM_SDCARD;
#endif
}
}
}
#endif
// reset config variables; they should be set by boot.py
pyb_config_main = MP_OBJ_NULL;
pyb_config_usb_mode = 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) {
const char *boot_py = "boot.py";
FRESULT res = f_stat(boot_py, NULL);
if (res == FR_OK) {
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
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_HOST_MODE)
// USB host
pyb_usb_host_init();
#elif defined(USE_DEVICE_MODE)
// USB device
usb_device_mode_t usb_mode = USB_DEVICE_MODE_CDC_MSC;
// if we are not in reset_mode==1, this config variable will always be NULL
if (pyb_config_usb_mode != MP_OBJ_NULL) {
if (strcmp(mp_obj_str_get_str(pyb_config_usb_mode), "CDC+HID") == 0) {
usb_mode = USB_DEVICE_MODE_CDC_HID;
}
}
pyb_usb_dev_init(usb_mode, usb_medium);
#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
mod_network_init();
// At this point everything is fully configured and initialised.
// Run the main script from the current directory.
if (reset_mode == 1 && pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
const char *main_py;
if (pyb_config_main == MP_OBJ_NULL) {
main_py = "main.py";
} else {
main_py = mp_obj_str_get_str(pyb_config_main);
}
FRESULT res = f_stat(main_py, NULL);
if (res == FR_OK) {
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();
first_soft_reset = false;
goto soft_reset;
}