Loïc Chagnoleau

STM32 minimal blinky code

2024-06-12T00:00:00+00:00

Introduction

This post will show you how to write the minimal blinky code for STM32 microcontrollers. It is inspired by this github project but here we will try to fully understand the code.

Prerequisites

We only need the svd file for the STM32F429 microcontroller. We can found the official svd file on the ST website -> STM32F4 System View Description.

Code

The Led we will use is the GPIOB pin 0.

Main program

RCC_AHB1ENR

To enable the led, we start by enabling the GPIOB peripheral clock. The register controlling the GPIOB peripheral clock is the RCC_AHB1ENR register.

Following the svd file, we are looking foir the address of the RCC_AHB1ENR register.

<peripheral>
  <name>RCC</name>
  <description>Reset and clock control</description>
  <groupName>RCC</groupName>
  <baseAddress>0x40023800</baseAddress>
  <addressBlock>

<register>
  <name>AHB1ENR</name>
  <displayName>AHB1ENR</displayName>
  <description>AHB1 peripheral clock register</description>
  <addressOffset>0x30</addressOffset>

We define it like this is our maiu.c file:

#define PERIPH_BASE 0x40000000U
#define RCC_BASE (PERIPH_BASE + 0x23800)
#define RCC_AHB1ENR (*(volatile unsigned long *)(RCC_BASE + 0x30))

int main() {
  // Enable clock on GPIOB peripheral
  RCC_AHB1ENR = 1 << 1;
  ...

GPIOB_MODER

The MODER register is used to set the mode of the GPIOB pin 0. Like previously, we look for the address of the MODER register in the svd file.

<peripheral>
  <name>GPIOB</name>
  <description>General-purpose I/Os</description>
  <groupName>GPIO</groupName>
  <baseAddress>0x40020400</baseAddress>

<registers>
  <register>
    <name>MODER</name>
    <displayName>MODER</displayName>
    <description>GPIO port mode register</description>
    <addressOffset>0x0</addressOffset>

To set the pin 0 as an output, we need to set the bit 0 (because we use the pin 0) of the MODER register to 1. In the main.c file, we define it like this:

#define GPIOB_BASE (PERIPH_BASE + 0x20400)
#define GPIOB_MODER (*(volatile unsigned long *)(GPIOB_BASE + 0x00))

#define LED_PIN 0

int main() {
  ...
  // Put GPIOB0 into output mode
  GPIOB_MODER |= 0x01 << LED_PIN * 2;
  ...

GPIOB_ODR

Finally, we can toggle the pin 0 of the GPIOB port to make the led blink. The register controlling the output of the GPIOB pin 0 is the ODR register.

<register>
  <name>ODR</name>
  <displayName>ODR</displayName>
  <description>GPIO port output data register</description>
  <addressOffset>0x14</addressOffset>

main.c file:

#define GPIOB_ODR (*(volatile unsigned long *)(GPIOB_BASE + 0x14))
#define LED_PIN 0

int main() {
  ...
  GPIOB_ODR = 1 << LED_PIN; // set LED pin high
  ...

Delay

To make the led blink, we need to add a delay. We simply loop for a certain amount of time.

void sleep(unsigned long sleep_time) {
  while (sleep_time--)
    __asm__("nop");
}

We need to define the vector table at the beginning of the main.c file. The vector table is the first thing the microcontroller reads when it boots up. The first address of the vector table is the stack pointer and the second address is the reset handler.

We will set the stack pointer to the end of the RAM and the reset handler to the main function.

#define SRAM_BASE 0x20000000U
#define SRAM_SIZE 192 * 1024
#define SRAM_END (SRAM_BASE + SRAM_SIZE)

unsigned long *vector_table[] __attribute__((section(".vector_table"))) = {
    (unsigned long *)SRAM_END, // place stack pointer at the end of SRAM
                               // (stack grows down)
    (unsigned long *)main      // reset handler, jump directly to main
};

Full code

#define PERIPH_BASE 0x40000000U
#define RCC_BASE (PERIPH_BASE + 0x23800)
#define RCC_AHB1ENR (*(volatile unsigned long *)(RCC_BASE + 0x30))

#define GPIOB_BASE (PERIPH_BASE + 0x20400)
#define GPIOB_MODER (*(volatile unsigned long *)(GPIOB_BASE + 0x00))
#define GPIOB_ODR (*(volatile unsigned long *)(GPIOB_BASE + 0x14))

#define LED_PIN 0

#define SRAM_BASE 0x20000000U
#define SRAM_SIZE 192 * 1024
#define SRAM_END (SRAM_BASE + SRAM_SIZE)

void sleep(unsigned long sleep_time) {
  while (sleep_time--)
    __asm__("nop");
}

int main() {
  // Enable clock on GPIOB peripheral
  RCC_AHB1ENR = 1 << 1;

  // Put GPIOB0 into output mode
  GPIOB_MODER |= 0x01 << LED_PIN * 2;

  while (1) {
    GPIOB_ODR = 1 << LED_PIN; // set LED pin high
    sleep(1000000);
    GPIOB_ODR = 0 << LED_PIN; // set LED pin low
    sleep(1000000);
  }
}

unsigned long *vector_table[] __attribute__((section(".vector_table"))) = {
    (unsigned long *)SRAM_END, // place stack pointer at the end of SRAM
                               // (stack grows down)
    (unsigned long *)main      // reset handler, jump directly to main
};

Linker script

MEMORY

In the linker script we will define the memory layout of the microcontroller. The address of the FLASH and the RAM are defined in the datasheet of the microcontroller.

MEMORY
{
    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 2048K
    SRAM (xrw)  : ORIGIN = 0x20000000, LENGTH = 192K
}

SECTIONS

We will only define the .text section for the code and the .vector_table section for the vector table. The .text section is used to store the code and the .vector_table section is used to store the vector table.

SECTIONS
{
    .text :
    {
        *(.vector_table)
        *(.text)            /* code */
    } >FLASH
}

The >FLASH means that the .text section will be stored in the FLASH memory.

Full linker script

MEMORY
{
    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 2048K
    SRAM (xrw)  : ORIGIN = 0x20000000, LENGTH = 192K
}

SECTIONS
{
    .text :
    {
        *(.vector_table)
        *(.text)            /* code */
    } >FLASH
}

Makefile

The Makefile is used to compile the code:

LINKER_SCRIPT = linker_script.ld
C_FLAGS  = -c -Og -mcpu=cortex-m4 -mthumb -g3 -ggdb3
OPENOCD_FLAGS = -f interface/stlink-v2-1.cfg -f target/stm32f4x.cfg
 
all: main.elf
 
%.o: %.c
	arm-none-eabi-gcc $(C_FLAGS) -o $@ $<

main.elf: main.o
	arm-none-eabi-ld -T$(LINKER_SCRIPT) -o main.elf main.o

clean:
	rm -rf *.o *.elf

flash: main.elf
	openocd $(OPENOCD_FLAGS) -c "program main.elf reset" -c "shutdown"

Compile and flash

To compile the code, you can use the following command:

make

To flash the code on the microcontroller, you can use the following command:

make flash

The led should blink.

ARM keywords cheatsheet

2024-05-13T00:00:00+00:00

Glossary

Name	Meaning
ARM	Advanced RISC Machines
RISC	Reduced Instruction Set Computer
I-cache	Instruction Cache
D-cache	Data Cache
LR	Link Register
SP	Stack Pointer
PC	Program Counter

I-cache

Instruction cache is a high speed memory that stores the instructions that the CPU is likely to execute next. It is used to speed up the execution of instructions by reducing the time it takes to fetch instructions from the main memory. I-cache is the first place that the processor looks for instructions to execute. If the instruction is found in the cache, it is executed immediately. If the instruction is not found in the cache, it is fetched from the main memory and stored in the cache for future use.

D-cache

Data cache is a high speed memory that stores the data that the CPU is likely to access next.

Link Register

The link register is a register which holds the address to return to when a subroutine call completes. It is also named R14.

Stack Pointer

The stack pointer is a register which holds the address of the top of the stack. It is also named R13.

Program Counter

The program counter is a register which holds the address of the next instruction to be executed. It is also named R15.

Setup a personal blog with Hugo

2024-04-07T00:00:00+00:00

I decided to create a personal blog to share my thoughts, ideas, and projects with the world. I chose Hugo as my static site generator because of its simplicity, speed, and flexibility. So, it's a good idea to start this blog by explaining how to setup a personal blog with Hugo and deploy it on GitHub Pages.

Prerequisites

Choose a appropriate theme

Hugo has a lot of themes available on the official website. You can choose one that fits your needs and customize it to your liking. For this blog, I chose the Nightfall theme because of its clean design and simplicity.

Installation

To install Hugo, you can follow the instructions on the official website. I'm using Arch Linux, so I installed Hugo with the following command:

sudo pacman -S hugo

Because I choose the Nightfall theme, I need to install dart-sass, following the instructions in the Nightfall repository

sudo pacman -S dart-sass

Start a new site

To create a new site with Hugo, you can use the following command:

hugo new site personal_blog

This will create a new directory called personal_blog. Next, we need to init hugo mod to be able to use the theme

hugo mod init github.com/lchagnoleau/personal_blog
hugo mod get -u

And add the following line to the hugo.toml file:

[module]
[[module.imports]]
  path = 'github.com/LordMathis/hugo-theme-nightfall'

To add a new post, you can use the following command:

hugo new content posts/my-first-post.m

Write your post in markdown format in the file content/posts/my-first-post.md and set the draft field to false to publish it.

Finally, we can start the server with the following command:

hugo server

Publish on Github

Create a Github repository

I push it into the .gitignore file

*.lock
public/
resources/

Then, create your Github repository and push your code to it

git init .
git add .
git commit -m "Initial commit"
git remote add origin git@github.com:lchagnoleau/lchagnoleau.git
git push -u origin master

Deploy on Github Pages

The instructions to deploy the blog on Github Pages are available here.