i denne grundige artikkelen lærer du hvordan du utvikler innebygd firmware FOR STM32 Cortex-M 32-bits mikrokontrollere ved hjelp av de ulike utviklingsverktøyene.
STM32-serien er noen av DE mest populære mikrokontrollere som brukes i et bredt utvalg av produkter. De har også en utmerket støttebase fra flere mikrokontrollerutviklingsfora.denne familien av mikrokontrollere Fra STMicroelectronics er basert PÅ ARM Cortex-M 32-bits prosessorkjerne.
STM32 mikrokontrollere tilbyr et stort antall serielle og parallelle kommunikasjon enheter som kan kobles med alle typer elektroniske komponenter, inkludert sensorer, skjermer, kameraer, motorer, etc. ALLE STM32-varianter leveres med internt Flashminne og RAM.
utvalget av ytelse tilgjengelig MED STM32 er ganske ekspansivt. NOEN av de mest grunnleggende varianter inkluderer STM32F0 og STM32F1 sub-serien som starter med en klokkefrekvens på bare 24 MHz, og er tilgjengelig i pakker med så få som 16 pinner.PÅ den andre ytelses ekstreme opererer STM32H7 på opptil 400 MHz, og er tilgjengelig i pakker med så mange som 240 pinner.
de mer avanserte modellene er tilgjengelige Med Flyttallsenheter (Fpu) for applikasjoner med alvorlige numeriske behandlingskrav. Disse mer avanserte modellene slør linjen mellom en mikrokontroller og en mikroprosessor.
Endelig ER stm32l sub-serien designet spesielt for lavt strømforbruk bærbare applikasjoner som kjører fra et lite batteri.
Utviklingsverktøy
Utviklingsverktøy kreves for å utvikle koden, programmere mikrokontrolleren og teste/feilsøke koden. Utviklingsverktøyene inkluderer:
- Kompilator
- Debugger
- In-Circuit Serial Programmerer (ICSP)
Programmering AV STM32 via IN-Circuit-Serial-Programmerer (ICSP).
det finnes flere programvareutviklingsverktøy tilgjengelig for kodeutvikling PÅ STM32 mikrokontrollere. Programvareverktøyene er tilgjengelige Som Integrerte Utviklingsmiljøer (IDE) som kombinerer alle nødvendige verktøy i et integrert miljø.To vanlige utviklingspakker inkluderer: Keil MDK ARM (uVison5 IDE) – MDK ARM IDE er et veldig stabilt utviklingsmiljø som kan lastes ned gratis. Det tillater utvikling av kode opp til en programstørrelse på 32 KB. For å utvikle større programmer må en lisensiert versjon kjøpes her.CoIDE-en gratis verktøykjede som er basert på en trimmet ned versjon av Eclipse IDE integrert sammen med en innebygd ARM versjon av free GCC kompilatoren.
Det finnes også flere Andre Ideer som er tilgjengelige for BRUK MED STM32 mikrokontrollere. Denne artikkelen fokuserer imidlertid på å utvikle og blinke et program ved hjelp av Den svært populære Keil MDK ARM uVision5 IDE.Bortsett fra programvareverktøyene, er DET nødvendig MED EN Seriell Programmerer (ICSP) I Kretsen for å programmere og teste koden på den faktiske mikrokontrolleren. ICSP er nødvendig for å grensesnitt mikrokontrolleren TIL PC-programvareverktøyene via EN USB-port.ARM Cortex – m mikrokontrollere støtter to programmeringsprotokoller: JTAG (navngitt Av electronics industry association Joint Test Action Group) og Serial Wire Debug (SWD).
DET er flere ICSP programmerere tilgjengelig som støtter disse protokollene, inkludert:
- Keil U-Link 2
- Segger J-Link
- ST-Link
Utvikle den første søknaden
Det er alltid enklest å starte med en lett tilgjengelig grunnleggende kode rammeverk. Deretter legger du til koden som kreves for den spesifikke applikasjonen og modellen til microcontroller.Heldigvis Gir STMicroelectronics et veldig nyttig grafisk verktøy kalt STM32CubeMx som hjelper til med å skape et grunnleggende applikasjonsprosjekt for ENHVER STM32 mikrokontroller av ditt valg. Det kan også brukes til å konfigurere eksterne enheter på multipleksede pinnene til mikrokontrolleren.
stm32cubemx-verktøyet kan lastes ned herfra. STM32Cube leveres med et omfattende sett med drivere for alle typer eksterne enheter og støtte for En valgfri FreeRTOS (et gratis Sanntids Operativsystem) pre-integrert med koden.følgende avsnitt beskriver i detalj hvordan du lager en enkel uart-applikasjon FOR STM32F030 mikrokontroller som ekko hva som er skrevet på et terminalvindu.
- Installer STM32CubeMX-programvaren.
- Kjør programmet og velg Nytt Prosjekt. DET vil da åpne MCU-Velgervinduet som vist nedenfor.
- Dobbeltklikk for å velge mikrokontrollermodellen som brukes. I dette tilfellet bruker VI STM32F030K6. Det tar deg deretter til pinout-siden for den valgte mikrokontrolleren.
STM32F030K6 ER EN ARM Cortex-M0 kjerne MED 32kb Flashminne OG 4KB RAM-minne. Eksempelkoden gjør DET MULIG FOR UART som bruker pa9 og PA10-pinnene for mottak og overføring av serielle data som vist nedenfor med de grønne pinnene.
Konfigurer uart-innstillingene under Fanen Konfigurasjon og velg UART-innstillingene som vist nedenfor. Aktiver alternativet nvic global interrupt under FANEN Nvic-Innstillinger.
neste, naviger Til Project–>Innstillinger for å legge til det nye prosjektnavnet og velge VERKTØYKJEDEN IDE som skal brukes. I dette eksemplet angir du prosjektnavnet Til ‘UARTEcho’ og velger Keil-MDK5 IDE for prosjektutviklingen.
til Slutt generer du prosjektkoden ved å klikke Prosjekt- > Generer Kode.
Bygg og blinkende koden
åpne nå den genererte MDK-ARM prosjektfilen UARTEcho \ MDK-ARM\UartEcho.uprojx.
dette programmet så langt initialiserer BARE uart perifer og stopper i en uendelig sløyfe.
Det er viktig å merke Seg At STM32Cube genererer / * BRUKERKODE START x * / OG / * BRUKERKODE END x * / kommentar blokker for å implementere brukerspesifikk kode. Brukerkoden må skrives innenfor disse kommentarblokkene. Når koden er re-generert med endrede konfigurasjoner STMCube verktøyet beholder brukerkoden i disse bruker kommentar blokker.
neste, definer en global variabel for å motta en byte fra UART i hoved.c kildefil:
/* USER CODE BEGIN PV *//* Private variables ———————————————————*/static uint8_t recv_data;/* USER CODE END PV */etter all initialiseringskoden, aktiver driveren for å motta 1 byte. Folgende funksjon aktiverer rxne-avbruddsbiten.
/* USER CODE BEGIN 2 */HAL_UART_Receive_IT(&huart1, &recv_data, 1);/* USER CODE END 2 */legg nå til en tilbakeringingsfunksjon for å håndtere mottaksavbruddet og overføre mottatt byte.
/* USER CODE BEGIN 0 */void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){HAL_UART_Transmit(huart, huart->pRxBuffPtr, 1, 1000);}/* USER CODE END 0 */Til Slutt må vi kompilere koden og flash (laste ned) den til mikrokontrolleren.
Når Keil MDK ARM IDE er installert, er drivere FOR ST-LINK V2, J-Link og Ulink2 tilgjengelige. ST-Link debugger vil bli valgt som standard. Gå Til Prosjekter – >Alternativer For Mål og I Kategorien Debug velg ICSP programmerer brukt.
Flash koden ved å velge Flash->Last Ned.
mikrokontrolleren vil nå ekko alle data mottatt over UART. Den kan kobles til EN PC ved HJELP AV EN USB-Til-Seriell Omformer. PÅ PCEN åpner COM-porten MED et terminalprogram ved hjelp av innstillingene til 115200-8-N-1. Nå vil alt som sendes fra terminalen ekko tilbake gjennom mikrokontrolleren.
Interrupt system
stm32 interrupt system er basert PÅ ARM Cortex m kjerne nvic perifer. STM32 Mcuer støtter flere maskerbare avbruddskanaler bortsett fra DE 16 avbruddskanaler I ARMKJERNEN.
FOR EKSEMPEL STØTTER STM32F0 MCU-serien 32 maskerbare avbrudd. Unntaket og avbruddsvektortabellen for Denne Familien Av Mcuer er gitt i tabellen nedenfor.
| 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 Avbrudd og Hendelseskontroller (EXTI)
Stm32 Mcu-Ene har En Utvidet avbrudd og Hendelseskontroller som styrer de eksterne og interne asynkrone hendelsene/avbruddene og genererer hendelsesforespørselen TIL CPU/Avbruddskontrolleren og en vekkeforespørsel til Power Manager.
HVER AV EN ELLER flere EXTI-linjer er kartlagt til EN AV nvic-avbruddsvektorene.
for de eksterne avbruddslinjene, for å generere et avbrudd, bør avbruddslinjen konfigureres og aktiveres. Dette gjøres ved å programmere de to utløserregistrene med ønsket kantdeteksjon og ved å aktivere avbruddsforespørselen ved å skrive en ‘ 1 ‘ til den tilsvarende biten i avbruddsmaskeregisteret.
Ekstern Interrupt og GPIO mapping
HVER AV GPIO tilgjengelig på systemet kan konfigureres til å generere et avbrudd. MEN HVER AV EXTI-avbruddslinjene er kartlagt til flere gpio-pinner. FOR EKSEMPEL, PIO0 på alle tilgjengelige gpio-porter(A, B, C, etc.) vil bli kartlagt TIL EXTI0-linjen. PIO1 for alle porter vil bli kartlagt TIL EXTI1 linje og så videre.
NOEN AV EXTI-linjene er kombinert til en ENKELT nvic-vektor. FOR eksempel er EXTI4_15 kartlagt til en enkelt vektoradresse, så det vil være en enkelt avbruddsrutine for alle avbruddene FRA PIO4 TIL PIO15. Men kilden til avbruddet kan identifiseres ved å lese avbruddets ventende register.En viktig ting å vurdere når du designer et system ved HJELP AV STM32 Mcuer, er valget AV GPIO-pinnene for avbruddene. MCU kan ha mer enn 16 GPIOs tilgjengelig på enheten, men det er bare 16 eksterne avbruddslinjer tilgjengelig.FOR eksempel KAN EXTI_0 tilordnes TIL ENTEN PA0 eller PB0, men ikke begge deler. Så mens du velger pinnene for eksterne avbrudd de bør velges slik at de kan være unikt kartlagt til EN AV EXTI linjene.
følgende avsnitt beskriver hvordan du konfigurerer et avbrudd ved HJELP AV Stm32-Kuben.
Velg Fanen Konfigurasjon og velg maskinvaremodulen som avbruddet må konfigureres for. Vinduet modulkonfigurasjon åpnes.
velg deretter fanen nvic-innstillinger og aktiver det globale avbruddet.
koden for å aktivere avbrudd for modulen vil bli generert i stm32f0xx_hal_msp.c I HAL_ <modul>_MSPInit (…) – funksjonen.
/* USART1 interrupt Init */HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);HAL_NVIC_EnableIRQ(USART1_IRQn);koden generert AV Stm32-Kuben vil Ha IRQ_Handler-implementeringen av alle avbruddene. Når avbruddet er aktivert koden vil bli inkludert i programmet.
vanligvis den genererte koden håndterer ALLEREDE IRQ og fjerner flagget som genererte avbrudd. Det kaller deretter et program tilbakeringing som tilsvarer hendelsen som genererte avbrudd for modulen.
STM32 HAL (Hardware Abstraction Layer) implementerer en tilbakeringing for hver av hendelsestypene i hver modul som en del av driveren. I dette eksemplet Rx Transfer Komplett tilbakeringing skal kopieres fra stm32f0xx_hal_UART.c-fil.
tilbakeringingsfunksjonene i driveren vil bli implementert med et __weak linker-attributt. Brukeren må implementere en kopi av den nødvendige tilbakeringingsfunksjonen ved å fjerne _ _ weak-attributtet i en av programfilene og deretter skrive den spesifikke håndteringen som kreves i den funksjonen.
/*** @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.*/}
Konklusjon
denne opplæringen er en introduksjon til å skrive et program som fungerer MED STM32-familien av mikrokontrollere. Det finnes flere andre metoder for å skrive et program, Men stm32cube diskutert er en enkel og intuitiv metode for å komme i gang.
dette verktøyet forenkler initialiseringen av mikrokontrollerens eksterne enheter. Det forbedrer også vedlikehold av koden, spesielt når det er maskinvarerevisjoner som krever remapping av signalene til forskjellige pinner.En annen fordel Ved å bruke stm32cube-verktøyet er at det genererer en rapport om brukerkonfigurasjonen for mikrokontrolleren. I denne rapporten detaljer det klokke treet, pin kartlegging og maskinvare modul konfigurasjon som alle er svært nyttig.
det finnes også flere andre kodebiblioteker og eksempelprogrammer tilgjengelig for ALLE stm32-varianter. Støtte for flere Ideer er også inkludert.
hvis prosjektet krever en sofistikert 32-biters mikrokontroller, anbefaler JEG STM32-serien. IKKE bare er de kraftige og populære, MEN STM32 mikrokontrollere er også ganske rimelige.
Trenger du mer trening PÅ programmering AV STM32 mikrokontrollere? I så fall, her er et mer grundig introduksjonskurs som du bør sjekke ut.Denne artikkelen ble skrevet Av Mohan Kashivasi Fra Vithamas Technologies. Han er også en av ekspertene som er tilgjengelige for å hjelpe deg med produktet ditt i Maskinvareakademiet.
Til Slutt, ikke glem å laste ned DIN GRATIS PDF: Ultimate Guide Til Å Utvikle Og Selge Ditt Nye Elektroniske Maskinvareprodukt. Du vil også motta mitt ukentlige nyhetsbrev der jeg deler premium-innhold som ikke er tilgjengelig på bloggen min.
Annet innhold du kan like:
- Introduksjon Til STM32CubeIDE FOR STM32 Mikrokontrollere
- Slik Velger Du Mikrokontrolleren for Ditt Nye Produkt
- Ved Hjelp Av Arduino som En Innebygd Utviklingsplattform
- Dataark Gjennomgang: Entry-Level STM32 Cortex-M0 Microcontroller (Blog + Video)
- Introduction to the Ultra High-Performance STM32H7 32-bit Microcontroller