Hands-On with STM32 MCU Francesco Conti

Transcription

1 Hands-On with STM32 MCU Francesco Conti

2 Calendar (Microcontroller Section) : Power consumption; Low power States; Buses, Memory, GPIOs Serial Interfaces Programming STM32 (intro) Interrupts & Timers Programming STM32 (hands-on) Wireless Sensor Networks Exercises + Projects

3 Programming a Microcontroller C is the programming language for microcontrollers, and a de facto golden standard for all embedded languages: very low-level control (i.e. it is typically clear what happens under the hood), but much more readable/usable than assembly code. high efficiency thanks to the tight control over hardware portability and reusability, standard C code can be recompiled for virtually any modern ISA wide availability of existing libraries and examples ready to use

4 Programming a Microcontroller - 2 The C language is the same as that usable for x86 PC programs; however, it is executed in a very different environment: 1. an underlying operating system provides the illusion that the program is the only one currently in memory. 2. there is protection: access to the memory map of other processes is restricted. 3. access to low-level peripherals and interrupts is restricted to the OS. 4. well-defined entry and exit points (program starts at beginning of main and closes at its end). 1. an MCU program is typically executed on bare metal, and it is really the only program running on the MCU. 2. there is no protection, the program can access all the MCU memory map. 3. low-level peripherals are available and interrupts are an important part of the program! 4. well-defined entry, but no exit point (what to do after main ends? usually we avoid exiting at all!)

5 Programming a Microcontroller - 2 The C language is the same as that usable for x86 PC programs; however, it is executed in a very different environment: 1. an underlying operating system provides the illusion that the program is the only one currently in memory. 2. there is protection: access to the memory map of other processes is restricted. 3. access to low-level peripherals and interrupts is restricted to the OS. 4. well-defined entry and exit points (program starts at beginning of main and closes at its end). 1. an MCU program is typically executed on bare metal, and it is really the only program running on the MCU. 2. often there is no protection, the program can access all the MCU memory map. 3. low-level peripherals are available and interrupts are an important part of the program! 4. well-defined entry, but no exit point (what to do after main ends? usually we avoid exiting at all!)

6 Programming a Microcontroller - 2 The C language is the same as that usable for x86 PC programs; however, it is executed in a very different environment: 1. an underlying operating system provides the illusion that the program is the only one currently in memory. 2. there is protection: access to the memory map of other processes is restricted. 3. access to low-level peripherals and interrupts is restricted to the OS. 4. well-defined entry and exit points (program starts at beginning of main and closes at its end). 1. an MCU program is typically executed on bare metal, and it is really the only program running on the MCU. 2. often there is no protection, the program can access all the MCU memory map. 3. low-level peripherals are available and interrupts are an important part of the program! 4. well-defined entry, but no exit point (what to do after main ends? usually we avoid exiting at all!)

7 Programming a Microcontroller - 2 The C language is the same as that usable for x86 PC programs; however, it is executed in a very different environment: 1. an underlying operating system provides the illusion that the program is the only one currently in memory. 2. there is protection: access to the memory map of other processes is restricted. 3. access to low-level peripherals and interrupts is restricted to the OS. 4. well-defined entry and exit points (program starts at beginning of main and closes at its end). 5. variables that have global scope are evil. 1. an MCU program is typically executed on bare metal, and it is really the only program running on the MCU. 2. often there is no protection, the program can access all the MCU memory map. 3. low-level peripherals are available and interrupts are an important part of the program! 4. well-defined entry, but no exit point (what to do after main ends? usually we avoid exiting at all!) 5. variables that have global scope are a necessary evil.

8 Programming a Microcontroller - 2 The C language is the same as that usable for x86 PC programs; however, it is executed in a very different environment: 1. an underlying operating system provides the illusion that the program is the only one currently in memory. 2. there is protection: access to the memory map of other processes is restricted. 3. access to low-level peripherals and interrupts is restricted to the OS. 4. well-defined entry and exit points (program starts at beginning of main and closes at its end). 5. global variables are evil. 1. an MCU program is typically executed on bare metal, and it is really the only program running on the MCU. 2. often there is no protection, the program can access all the MCU memory map. 3. low-level peripherals are available and interrupts are an important part of the program! 4. well-defined entry, but no exit point (what to do after main ends? usually we avoid exiting at all!) 5. global variables are a necessary evil.

9 Programming a Microcontroller - 3 A C program cannot tell the MCU all information (and there is no operating system to help):

10 Programming a Microcontroller - 3 A C program cannot tell the MCU all information (and there is no operating system to help): Where to allocate global variables and the stack (i.e. local variables)? linker script (e.g. link.ld) script that tells the compiler where to physically place sections containing global variables (e.g..data,.bss) and the place were the stack will be allocated (e.g..local or similar) How to start a program? boot script (e.g. crt0.s) collection of assembly routines that set up the runtime environment necessary to run a bare metal program (e.g. the stack) and then jump to the beginning of the main function

11 Programming a Microcontroller - 3 A C program cannot tell the MCU all information (and there is no operating system to help): Where to allocate global variables and the stack (i.e. local variables)? linker script (e.g. link.ld) script that tells the compiler where to physically place sections containing global variables (e.g..data,.bss) and the place were the stack will be allocated (e.g..local or similar) How to start a program? boot script (e.g. crt0.s) collection of assembly routines that set up the runtime environment necessary to run a bare metal program (e.g. the stack) and then jump to the beginning of the main function

12 Compiling for a Microcontroller Definition of a cross-compiler toolchain: a compiler that generates binary code for a platform other than that it is executed on: example: gcc executed on x86 to compile arm code arm-none-eabi-gcc

13 Compiling for a Microcontroller Definition of a cross-compiler toolchain: a compiler that generates binary code for a platform other than that it is executed on: example: gcc executed on x86 to compile arm code architecture target: in our case, arm ARM, Thumb, Thumb2 arm-none-eabi-gcc

14 Compiling for a Microcontroller Definition of a cross-compiler toolchain: a compiler that generates binary code for a platform other than that it is executed on: example: gcc executed on x86 to compile arm code architecture target: in our case, arm ARM, Thumb, Thumb2 arm-none-eabi-gcc OS target: in our case, none bare metal

15 Compiling for a Microcontroller Definition of a cross-compiler toolchain: a compiler that generates binary code for a platform other than that it is executed on: example: gcc executed on x86 to compile arm code architecture target: in our case, arm ARM, Thumb, Thumb2 application binary interface: set of conventions the binary adheres to (e.g. for interfacing with precompiled libraries) arm-none-eabi-gcc OS target: in our case, none bare metal

16 Compiling for a Microcontroller Definition of a cross-compiler toolchain: a compiler that generates binary code for a platform other than that it is executed on: example: gcc executed on x86 to compile arm code architecture target: in our case, arm ARM, Thumb, Thumb2 application binary interface: set of conventions the binary adheres to (e.g. for interfacing with precompiled libraries) arm-none-eabi-gcc OS target: in our case, none bare metal compiler family: GNU Compiler Collection

17 Debugging a Microcontroller Debugging embedded systems is different in many aspects from traditional application debugging, due to hardware constraints and limited resources. This makes it inconvenient or even impossible to run a software debugger together with the debugged program on the same system. Because of these restrictions, embedded systems are usually debugged using remote debugging: The debugger is running on a host computer, and controls the target either through hardware, or through a small software running on the target. The developer can passively watch the code and the data flow or actively stop the target at the interest points.

18 Debugging a Microcontroller - 2 JTAG (Joint Test Action Group) implements standards for on-chip instrumentation for device testing. It specifies the use of a dedicated debug port implementing a serial communications interface for low-overhead access to the system components (registers and memory). It allows the device programmer to transfer data into the internal memory. It is used for device programming and for active debugging (testing) of the executed program.

19 Integrated Development Environments How to manage all this complexity? An integrated development environment (IDE) is a software application that provides comprehensive facilities to computer programmers for software development: source code editor compiler (or cross-compiler) + assembler + linker debugger IDEs try to maximize programmer productivity by providing tightly-knit components in a unique user interface, avoiding the programmer to switch to several programs. Not all programmers prefer IDEs, but they are a very powerful tool to manage a complex embedded workflow!

20 System Workbench System Workbench for STM32 Bare Metal Edition is an Eclipse-based IDE. It provides a complete and free development platform for STM32 MCUs. It integrates a complete code editor, compilation (compiler, assembler, linker ) tools and remote-debugging tools. Features STM32 Devices database and libraries Source code editor Linker script generator Building tools (GCC-based toolchain, assembler, linker) Debugging tools (OpenOCD, GDB) Flash programing tools

21 Workspace In Eclipse, the Workspace is a folder containing different projects, which are conveniently grouped together. You can have a workspace for a certain MCU or board and keep there the different projects It s easy to have shared resources (e.g. libraries) for different projects in a workspace At startup a default Workspace is created (in user/documents), You can easily switch between different workspaces: File -> Switch Workspace If you want a new workspace just switch to a new empty folder. create a new folder named HSDES16 and set it as the current workspace.

22 New Project Creation 1

23 New Project Creation 2 Insert Project Name Use default location (creates a new project folder in the current workspace) Choose Executable -> Empty Project -> AC6 STM32 MCCU GCC As project configurations leave Debug and Release

24 New Project Creation 3 Select your board: Series STM32F4 NUCLEO-F401RE

25 New Project Creation 4 Select Standard Peripheral Library If you do not have the library, the tool will ask you to download it. Add low level drivers (StdPeriph) in the project as static external files. static external files creates only one library folder which will be shared among projects in the workspace As sources copies the library in every project folder

26 New Project Creation 5 You will have to download a firmware or copy it from me. In the latter case, copy it from user hwswdesign ; password embeddedsystems Copy it to the following folder (if it does not exist, create it) Windows : c:/utenti/yourname/appdata/roaming/ac6/sw4stm32/firmwares/ Linux : ~/.ac6/sw4stm32/firmwares/

27 Eclipse Interface 1. Save 2. Build (compile) 3. Debug (do not click now)

28 Eclipse Interface warnings Breakpoint (code execution during debug pauses here) Build Output Console

29 Eclipse View Perspectives Interface perspectives for developing code (as seen for now) and for debug Debug Interface Development interface

30 Project Structure Project folder Interrupt definition Header File Main with your code System calls (redefinition of stdio.h calls) STM32 System initialization (executed before main) Assembly startup file, the very first code executed by MCU and interrupt prototypes Standard peripheral Library

31 Standard Peripheral Library The STM32F4xx standard peripherals library enables a more abstract way to program a STM32 MCU with respect to the direct way we explored last week: it provides a complete register address mapping with all bits, bit-fields and registers declared in C. it includes a collection of routines and data structures, covering all the MCU s internal peripherals functions and their drivers. each driver follows a common API, with standard structure, the functions and the parameter names. it provides a set of examples, covering all available peripherals with template projects for the most common development tools.

32 Standard Peripheral Library Description CMSIS (developed by ARM) provide access to Cortex M CORE registers

33 Standard Peripheral Library Description CMSIS (developed by ARM) provide access to Cortex M CORE registers StdPeriph Driver (developed by ST) deliver high level functions to access peripherals (one file for each periph.)

34 Standard Peripheral Library Description CMSIS (developed by ARM) provide access to Cortex M CORE registers StdPeriph Driver (developed by ST) deliver high level functions to access peripherals (one file for each periph.) Utilities (developed by ST) useful to access external devices on the board (sensors, LEDs, etc )

35 Using the Standard Peripheral Library Hands on with some code! Zeroth example: led on forever. With respect to what we did with I 2 C last week: we still need to enable the clock there is no need for setting and alternate function (GPIO is the default) configuration and usage are simplified However, the logic behind using the Standard Peripheral Library is the same we have seen at the end of the last lecture! Now, get to your main.c.

36 Using the Standard Peripheral Library 0. Preliminary stuff and initialization. // include the Standard Peripheral Library #include "stm32f4xx.h int main(void) { // code here // [...] // never exit from main while(1);

37 Using the Standard Peripheral Library 0. Preliminary stuff and initialization. // include the Standard Peripheral Library #include "stm32f4xx.h int main(void) { // code here // [...] // never exit from main while(1);

38 Using the Standard Peripheral Library 1. Enable the clock. // include the Standard Peripheral Library #include "stm32f4xx.h int main(void) { // still missing GPIO structure initialization [...] RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); // [...] // never exit from main while(1);

39 Using the Standard Peripheral Library 3. Configure the GPIO pin. // include the Standard Peripheral Library #include "stm32f4xx.h int main(void) { GPIO_InitTypeDef led; declare the LED data structure RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); initialize the LED data structure // [...] // never exit from main while(1);

40 Using the Standard Peripheral Library 3. Configure the GPIO pin. // include the Standard Peripheral Library #include "stm32f4xx.h int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); configure the LED using the data structure // [...] // never exit from main while(1);

41 Using the Standard Peripheral Library 4. Light the led. // include the Standard Peripheral Library #include "stm32f4xx.h int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); GPIO_SetBits(GPIOA, GPIO_Pin_5); set the LED (pin A5) to 1 // never exit from main while(1);

42 Using the Standard Peripheral Library 4. Light the led. // include the Standard Peripheral Library #include "stm32f4xx.h int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); GPIO_SetBits(GPIOA, GPIO_Pin_5); // never exit from main while(1);

43 Eclipse Tips By default, you have to save your file before building it with the latest modification. To automatically save before build, go to Window > Preferences > General > Workspace and check Save automatically before build If you get reference not found errors even if you included the correct headers, rebuild the index: Project -> C/C++ Index -> Rebuild

44 Start Debugger Right click on project -> Debug as Ac6 STM32 C/C++ Application

45 Open Debug Perspective Click Allow access for Windows firewall Click Yes to open Debug Perspective (you can tick Remember my decision to automatically open debug perspective)

46 Debug Interface Start / pause code execution Stop / disconnect debugger Debug steps: - Step Into - Step Over - Step Out Debug status: Check green Play light

47 Debug Interface Mouse over a variable name to check its value Current debugger location Breakpoints (code execution pauses here)

48 Variables monitoring

49 More Views You can add more view to monitor: Assembly code Memory addresses Global variables Microcontroller s registers

50 System Tick For more interesting functionality than an always-on LED, it is necessary to introduce a notion of time The System Tick (SysTick) is used to schedule periodic events When enabled, it generates an interrupt every N clock cycles, resulting in the call to its IRQ handler (i.e the interrupt service routine)

51 Blinking a LED with the SysTick 5. Enable the SysTick. #include "stm32f4xx.h int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); GPIO_SetBits(GPIOA, GPIO_Pin_5); configure the SysTick to trigger every 1ms if(systick_config(systemcoreclock / 1000)) { // error! while(1); while(1);

52 Blinking a LED with the SysTick 5. Enable the SysTick. #include "stm32f4xx.h int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); GPIO_SetBits(GPIOA, GPIO_Pin_5); if(systick_config(systemcoreclock / 1000)) { // error! while(1); while(1); do something in case of error J

53 Blinking a LED with the SysTick 5. Enable the SysTick. #include "stm32f4xx.h int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); GPIO_SetBits(GPIOA, GPIO_Pin_5); if(systick_config(systemcoreclock / 1000)) { // error! while(1); while(1);

54 Blinking a LED with the SysTick Try it. Does it work?

55 Blinking a LED with the SysTick Try it. Does it work? No???

56 Blinking a LED with the SysTick Try it. Does it work? No??? Well, maybe we forgot to add the interrupt handler

57 Blinking a LED with the SysTick 6. Add an interrupt handler! (in stm32f4xx_it.c). #include "stm32f4xx.h #include "stm32f4xx_it.h include the interrupt handler declarations extern int status, count; helper variables ( extern as they will be declared in the main.c file) void SysTick_Handler(void) { count ++; if (count >= NB_COUNT) { if(status) { GPIO_SetBits(GPIOA, GPIO_Pin_5); count = 0; status = 0; else { GPIO_ResetBits(GPIOA, GPIO_Pin_5); count = 0; status = 1;

58 Blinking a LED with the SysTick 6. Add an interrupt handler! (in stm32f4xx_it.c). #include "stm32f4xx.h #include "stm32f4xx_it.h extern int status, count; void SysTick_Handler(void) { count ++; if (count >= NB_COUNT) { if(status) { GPIO_SetBits(GPIOA, GPIO_Pin_5); count = 0; set the LED to 1 status = 0; else { GPIO_ResetBits(GPIOA, GPIO_Pin_5); count = 0; set the LED to 0 status = 1;

59 Blinking a LED with the SysTick 6. Add an interrupt handler! (in stm32f4xx_it.c). #include "stm32f4xx.h #include "stm32f4xx_it.h extern int status, count; void SysTick_Handler(void) { count ++; if (count >= NB_COUNT) { if(status) { GPIO_SetBits(GPIOA, GPIO_Pin_5); count = 0; status = 0; else { GPIO_ResetBits(GPIOA, GPIO_Pin_5); count = 0; status = 1;

60 Blinking a LED with the SysTick 7. Add helper variables to main. stm32f4xx_it.c #include "stm32f4xx.h #include "stm32f4xx_it.h extern int status, count; void SysTick_Handler(void) { count ++; if (count >= NB_COUNT) { if(status) { GPIO_SetBits(GPIOA, GPIO_Pin_5); count = 0; status = 0; else { GPIO_ResetBits(GPIOA, GPIO_Pin_5); count = 0; status = 1; main.c #include "stm32f4xx.h int status, count; int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); status = 0; count = 0; if(systick_config(systemcoreclock / 1000)) { // error! while(1); while(1);

61 Blinking a LED with the SysTick 7. Add helper variables to main. stm32f4xx_it.c #include "stm32f4xx.h #include "stm32f4xx_it.h extern int status, count; void SysTick_Handler(void) { count ++; if (count >= 500) { if(status) { GPIO_SetBits(GPIOA, GPIO_Pin_5); count = 0; status = 0; else { GPIO_ResetBits(GPIOA, GPIO_Pin_5); count = 0; status = 1; main.c #include "stm32f4xx.h int status, count; int main(void) { GPIO_InitTypeDef led; RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE); led.gpio_pin = GPIO_Pin_5; led.gpio_mode = GPIO_Mode_OUT; led.gpio_otype = GPIO_OType_PP; led.gpio_pupd = GPIO_PuPd_UP; led.gpio_pupd = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &led); status = 0; count = 0; if(systick_config(systemcoreclock / 1000)) { // error! while(1); while(1);

62 SPI Example