loading

The STM32Fx and STM32Lx are MCUs based on ARM architecture. For building programs is available gcc compiler under GNU/Linux. The gcc compiler has many settings and flags, so it is not so easy build medium size project.

In this article will be shown how to build code for STM32 MCU under Linux. It will be used these SW:

  • STM32CubeMX for generating project
  • Makefile4CubeMX to generate makefile from CubeMX project
  • Code::Block IDE for edit, build, and flash code

Whole tutorial is for GNU/Linux. This procedure was tested on Ubuntu 14.04 (trusty).

Step 1: Install Necessary Software

The first of all, install the necessary software.

Install the gcc compiler for ARM:

The gcc compiler contains tools for compiling, linking and building building code for MCU. Install these three packeges:

  • gcc-arm-none-eabi
  • binutils-arm-none-eabi
  • libnewlib-arm-none-eabi
sudo apt-get install gcc-arm-none-eabi binutils-arm-none-eabi libnewlib-arm-none-eabi

Install STM32CubeMX

STM32CubeMX is java based tool for generating C project. With this tool is possible to configure all parts of used MCU, e.g. USART, I2C, SPI, GPIO, TIMx, ....

The webpage: www.st.com/stm32cube

The CubeMX tool has Linux support. It is easy to install:

  • Download and extract zip file
  • Run the installer
  • Follow the wizard

Depends on your ST32 hardware (STM32F0, STM32F10x...|, you need download library for your MCU. Run the STM32CubeMX and click Help->Install New Libraries. From list choose the newest library for your MCU.

Install Makefile4CubeMX

The Makefile4CubeMX is needed to generate Makefile from CubeMX project.

Download link: github.com/duro80/Makefile4CubeMX

How to install:

    git clone https://github.com/duro80/Makefile4CubeMX.git
    sudo ln -s "$PWD"/CubeMX2Makefile.py /usr/bin/CubeMX2Makefile.py


    Install Code::Blocks IDE

    To install Code::Blocks IDE use your package manager. Under Ubuntu is available version 13.12-3:

    sudo apt-get install codeblocks

    Install stlink

    stlink is program to download builded code to MCU (flash). There exist Linux version maintained by texane, on github: github.com/texane/stlink. The install procedure is described there. If you prefer binary files, the latest release is here: github.com/texane/stlink/releases.

    Step 2: Set-up the Code::Blocks IDE

    To compile and build your own program for ARM processor, it is necessary set up the C::B IDE. In "Settings- >Compiler...":

    1. In left pane select Global compiler settings
    2. In top pane select compiler: GNU GCC Compiler for ARM
    3. In center pane choose "Toolchain executables" tab and fill these values:

    Compiler instalation directory: /usr

    • C compiler: arm-none-eabi-gcc
    • C++ compiler: arm-none-eabi-g++
    • Linker for dynamic libs: arm-none-eabi-gcc
    • Linker for static libs: arm-none-eabi-ar
    • Debugger: can be empty for now
    • make program: make

    Step 3: Create STM32CubeMX Project

    Before starting a project, check presence of library for specific MCU. In menu Help->Install New Libraries, check the desired library (in my case STM32F0 ver 1.5.0). Click in "Install now" to install library on your local repository.

    Next project will be for STM32F0 MCU.

    Create new project

    There are two possibilities: Create new project

    1. by selecting MCU,
    2. by selecting STM board.

    In "New project" dialog choose Series: STM32F0, Lines: STM32F0x0 Value Line. From list choose STM32F030F4Px

    For testing purposes, check pin PA0 as GPIO_Output.

    Set project properties

    Click on setting of project: menu Project -> Settings...

    1. Type project name (e.g. InstructableF0)
    2. Change project location (if you want)
    3. Toolchain / IDE: select SW4STM32
    4. Uncheck "Generate Under Root"
    5. Click OK

    Generate C code

    Click Project->Generate code to generate empty project

    Step 4: Generate Makefile and C::B Project

    To generate Makefile and Code::Block project, the Makefile4CubeMX script will be used.

    Open directory where CubeMX project was generated and open terminal there. Type:

    CubeMX2Makefile.py .

    In working directory will be generated files: Makefile, InstructableF0.cbp (name of this file depend on CubeMX project name)

    Step 5: Write and Build You Program

    Open project InstructableF0.cbp and open main.c file.

    Now, we can a little bit code. Lets toggle the port PA.0 to demonstrate working code.


    int main(void){
      /* MCU Configuration-------------------------*/
      /* Reset of all peripherals, Initializes the Flash interface and the Systick. */   
       HAL_Init();
      /* Configure the system clock */   
       SystemClock_Config();
      /* Initialize all configured peripherals */   
       MX_GPIO_Init();
      /* Infinite loop */   
      /* USER CODE BEGIN WHILE */   
      while (1)   {       
       HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_0);
       HAL_Delay(500);   // 500ms   
      /* USER CODE END WHILE */
      /* USER CODE BEGIN 3 */
      }   
    /* USER CODE END 3 */
    }
    

    Build your code to verify the correctness of our code: Build->Rebuild (Ctrl+F11)

    Step 6: Connect Hardware

    Prepare your hardware:

    1. Connect stlink-v2 dongle with your board
    2. Connect the LED diode to port PA0 (in series to resistor 150 Ohm or more)

    Build

    1. In Code::Block choose "Release" in compiler toolbar.
    2. Choose "Rebuild" (Ctrl+F11). After rebuilding, the code is automatically loaded into MCU
    3. LED diode start blink.

    You can use the Makefile also without Code::Block IDE.

    Open terminal in working directory (where Makefile is placed) and type:

    Build code:

    make<br>

    flash code to MCU:

    make flash<br>
    <p>STM32 are a very powerfull beasts capable of beind debugged step by step, also are the cheapest ARM based board you'll find in the world for USD around $1.70 ( <a href="http://s.click.aliexpress.com/e/B6yNjM3" rel="nofollow">http://s.click.aliexpress.com/e/B6yNjM3</a> ) ST LINK usb debug tool is also needed, but es very cheap also!</p>
    great thanks
    <p>Great project! Are you able to set breakpoints and debug your code step by step, etc? I depend right now on Keil uVision to do that...</p>
    <p>I'm preparing next instructables with debuging code under Linux.</p>
    <p>Cool, thanks! Looking forward to read it.</p>
    <p>Great project. Thanks for sharing.</p>

    About This Instructable

    4,537views

    12favorites

    License:

    More by Juraj Dudak:Build a program for STM32 MCU under Linux 
    Add instructable to: