# STM32 L1 Tutorial #1: Hello, World! (LED Blink)

Today I’m about to show you how to make any use of my version of STM32L Standard Peripheral Library (post, .zip). First order of business for everyone that starts using MCU that he never used before is to get into controlling states of MCUs General Purpose Input/Output (GPIO) pins which translates to setting the voltage high or low on those pins. This can (and will) be used to lit up a LED directly connected to leads of our STM32L. I am assuming that reader has some basic knowledge about C Programming language, because I’m not planning to describe every line in every file, but to focus on what’s important. Here’s the code that does all that magic:

/* system entry point */
int main(void)
{
/* gpio init struct */
gpio_init_t gpio;

/* reset rcc */
RCC_DeInit();

/* enable clock to GPIOC */
RCC_AHBPeriphClockCmd(AHB_GPIOC, ENABLE);

/* initialize gpio structure */
GPIO_StructInit(&gpio);
/* use pin 13 */
gpio.pins = GPIO_P13;
/* mode: output */
gpio.mode = GPIO_OUTPUT;
/* output type: push-pull */
gpio.otype = GPIO_OT_PP;
/* apply configuration */
GPIO_Init(GPIOC, &gpio);

/* main program loop */
for (;;) {
/* set led on */
GPIO_SetPins(GPIOC, GPIO_P13);
/* delay */
simple_delay(100000);
/* clear led */
GPIO_ClearPins(GPIOC, GPIO_P13);
/* delay */
simple_delay(100000);
}

/* never reached */
return 0;
}


## Preparing the MCU

First step when you are dealing with STM32L will be resetting the RCC, which is done in line #8. RCC is that little MCU fragment that is responsible for enabling/disabling clock to all other modules, such as GPIO, as well as controlling MCU clock speed. After a reset we need to bring it to a known state and that’s why we call RCC_Deinit() routine.

## Configuring GPIO

In order to be able to use GPIO port (MCU pins are grouped in ports, every port can have up to 16 pins) we need to enable it’s clock. It is a common pitfall to forget about enabling particular peripheral’s clock, so keep in mind that this should be the first step before using any of peripheral’s registers.

Since we’ve got our GPIO up and running, we need to configure the operation of pin that will drive our LED. This is accomplished with the use of gpio_init_t structure. First thing that should be done here is to reset it’s contents by calling GPIO_StructInit() which will set all fields to their default values. Why bother using this function? Well, since our struct is stored on stack (it is defined inside main() function, not as a global variable) it will contain rubbish values, because stack variables aren’t initialized just as global variables are. Several fields of that data structure have been used to define pin’s behavior:

• gpio.pins – selects which pin we are about to configure. In this case it’s pin 13.
• gpio.mode – chooses pin mode of operation, which can be input, output, alternate function (pin driven by some other peripheral) or analog (pin used by analog to digital converter), in this case, since we want to *drive* LED we need to go for GPIO_OUTPUT.
• gpio.otype – output pins can operate in two modes: push-pull (MCU can set pin high and low) or open-drain (MCU can set pin low and high-impedance). We choose push-pull mode to be able to set pin high.

After setting all the fields we need to apply this configuration to given port. My LED is connected to pin PC13, I used GPIO_Init() with the first argument set to GPIOC.

## Using GPIO pin

Now the eye-candy. I have written a simple loop (lines 25 – 34) that will turn-on and turn-off the LED just to demonstrate that this tutorial actually does something. As you can see the simplest way of altering pin output states is to use GPIO_SetPin() and GPIO_ClearPin() respectively. I have also inserted some wait-sates just so the LED doesn’t blink too fast.

## Files

• Source Code – all that you need to run this example, just compile, upload to your mcu and observe the magic!
Posted in Uncategorized and tagged , .