Let’s Light an LED

ARM Microcontroller Basics

I’m an amateur hardware tinkerer, learning the basics of electronics, PCB design and programming a microcontroller. I’ve been at it for the last two years as a hobby and truly appreciate your feedback. Playing with hardware has been a source of joy in my life, so this post is my way of sharing what I’ve learned, hoping to smooth the journey for anyone starting down a similar path. Let’s dive in!

What you’ll learn

1. How to light an LED with an STM32 microcontroller by configuring GPIO pins

2. The basics of microcontroller registers and how to manipulate them directly

3. A step-by-step guide to writing assembly and C code for controlling an LED

I’ve been working on the driver for an array of 110 Charlieplexed LEDs of a countdown timer. The microcontroller is STM32L010K4. It’s a solid ultra-low-power 32 Mhz chip, with 16 Kb of Flash memory and a whopping 2 Kb of RAM. (I mostly chose it because it was first in the massive lineup of STM32 micros, thinking it’ll be faster to learn on the chip with the fewest peripherals.) I designed the LEDs to sit in a circle and two arcs, representing the minutes (inner), hours (middle) and days (outer):

In retrospect, I could have added an LED driver chip (e.g. IS31FL3746A) and saved myself a ton of trouble, but one MCU seemed simpler when I started, and now that I’ve laid out the PCB (by-hand on a proto-board first, with over 300 solder joints, but I’ll save that story for another time) and programmed a working driver, a dedicated chip for this purpose doesn’t seem necessary. I’m also happy I took the path if only for the learnings.

Controlling LEDs

In case you are like me from about a year ago, the way you turn on an LED in this environment is by toggling a bit in a very specific memory location. It is a bit that corresponds to one of the general purpose input and output (GPIO) pins of the microcontroller. These two in the picture below—which my first LED is connected to— for example are pins 7 and 14, which from the datasheet we know are pins PA1 and PB0 respectively; which in turn means they’re on the GPIOA and GPIOB pin group respectively—all facts that will help us find their address.

The reference manual that came with the MCU (page 40 of 784 btw) has a memory map showing that the controller’s Peripherals/IOPORTs are somewhere between 0x50000000 and 0x50001FFF.

And a page below, we can spot that GPIOA starts at 0x50000000 and GPIOB starts at 0x50000400:

To connect an LED with its anode (+) attached to that PB0 (GPIOB / pin 14) and the cathode (-) attached to PA1 (GPIOA / pin 7), we have to make sure PB0 is sending a voltage (3.3V in my case) and PA1 is acting as ground. And we do that by (1) first configuring the mode of these pins to “general purpose output mode”, followed by (2) toggling a bit corresponding to pin 14 in the bit set/reset register (BSRR) of GPIOB. I’ll explain how this works in a bit, but long story short, those three steps are:

1. 0x50000000 ← 0xEBFFFCF7
   0x50000400 ← 0xFFFFFFFD
2. 0x50000418 ← 1

The first question you may have is where the 0xEBFFFCF7 (E:1110 B:1011 F:1111 F:1111 F:1111 C:1100 F:1111 7:0111), 0xFFFFFFFD (F:1111 F:1111 F:1111 F:1111 F:1111 F:1111 F:1111 D:1101), and 1 came from. To answer that, below is another snippet from the reference manual. It shows the bits that you need to set to configure the mode of GPIOA and GPIOB:

Let’s tackle 0xFFFFFFFD (GPIOB_MODER value) first. F in hex translates to 1111, of course, and D is 1101, so 0xFFFFFFFD (F:1111 F:1111 F:1111 F:1111 F:1111 F:1111 F:1111 D:1101) is:

You see, all of the pins except the 0th pin, are set to “11: Analog mode (reset state)” and pin 0 of GPIOB is “01: General purpose output mode”.

0xEBFFFCF7 (GPIOA_MODER value) on the other hand uses the same idea, except instead of all analog mode, the GPIOA starts out in a different reset state. If you look at the picture 8.4.1 above, note that below the bold title it reads, “Reset value: 0xEBFF FCFF for port A” because some of the pins, by default, are set to analog mode (14 & 13) and input mode (4) to enable programming and debugging the microcontroller on certain pins. And we set pin 1 to “general purpose output”. So, 0xEBFFFCF7 (E:1110 B:1011 F:1111 F:1111 F:1111 C:1100 F:1111 7:0111) :

Being able to simultaneously configure sixteen pins’ modes is rather beautiful in my opinion, but not easy to grasp at first.

Finally, the 1 (in 0x50000418 ← 1) is set into the bit set and reset register (BSRR) to send voltage to the 0th pin of the GPIOB:

Notice the “Address offset 0x18” on top. Knowing that GPIOB is at 0x50000400 + 0x18 tells us that the BSRR for GPIOB is 0x50000418. So to “SET” the 0th bit to 1 we must write 1 into the memory at that address.

Here’s the whole sequence in assembly:

ldr r0, =0x50000000    // load the GPIOA address into register r0
ldr r1, =0xEBFFFCF7    // load the mode for GPIOA into register r1
str r1, [r0, #0x00]    // write value of r1 into address at r0

ldr r0, =0x50000400    // same as above but for GPIOB
ldr r1, =0xFFFFFFFD 
str r1, [r0, #0x00]

ldr r1, =1             // load 1, which is pin 0 in PB0, into r1
str r1, [r0, #0x18]    // write that 1 into GPIOB with BSRR offset of 18

And in C:

*(volatile uint32_t *)(0x50000000) = 0xEBFFFCF7;
*(volatile uint32_t *)(0x50000400) = 0xFFFFFFFD;
*(volatile uint32_t *)(0x50000418) = 1;

But, most likely, you’d want to at least use CMSIS (Cortex Microcontroller Software Interface Standard) on top, making the code a ton more readable:

#include "stm32l010xb.h"

void turnOnLED() {
  GPIOA->MODER = 0xEBFFFCF7;
  GPIOB->MODER = 0xFFFFFFFD;
  GPIOB->BSRR = 1;
}

And to make life easier for us (and avoid calculating that hex value ourselves), STM (the maker of the micro) maintains a library called HAL (Hardware Abstraction Layer). Here’s what that looks like:

#include "stm32l0xx_hal.h"

void turnOnLED() {
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = GPIO_PIN_1;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
}

For completeness’ sake I’ll add that there’s just a bit more work you have to do before that code above works, that is to configure and enable the clocks that control GPIOA/B; but that part is handled by either the code generator / bootstrap tool that STM maintains called STM32CubeMX (which I prefer to use along with VSCode) or their IDE STM32CubeIDE.

There you have it: we set three values in three very specific sections of memory and that sends 3.3V to one pin, and makes sure the other acts as ground. And when it works for my timer, turning on a few LEDs looks a bit like this:

---

This project is just a small step into the vast world of microcontroller programming. Understanding these fundamentals has been invaluable for me in tackling more complex challenges, and I hope it will do the same for you. Speaking of challenges, I’d love to share my journey—from not knowing how a resistor works (that was me two years ago!) to building a product I hope to one day see on a store shelf. If that sounds like fun, stay tuned for more!