main.c 20.8 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * 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.
 */

Dave Hylands's avatar
Dave Hylands committed
27
28
29
#include <stdio.h>
#include <string.h>

30
31
32
#include "py/runtime.h"
#include "py/stackctrl.h"
#include "py/gc.h"
33
#include "py/mphal.h"
34
#include "lib/utils/pyexec.h"
35
36
#include "lib/oofatfs/ff.h"
#include "extmod/vfs.h"
37
#include "extmod/vfs_fat.h"
38

39
#include "systick.h"
40
#include "pendsv.h"
41
#include "pybthread.h"
Dave Hylands's avatar
Dave Hylands committed
42
#include "gccollect.h"
43
#include "readline.h"
44
#include "modmachine.h"
Damien George's avatar
Damien George committed
45
46
#include "i2c.h"
#include "spi.h"
Damien George's avatar
Damien George committed
47
#include "uart.h"
48
#include "timer.h"
49
#include "led.h"
50
51
#include "pin.h"
#include "extint.h"
52
#include "usrsw.h"
53
#include "usb.h"
Damien George's avatar
Damien George committed
54
#include "rtc.h"
55
#include "storage.h"
Damien George's avatar
Damien George committed
56
#include "sdcard.h"
57
#include "rng.h"
58
#include "accel.h"
Dave Hylands's avatar
Dave Hylands committed
59
#include "servo.h"
Damien George's avatar
Damien George committed
60
#include "dac.h"
61
#include "can.h"
62
#include "modnetwork.h"
Dave Hylands's avatar
Dave Hylands committed
63

64
65
void SystemClock_Config(void);

66
pyb_thread_t pyb_thread_main;
67
fs_user_mount_t fs_user_mount_flash;
68
mp_vfs_mount_t mp_vfs_mount_flash;
Dave Hylands's avatar
Dave Hylands committed
69
70
71

void flash_error(int n) {
    for (int i = 0; i < n; i++) {
72
73
        led_state(PYB_LED_RED, 1);
        led_state(PYB_LED_GREEN, 0);
74
        mp_hal_delay_ms(250);
75
76
        led_state(PYB_LED_RED, 0);
        led_state(PYB_LED_GREEN, 1);
77
        mp_hal_delay_ms(250);
Dave Hylands's avatar
Dave Hylands committed
78
    }
79
    led_state(PYB_LED_GREEN, 0);
Dave Hylands's avatar
Dave Hylands committed
80
81
}

mux's avatar
mux committed
82
void NORETURN __fatal_error(const char *msg) {
83
84
85
86
87
88
    for (volatile uint delay = 0; delay < 10000000; delay++) {
    }
    led_state(1, 1);
    led_state(2, 1);
    led_state(3, 1);
    led_state(4, 1);
89
90
    mp_hal_stdout_tx_strn("\nFATAL ERROR:\n", 14);
    mp_hal_stdout_tx_strn(msg, strlen(msg));
91
92
93
94
    for (uint i = 0;;) {
        led_toggle(((i++) & 3) + 1);
        for (volatile uint delay = 0; delay < 10000000; delay++) {
        }
95
96
        if (i >= 16) {
            // to conserve power
97
98
            __WFI();
        }
Dave Hylands's avatar
Dave Hylands committed
99
100
101
    }
}

102
103
void nlr_jump_fail(void *val) {
    printf("FATAL: uncaught exception %p\n", val);
104
    mp_obj_print_exception(&mp_plat_print, (mp_obj_t)val);
105
106
107
    __fatal_error("");
}

mux's avatar
mux committed
108
#ifndef NDEBUG
mux's avatar
mux committed
109
void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
mux's avatar
mux committed
110
111
112
113
    (void)func;
    printf("Assertion '%s' failed, at file %s:%d\n", expr, file, line);
    __fatal_error("");
}
mux's avatar
mux committed
114
#endif
mux's avatar
mux committed
115

116
117
118
119
120
121
122
123
124
125
126
127
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;
Dave Hylands's avatar
Dave Hylands committed
128
129
130
    }
    return mp_const_none;
}
131
MP_DEFINE_CONST_FUN_OBJ_KW(pyb_main_obj, 1, pyb_main);
Dave Hylands's avatar
Dave Hylands committed
132
133

static const char fresh_boot_py[] =
134
135
136
"# boot.py -- run on boot-up\r\n"
"# can run arbitrary Python, but best to keep it minimal\r\n"
"\r\n"
137
"import machine\r\n"
138
139
"import pyb\r\n"
"#pyb.main('main.py') # main script to run after this one\r\n"
140
141
"#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"
Dave Hylands's avatar
Dave Hylands committed
142
143
144
;

static const char fresh_main_py[] =
145
"# main.py -- put your code here!\r\n"
Dave Hylands's avatar
Dave Hylands committed
146
147
;

148
static const char fresh_pybcdc_inf[] =
149
#include "genhdr/pybcdc_inf.h"
150
151
;

152
static const char fresh_readme_txt[] =
153
"This is a MicroPython board\r\n"
154
155
156
157
158
159
160
161
162
163
164
165
166
"\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"
;

167
// avoid inlining to avoid stack usage within main()
168
MP_NOINLINE STATIC bool init_flash_fs(uint reset_mode) {
169
    // init the vfs object
170
171
172
173
174
    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);
175

176
    // try to mount the flash
177
    FRESULT res = f_mount(&vfs_fat->fatfs);
178
179
180
181
182

    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
183
        led_state(PYB_LED_GREEN, 1);
184
185
        uint32_t start_tick = HAL_GetTick();

186
187
        uint8_t working_buf[_MAX_SS];
        res = f_mkfs(&vfs_fat->fatfs, FM_FAT, 0, working_buf, sizeof(working_buf));
188
189
190
        if (res == FR_OK) {
            // success creating fresh LFS
        } else {
191
            printf("PYB: can't create flash filesystem\n");
192
            return false;
193
194
195
        }

        // set label
196
        f_setlabel(&vfs_fat->fatfs, "pybflash");
197
198
199

        // create empty main.py
        FIL fp;
200
        f_open(&vfs_fat->fatfs, &fp, "/main.py", FA_WRITE | FA_CREATE_ALWAYS);
201
202
203
204
205
206
        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
207
        f_open(&vfs_fat->fatfs, &fp, "/pybcdc.inf", FA_WRITE | FA_CREATE_ALWAYS);
208
209
210
211
        f_write(&fp, fresh_pybcdc_inf, sizeof(fresh_pybcdc_inf) - 1 /* don't count null terminator */, &n);
        f_close(&fp);

        // create readme file
212
        f_open(&vfs_fat->fatfs, &fp, "/README.txt", FA_WRITE | FA_CREATE_ALWAYS);
213
214
215
216
217
        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);
218
        led_state(PYB_LED_GREEN, 0);
219
220
221
    } else if (res == FR_OK) {
        // mount sucessful
    } else {
222
        printf("PYB: can't mount flash\n");
223
        return false;
224
225
    }

226
227
228
229
230
231
232
233
    // 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;

234
235
    // The current directory is used as the boot up directory.
    // It is set to the internal flash filesystem by default.
236
    MP_STATE_PORT(vfs_cur) = vfs;
237
238
239

    // Make sure we have a /flash/boot.py.  Create it if needed.
    FILINFO fno;
240
241
    res = f_stat(&vfs_fat->fatfs, "/boot.py", &fno);
    if (res != FR_OK) {
242
243
244
        // doesn't exist, create fresh file

        // LED on to indicate creation of boot.py
245
        led_state(PYB_LED_GREEN, 1);
246
247
248
        uint32_t start_tick = HAL_GetTick();

        FIL fp;
249
        f_open(&vfs_fat->fatfs, &fp, "/boot.py", FA_WRITE | FA_CREATE_ALWAYS);
250
251
252
253
254
255
256
        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);
257
        led_state(PYB_LED_GREEN, 0);
258
    }
259
260

    return true;
261
262
}

263
#if MICROPY_HW_HAS_SDCARD
264
STATIC bool init_sdcard_fs(bool first_soft_reset) {
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
    bool first_part = true;
    for (int part_num = 1; part_num <= 4; ++part_num) {
        // 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) {
            break;
        }
        vfs_fat->str = NULL;
        vfs_fat->len = 0;
        vfs_fat->flags = FSUSER_FREE_OBJ;
        sdcard_init_vfs(vfs_fat, part_num);

        // try to mount the partition
        FRESULT res = f_mount(&vfs_fat->fatfs);

        if (res != FR_OK) {
            // couldn't mount
            m_del_obj(fs_user_mount_t, vfs_fat);
            m_del_obj(mp_vfs_mount_t, vfs);
        } else {
            // mounted via FatFs, now mount the SD partition in the VFS
            if (first_part) {
                // the first available partition is traditionally called "sd" for simplicity
                vfs->str = "/sd";
                vfs->len = 3;
            } else {
                // subsequent partitions are numbered by their index in the partition table
                if (part_num == 2) {
                    vfs->str = "/sd2";
                } else if (part_num == 2) {
                    vfs->str = "/sd3";
                } else {
                    vfs->str = "/sd4";
                }
                vfs->len = 4;
            }
            vfs->obj = MP_OBJ_FROM_PTR(vfs_fat);
            vfs->next = NULL;
            for (mp_vfs_mount_t **m = &MP_STATE_VM(vfs_mount_table);; m = &(*m)->next) {
                if (*m == NULL) {
                    *m = vfs;
                    break;
                }
            }

            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
            {
                if (first_part) {
                    // use SD card as current directory
                    MP_STATE_PORT(vfs_cur) = vfs;
                }
            }
            first_part = false;
        }
    }

    if (first_part) {
        printf("PYB: can't mount SD card\n");
334
335
336
        return false;
    } else {
        return true;
337
338
    }
}
339
#endif
340

341
342
343
344
345
346
347
348
349
350
351
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;
            }
352
            mp_hal_delay_ms(20);
353
354
355
356
357
358
359
360
361
362
363
364
365
366
            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);
367
            mp_hal_delay_ms(50);
368
369
370
            led_state(2, reset_mode & 1);
            led_state(3, reset_mode & 2);
            led_state(4, reset_mode & 4);
371
            mp_hal_delay_ms(50);
372
        }
373
        mp_hal_delay_ms(400);
374
375
376
377
378
379
380
381
382
383
384
385

#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);
386
                mp_hal_delay_ms(100);
387
                led_state(1, 0);
388
                mp_hal_delay_ms(200);
389
            }
390
            mp_hal_delay_ms(400);
391
392
393
394
395
396
397
398
399
400
401
            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);
402
                mp_hal_delay_ms(100);
403
                led_state(1, 0);
404
                mp_hal_delay_ms(200);
405
            }
406
            mp_hal_delay_ms(400);
407
408
409
410
411
412
413
414
415
        }
#else
#error Need a reset mode update method
#endif
    }
#endif
    return reset_mode;
}

Dave Hylands's avatar
Dave Hylands committed
416
417
418
419
420
421
422
423
424
425
426
int main(void) {
    // TODO disable JTAG

    /* 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();

427
428
429
430
431
432
433
434
435
    // set the system clock to be HSE
    SystemClock_Config();

    // enable GPIO clocks
    __GPIOA_CLK_ENABLE();
    __GPIOB_CLK_ENABLE();
    __GPIOC_CLK_ENABLE();
    __GPIOD_CLK_ENABLE();

436
437
438
439
440
    #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();
441
        #elif defined(CCMDATARAM_BASE)
442
        // enable the CCM RAM
443
        __HAL_RCC_CCMDATARAMEN_CLK_ENABLE();
444
        #endif
445
    #endif
446

447
448
449
450
    #if defined(MICROPY_BOARD_EARLY_INIT)
    MICROPY_BOARD_EARLY_INIT();
    #endif

Dave Hylands's avatar
Dave Hylands committed
451
    // basic sub-system init
452
    #if MICROPY_PY_THREAD
453
    pyb_thread_init(&pyb_thread_main);
454
    #endif
Dave Hylands's avatar
Dave Hylands committed
455
456
    pendsv_init();
    led_init();
457
#if MICROPY_HW_HAS_SWITCH
458
    switch_init0();
459
#endif
Dave Hylands's avatar
Dave Hylands committed
460

461
462
463
464
465
#if defined(USE_DEVICE_MODE)
    // default to internal flash being the usb medium
    pyb_usb_storage_medium = PYB_USB_STORAGE_MEDIUM_FLASH;
#endif

466
467
468
469
470
    int first_soft_reset = true;

soft_reset:

    // check if user switch held to select the reset mode
471
#if defined(MICROPY_HW_LED2)
472
473
    led_state(1, 0);
    led_state(2, 1);
474
475
476
477
#else
    led_state(1, 1);
    led_state(2, 0);
#endif
478
479
    led_state(3, 0);
    led_state(4, 0);
480
    uint reset_mode = update_reset_mode(1);
481

482
483
    machine_init();

Dave Hylands's avatar
Dave Hylands committed
484
#if MICROPY_HW_ENABLE_RTC
485
    if (first_soft_reset) {
486
        rtc_init_start(false);
487
    }
488
#endif
Dave Hylands's avatar
Dave Hylands committed
489
490
491

    // more sub-system init
#if MICROPY_HW_HAS_SDCARD
492
493
494
    if (first_soft_reset) {
        sdcard_init();
    }
Dave Hylands's avatar
Dave Hylands committed
495
#endif
496
497
498
    if (first_soft_reset) {
        storage_init();
    }
Dave Hylands's avatar
Dave Hylands committed
499

500
501
502
503
504
505
506
507
    // Python threading init
    #if MICROPY_PY_THREAD
    mp_thread_init();
    #endif

    // Stack limit should be less than real stack size, so we have a chance
    // to recover from limit hit.  (Limit is measured in bytes.)
    // Note: stack control relies on main thread being initialised above
508
509
    mp_stack_set_top(&_estack);
    mp_stack_set_limit((char*)&_estack - (char*)&_heap_end - 1024);
510

Dave Hylands's avatar
Dave Hylands committed
511
512
    // GC init
    gc_init(&_heap_start, &_heap_end);
513
514
515
516
517
518

    // 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_init(mp_sys_argv, 0);
Dave Hylands's avatar
Dave Hylands committed
519

520
521
522
523
524
525
526
527
528
529
530
    // 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();

531
532
533
534
    // 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)
535
536
    {
        mp_obj_t args[2] = {
537
538
            MP_OBJ_NEW_SMALL_INT(MICROPY_HW_UART_REPL),
            MP_OBJ_NEW_SMALL_INT(MICROPY_HW_UART_REPL_BAUD),
539
        };
540
        MP_STATE_PORT(pyb_stdio_uart) = pyb_uart_type.make_new((mp_obj_t)&pyb_uart_type, MP_ARRAY_SIZE(args), 0, args);
541
    }
Dave Hylands's avatar
Dave Hylands committed
542
#else
543
    MP_STATE_PORT(pyb_stdio_uart) = NULL;
Dave Hylands's avatar
Dave Hylands committed
544
545
#endif

546
547
548
#if MICROPY_HW_ENABLE_CAN
    can_init0();
#endif
549
550
551
552

#if MICROPY_HW_ENABLE_RNG
    rng_init0();
#endif
Dave Hylands's avatar
Dave Hylands committed
553

554
555
556
557
558
    i2c_init0();
    spi_init0();
    pyb_usb_init0();

    // Initialise the local flash filesystem.
559
    // Create it if needed, mount in on /flash, and set it as current dir.
560
    bool mounted_flash = init_flash_fs(reset_mode);
Dave Hylands's avatar
Dave Hylands committed
561

562
    bool mounted_sdcard = false;
Dave Hylands's avatar
Dave Hylands committed
563
#if MICROPY_HW_HAS_SDCARD
564
    // if an SD card is present then mount it on /sd/
565
    if (sdcard_is_present()) {
566
567
568
569
        // if there is a file in the flash called "SKIPSD", then we don't mount the SD card
        if (!mounted_flash || f_stat(&fs_user_mount_flash.fatfs, "/SKIPSD", NULL) != FR_OK) {
            mounted_sdcard = init_sdcard_fs(first_soft_reset);
        }
Dave Hylands's avatar
Dave Hylands committed
570
571
572
    }
#endif

573
574
575
576
577
578
579
580
581
582
    // set sys.path based on mounted filesystems (/sd is first so it can override /flash)
    if (mounted_sdcard) {
        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 (mounted_flash) {
        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));
    }

583
    // reset config variables; they should be set by boot.py
584
    MP_STATE_PORT(pyb_config_main) = MP_OBJ_NULL;
585

586
    // run boot.py, if it exists
587
    // TODO perhaps have pyb.reboot([bootpy]) function to soft-reboot and execute custom boot.py
588
    if (reset_mode == 1 || reset_mode == 3) {
589
        const char *boot_py = "boot.py";
590
591
        mp_import_stat_t stat = mp_import_stat(boot_py);
        if (stat == MP_IMPORT_STAT_FILE) {
592
593
594
595
596
            int ret = pyexec_file(boot_py);
            if (ret & PYEXEC_FORCED_EXIT) {
                goto soft_reset_exit;
            }
            if (!ret) {
597
598
599
600
601
602
                flash_error(4);
            }
        }
    }

    // turn boot-up LEDs off
603
604
605
606
607
608
#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
609
610
611
612
    led_state(2, 0);
    led_state(3, 0);
    led_state(4, 0);

613
614
615
616
    // Now we initialise sub-systems that need configuration from boot.py,
    // or whose initialisation can be safely deferred until after running
    // boot.py.

617
618
619
#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)) {
620
        pyb_usb_dev_init(USBD_VID, USBD_PID_CDC_MSC, USBD_MODE_CDC_MSC, NULL);
621
    }
Dave Hylands's avatar
Dave Hylands committed
622
623
#endif

624
625
626
627
628
#if MICROPY_HW_HAS_MMA7660
    // MMA accel: init and reset
    accel_init();
#endif

629
630
631
632
633
634
635
636
637
638
#if MICROPY_HW_ENABLE_SERVO
    // servo
    servo_init();
#endif

#if MICROPY_HW_ENABLE_DAC
    // DAC
    dac_init();
#endif

639
#if MICROPY_PY_NETWORK
640
    mod_network_init();
641
#endif
642

643
644
645
    // At this point everything is fully configured and initialised.

    // Run the main script from the current directory.
646
    if ((reset_mode == 1 || reset_mode == 3) && pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL) {
647
        const char *main_py;
648
        if (MP_STATE_PORT(pyb_config_main) == MP_OBJ_NULL) {
649
            main_py = "main.py";
Dave Hylands's avatar
Dave Hylands committed
650
        } else {
651
            main_py = mp_obj_str_get_str(MP_STATE_PORT(pyb_config_main));
Dave Hylands's avatar
Dave Hylands committed
652
        }
653
654
        mp_import_stat_t stat = mp_import_stat(main_py);
        if (stat == MP_IMPORT_STAT_FILE) {
655
656
657
658
659
            int ret = pyexec_file(main_py);
            if (ret & PYEXEC_FORCED_EXIT) {
                goto soft_reset_exit;
            }
            if (!ret) {
660
661
                flash_error(3);
            }
Dave Hylands's avatar
Dave Hylands committed
662
663
664
        }
    }

665
666
    // Main script is finished, so now go into REPL mode.
    // The REPL mode can change, or it can request a soft reset.
667
668
669
670
671
672
673
674
675
676
677
    for (;;) {
        if (pyexec_mode_kind == PYEXEC_MODE_RAW_REPL) {
            if (pyexec_raw_repl() != 0) {
                break;
            }
        } else {
            if (pyexec_friendly_repl() != 0) {
                break;
            }
        }
    }
Dave Hylands's avatar
Dave Hylands committed
678

679
680
soft_reset_exit:

681
682
    // soft reset

Dave Hylands's avatar
Dave Hylands committed
683
684
685
686
    printf("PYB: sync filesystems\n");
    storage_flush();

    printf("PYB: soft reboot\n");
687
    timer_deinit();
688
    uart_deinit();
689
690
691
#if MICROPY_HW_ENABLE_CAN
    can_deinit();
#endif
Dave Hylands's avatar
Dave Hylands committed
692

693
694
695
696
    #if MICROPY_PY_THREAD
    pyb_thread_deinit();
    #endif

Dave Hylands's avatar
Dave Hylands committed
697
698
699
    first_soft_reset = false;
    goto soft_reset;
}