main.c

/*
 * This file is part of the MicroPython project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2019 Damien P. George
 * Copyright (c) 2020 Jim Mussared
 *
 * 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 "py/compile.h"
#include "py/runtime.h"
#include "py/gc.h"
#include "py/mperrno.h"
#include "shared/readline/readline.h"
#include "shared/runtime/gchelper.h"
#include "shared/runtime/pyexec.h"
#include "shared/runtime/softtimer.h"
#include "shared/tinyusb/mp_usbd.h"
#include "ticks.h"
#include "led.h"
#include "pendsv.h"
#include "psram.h"
#include "modmachine.h"
#include "modmimxrt.h"

#if MICROPY_PY_LWIP
#include "lwip/init.h"
#include "lwip/apps/mdns.h"
#if MICROPY_PY_NETWORK_CYW43
#include "lib/cyw43-driver/src/cyw43.h"
#endif
#endif

#if MICROPY_PY_BLUETOOTH
#include "mpbthciport.h"
#include "extmod/modbluetooth.h"
#endif

#include "systick.h"
#include "extmod/modmachine.h"
#include "extmod/modnetwork.h"
#include "extmod/vfs.h"

extern uint8_t _sstack, _estack, _gc_heap_start, _gc_heap_end;

void board_init(void);

int main(void) {
    board_init();
    ticks_init();
    pendsv_init();

    #if MICROPY_HW_ENABLE_PSRAM
    size_t psram_size = configure_external_ram();
    #endif

    #if MICROPY_PY_LWIP
    // lwIP doesn't allow to reinitialise itself by subsequent calls to this function
    // because the system timeout list (next_timeout) is only ever reset by BSS clearing.
    // So for now we only init the lwIP stack once on power-up.
    lwip_init();
    #if LWIP_MDNS_RESPONDER
    mdns_resp_init();
    #endif

    systick_enable_dispatch(SYSTICK_DISPATCH_LWIP, mod_network_lwip_poll_wrapper);
    #endif
    #if MICROPY_PY_BLUETOOTH
    mp_bluetooth_hci_init();
    #endif

    #if MICROPY_PY_NETWORK_CYW43
    {
        cyw43_init(&cyw43_state);
        uint8_t buf[8];
        memcpy(&buf[0], "PYBD", 4);
        mp_hal_get_mac_ascii(MP_HAL_MAC_WLAN0, 8, 4, (char *)&buf[4]);
        cyw43_wifi_ap_set_ssid(&cyw43_state, 8, buf);
        cyw43_wifi_ap_set_auth(&cyw43_state, CYW43_AUTH_WPA2_MIXED_PSK);
        cyw43_wifi_ap_set_password(&cyw43_state, 8, (const uint8_t *)"pybd0123");
    }
    #endif

    for (;;) {
        #if defined(MICROPY_HW_LED1_PIN)
        led_init();
        #endif

        mp_cstack_init_with_top(&_estack, &_estack - &_sstack);

        #if MICROPY_HW_ENABLE_PSRAM
        if (psram_size) {
            #if MICROPY_GC_SPLIT_HEAP
            gc_init(&_gc_heap_start, &_gc_heap_end);
            gc_add((void *)PSRAM_BASE, (void *)(PSRAM_BASE + psram_size));
            #else
            gc_init((void *)PSRAM_BASE, (void *)(PSRAM_BASE + psram_size));
            #endif
        } else {
            gc_init(&_gc_heap_start, &_gc_heap_end);
        }
        #else
        gc_init(&_gc_heap_start, &_gc_heap_end);
        #endif
        mp_init();

        #if MICROPY_PY_NETWORK
        mod_network_init();
        #endif

        // Initialise sub-systems.
        readline_init0();

        // Execute _boot.py to set up the filesystem.
        pyexec_frozen_module("_boot.py", false);

        #if MICROPY_HW_USB_MSC
        // Set the USB medium to flash block device.
        mimxrt_msc_medium = &mimxrt_flash_type;

        #if MICROPY_PY_MACHINE_SDCARD
        const char *path = "/sdcard";
        // If SD is mounted, set the USB medium to SD.
        if (mp_vfs_lookup_path(path, &path) != MP_VFS_NONE) {
            mimxrt_msc_medium = &machine_sdcard_type;
        }
        #endif
        #endif

        // Execute user scripts.
        int ret = pyexec_file_if_exists("boot.py");

        #if MICROPY_HW_ENABLE_USBDEV
        mp_usbd_init();
        #endif

        if (ret & PYEXEC_FORCED_EXIT) {
            goto soft_reset_exit;
        }
        // Do not execute main.py if boot.py failed
        if (pyexec_mode_kind == PYEXEC_MODE_FRIENDLY_REPL && ret != 0) {
            ret = pyexec_file_if_exists("main.py");
            if (ret & PYEXEC_FORCED_EXIT) {
                goto soft_reset_exit;
            }
        }

        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:
        mp_printf(MP_PYTHON_PRINTER, "MPY: soft reboot\n");
        machine_pin_irq_deinit();
        machine_rtc_irq_deinit();
        #if MICROPY_PY_MACHINE_I2S
        machine_i2s_deinit_all();
        #endif
        #if MICROPY_PY_BLUETOOTH
        mp_bluetooth_deinit();
        #endif
        #if MICROPY_PY_NETWORK
        mod_network_deinit();
        #endif
        #if MICROPY_PY_MACHINE_UART
        machine_uart_deinit_all();
        #endif
        #if MICROPY_PY_MACHINE_PWM
        machine_pwm_deinit_all();
        #endif
        soft_timer_deinit();
        gc_sweep_all();
        mp_deinit();
    }

    return 0;
}

void gc_collect(void) {
    gc_collect_start();
    gc_helper_collect_regs_and_stack();
    gc_collect_end();
}

void nlr_jump_fail(void *val) {
    for (;;) {
    }
}

#ifndef NDEBUG
void MP_WEAK __assert_func(const char *file, int line, const char *func, const char *expr) {
    mp_printf(MP_PYTHON_PRINTER, "Assertion '%s' failed, at file %s:%d\n", expr, file, line);
    for (;;) {
    }
}
#endif