în acest articol aprofundat veți învăța cum să dezvoltați firmware încorporat pentru microcontrolerele Stm32 Cortex-M pe 32 de biți folosind diferitele instrumente de dezvoltare.
seria STM32 sunt unele dintre cele mai populare microcontrolere utilizate într-o mare varietate de produse. De asemenea, au o bază excelentă de asistență din mai multe forumuri de dezvoltare a microcontrolerelor.
această familie de microcontrolere de la STMicroelectronics se bazează pe nucleul procesorului ARM Cortex-M pe 32 de biți.
microcontrolerele STM32 oferă un număr mare de periferice de comunicații seriale și paralele care pot fi interfațate cu toate tipurile de componente electronice, inclusiv senzori, afișaje, camere, motoare etc. Toate variantele STM32 vin cu memorie Flash internă și RAM.gama de performanță disponibilă cu STM32 este destul de extinsă. Unele dintre cele mai de bază variante includ sub-seriile STM32F0 și STM32F1 care încep cu o frecvență de ceas de numai 24 MHz și sunt disponibile în pachete cu doar 16 pini.
la cealaltă extremă de performanță, STM32H7 funcționează până la 400 MHz și este disponibil în pachete cu până la 240 de pini.
modelele mai avansate sunt disponibile cu unități în virgulă mobilă (FPU) pentru aplicații cu cerințe serioase de procesare numerică. Aceste modele mai avansate estompează linia dintre un microcontroler și un microprocesor.
în cele din urmă, sub-seria STM32L este proiectată special pentru aplicații portabile cu putere redusă care rulează de la o baterie mică.
instrumente de dezvoltare
instrumentele de dezvoltare sunt necesare pentru a dezvolta codul, a programa microcontrolerul și a testa / depana codul. Instrumentele de dezvoltare includ:
- compilator
- Debugger
- programator Serial în Circuit (ICSP)
programare STM32 prin intermediul programatorului Serial în Circuit (ICSP).
există mai multe instrumente de dezvoltare software disponibile pentru dezvoltarea codului pe microcontrolerele STM32. Instrumentele software sunt disponibile ca medii de dezvoltare integrate (IDE) care combină toate instrumentele necesare într-un mediu integrat.
două pachete comune de dezvoltare includ:
- Keil MDK ARM (uVison5 IDE) – ide MDK ARM este un mediu de dezvoltare foarte stabil, care poate fi descărcat gratuit. Acesta permite dezvoltarea de cod de până la o dimensiune program de 32 KB. Pentru a dezvolta programe mai mari, o versiune licențiată trebuie achiziționată aici.
- CoIDE – un lanț de instrumente gratuit care se bazează pe o versiune tăiată a Eclipse IDE integrată împreună cu o versiune Arm încorporată a compilatorului GCC gratuit.
există, de asemenea, mai multe alte IDE care sunt disponibile pentru utilizare cu microcontrolere STM32. Cu toate acestea, acest articol se concentrează pe dezvoltarea și intermiterea unui program folosind foarte popularul Keil MDK ARM uVision5 IDE.
în afară de instrumentele software, este necesar un programator Serial în Circuit (ICSP) pentru a programa și testa codul pe microcontrolerul propriu-zis. ICSP este necesar pentru interfața microcontrolerului cu instrumentele software pentru PC printr-un port USB.microcontrolerele ARM Cortex-M acceptă două protocoale de programare: JTAG (numit de Asociația industriei electronice grupul de acțiune comună de testare) și Serial Wire Debug (SWD).
există mai mulți programatori ICSP disponibili care acceptă aceste protocoale, inclusiv:
- Keil U-Link 2
- Segger J-Link
- ST-Link
Dezvoltarea primei aplicații
este întotdeauna mai ușor să începeți cu un cadru de cod de bază ușor disponibil. Apoi, adăugați codul necesar pentru aplicația și modelul specific al microcontrolerului.din fericire, STMicroelectronics oferă un instrument grafic foarte util numit STM32CubeMx care ajută la crearea unui proiect de aplicație de bază pentru orice microcontroler STM32 la alegere. De asemenea, poate fi folosit pentru a configura perifericele pe pinii multiplexați ai microcontrolerului.
instrumentul STM32CubeMX poate fi descărcat de aici. Stm32cube vine cu un set extins de drivere pentru toate tipurile de periferice și suport pentru un FreeRTOS opțional (un sistem de Operare gratuit în timp real) pre-integrat cu codul.
următoarea secțiune descrie în detaliu cum se creează o aplicație UART simplă pentru microcontrolerul STM32F030 care ecou orice este tastat pe o fereastră de terminal.
- instalați software-ul STM32CubeMX.
- rulați aplicația și selectați proiect nou. Se va deschide apoi fereastra selectorului MCU așa cum se arată mai jos.
- faceți dublu clic pentru a selecta modelul de microcontroler utilizat. În acest caz, folosim STM32F030K6. Apoi vă duce la pagina pinout pentru microcontrolerul selectat.
STM32F030K6 este un nucleu ARM Cortex-M0 cu 32kB de memorie Flash și 4KB de memorie RAM. Codul exemplu permite UART care utilizează pinii PA9 și PA10 pentru primirea și transmiterea datelor seriale așa cum se arată mai jos cu pinii verzi.
configurați setările UART sub fila Configurare și alegeți setările UART așa cum se arată mai jos. Activați opțiunea de întrerupere globală NVIC din fila Setări NVIC.
apoi, navigați la Project–>Setări pentru a adăuga noul nume de proiect și selectați IDE-ul lanțului de instrumente care va fi utilizat. Pentru acest exemplu, setați numele proiectului la ‘UARTEcho’ și selectați IDE-ul Keil-MDK5 pentru dezvoltarea proiectului.
în cele din urmă, generați codul proiectului făcând clic pe Project- > Generați codul.
construirea și intermitent codul
acum deschideți fișierul de proiect generat MDK-ARM UARTEcho\MDK-ARM\UartEcho.uprojx.
acest program până acum inițializează perifericul UART și se oprește într-o buclă infinită.
este important să rețineți că stm32cube generează / * USER CODE BEGIN X * / și / * USER CODE end x * / comment blochează pentru a implementa codul specific utilizatorului. Codul de utilizator trebuie să fie scris în aceste blocuri de comentarii. Ori de câte ori codul este re-generat cu configurații modificate instrumentul STMCube păstrează codul de utilizator în cadrul acestor blocuri comentariu utilizator.
apoi, definiți o variabilă globală pentru a primi un octet de la UART în principal.fișier sursă C:
/* USER CODE BEGIN PV *//* Private variables ———————————————————*/static uint8_t recv_data;/* USER CODE END PV */după tot codul de inițializare, permiteți driverului să primească 1 octet. Următoarea funcție permite bitul de întrerupere RXNE.
/* USER CODE BEGIN 2 */HAL_UART_Receive_IT(&huart1, &recv_data, 1);/* USER CODE END 2 */Acum, adăugați o funcție de apel invers pentru a gestiona întreruperea recepției și a transmite octetul primit.
/* USER CODE BEGIN 0 */void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart){HAL_UART_Transmit(huart, huart->pRxBuffPtr, 1, 1000);}/* USER CODE END 0 */În cele din urmă, trebuie să compilăm codul și să îl descărcăm (descărcați) la microcontroler.
când este instalat IDE-ul Keil MDK ARM, sunt disponibile drivere pentru ST-LINK V2, J-Link și Ulink2. Depanatorul ST-Link va fi selectat în mod implicit. Accesați proiecte – >opțiuni pentru țintă și în fila Debug selectați programatorul ICSP utilizat.
Flash codul selectând Flash->descărcare.
microcontrolerul va ecou acum orice date primite pe UART. Poate fi conectat la un PC utilizând un convertor USB-Serial. Pe PC deschideți portul COM cu o aplicație terminal utilizând setările 115200-8-N-1. Acum, orice este trimis de la terminal va ecou înapoi prin microcontroler.
sistem de întrerupere
sistemul de întrerupere STM32 se bazează pe nucleul ARM Cortex M nvic periferic. MCU-urile STM32 acceptă mai multe canale de întrerupere mascabile, în afară de cele 16 canale de întrerupere ale miezului ARM.
de exemplu, seria STM32F0 MCU acceptă 32 de întreruperi mascabile. Excepția și tabelul vectorial de întrerupere pentru această familie de MCU-uri sunt prezentate în tabelul de mai jos.
| 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 Întreruperile și evenimente Controller (EXTI)
MCU-urile STM32 au un controler de întreruperi și evenimente extins care gestionează evenimentele/întreruperile asincrone externe și interne și generează cererea de eveniment către controlerul CPU / întrerupere și o cerere de trezire către Power Manager.
fiecare dintre una sau mai multe linii EXTI sunt mapate la unul dintre vectorii de întrerupere NVIC.
pentru liniile de întrerupere externe, pentru a genera o întrerupere, linia de întrerupere trebuie configurată și activată. Acest lucru se realizează prin programarea celor două registre de declanșare cu detectarea muchiei dorite și prin activarea cererii de întrerupere scriind un ‘1’ la bitul corespunzător din registrul măștii de întrerupere.
întrerupere externă și mapare GPIO
fiecare GPIO Disponibil în sistem poate fi configurat pentru a genera o întrerupere. Dar fiecare dintre liniile de întrerupere EXTI este mapată la mai mulți pini GPIO. De exemplu,PIO0 pe toate porturile GPIO disponibile (A,B, C etc.) va fi mapat la linia EXTI0. PIO1 pentru toate porturile vor fi mapate la linia EXTI1 și așa mai departe.
unele dintre liniile EXTI sunt combinate cu un singur vector NVIC. De exemplu, EXTI4_15 este mapat la o singură adresă vectorială, astfel încât va exista o singură rutină de întrerupere pentru toate întreruperile de la PIO4 la PIO15. Dar sursa întreruperii poate fi identificată prin citirea registrului de așteptare a întreruperii.
un lucru important de luat în considerare în timpul proiectării unui sistem folosind MCU-urile STM32 este selectarea pinilor GPIO pentru întreruperi. MCU poate avea mai mult de 16 GPIO disponibile pe dispozitiv, dar există doar 16 linii de întrerupere externe disponibile.
de exemplu, EXTI_0 poate fi mapat fie la PA0, fie la PB0, dar nu la ambele. Deci, în timp ce alegerea pinii pentru întreruperi externe ar trebui să fie alese astfel încât acestea pot fi mapate unic la una dintre liniile EXTI.
următoarea secțiune descrie modul de configurare a unei întreruperi utilizând cubul STM32.
selectați fila Configurare și alegeți modulul hardware pentru care trebuie configurată întreruperea. Se deschide fereastra de configurare a modulului.
apoi selectați fila Setări NVIC și activați întreruperea globală.
codul pentru activarea întreruperii pentru modul va fi generat în stm32f0xx_hal_msp.c în HAL_ <modul> _mspinit(…) funcție.
/* USART1 interrupt Init */HAL_NVIC_SetPriority(USART1_IRQn, 0, 0);HAL_NVIC_EnableIRQ(USART1_IRQn);codul generat de Cubul STM32 va avea implementarea IRQ_Handler a tuturor întreruperilor. Când întreruperea este activată, codul va fi inclus în aplicație.
de obicei, codul generat gestionează deja IRQ și șterge steagul care a generat întreruperea. Apoi apelează un apel invers al aplicației care corespunde evenimentului care a generat întreruperea modulului.
STM32 HAL (hardware Abstraction Layer) implementează un apel invers pentru fiecare tip de eveniment din fiecare modul ca parte a driverului. În acest exemplu, RX Transfer complete callback ar trebui să fie copiate din stm32f0xx_hal_UART.fișier C.
funcțiile de apel invers din driver vor fi implementate cu un atribut __weak linker. Utilizatorul trebuie să implementeze o copie a funcției de apel invers necesare prin eliminarea atributului _ _ weak într-unul din fișierele aplicației și apoi scrierea manipulării specifice necesare în cadrul acelei funcții.
/*** @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.*/}
concluzie
acest tutorial este o introducere în scrierea unei aplicații care funcționează cu familia de microcontrolere STM32. Există mai multe alte metode pentru scrierea unei aplicații, dar stm32cube discutat este o metodă ușoară și intuitivă pentru a începe.
acest instrument simplifică inițializarea perifericelor microcontrolerului. De asemenea, îmbunătățește mentenabilitatea codului, în special atunci când există revizuiri hardware care necesită remaparea semnalelor către pini diferiți.
Un alt avantaj al utilizării instrumentului STM32Cube este că generează un raport al configurației utilizatorului pentru microcontroler. În acest raport detaliază arborele ceasului, maparea pinilor și configurația modulului hardware, care sunt toate foarte utile.
există, de asemenea, mai multe alte biblioteci de cod și programe de exemplu disponibile pentru toate variantele STM32. Suport pentru mai multe IDE este de asemenea inclus.
dacă proiectul dvs. necesită un microcontroler sofisticat pe 32 de biți, atunci vă recomand seria STM32. Nu numai că sunt puternice și populare, dar microcontrolerele STM32 sunt, de asemenea, destul de accesibile.
aveți nevoie de mai multă pregătire pentru programarea microcontrolerelor STM32? Dacă da, iată un curs introductiv mai aprofundat pe care ar trebui să îl verificați.
Acest articol a fost scris de Mohan Kashivasi de la Vithamas Technologies. El este, de asemenea, unul dintre experții disponibili pentru a vă ajuta cu produsul dvs. în cadrul Academiei Hardware.
în cele din urmă, nu uitați să descărcați PDF-ul gratuit: Ghid final pentru dezvoltarea și vânzarea noului dvs. produs Hardware Electronic. De asemenea, veți primi buletinul meu informativ săptămânal în care partajez conținut premium care nu este disponibil pe blogul meu.
alt conținut care vă poate plăcea:
- Introducere în Stm32cubeide pentru microcontrolerele STM32
- cum să selectați microcontrolerul pentru noul dvs. produs
- folosind Arduino ca platformă de dezvoltare încorporată
- revizuirea Fișei Tehnice: Entry-Level STM32 Cortex-M0 Microcontroller (Blog + Video)
- Introduction to the Ultra High-Performance STM32H7 32-bit Microcontroller