In dit diepgaande artikel leert u hoe u embedded firmware kunt ontwikkelen voor STM32 Cortex-M 32-bit microcontrollers met behulp van de verschillende ontwikkeltools.
de STM32-serie is een van de meest populaire microcontrollers die in een breed scala van producten worden gebruikt. Ze hebben ook een uitstekende support basis van meerdere Microcontroller ontwikkeling forums.
deze familie van microcontrollers van STMicroelectronics is gebaseerd op de ARM Cortex-M 32-bit processorkern.
STM32 microcontrollers bieden een groot aantal seriële en parallelle communicatie-randapparatuur die kan worden gekoppeld aan allerlei elektronische componenten, waaronder sensoren, displays, camera ‘ s, motoren, enz. Alle STM32-varianten worden geleverd met intern flashgeheugen en RAM.
het bereik van de beschikbare prestaties met de STM32 is vrij uitgebreid. Enkele van de meest fundamentele varianten omvatten de stm32f0 en STM32F1 sub-series die beginnen met een klokfrequentie van slechts 24 MHz, en zijn beschikbaar in pakketten met slechts 16 spelden.
De STM32H7 werkt op 400 MHz en is verkrijgbaar in pakketten met maar liefst 240 pinnen.
de meer geavanceerde modellen zijn beschikbaar met Floating Point Units (FPU) voor toepassingen met ernstige numerieke verwerkingseisen. Deze meer geavanceerde modellen vervagen de lijn tussen een microcontroller en een microprocessor.
ten slotte is de stm32l sub-serie speciaal ontworpen voor draagbare toepassingen met een laag vermogen die draaien op een kleine batterij.
ontwikkeltools
ontwikkeltools zijn nodig om de code te ontwikkelen, de microcontroller te programmeren en de code te testen / debuggen. De ontwikkeltools omvatten:
- Compiler
- Debugger
- In-Circuit Serial Programmer (ICSP)
programmeren van de STM32 via de In-Circuit-Serial-Programmer (ICSP).
Er zijn verschillende software development tools beschikbaar voor code ontwikkeling op STM32 microcontrollers. De software tools zijn beschikbaar als Integrated Development Environments (IDE) die alle benodigde tools combineert in een geïntegreerde omgeving.
twee gemeenschappelijke ontwikkelingspakketten omvatten:
- Keil MDK ARM (UVISON5 IDE) – de MDK ARM IDE is een zeer stabiele ontwikkelomgeving die gratis kan worden gedownload. Het maakt de ontwikkeling van code mogelijk tot een programmagrootte van 32 KB. Voor het ontwikkelen van grotere programma ‘ s moet hier een gelicentieerde versie worden aangeschaft.
- CoIDE-een free tool chain die gebaseerd is op een bijgesneden versie van de Eclipse IDE geïntegreerd samen met een embedded ARM versie van de free GCC compiler.
er zijn ook verschillende andere IDEs beschikbaar voor gebruik met STM32 microcontrollers. Echter, dit artikel richt zich op het ontwikkelen en knipperen van een programma met behulp van de zeer populaire Keil MDK ARM UVISION5 IDE.
naast de softwaretools is een In-Circuit Serial Programmer (ICSP) vereist om de code te programmeren en te testen op de eigenlijke microcontroller. ICSP is vereist om de microcontroller aan de PC softwarehulpmiddelen via een USB-poort te koppelen.
de ARM Cortex-M microcontrollers ondersteunen twee programmeerprotocollen: JTAG (genoemd door de electronics industry association de Joint Test Action Group) en Serial Wire Debug (SWD).
Er zijn verschillende ICSP-programmeurs beschikbaar die deze protocollen ondersteunen, waaronder:
- Keil U-Link 2
- Segger J-Link
- ST-Link
ontwikkelen van de eerste toepassing
Het is altijd het makkelijkst om te beginnen met een direct beschikbaar Basic Code framework. Voeg dan de code toe die nodig is voor de specifieke toepassing en het model van microcontroller.
Gelukkig biedt STMicroelectronics een zeer nuttig grafisch hulpmiddel genaamd STM32CubeMx dat helpt bij het maken van een basic applicatie project voor elke STM32 microcontroller van uw keuze. Het kan ook worden gebruikt om de randapparatuur op de multiplexed pinnen van de microcontroller te configureren.
Het hulpprogramma STM32CubeMX kan hier worden gedownload. De STM32Cube wordt geleverd met een uitgebreide set drivers voor alle soorten randapparatuur en ondersteuning voor een optionele FreeRTOS (een gratis Real-Time besturingssysteem) vooraf geà ntegreerd met de code.
de volgende paragraaf beschrijft in detail hoe u een eenvoudige UART-toepassing voor de stm32f030 microcontroller kunt maken die echo ‘ s geeft van wat er op een terminalvenster wordt getypt.
- installeer de stm32cubemx-software.
- Voer de toepassing uit en selecteer Nieuw Project. Het opent dan het MCU Selector venster zoals hieronder getoond.
- Dubbelklik om het gebruikte microcontroller-model te selecteren. In dit geval gebruiken we de STM32F030K6. Het brengt je dan naar de pinout pagina voor de geselecteerde microcontroller.
De STM32F030K6 is een ARM Cortex-M0-kern met 32KB flashgeheugen en 4KB RAM-geheugen. De voorbeeldcode maakt het mogelijk dat de UART die de pa9 en PA10 pinnen gebruikt voor het ontvangen en verzenden van seriële gegevens zoals hieronder weergegeven met de groene pinnen.
Configureer de UART-instellingen op het tabblad Configuratie en kies de UART-instellingen zoals hieronder getoond. Schakel de optie NVIC global interrupt in op het tabblad NVIC-Instellingen.
volgende, navigeer naar Project – >Instellingen om de nieuwe projectnaam toe te voegen en de te gebruiken gereedschapsketting-IDE te selecteren. Stel in dit voorbeeld de projectnaam in op ‘UARTEcho’ en selecteer de Keil-MDK5 IDE voor de projectontwikkeling.
ten slotte, Genereer de projectcode door te klikken op Project – > Genereer Code.
bouwen en knipperen van de code
open nu het gegenereerde MDK-ARM projectbestand UARTEcho\MDK-ARM\UARTECHO.uprojx.
Dit programma initialiseert tot nu toe alleen de UART randlijn en stopt in een oneindige lus.
Het is belangrijk op te merken dat de STM32Cube /* USER CODE BEGIN x */ en /* USER CODE END x */ commentaarblokken genereert om de gebruikersspecifieke code te implementeren. De gebruikerscode moet geschreven worden binnen deze commentaarblokken. Wanneer de code opnieuw wordt gegenereerd met gewijzigde configuraties, behoudt de stmcube-tool de gebruikerscode binnen deze gebruikerscommentaarblokken.
definieer vervolgens een globale variabele om een byte te ontvangen van de UART in de main.c bronbestand:
/* USER CODE BEGIN PV *//* Private variables ———————————————————*/static uint8_t recv_data;/* USER CODE END PV */na alle initialisatiecode kan het stuurprogramma 1 byte ontvangen. De volgende functie schakelt de rxne interrupt bit in.
/* USER CODE BEGIN 2 */HAL_UART_Receive_IT(&huart1, &recv_data, 1);/* USER CODE END 2 */Voeg nu een callback functie toe om de receive interrupt af te handelen en de ontvangen byte te verzenden.
/* USER CODE BEGIN 0 */void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){HAL_UART_Transmit(huart, huart->pRxBuffPtr, 1, 1000);}/* USER CODE END 0 */ten slotte moeten we de code compileren en flash (download) naar de microcontroller.
wanneer de Keil MDK ARM IDE is geïnstalleerd, zijn stuurprogramma ‘ s voor ST-LINK V2, J-Link en Ulink2 beschikbaar. De ST-Link debugger wordt standaard geselecteerd. Ga naar Projects – >opties voor Target en selecteer in het Debug tabblad de gebruikte ICSP programmer.
Flash de code door Flash->Download te selecteren.
de microcontroller zal nu alle gegevens weergeven die via de UART zijn ontvangen. Het kan worden aangesloten op een PC met behulp van een USB-naar-seriële Converter. Open op de PC de COM-poort met een terminal applicatie met behulp van de instellingen van 115200-8-N-1. Alles wat vanaf de terminal wordt verzonden, zal via de microcontroller weerklinken.
Interruptsysteem
het STM32 interruptsysteem is gebaseerd op de ARM Cortex M core NVIC perifeer. De STM32 MCU ‘ s ondersteunen meerdere maskeerbare interrupt kanalen behalve de 16 interrupt kanalen van de ARM core.
bijvoorbeeld de STM32F0 MCU-serie ondersteunt 32 gemaskerde interrupts. De uitzondering en de interrupt vector tabel voor deze familie van MCU ‘ s wordt gegeven in de onderstaande tabel.
| Interrupt | Description | Vector Address |
| – | Reserved | 0x00000000 |
| Reset | Reset | 0x00000004 |
| NMI | Non maskable interrupt. The RCC clock security system (CSS) is linked to the NMI vector | 0x00000008 |
| HardFault | All class of faults | 0x0000000C |
| SVCall | System service call via SWI Instruction | 0x0000002C |
| PendSV | Pendable request for system service | 0x00000038 |
| SysTick | System tick timer | 0x0000003C |
| WWDG | Window watchdog interrupt | 0x00000040 |
| PVD_VDDIO2 | PVD and VDDIO2 supply comparator interrupt (combined with EXTI lines 16 and 31) | 0x00000044 |
| RTC | RTC interrupts (combined EXTI lines 17, 19 and 20) | 0x00000048 |
| Flash | Flash global interrupt | 0x0000004C |
| RCC_CRS | RCC and CRS global interrupts | 0x00000050 |
| EXTI0_1 | EXTI line interrupts | 0x00000054 |
| EXTI2_3 | EXTI line interrupts | 0x00000058 |
| EXTI4_15 | EXTI line interrupts | 0x0000005C |
| TSC | Touch sensing interrupt | 0x00000060 |
| DMA_CH1 | DMA channel 1 interrupt | 0x00000064 |
| DMA_CH2_3 DMA2_CH1_2 |
DMA channels 2 and 3 interrupts DMA2 channel1 and 2 interrupts |
0x00000068 |
| DMA_CH4_5_6_7 DMA2_CH3_4_5 |
DMA channel 4,5,6 and 7 interrupts DMA2 channel 3, 4, and 5 interrupts |
0x0000006C |
| ADC_COMP | ADC and COMP interrupts (Combined EXTI lines 21 and 22) | 0x00000070 |
| TIM1_BRK_UP_TRG_COM | TIM1 break, update, trigger and commutation interrupts | 0x00000074 |
| TIM1_CC | TIM1 capture compare interrupt | 0x00000078 |
| TIM2 | TIM2 global interrupt | 0x0000007C |
| TIM3 | TIM3 global interrupt | 0x00000080 |
| TIM6_DAC | TIM6 global interrupt and DAC underrun interrupt | 0x00000084 |
| TIM7 | TIM7 global interrupt | 0x00000088 |
| TIM14 | TIM14 global interrupt | 0x0000008C |
| TIM15 | TIM15 global interrupt | 0x00000090 |
| TIM16 | TIM16 global interrupt | 0x00000094 |
| TIM17 | TIM17 global interrupt | 0x00000098 |
| I2C1 | I2C1 global interrupt (combined with EXTI line 23) | 0x0000009C |
| I2C2 | I2C2 global interrupt | 0x000000A0 |
| SPI1 | SPI1 global interrupt | 0x000000A4 |
| SPI2 | SPI2 global interrupt | 0x000000A8 |
| USART1 | USART1 global interrupt (combined with EXTI line 25) | 0x000000AC |
| UART2 | USART2 global interrupt (combined with EXTI line 26) | 0x000000B0 |
| USART3_4_5_6_7_ 8 | USART3, USART4, USART5, USART6, USART7, USART8 global interrupts (combined with EXTI line 28) | 0x000000B4 |
| CEC_CAN | CEC and CAN global interrupts (combined with EXTI line 27 | 0x000000B8 |
| USB | USB global interrupt (combined with EXTI line 18) | 0x000000BC |
Extended Interrupts and Events Controller (Extended interrupts and Events controller (Extended interrupts and Events controller)
de STM32 MCU ‘ s hebben een Extended interrupts and Events controller die de externe en interne asynchrone gebeurtenissen/interrupts beheert en de event request genereert aan de CPU/Interrupt Controller en een wake-up request aan de Power Manager.
elk van de één of meer EXTI-lijnen wordt toegewezen aan een van de NVIC-interruptvectoren.
voor de externe interruptregels moet de interruptregel worden geconfigureerd en ingeschakeld om een interrupt te genereren. Dit wordt gedaan door de twee trigger registers te programmeren met de gewenste randdetectie en door de interrupt request aan te zetten door een ‘1’ te schrijven naar het corresponderende bit in het interrupt mask register.
externe Interrupt en GPIO-toewijzing
elk van de GPIO beschikbaar op het systeem kan worden geconfigureerd om een interrupt te genereren. Maar elk van de EXTI interrupt lijnen is gekoppeld aan meerdere GPIO pinnen. Bijvoorbeeld, PIO0 op alle beschikbare GPIO-poorten (A, B, C, enz.) zal worden toegewezen aan de EXTI0 lijn. PIO1 voor alle poorten zal worden toegewezen aan de EXTI1 lijn en ga zo maar door.
sommige EXTI-lijnen worden gecombineerd tot een enkele NVIC-vector. Bijvoorbeeld, EXTI4_15 is toegewezen aan een enkel vector adres, zodat er een enkele interrupt routine zal zijn voor alle interrupts van PIO4 naar PIO15. Maar de bron van de interrupt kan worden geïdentificeerd door het lezen van de interrupt lopende register.
een belangrijk ding om te overwegen bij het ontwerpen van een systeem met behulp van de STM32 MCU ‘ s is de selectie van de GPIO pinnen voor de interrupts. De MCU kan meer dan 16 GPIO ‘ s beschikbaar op het apparaat, maar er zijn slechts 16 externe interrupt lijnen beschikbaar.
bijvoorbeeld, de EXTI_0 kan worden toegewezen aan PA0 of PB0, maar niet beide. Dus tijdens het kiezen van de pinnen voor externe interrupts moeten ze zodanig worden gekozen dat ze uniek kunnen worden toegewezen aan een van de EXTI-lijnen.
in de volgende sectie wordt beschreven hoe een interrupt kan worden geconfigureerd met de STM32-kubus.
Selecteer het tabblad Configuratie en kies de hardwaremodule waarvoor de interrupt moet worden geconfigureerd. Het configuratievenster van de module wordt geopend.
selecteer vervolgens het tabblad NVIC-instellingen en schakel de Globale interrupt in.
de code om de interrupt voor de module in te schakelen zal worden gegenereerd in de stm32f0xx_hal_msp.c in de HAL_< module>_MSPInit (…) functie.
/* USART1 interrupt Init */HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);HAL_NVIC_EnableIRQ(USART1_IRQn);de door de STM32-kubus gegenereerde code heeft de IRQ_Handler-implementatie van alle interrupts. Wanneer de interrupt is ingeschakeld zal de code worden opgenomen in de toepassing.
gewoonlijk behandelt de gegenereerde code de IRQ al en wist de vlag die de interrupt genereerde. Het roept dan een applicatie callback die overeenkomt met de gebeurtenis die de interrupt gegenereerd voor de module.
de STM32 HAL (Hardware Abstraction Layer) implementeert een callback voor elk van de gebeurtenistypen binnen elke module als onderdeel van het stuurprogramma. In dit voorbeeld moet de Rx Transfer Complete callback gekopieerd worden van de stm32f0xx_hal_UART.C-bestand.
de callback functies binnen het stuurprogramma zullen worden geïmplementeerd met een __weak linker attribuut. De gebruiker moet een kopie van de benodigde callback-functie implementeren door het __zwakke attribuut in een van de applicatie bestanden te verwijderen en vervolgens de specifieke afhandeling te schrijven die nodig is binnen die functie.
/*** @brief Rx Transfer completed callback.* @param huart UART handle.* @retval None*/__weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){/* Prevent unused argument(s) compilation warning */UNUSED(huart);/* NOTE : This function should not be modified, when the callback is needed,the HAL_UART_RxCpltCallback can be implemented in the user file.*/}
conclusie
Deze tutorial is een inleiding tot het schrijven van een toepassing die werkt met de STM32 familie van microcontrollers. Er zijn verschillende andere methoden voor het schrijven van een toepassing, maar de stm32cube besproken is een eenvoudige en intuã tieve methode om te beginnen.
deze tool vereenvoudigt de initialisatie van de randapparatuur van de microcontroller. Het verbetert ook de onderhoudbaarheid van de code, vooral wanneer er hardware revisies die remapping van de signalen naar verschillende pins vereisen.
een ander voordeel van het gebruik van het stm32cube gereedschap is dat het een rapport genereert van de gebruikersconfiguratie voor de microcontroller. In dit rapport wordt de clock tree, pin mapping en hardware module configuratie beschreven die allemaal erg handig zijn.
er zijn ook verschillende andere codebibliotheken en voorbeeldprogramma ‘ s beschikbaar voor alle STM32 varianten. Ondersteuning voor verschillende IDEs is ook inbegrepen.
als uw project een geavanceerde 32-bit microcontroller vereist, dan raad ik de STM32-serie ten zeerste aan. Niet alleen zijn ze krachtig en populair, maar STM32 microcontrollers zijn ook heel betaalbaar.
behoefte aan meer training over het programmeren van STM32 microcontrollers? Zo ja, hier is een meer diepgaande inleidende cursus die u moet controleren.
Dit artikel is geschreven door Mohan Kashivasi van Vithamas Technologies. Hij is ook een van de experts beschikbaar om u te helpen met uw product binnen de Hardware Academy.
vergeet Tot slot niet om uw gratis PDF te downloaden: Ultieme Gids Voor het ontwikkelen en verkopen van uw nieuwe elektronische Hardware Product. Je ontvangt ook mijn wekelijkse nieuwsbrief waar ik premium content Deel die niet beschikbaar is op mijn blog.
andere inhoud die u misschien leuk vindt:
- Inleiding tot de Stm32cubeide voor STM32 Microcontrollers
- Hoe selecteert u de Microcontroller voor uw nieuwe Product
- gebruikmakend van Arduino als een Embedded ontwikkelingsplatform
- Datasheet Review: Entry-Level STM32 Cortex-M0 Microcontroller (Blog + Video)
- Introduction to the Ultra High-Performance STM32H7 32-bit Microcontroller