Porting NUCLEO-U575ZI-Q #9210

jandriea · 2022-09-05T04:13:45Z

jandriea
Sep 5, 2022

Hello everyone,

I am trying to port the NUCLEO-U575ZI-Q board using the micropython. At first, I am trying to port the new board inside the ports/stm32 by adding a new board folder, adding the CMSIS library, and modifying some c codes for the STM32U5 chip. However, Even though I successfully compiled the code, the image failed to run.

So, I decided to start again using minimal porting. I create a new folder (port/minimal-stm32u5) and copy all the files inside the port/minimal. I started off by adding the linker file

/*
    GNU linker script for STM32U575
*/

/* Memories definition */
MEMORY
{
  RAM	(xrw)	: ORIGIN = 0x20000000,	LENGTH = 768K
  SRAM4	(xrw)	: ORIGIN = 0x28000000,	LENGTH = 16K
  FLASH	(rx)	: ORIGIN = 0x08000000,	LENGTH = 2048K
}

/* top end of the stack */
_estack = ORIGIN(RAM) + LENGTH(RAM);

/* define output sections */
SECTIONS
{
    /* The program code and other data goes into FLASH */
    .text :
    {
        . = ALIGN(4);
        KEEP(*(.isr_vector)) /* isr vector table */
        *(.text)           /* .text sections (code) */
        *(.text*)          /* .text* sections (code) */
        *(.rodata)         /* .rodata sections (constants, strings, etc.) */
        *(.rodata*)        /* .rodata* sections (constants, strings, etc.) */

        . = ALIGN(4);
        _etext = .;        /* define a global symbol at end of code */
        _sidata = _etext;  /* This is used by the startup in order to initialize the .data secion */
    } >FLASH

    /* This is the initialized data section
    The program executes knowing that the data is in the RAM
    but the loader puts the initial values in the FLASH (inidata).
    It is one task of the startup to copy the initial values from FLASH to RAM. */
    .data : AT ( _sidata )
    {
        . = ALIGN(4);
        _sdata = .;        /* create a global symbol at data start; used by startup code in order to initialise the .data section in RAM */
        *(.data)           /* .data sections */
        *(.data*)          /* .data* sections */

        . = ALIGN(4);
        _edata = .;        /* define a global symbol at data end; used by startup code in order to initialise the .data section in RAM */
    } >RAM

    /* Uninitialized data section */
    .bss :
    {
        . = ALIGN(4);
        _sbss = .;         /* define a global symbol at bss start; used by startup code */
        *(.bss)
        *(.bss*)
        *(COMMON)

        . = ALIGN(4);
        _ebss = .;         /* define a global symbol at bss end; used by startup code */
    } >RAM

    .ARM.attributes 0 : { *(.ARM.attributes) }
}

In this linker file, I only change the MEMORY definition to match the actual board

Then, I change the RCC and UART struct in the main.c and uart_core.c to match the actual structure in the STM32U5 chip

/***** main.c *****/
------- UNCHANGED -------

#if MICROPY_MIN_USE_STM32_MCU

// this is minimal set-up code for an STM32 MCU

typedef struct {
    volatile uint32_t CR;
    uint32_t _0[6];
    volatile uint32_t CFGR1;
    volatile uint32_t CFGR2;
    volatile uint32_t CFGR3;
    volatile uint32_t PLL1CFGR;
    volatile uint32_t PLL2CFGR;
    volatile uint32_t PLL3CFGR;
    uint32_t _1[7];
    volatile uint32_t CIER;
    uint32_t _2[13];
    volatile uint32_t AHB1ENR;
    volatile uint32_t AHB2ENR1;
    volatile uint32_t AHB2ENR2;
    volatile uint32_t AHB3ENR;
    uint32_t _3;
    volatile uint32_t APB1ENR1;
    volatile uint32_t APB1ENR2;
    volatile uint32_t APB2ENR;
    volatile uint32_t APB3ENR;
} periph_rcc_t;

typedef struct {
    volatile uint32_t MODER;
    volatile uint32_t OTYPER;
    volatile uint32_t OSPEEDR;
    volatile uint32_t PUPDR;
    volatile uint32_t IDR;
    volatile uint32_t ODR;
    volatile uint16_t BSRR;
    volatile uint32_t LCKR;
    volatile uint32_t AFR[2];
    volatile uint16_t BRR;
} periph_gpio_t;

typedef struct {
    volatile uint32_t CR1;
    volatile uint32_t CR2;
    volatile uint32_t CR3;
    volatile uint32_t BRR;
    volatile uint32_t GTPR;
    volatile uint32_t RTOR;
    volatile uint32_t RQR;
    volatile uint32_t ISR;
    volatile uint32_t ICR;
    volatile uint32_t RDR;
    volatile uint32_t TDR;
    volatile uint32_t PRESC;
    volatile uint32_t AUTOCR;
} periph_uart_t;

#define USART1 ((periph_uart_t *)0x40013800)
#define GPIOA  ((periph_gpio_t *)0x42020000)
#define GPIOB  ((periph_gpio_t *)0x42020400)
#define GPIOC  ((periph_gpio_t *)0x42020800)
#define RCC    ((periph_rcc_t *)0x46020C00)

// simple GPIO interface
#define GPIO_MODE_IN (0)
#define GPIO_MODE_OUT (1)
#define GPIO_MODE_ALT (2)
#define GPIO_PULL_NONE (0)
#define GPIO_PULL_UP (1)
#define GPIO_PULL_DOWN (2)
void gpio_init(periph_gpio_t *gpio, int pin, int mode, int pull, int alt) {
    gpio->MODER = (gpio->MODER & ~(3 << (2 * pin))) | (mode << (2 * pin));
    // OTYPER is left as default push-pull
    // OSPEEDR is left as default low speed
    gpio->PUPDR = (gpio->PUPDR & ~(3 << (2 * pin))) | (pull << (2 * pin));
    gpio->AFR[pin >> 3] = (gpio->AFR[pin >> 3] & ~(15 << (4 * (pin & 7)))) | (alt << (4 * (pin & 7)));
}
#define gpio_get(gpio, pin) ((gpio->IDR >> (pin)) & 1)
#define gpio_set(gpio, pin, value) do { gpio->ODR = (gpio->ODR & ~(1 << (pin))) | (value << pin); } while (0)
#define gpio_low(gpio, pin) do { gpio->BSRR = (1 << (16 + pin)); } while (0)
#define gpio_high(gpio, pin) do { gpio->BSRR = (1 << (pin)); } while (0)

void stm32_init(void) {
    // basic MCU config
    RCC->CR |= (uint32_t)0x00000001; // set MSION
    RCC->CFGR1 = 0x00000000; // reset all
    RCC->CFGR2 = 0x00000000; // reset all
    RCC->CFGR3 = 0x00000000; // reset all
    RCC->CR &= (uint32_t)0xEAF6FEFF; // reset HSEON, CSSON, PLLON, HSION
    RCC->PLL1CFGR = 0x00000000; // reset PLLCFGR
    RCC->CR &= (uint32_t)0xfffbffff; // reset HSEBYP
    RCC->CIER = 0x00000000; // disable IRQs

    // leave the clock as-is (internal 4MHz)

    // enable GPIO clocks
    RCC->AHB2ENR1 |= 0x00000007; // GPIOAEN, GPIOBEN, GPIOCEN

    // turn on an blue LED!
    gpio_init(GPIOB, 7, GPIO_MODE_OUT, GPIO_PULL_NONE, 0);
    gpio_high(GPIOB, 7);
    // turn on an green LED!
    gpio_init(GPIOC, 7, GPIO_MODE_OUT, GPIO_PULL_NONE, 0);
    gpio_high(GPIOC, 7);

    // enable UART1 at 9600 baud (TX=A9, RX=A10)
    gpio_init(GPIOA, 9, GPIO_MODE_ALT, GPIO_PULL_NONE, 7);
    gpio_init(GPIOA, 10, GPIO_MODE_ALT, GPIO_PULL_NONE, 7);
    RCC->APB2ENR |= 0x00004000; // USART1EN
    USART1->BRR = 417;          // 4MHz/417 = 9592 baud
    USART1->CR1 = 0x0000000D;   // USART enable, tx enable, rx enable
}

#endif

/***** uart_core.c *****/

#include <unistd.h>
#include "py/mpconfig.h"

/*
 * Core UART functions to implement for a port
 */

#if MICROPY_MIN_USE_STM32_MCU
typedef struct {
    volatile uint32_t CR1;
    volatile uint32_t CR2;
    volatile uint32_t CR3;
    volatile uint32_t BRR;
    volatile uint32_t GTPR;
    volatile uint32_t RTOR;
    volatile uint32_t RQR;
    volatile uint32_t ISR;
    volatile uint32_t ICR;
    volatile uint32_t RDR;
    volatile uint32_t TDR;
    volatile uint32_t PRESC;
    volatile uint32_t AUTOCR;
} periph_uart_t;
#define USART1 ((periph_uart_t *)0x40013800)
#endif

// Receive single character
int mp_hal_stdin_rx_chr(void) {
    unsigned char c = 0;
    #if MICROPY_MIN_USE_STDOUT
    int r = read(STDIN_FILENO, &c, 1);
    (void)r;
    #elif MICROPY_MIN_USE_STM32_MCU
    // wait for RXNE
    while ((USART1->ISR & (1 << 5)) == 0) {
    }
    c = USART1->RDR;
    #endif
    return c;
}

// Send string of given length
void mp_hal_stdout_tx_strn(const char *str, mp_uint_t len) {
    #if MICROPY_MIN_USE_STDOUT
    int r = write(STDOUT_FILENO, str, len);
    (void)r;
    #elif MICROPY_MIN_USE_STM32_MCU
    while (len--) {
        // wait for TXE
        while ((USART1->ISR & (1 << 7)) == 0) {
        }
        USART1->TDR = *str++;
    }
    // wait until TC is set
    while ((USART1->ISR & (1 << 6)) == 0) {
        }
    #endif
}

And finally, I change the Makefile to use the correct CPU

include ../../py/mkenv.mk

CROSS = 0

# qstr definitions (must come before including py.mk)
QSTR_DEFS = qstrdefsport.h

# MicroPython feature configurations
MICROPY_ROM_TEXT_COMPRESSION ?= 1

# include py core make definitions
include $(TOP)/py/py.mk

ifeq ($(CROSS), 1)
CROSS_COMPILE ?= arm-none-eabi-
endif

INC += -I.
INC += -I$(TOP)
INC += -I$(BUILD)

ifeq ($(CROSS), 1)
DFU = $(TOP)/tools/dfu.py
PYDFU = $(TOP)/tools/pydfu.py
CFLAGS_CORTEX_M = -mthumb -fsingle-precision-constant -Wdouble-promotion
CFLAGS_MCU_M33 = $(CFLAGS_CORTEX_M) -mcpu=cortex-m33 -march=armv8-m.main+dsp -mfpu=fpv5-sp-d16 -mfloat-abi=hard
CFLAGS = $(INC) -Wall -Werror -std=c99 -nostdlib $(CFLAGS_MCU_M33 ) $(COPT)
LDFLAGS = -nostdlib -T stm32u575.ld -Map=$@.map --cref --gc-sections
else
LD = gcc
CFLAGS = $(INC) -Wall -Werror -Wdouble-promotion -Wfloat-conversion -std=c99 $(COPT)
LDFLAGS = -Wl,-Map=$@.map,--cref -Wl,--gc-sections
endif

CSUPEROPT = -Os # save some code space

# Tune for Debugging or Optimization
ifeq ($(DEBUG), 1)
CFLAGS += -O0 -ggdb
else
CFLAGS += -Os -DNDEBUG
CFLAGS += -fdata-sections -ffunction-sections
endif

# Flags for optional C++ source code
CXXFLAGS += $(filter-out -std=c99,$(CFLAGS))
CXXFLAGS += $(CXXFLAGS_MOD)

# Flags for user C modules
CFLAGS += $(CFLAGS_MOD)
LDFLAGS += $(LDFLAGS_MOD)

LIBS =

SRC_C = \
	main.c \
	uart_core.c \
	shared/libc/printf.c \
	shared/readline/readline.c \
	shared/runtime/pyexec.c \
	shared/runtime/stdout_helpers.c \
	$(BUILD)/_frozen_mpy.c \

ifeq ($(CROSS), 1)
SRC_C += shared/libc/string0.c
endif

SRC_C += $(SRC_MOD)

SRC_CXX += $(SRC_MOD_CXX)

SRC_QSTR += $(SRC_MOD) $(SRC_MOD_CXX)

OBJ += $(PY_CORE_O) $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
OBJ += $(addprefix $(BUILD)/, $(SRC_CXX:.cpp=.o))

ifeq ($(CROSS), 1)
all: $(BUILD)/firmware.dfu
else
all: $(BUILD)/firmware.elf
endif

$(BUILD)/_frozen_mpy.c: frozentest.mpy $(BUILD)/genhdr/qstrdefs.generated.h
	$(ECHO) "MISC freezing bytecode"
	$(Q)$(TOP)/tools/mpy-tool.py -f -q $(BUILD)/genhdr/qstrdefs.preprocessed.h -mlongint-impl=none $< > $@

$(BUILD)/firmware.elf: $(OBJ)
	$(ECHO) "LINK $@"
	$(Q)$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
	$(Q)$(SIZE) $@

$(BUILD)/firmware.bin: $(BUILD)/firmware.elf
	$(Q)$(OBJCOPY) -O binary -j .isr_vector -j .text -j .data $^ $(BUILD)/firmware.bin

$(BUILD)/firmware.dfu: $(BUILD)/firmware.bin
	$(ECHO) "Create $@"
	$(Q)$(PYTHON) $(DFU) -b 0x08000000:$(BUILD)/firmware.bin $@

deploy: $(BUILD)/firmware.dfu
	$(ECHO) "Writing $< to the board"
	$(Q)$(PYTHON) $(PYDFU) -u $<

# Run emulation build on a POSIX system with suitable terminal settings
run:
	stty raw opost -echo
	build/firmware.elf
	@echo Resetting terminal...
# This sleep is useful to spot segfaults
	sleep 1
	reset

test: $(BUILD)/firmware.elf
	$(Q)/bin/echo -e "print('hello world!', list(x+1 for x in range(10)), end='eol\\\\n')\\r\\n\\x04" | $(BUILD)/firmware.elf | tail -n2 | grep "^hello world! \\[1, 2, 3, 4, 5, 6, 7, 8, 9, 10\\]eol"

include $(TOP)/py/mkrules.mk

I successfully compiled the code and flashed the binary to the board. The Micropython appears but whenever I write any code, the program stuck.

after some debugging, I found out that the program stuck when calling the nlr_push function.
I modify the main.c to this

int main(int argc, char **argv) {
    int stack_dummy;
    stack_top = (char *)&stack_dummy;

    #if MICROPY_ENABLE_GC
    gc_init(heap, heap + sizeof(heap));
    #endif
    mp_init();
    #if MICROPY_ENABLE_COMPILER
    #if MICROPY_REPL_EVENT_DRIVEN
    pyexec_event_repl_init();
    for (;;) {
        int c = mp_hal_stdin_rx_chr();
        if (pyexec_event_repl_process_char(c)) {
            break;
        }
    }
    // #else
    // pyexec_friendly_repl();
    #endif
    do_str("print('hello world!', list(x+1 for x in range(10)), end='eol\\n')", MP_PARSE_SINGLE_INPUT);
    do_str("for i in range(10):\r\n  print(i)", MP_PARSE_FILE_INPUT);
    #else
    pyexec_frozen_module("frozentest.py");
    #endif
    mp_deinit();
    return 0;
}

and the do_str function to this

#if MICROPY_ENABLE_COMPILER
void do_str(const char *src, mp_parse_input_kind_t input_kind) {
    nlr_buf_t nlr;
    printf("Checkpoint 1\n");
    if (nlr_push(&nlr) == 0) {
        printf("Checkpoint 2\n");
        mp_lexer_t *lex = mp_lexer_new_from_str_len(MP_QSTR__lt_stdin_gt_, src, strlen(src), 0);
        qstr source_name = lex->source_name;
        mp_parse_tree_t parse_tree = mp_parse(lex, input_kind);
        mp_obj_t module_fun = mp_compile(&parse_tree, source_name, true);
        mp_call_function_0(module_fun);
        nlr_pop();
    } else {
        printf("Checkpoint 3\n");
        // uncaught exception
        mp_obj_print_exception(&mp_plat_print, (mp_obj_t)nlr.ret_val);
    }
    printf("Checkpoint 4\n");
}
#endif

The terminal only printing the first check point

what do I miss? is it the linker file or the CFLAGS that make it all wrong?

Thank you for your help

Answered by jimmo

Sep 5, 2022

@reanovich the NUCLEO-U575ZI-Q has an integrated st-link. This will likely be a lot easier to figure out using the debugger (via openocd + gdb). OpenOCD supports the U5.

I am trying to port the new board inside the ports/stm32 by adding a new board folder, adding the CMSIS library, and modifying some c codes for the STM32U5 chip.

Did you also add the STM U5 HAL to lib/stm32lib?

View full answer

jimmo · 2022-09-05T15:17:29Z

jimmo
Sep 5, 2022
Maintainer

@reanovich the NUCLEO-U575ZI-Q has an integrated st-link. This will likely be a lot easier to figure out using the debugger (via openocd + gdb). OpenOCD supports the U5.

I am trying to port the new board inside the ports/stm32 by adding a new board folder, adding the CMSIS library, and modifying some c codes for the STM32U5 chip.

Did you also add the STM U5 HAL to lib/stm32lib?

2 replies

jandriea Sep 7, 2022
Author

Thank you for your reply,

Yes, I have added the STM32U5 HAL to the lib/stm32lib when I tried to add the board to the ports/stm32 library. However the code won't run on my board, so I use the minimal port instead.

Does the minimal port also need the HAL library?

jandriea Sep 13, 2022
Author

After debugging for a few days, I discovered that my clock initiation was wrong. After some modification, the board is now able to drop the uPython REPL with limited peripherals. I will continue the development to get the board running with all features

Thanks for your help

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

MicroPython

Porting NUCLEO-U575ZI-Q #9210

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 1 comment 2 replies

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

Select a reply

MicroPython

Porting NUCLEO-U575ZI-Q #9210

jandriea Sep 5, 2022

Replies: 1 comment · 2 replies

jimmo Sep 5, 2022 Maintainer

jandriea Sep 7, 2022 Author

jandriea Sep 13, 2022 Author

jandriea
Sep 5, 2022

Replies: 1 comment 2 replies

jimmo
Sep 5, 2022
Maintainer

jandriea Sep 7, 2022
Author

jandriea Sep 13, 2022
Author