{"id":385250,"date":"2024-06-29T06:00:00","date_gmt":"2024-06-29T06:00:00","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=385250"},"modified":"-0001-11-30T00:00:00","modified_gmt":"2024-06-29T06:00:00","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=385250","title":{"rendered":"Setup of Qt Creator for programming and debugging of STM32 microcontrollers<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n

Introduction<\/h3>\n

Hi,<\/p>\n

Currently I am investigating firmware development for STM32 microcontrollers and I would like to share with you my experience for doing it in Qt Creator IDE.<\/p>\n

There are a lot of IDEs, which are used for firmware development of STM32. Some of them, being quite comfortable, have restrictions for trial license. For example, the one of the most known IDE, IAR Embedded, suggests either a limited amount of product usage time (30 days) or the limited firmware size of 32 MB, which is not too much.<\/p>\n

Within this scope of the publication, we investigate the method of setting up an environment that allows developing the full value of the STM32 firmware in Qt Creator.<\/p>\n

First, we need to determine the components for the execution of experiments.<\/p>\n

Hardware<\/h3>\n

I use the bluepill<\/strong> board based on the STM32F103C8T6<\/strong> microcontroller unit (MCU) to conduct the experiments. Sometimes, there could be issues with openocd<\/strong>, which claims the incorrect MCU number. It could be solved by 2 methods: either by replacing the number in the openocd<\/strong> configuration file or by changing the MCU to the original one. I chose the second option. For firmware burning and debugging purposes we use the ST-Link<\/strong> interface.<\/p>\n

Software<\/h3>\n

The experiments are conducted on a Windows 10 virtual machine in Virtual Box. In addition, we will need to install the following software:<\/p>\n

    \n
  1. \n

    Qt Creator<\/strong>. It could be installed with the online installer package from the Qt website. In this case, registration is required, and we do not need the Qt framework itself. For this reason, I download Qt Creator directly from the GitHub releases: https:\/\/github.com\/qt-creator\/qt-creator\/tags.<\/p>\n<\/li>\n

  2. \n

    gcc-arm-none-eabi<\/strong>. <\/strong>https:\/\/developer.arm.com\/downloads\/-\/gnu-rm.<\/p>\n<\/li>\n

  3. \n

    Git<\/strong>. https:\/\/git-scm.com\/downloads.<\/p>\n<\/li>\n

  4. \n

    openocd<\/strong>. https:\/\/github.com\/openocd-org\/openocd\/tags. This software is designed for firmware burning and on-chip firmware debugging .<\/p>\n<\/li>\n

  5. \n

    make<\/strong>. https:\/\/gnuwin32.sourceforge.net\/packages\/make.htm<\/p>\n<\/li>\n

  6. \n

    ST-LINK Utility<\/strong>. This utility is used for firmware burning and also contains a USB driver for ST-Link interface. https:\/\/www.st.com\/en\/development-tools\/stsw-link004.html<\/p>\n<\/li>\n

  7. \n

    Python2.7<\/strong>. https:\/\/www.python.org\/downloads\/release\/python-2718\/<\/p>\n<\/li>\n<\/ol>\n

    First, we need to download and unpack Qt Creator, and after that to install git, gcc compiler, openocd, python, make and ST-Link utility.<\/p>\n

    \"\"<\/figure>\n

    I unpacked Qt Creator and openocd into C:\\Tools. All programs, except Qt Creator, should be added to Path<\/strong>.<\/p>\n

    \"\"<\/figure>\n

    Then we need to check whether gcc and openocd are pushed to Path by calling them from the command line.<\/p>\n

    \"\"<\/figure>\n

    If gcc and openocd are available from cmd, we can move forward and tune the Qt Creator IDE.<\/p>\n

    Setup of Qt Creator<\/h3>\n

    Now we can launch the IDE and install the necessary plugins: BareMetal<\/strong> and GenericProjectManager<\/strong>. To do this we need to go to Help->About Plugins<\/strong>, check the plugins and restart Qt Creator.<\/p>\n

    \"\"<\/figure>\n

    The first thing we need to do is to go to Edit->Preferences<\/strong> and choose Kits<\/strong> from the list on left. Here we should see our kit for building an ARM, which was pulled from Path. Next, we go to Devices <\/strong>from the list on the left, on the Bare Metal<\/strong> tab, and add an OpenOCD<\/strong> server. In our case, I call it OpenOCD-STM32F103<\/strong>.<\/p>\n

    \"\"<\/figure>\n

    In Executable file<\/strong> we write the path to openocd <\/strong>(theoretically could be taken from Path<\/strong>).<\/p>\n

    In the Root scripts<\/strong> directory we point the script directory for openocd.<\/p>\n

    In Additional arguments<\/strong> we write the arguments for burning of firmware to MCU: config file for ST-Link and our target: stm32f1x<\/strong>. Then apply.<\/p>\n

    Go to Devices<\/strong>. Click Add->Bare Metal Device<\/strong> and Start Wizard<\/strong>. In the appeared window we choose Debug server provider<\/strong> and previously added OpenOCD-STM32F103 <\/strong>server provider. Click Finish.<\/p>\n

    \"\"<\/figure>\n

    Return to Kits<\/strong> and readjust our ARM kit. We need to choose previously configured Device type<\/strong> and Device \u2013 Bar Metal Device<\/strong>. Apply.<\/p>\n

    \"\"<\/figure>\n

    At this stage we postpone Qt Creator and move to setup of the project.<\/p>\n

    Setup of project<\/h3>\n

    We will create the simplest project using only CMSIS<\/strong> library which will blink with LED. <\/p>\n

    First, we need to pull the necessary libraries as the submodules from the official repositories of ARM and ST. Open bash terminal, which usually goes together with git, and create led_blink_cmsis folder.<\/p>\n

    mkdir led_blink_cmsis && cd led_blink_cmsis<\/code><\/pre>\n
    Create inside build<\/strong>, lib and<\/strong> src<\/strong> folders.<\/p>\n
    mkdir build && mkdir src && mkdir lib<\/code><\/pre>\n
    In the build<\/strong> folder we have the artifacts, in src<\/strong> — our source files and in lib<\/strong> — third party libraries. <\/p>\n
    Initialize git.<\/p>\n
    git init<\/code><\/pre>\n
    Next, add CMSIS libraries using git submodules<\/strong>. The first library is the ST fork from the ARM repo. The second has the settings and definitions for the STM32 F1 family.<\/p>\n
    git submodule add https:\/\/github.com\/STMicroelectronics\/cmsis_core lib\/cmsis_core && cd lib\/cmsis_core git checkout v5.6.0 && cd ..\/..<\/code><\/pre>\n
    \"\"<\/figure>\n
    git submodule add https:\/\/github.com\/STMicroelectronics\/cmsis_device_f1 lib\/cmsis_device_f1 && cd lib\/cmsis_device_f1 git checkout v4.3.3 && cd ..\/..<\/code><\/pre>\n
    After adding submodules we make git checkout to release versions of libraries. For cmsis_core and cmsis_device the current versions are correspondingly 5.6.0 and 4.3.3   .<\/p>\n
    Create main.c<\/strong>, init.h<\/strong> and init.c<\/strong> in the src <\/strong>directory, which contain our source code.<\/p>\n
    touch src\/main.c src\/init.h src\/init.c<\/code><\/pre>\n
    Let us fill our files with code. In main.c<\/strong> there is a code which turns on and off the LED as well as calls the clock_init<\/strong> \u0438 port_init <\/strong>functions. These functions set up the clock frequency and external clocking from the quartz resonator as well the functioning of port C for output in low frequency push-pull mode. The init.c file <\/strong>also contains the implementation of the delay_ms<\/strong> function   . <\/p>\n
    \nmain.c<\/summary>\n
    \n
    #include \"init.h\" int main(void) { clock_init();                                                \/\/Clock initialization port_init();                                                 \/\/Port initialization while(1) { GPIOC->BSRR = GPIO_BSRR_BR13;                            \/\/Pin 13 of PORT C on delay_ms(100); GPIOC->BSRR = GPIO_BSRR_BS13;                            \/\/Pin 13 of PORT C off delay_ms(100); } return 0; } <\/code><\/pre>\n<\/p>\n<\/div>\n<\/details>\n
    \ninit.h<\/summary>\n
    \n
    #ifndef STM32F103xB #define STM32F103xB #endif #include \"stm32f1xx.h\" int clock_init(); void port_init(); void delay_ms(uint16_t); <\/code><\/pre>\n<\/p>\n<\/div>\n<\/details>\n
    \ninit.c<\/summary>\n
    \n
    #include \"init.h\" volatile uint32_t SysTickDelayMsec = 0; void SysTick_Handler(void) { --SysTickDelayMsec; } \/* OSC - 8 MHz PLLSRC - 8 MHz SYSCLK - 16 MHz PLL - 2 AHB - 1\/16 *\/ int clock_init() { RCC->CR |= RCC_CR_HSEON;                                    \/\/Start HSE generator for(volatile int StartUpCounter = 0; ; ++StartUpCounter)    \/\/Wait for successfull start or timeout { if(RCC->CR & RCC_CR_HSERDY)                             \/\/If started successfully, break the cycle { break; } if(StartUpCounter > 4096)                               \/\/If not started - turn off and return an error { RCC->CR &= ~RCC_CR_HSEON;                           \/\/Stop HSE return 1; } } RCC->CFGR = 0;                                              \/\/PLL mult is equal 2 RCC->CFGR |= RCC_CFGR_PLLSRC;                               \/\/Clock PLL from HSE RCC->CR |= RCC_CR_PLLON;                                    \/\/Start PLL for(volatile int StartUpCounter = 0; ; ++StartUpCounter)    \/\/Wait for successfull start or timeout { if(RCC->CR & RCC_CR_PLLRDY)                             \/\/If started successfully, break the cycle { break; } if(StartUpCounter > 4096)                               \/\/If PLL didn't start , turn off everything and return an error { RCC->CR &= ~RCC_CR_HSEON;                           \/\/Stop HSE RCC->CR &= ~RCC_CR_PLLON;                           \/\/Stop PLL return 2; } } FLASH->ACR |= FLASH_ACR_LATENCY;                            \/\/0 cycles for flash, core clock 16 MHz RCC->CFGR |= RCC_CFGR_PPRE2;                                \/\/APB2 turned off (0 by default) RCC->CFGR |= RCC_CFGR_HPRE_3 | RCC_CFGR_HPRE_1 | RCC_CFGR_HPRE_0;                               \/\/AHB prescaler 16 RCC->CFGR |= RCC_CFGR_SW_1;                                 \/\/Switch to PLL while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);      \/\/Wait for switch to PLL RCC->CR &= ~RCC_CR_HSION;                                   \/\/Turn off the internal clock for energy save SystemCoreClockUpdate();                                    \/\/Apply alterations to generator SysTick_Config(SystemCoreClock\/1000);                       \/\/Initialisation of interrupt (1 ms) return 0;                                                   \/\/Return 0 if success } void port_init() { RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;                         \/\/Turn on clock for GPIOC GPIOC->CRH = 0; GPIOC->CRH |= GPIO_CRH_MODE13;                              \/\/Pin 13 of PORT C in Push-Pull mode GPIOC->BSRR |= GPIO_BSRR_BR13;                              \/\/Pin 13 of PORT C reset } void delay_ms(uint16_t msec)                                     \/\/Delay function { SysTickDelayMsec = msec; while (SysTickDelayMsec); } <\/code><\/pre>\n<\/p>\n<\/div>\n<\/details>\n
    Finally, we add the Makefile<\/strong>, which is used for building of firmware. The template of the file was taken from MXCube generator and adapted for the current project. It contains the following code.<\/p>\n
    \nMakefile<\/summary>\n
    \n
    ###################################### target ###################################### TARGET = mppt_firmware ###################################### building variables ###################################### DEBUG = 1 OPT = -O0 ####################################### paths ####################################### BUILD_DIR = build ###################################### source ###################################### C_SOURCES =   src\/main.c  src\/init.c  lib\/cmsis_device_f1\/Source\/Templates\/system_stm32f1xx.c ASM_SOURCES =   lib\/cmsis_device_f1\/Source\/Templates\/gcc\/startup_stm32f103xb.s ####################################### binaries ####################################### PREFIX = arm-none-eabi- ifdef GCC_PATH CC = (PREFIX)gcc AS = (PREFIX)gcc -x assembler-with-cpp CP = (PREFIX)objcopy SZ = (PREFIX)size else CC = $(PREFIX)gcc AS = $(PREFIX)gcc -x assembler-with-cpp CP = $(PREFIX)objcopy SZ = $(PREFIX)size endif HEX = $(CP) -O ihex BIN = $(CP) -O binary -S ####################################### CFLAGS ####################################### CPU = -mcpu=cortex-m3 MCU = $(CPU) -mthumb $(FPU) $(FLOAT-ABI) AS_DEFS = C_DEFS =   -DSTM32F103xB AS_INCLUDES = C_INCLUDES =   -Isrc  -Ilib\/cmsis_core\/Include  -Ilib\/cmsis_device_f1\/Include ASFLAGS = $(MCU) $(AS_DEFS) $(AS_INCLUDES) $(OPT) -Wall -fdata-sections -ffunction-sections CFLAGS = $(MCU) $(C_DEFS) $(C_INCLUDES) $(OPT) -Wall -fdata-sections -ffunction-sections ifeq ($(DEBUG), 1) CFLAGS += -g -gdwarf-2 endif CFLAGS += -MMD -MP -MF\"$(@:%.o=%.d)\" ####################################### LDFLAGS ####################################### LDSCRIPT = lib\/cmsis_device_f1\/Source\/Templates\/gcc\/linker\/STM32F103XB_FLASH.ld LIBS = -lc -lm -lnosys LIBDIR = LDFLAGS = (LDSCRIPT) (BUILD_DIR)\/$(TARGET).map,--cref -Wl,--gc-sections ####################################### build the application ####################################### all: (TARGET).elf (TARGET).hex (TARGET).bin OBJECTS = (notdir $(C_SOURCES:.c=.o))) vpath %.c $(sort $(dir $(C_SOURCES))) OBJECTS += (notdir $(ASM_SOURCES:.s=.o))) vpath %.s $(sort $(dir $(ASM_SOURCES))) (BUILD_DIR)\/$(notdir $(<:.c=.lst)) $< -o $@ $(BUILD_DIR)\/%.o: %.s Makefile | $(BUILD_DIR) $(AS) -c $(CFLAGS) $< -o $@ (TARGET).elf: $(OBJECTS) Makefile $(CC) $(OBJECTS) $(LDFLAGS) -o $@ $(SZ) $@ $(BUILD_DIR)\/%.hex: $(BUILD_DIR)\/%.elf | $(BUILD_DIR) $(BIN) $< $@ $(BUILD_DIR)\/%.bin: $(BUILD_DIR)\/%.elf | $(BUILD_DIR) $(BIN) $< $@ $(BUILD_DIR): mkdir $@ clean_build: (TARGET).elf (TARGET).bin find (TARGET).bin' -type f -exec rm -f {} + ####################################### clean up ####################################### clean: rm -fR $(BUILD_DIR)\/* <\/code><\/pre>\n<\/p>\n<\/div>\n<\/details>\n