How does the STM32 board handle events written in Python after calling the main function and not terminate?

[mong87suk]

I was investigating how the STM32 MCU operates when running Micropython on an STM32 board.

Upon examining the resethandler_m0.s file, I found that after booting, the STM32 jumps to stm32_main.

After checking the stm32_main code in micropython/ports/stm32/main.c, I noticed that it calls MICROPY_BOARD_BEFORE_SOFT_RESET_LOOP(&state); and then terminates.

When running an example Python code, I want to know if the STM32 board will continue running and not terminate.

To keep the STM32 board from terminating and to receive events, it seems necessary to jump to soft_reset:. However, I am unsure where this jump to soft_reset occurs.

How does the STM32 board handle events written in Python after calling the main function and not terminate?

If there is any part of the question that is unclear, please let me know. I can provide additional explanations.

[glenn20]

I am not sure what you mean by "terminate", but after executing MICROPY_BOARD_BEFORE_SOFT_RESET_LOOP(&state); the code execution continues to proceed through the rest of the initialisation code in stm32_main() till it executes the main.py file (MICROPY_BOARD_RUN_MAIN_PY(&state)) and then enters the repl loop in the code block starting with #if MICROPY_ENABLE_COMPILER. This will continue until a soft or hard reset or loss of power.

If a soft-reset is invoked while the repl is running, the code will exit the repl loop and proceed to the code after the soft_reset_exit: label, which will cleanup the state of peripherals and internal systems, and finally executes goto soft-reset; which will return execution to the point just after MICROPY_BOARD_BEFORE_SOFT_RESET_LOOP(&state); (ie. the soft_reset: label) and micropython re-initialises and restarts the repl loop once again.

[glenn20]

If the compiler has not been enabled in your firmware build, then the repl loop will not execute (as it is unable to interpret any additional code entered at the repl) and the device will proceed immediately to perform a soft-reset. In this case you should write the main.py file so that it does not exit till you want your device to reset.

[mong87suk]

Thank you for your response.
The term "termination" in the context of the following code means that when stm32_main is executed, MICROPY_BOARD_BEFORE_SOFT_RESET_LOOP is executed at the end, and then the main function terminates.

MICROPY_BOARD_BEFORE_SOFT_RESET_LOOP is defined as boardctrl_before_soft_reset_loop, which updates the reset_mode and then terminates.

As you mentioned, in order to enter MICROPY_BOARD_RUN_MAIN_PY(&state), I believe it should enter the soft_reset within the main function to be executed (e.g., goto soft_reset:).

void stm32_main(uint32_t reset_mode) {
   ....
    boardctrl_state_t state;
    state.reset_mode = reset_mode;
    state.log_soft_reset = false;

    MICROPY_BOARD_BEFORE_SOFT_RESET_LOOP(&state);

soft_reset:
    
    MICROPY_BOARD_RUN_MAIN_PY(&state);
     #if MICROPY_ENABLE_COMPILER
    // Main script is finished, so now go into REPL mode.
    // The REPL mode can change, or it can request a soft reset.
    for (;;) {
 ....

1. Through which path does the soft_reset get entered?
   Is there a part in the main function that handles events in REPL mode?

[glenn20]

Ah. I think I understand the misundertanding ;). If you are not familiar with the C language goto statements, it may appear that the stm_main() function ends after the MICROPY_BOARD_BEFORE_SOFT_RESET_LOOP(&state); statement. It does not. The stm_main() function ends at the goto soft_reset; on line 695 (as of current code in master branch).

After the boardctrl_before_soft_reset_loop() function returns, execution will continue to the next line after the soft_reset: label statement (ie. MICROPY_BOARD_TOP_SOFT_RESET_LOOP(&state);) and then continue through the rest of the code in the stm-main() function. The first time through, the soft_reset: statement has no effect. It exists as a target for the goto soft_reset: statement at the end of the stm_main() function.

[mong87suk]

Understood. Thank you very much for the detailed review.