Software engineering voor Embedded Systemen

Tips en trucks om software te schrijven voor embedded devices

Embedded systems met een microcontroller als kern hebben software nodig om correct te funktioneren. Deze software is in veel gevallen geschreven in de taal C, maar steeds meer wordt ook de taal C++ hiervoor gebruikt. Software voor embedded systems is niet anders dan software voor PCs, maar de ontwerpen en programmeur hebben wel te maken met enkele beperkingen:

Enkele nuttige documenten over het programmeren van embedded systems zijn hier te vinden.

Het ontwikkelen van STM32 Cortex-M0-M7 software met GNU ARM tools op Unix, Apple en Windows

Voor het ontwikkelen van software voor de ARM Cortex-M microcontrollers zoals de STMicroelectronics STM32 bestaan enkele mogelijkheden. Enerzijds is het mogelijk een ontwikkelsuite (Keil, IAR of Atollic) aan te schaffen die voor het programmeren de infrastructuur verschaft, alsmede communicatie met de embedded target. Anderzijds is het voor de wat minder gefortuneerde ontwikkelaar ook mogelijk de gratis GNU ARM toolchain te gebruiken. Het probleem dat zich dan aandient is hoe men de compiler aanroept en gebruikt om daarmee uitvoerbare bestanden voor de embedded target te maken.
Een mogelijke oplossing presenteer ik hier. Het maakt gebruikt van drie kernonderdelen, allen gratis te downloaden:
  1. De GNU ARM EABI C/C++ toolchain. Deze kan worden gedownload bij ARM voor Unix/Linux, apple en Windows.
  2. Het CMake build system. Deze Makefile generator kan uitstekend cross-platform worden ingezet en ook voor embedded software ontwikkeling worden ingezet.
  3. Een command shell. Unix/Linux gebruikers hebben op hun systeem standaard een C of Bash shell. Op Apple OS X is het Terminal programma uitstekend geschikt als command shell. Windows gebruikers zullen MinGW (Msys) als shell moeten installeren.

Installatie van de componenten

FreeBSD

De installatie vereist root rechten.
  1. Als root, installeer (met portmaster of direct uit de ports) de linux emulatie laag en cmake.
  2. Download daarna de Linux versie van de GNU ARM EABI toolchain en installeer deze /usr/local.
  3. Zorg er voor dat de tool toegankelijk en uitvoerbaar door alle gerechtigde gebruikers (chmod 755 lijkt mij okay).
  4. Plaats een symlink naar de toolchain in /usr/local : arm-none-eabi -> gcc-arm-none-eabi-4_8-2014q3

Apple Mac OS X

In essentie moet hier dezelfde procedure worden gevolgd als op FreeBSD, maar dan met gebruikmaking van de Ports collectie en de Apple versie van de de GNU ARM toolchain. Installeer cmake uit de Ports en maak ook een symlink.

Microsoft Windows

Op Windows moeten de genoemde kernonderdelen worden geinstalleerd uit pakketten.
  1. Installeer allereerst MinGW. Zorg bij de installer dat de minimale onderdelenset geinstalleerd wordt:

    Zorg na installatie van MinGW er voor de dat gebruikersomgeving goed is opgezet. In het bijzonder moet het bestand fstab worden geplaatst:

  2. Installeer CMake met behulp van de Windows Installer. Zorg er voor, dat CMake aan het gebruikerspad wordt toegevoegd:

  3. Installeer de GNU ARM EABI toolchain met behulp van de Windows installer.

Het compileren van embedded software met Shell, CMake en GNU ARM C/C++

De aanpak

Voor een embedded systeem zijn vaak meerdere bestanden noodzakelijk om tot een uitvoerbaar bestand te komen. Het in de goede volgorde compileren en linken van deze bestanden wordt door een Make tool gedaan. De volgorde en de namen van de bestanden worden in een Makefile samengevat. In mijn opzet worden de Makefiles gegenereerd door de tool CMake op basis van een platform overstijgende samenvatting, meestal samengevat in een CMakeLists.txt bestand. Een voorbeeld van zo'n CMakeLists.txt is dit:

## Copyright 2011-2014 Hogeschool van Arnhem en Nijmegen
## Opleiding Embedded Systems Engineering
## Ewout Boks
## $Id: CMakeLists.txt 1775 2014-12-10 14:18:17Z ewout $

message("HAN ESE STM32F0 LEDs demo.")

set(PROJECTNAAM "stm32f0demo")

cmake_minimum_required(VERSION 2.8.4)

project(${PROJECTNAAM})

set(GEMDIR ${PROJECT_SOURCE_DIR}/../gemeenschappelijk)
set(BASISDIR ${GEMDIR}/basis)
set(CMAKESCRIPTDIR ${PROJECT_SOURCE_DIR}/../../buildsystem/STM32)
set (DISCOVERYDIR ${GEMDIR}/STM32F0Discovery)

add_definitions( -DUSE_STDPERIPH_DRIVER)

include_directories(. ${BASISDIR} ${DISCOVERYDIR})

include(${CMAKESCRIPTDIR}/STM32F0.cmake)

file(GLOB BasisBestanden ${BASISDIR}/stm32f0/*.c)
set(SRCS main.cpp ${BasisBestanden} stm32f0xx_it.c)

add_subdirectory(${DISCOVERYDIR} ${CMAKE_CURRENT_BINARY_DIR}/DiscoveryDir)

add_executable(${PROJECTNAAM}.elf ${SRCS})

# voor info na het linken
add_custom_target(info ALL
COMMAND ${COMP_INFO_TOOL} -A -d ${PROJECTNAAM}.elf
DEPENDS ${PROJECTNAAM}.elf
COMMENT "STM32 ${PROJECTNAAM}.elf is gemaakt. Hier volgt informatie over het ELF
bestand.")

# Doel wordt hier samengesteld.
target_link_libraries(${PROJECTNAAM}.elf STM32F0DiscoveryLib CMSISFIRMWARE F0StdPerifDriver)




Een Makefile word gegenereerd op basis van de CMake beschrijving. Dit gebeurt door in de shell cmake aan te roepen. Daarnaast is het raadzaam de gegenereerde Makefiles en de (tijdelijke) bestanden die bij het software bouwproces worden gemaakt in een aparte directory te plaatsen, omdat dan de broncode gescheiden blijft van de compilatiebestanden. CMake kan "out of source" bouwen om dit mogelijk te maken.

Een voorbeeld

In deze directory zijn enkele voorbeeldprojecten te vinden, waarbij alle benodigde bestanden voor de bouw van een simpel project al geconfigureerd zijn.
Neem als voorbeeld de bouw van het STM32F0 Discovery demoproject op Windows met MinGW. Dit project is hier te vinden.
Maak eerst een bouwdirectory in de root van het project, dus in de directory waar ook het CMakeListst.txt bestand aanwezig is. In mijn voorbeeld heet de bouwdirectory debug.
Genereer daarna de Makefiles op basis van CMake vanuit de bouwdirectory met het commando cmake .. -G"Unix Makefiles"

In de debug directory is nu een set (GNU) Makefiles aanwezig.
Het bouwen van de software is hierna eenvoudig. Simpelweg het commando make uitvoeren roept Make aan, dat op basis van de gegenereerde Makefiles de software gaat compileren en linken. CMake zorgt bovendien voor een nette make output, waarbij de progessie van het bouwen percentueel wordt aangegeven en elke aktie een eigen kleur heeft. CMake staat voor Colour Make en dat is wel duidelijk als je het gebruikt.

Op FreeBSD ziet het bouwproces er zeer vergelijkbaar uit. Hieronder staan de screenshots van het bouwproces op FreeBSD :

en

Om een eigen project te kunnen bouwen met behulp van deze aanpak is het nodig om het CMakeLists.txt bestand aan te passen, waarbij natuurlijk de variabele SRCS de te compileren bestanden aangeeft. Gebruik de demoprojecten dan ook om een eigen project op te zetten.
bij het installeren van een nieuwere of andere versie van de compiler moet onder Windows ook het toolchainpad worden aangepast. Dit gebeurt in BasisSTM32.cmake met de regel set(GNUARMWINVersie "4.8\ 2014q3") .

Programmeren van het embedded device

Het programmeren van het device gebeurt met een programmer. Bij gebruik van een STM32 Discovery kit kan met behulp van STLink de target worden geflasht. Ook kan een externe tool worden gebruik, zoals de Segger J-Link. Zie hiervoor ook mijn informatie over de JLinkProgrammer.

Terug naar begin