Arbeide med LCD-indikatoren på STM32L-Discovery-utviklingskortet. Trening på STM32 til massene Frekvensdeler blokk
Generell informasjon
STM32L-Discovery-utviklingskortet har en flytende krystallskjerm (LCD) med seks 14 segmenttegn, 4 kolon (kolon), 4 prikker (DP), 4 striper (Bar). Alle segmenter er kombinert i gruppene COM0, COM1, COM2, COM3 med 24 segmenter. Hver gruppe har sin egen separate "felles ledning".
STM32L152RBT6-mikrokontrolleren er installert på feilsøkingskortet. Mikrokontrolleren har en innebygd LCD-kontroller som styrer de monokrome LCD-indikatorene.
LCD-kontroller:
- Lar deg konfigurere oppdateringsfrekvensen (bildefrekvens - frekvensen som informasjonen på LCD-skjermen oppdateres med)
- Støtter statisk og multipleks kontrollmodus
- Støtter programvareinstallasjon kontrast
- Tillater flere kontrollspenningsnivåer (opptil fire)
- Bruker dobbel buffering, slik at data i LCD_RAM-registre kan oppdateres når som helst under programkjøring uten å krenke integriteten til den viste informasjonen
LCD-kontroller minneregistre
STM32L152RB-mikrokontrolleren har spesielle LCD_RAM-registre, hvor informasjonen som er lagret tilsvarer gruppen av segmenter COM0 - COM3. Hver gruppe tilsvarer to 32-bits registre. Dette antallet registre lar mikrokontrolleren kontrollere LCD-en c stort beløp segmenter enn de som er installert på utviklingsbrettet.For å kontrollere en LCD med 176 segmenter, brukes 4 grupper COM0 - COM3 med 44 segmenter hver; for å kontrollere en LCD med 320 segmenter, brukes 8 grupper COM0 - COM7 med 40 segmenter hver.
STM32L-Discovery-utviklingskortet bruker en LCD med 96 segmenter, delt inn i 4 grupper COM0 - COM3 med 24 segmenter hver. 
LCD-skjermen på STM32L-Discovery-utviklingskortet er koblet til på en slik måte at bitene S40, S41 i de andre LCD_RAM-registrene i hver gruppe og biter S0-S27 fra de første LCD_RAM-registrene brukes. For å redusere antall registre som brukes, vil informasjon fra bit S40-S43 bli skrevet til frie bit S28-S31 ved hjelp av remapping-funksjonen.
Frekvensdeler blokk
Frekvensdelerblokken (frekvensgenerator) lar deg oppnå forskjellige bildefrekvenser på LCD-skjermen i området fra 32 kHz til 1 MHz. Følgende kan brukes som en tidssignalkilde:- Ekstern lavfrekvensgenerator med en frekvens på 32 kHz (LSE. Ekstern lavhastighet)
- Intern lavfrekvensgenerator med en frekvens på 37 kHz (LSI. Intern lavhastighet)
- Ekstern RF-generator med frekvensdelere på 2,4,8 og 16 og en maksimal frekvens på 1 MHz. (HMS. Høyhastighet ekstern)
F ck_div =F LCDCLK / (2 PS *(16+DIV))
Bildefrekvensen beregnes ved hjelp av formelen:
F Ramme =f ck_div *plikt
Der duty er driftssyklusen - forholdet mellom pulsvarigheten og perioden. I løpet av ett bilde vises informasjon fra registrene LCD_RAM[x], LCD_RAM osv. sekvensielt på LCD-skjermen. For en LCD installert på et feilsøkingskort, må LCD-kontrolleren i én ramme sende ut informasjon fra 4 grupper av segmenter COM0 - COM3, derfor vil varigheten av kontrollpulsen for en gruppe være 1/4 av rammevarigheten, dvs. plikt=1/4.
LCD-kontroll
Det er to måter å kontrollere LCD-en - statisk kontrollmodus og multiplekskontrollmodus. Med statisk indikasjon er hvert segment av indikatorbiten koblet til utgangen til mikrokontrolleren. I forhold til LCD-en, på STM32LDiscovery-feilsøkingskortet, kreves 6 * 14 = 84 mikrokontrollerpinner (unntatt kolon, prikker og striper). På grunn av bruken av et slikt antall pinner, vil tilkobling av andre perifere enheter bli umulig. STM32L152RB mikrokontrolleren har 64 pinner. I multipleks kontrollmodus (dynamisk kontrollmodus) kombineres identiske segmenter av indikatorsiffer i grupper. Informasjonen vises på grunn av den alternative belysningen av segmenter av indikatorsifrene, med en frekvens som ikke er merkbar for det menneskelige øyet.Multiplekskontroll lar deg kontrollere et stort antall segmenter. I stedet for å kontrollere hvert element separat, kan de adresseres av rader og kolonner (COM og SEG), og dermed forenkle kontrollkretsen, fordi hvert segment krever ikke sin egen kontrolllinje. For å slå på det valgte segmentet, må potensialforskjellen COM og SEG brukes på det. Et eksempel på bruken av det første sifferet i indikatoren (indikatoren viser "1:"): 
Det første sifferet i indikatoren på tidspunktet t 0
Det første sifferet i indikatoren på tidspunktet t 1
Det første sifferet i indikatoren på tidspunktet t 2
Generelt diagram for tilkobling av segmenter til LCD-pinner
Tilkoblingsskjema over LCD-pinner til mikrokontrollerporter
For SEG-linjer brukes en styrespenning, hvor antall nivåer bestemmes av forspenningskoeffisienten. LCD-skjermen på utviklingskortet bruker en multipleks kontrollmodus med duty=1/4 og bias=1/3. Duty- og biasverdiene settes via LCD_CR-registeret (Control Register) i DUTY- og BIAS-bitene.
Øve på
Konfigurering av mikrokontrollerporter
For å kontrollere LCD-en må mikrokontrollerportene konfigureres tilsvarende:- Til utgangen
- Bruke AF 11 Alternativ-funksjonen
- Ha utgangsfrekvenser til porten på 400 kHz
- Bruk push-pull driftsmodus
- Ingen pull-up motstander
LCD-pinnene er koblet til GPIOA (PA1-PA3, PA8-PA10, PA15), GPIOB (PB3-PB5, PB8-PB15), GPIOC (PC0-PC3, PC6-PC11)-portene på mikrokontrolleren. For at LCD-skjermen skal fungere, må et klokkesignal leveres til de valgte portene. GPIO-portene til mikrokontrolleren klokkes fra AHB-bussen til RCC-systemet (Reset and Clock Control) - et klokke- og tilbakestillingssystem. Klokkesignalet tilføres ved å sette de tilsvarende bitene i RCC_AHBENR (AHB periferal clock enable register) registeret.
Registrer RCC_AHBENR (figuren viser de første 15 bitene)
For GPIOA, GPIOB, GPIOC-porter må du sette 1 til 0, 1, 2 biter av registeret.
Deretter vil jeg gi koden for å skrive informasjon til registeret ved å bruke en bitmaske og bruke heksadesimale koder. Å bruke bitmasker er mer praktisk, men å jobbe med heksadesimale koder lar deg forstå essensen av å jobbe med registre.
RCC->AHBENR |=(RCC_AHBENR_GPIOAEN|RCC_AHBENR_GPIOBEN|RCC_AHBENR_GPIOCEN); eller RCC->AHBENR = 0x7; /* 0x7=111 */
For å indikere driftsmodusene til porten, brukes GPIOx_MODER-registeret (GPIO-portmodusregister) (x = A..H). Alle registerbiter er gruppert i MODERy-grupper, hvor y er pin-nummeret til den tilsvarende porten. Portene må konfigureres for alternativ funksjonsmodus, dvs. i gruppen som er ansvarlig for pinnen, sett verdien til 10. For GPIOA-porten må du konfigurere pinnene 1-3,8-10,15, det vil si sette 1 til 3,5,7,17,19, 21,31 siffer. 
Registrer GPIOx_MODER (GPIO-portmodusregister)
GPIOA->MODER |= (GPIO_MODER_MODER1_1 | GPIO_MODER_MODER2_1 | GPIO_MODER_MODER3_1 | GPIO_MODER_MODER8_1 | GPIO_MODER_MODER9_1 | GPIO_MODER_MODER10_1 | GPIO_MODER_MODER_MODER); eller GPIOA->MODER = 0x802A00A8; /* 0x802A00A8=1000 0000 0010 1010 0000 0000 1010 1000 */
Mikrokontrollerportene må byttes til push-pull-modus. For å gjøre dette må du sette 1 i GPIOx_OTYPER registeret (GPIO port output type register) i bitene som er ansvarlige for pinnene. 
Registrer GPIOx_OTYPER (register for GPIO-portutgangstype)
GPIOA->OTYPER &= ~(GPIO_OTYPER_OT_1 | GPIO_OTYPER_OT_2 | GPIO_OTYPER_OT_3 | GPIO_OTYPER_OT_8 | GPIO_OTYPER_OT_9 | GPIO_OTYPER_OT_10 | GPIO_OTYPER_OT_15); eller GPIOA->OTYPER &= ~0x0000870E; /* 0x870E=1000 0111 0000 1110 */
Begge alternativene påvirker de valgte pinnene. (For GPIOA-porten er pinnene 1-3.8-10.15 konfigurert). Hvis du trenger å bytte alle portpinner til push-pull-modus, kan du skrive følgende verdi til registeret:
GPIOA->OTYPER = 0x0;
For å spesifisere frekvensen av informasjon som sendes ut til porten, brukes registeret GPIOx_OSPEEDR (GPIO port output speed register). Alle registerbiter er gruppert i grupper OSPEEDRy, der y er pin-nummeret til den tilsvarende porten. I dette arbeidet bør frekvensen settes til 400 kHz dvs. i gruppen som er ansvarlig for pinnen, sett verdien til 00. 
Registrer GPIOx_OSPEEDR (GPIO port utgangshastighetsregister)
GPIOA->OSPEEDR &= ~(GPIO_OSPEEDER_OSPEEDR1 | GPIO_OSPEEDER_OSPEEDR2 | GPIO_OSPEEDER_OSPEEDR3 | GPIO_OSPEEDER_OSPEEDR8 | GPIO_OSPEEDER_OSPEEDR9 | GPIO_OSPEEDR_10POSPOSPEEDR_5); eller GPIOA->OSPEEDR &= ~0xC03F00FC; /*0xC03F00FC=1100 0000 0011 1111 0000 0000 1111 1100 */
Hvis du trenger å sette utgangsfrekvensen til porten til 400 kHz for alle pinner, kan du skrive verdien til registeret:
GPIOA->OSPEEDR = 0x0;
For å deaktivere pull-up og pull-down motstander for valgte pinner, bruk GPIOx_PUPDR registeret (GPIO port pullup/pull down register). Alle registerbiter er gruppert i PUPDRy-grupper, der y er pin-nummeret til den tilsvarende porten. For å deaktivere opptrekksmotstander i gruppen som er ansvarlig for pinnen, sett verdien til 00. 
Registrer GPIOx_PUPDR (GPIO port pull-up/pull-down register)
GPIOA->PUPDR &= ~(GPIO_PUPDR_PUPDR1 | GPIO_PUPDR_PUPDR2 | GPIO_PUPDR_PUPDR3 | GPIO_PUPDR_PUPDR8 | GPIO_PUPDR_PUPDR9 | GPIO_PUPDR_PUPDR10 | GPPPIO_PUPDR1); eller GPIOA->PUPDR &= ~0xC03F00FC; /*0xC03F00FC=1100 0000 0011 1111 0000 0000 1111 1100 */
Hvis du trenger å deaktivere pull-up motstander for alle pinner, kan du skrive verdien til registeret:
GPIOA->PUPDR = 0x0;
For å bruke en alternativ funksjon for mikrokontrollerporter, to registre GPIOx_AFRL (GPIO alternativ funksjon lavt register), ansvarlig for de lave pinnene (0 til 7) og GPIOx_AFRH (GPIO alternativ funksjon høy register), ansvarlig for de høye pinnene (8 til 15) , er brukt. Alle registerbiter er gruppert i gruppene AFRly og AFRHy, hvor y er pin-nummeret til den tilsvarende porten. Portene må konfigureres til å bruke den alternative funksjonen AF11, for dette må gruppen som er ansvarlig for pinnen settes til 1011. 
Registrer GPIOx_AFRL (GPIO alternativ funksjon lavt register)
Registrer GPIOx_AFRH (GPIO alternativ funksjon høy register)
For å gjøre dette må du skrive følgende verdier inn i registrene:
GPIOA->AFR = 0xBBB0; /* 0xBBB0 = 1011 1011 1011 0000*/ GPIOA->AFR = 0xB0000BBB; /* 0xB0000BBB=1011 0000 0000 0000 0000 1011 1011 1011*/
AFR = 0xBBB0 – skriver en verdi til GPIOx_AFRL-registeret.
AFR = 0xB0000BBB – skriver en verdi til GPIOx_AFRH-registeret.
Innstillingene for de tilsvarende pinnene til GPIOB- og GPIOC-portene gjøres på samme måte.
Sette opp LCD-kontrolleren
Når du arbeider med en LCD-kontroller, som med andre eksterne enheter, må det tilføres et klokkesignal. Klokkesignalet leveres også til strømstyringssystemet. Kontrolleren og strømstyringssystemet bruker APB1-bussen for klokke. For å aktivere klokking i registeret RCC_APB1ENR (APB1 perifer klokkeaktiveringsregister), må du sette 1 i bit 9 og 28.
Register RCC_APB1ENR (APB1 perifer klokke aktiveringsregister)
RCC->APB1ENR |= RCC_APB1ENR_PWREN|RCC_APB1ENR_LCDEN; eller RCC->APB1ENR |= 0x10000200; /* 0x10000200=1 0000 0000 0000 0000 0010 0000 0000 */
For at LCD-kontrolleren skal fungere, er det nødvendig å spesifisere kilden til klokkesignalene. Kilden er spesifisert i RCC_CSR-registeret. Som standard er skriving til dette registeret deaktivert. Skrivebeskyttelsen i RCC_CSR-registeret fjernes i PWR_CR-effektkontrollregisteret. RCC_CSR-registeret kontrollerer klokkekildene til RTC- og LCD-kontrolleren
Skriving til RCC_CSR-registeret aktiveres ved å sette bit 8 i PWR_CR-registeret til 1. 
Register PWR_CR (PWR effektkontrollregister)
PWR->CR |= PWR_CR_DBP; eller PWR->CR |= 0x100; /* 0x100 =1 0000 0000 */
For å endre klokkekilden til LCD-kontrolleren (og RTC-klokken også), må du først tilbakestille klokkekilden ved å stille inn RTCRST-biten (innstilling 1 til bit 23) i RCC_CSR-registeret (Kontroll-/statusregister). 
Registrer RCC_CSR (kontroll-/statusregister)
RCC->CSR |= RCC_CSR_RTCRST;
Eller ved å skrive en verdi til et register ved å bruke «|=»-operatoren, fordi verdi av
standardregisteret er forskjellig fra 0x0:
RCC->CSR |= 0x800000; /* 0x800000 = 1000 0000 0000 0000 0000 0000 */
For å velge en ny klokkekilde må du fjerne RTCRST-biten:
RCC->CSR &= ~RCC_CSR_RTCRST; eller RCC->CSR &= ~0x800000;
En ekstern lavfrekvent generator er valgt som klokkesignalkilde. For å slå på generatoren i RCC_CSR-registeret, må du stille inn LSEON-biten (sett 1 til 8 bit):
RCC->CSR |= RCC_CSR_LSEON; eller RCC->CSR |= 0x100; /* 0x100 = 1 0000 0000 */
Etter å ha slått på generatoren, tar det litt tid å stabilisere den. Generatorens beredskap kontrolleres ved maskinvareinnstilling av LSERDY-biten i RCC_CSR-registeret:
while(!(RCC->CSR&RCC_CSR_LSERDY));
Valget av en ekstern lavfrekvensgenerator som klokkekilde utføres ved å sette RCC_CSR-registeret til 01 i RTCSEL-gruppen:
RCC->CSR |= RCC_CSR_RTCSEL_LSE; eller RCC->CSR |= 0x10000; /* 0x10000 = 01 0000 0000 0000 0000 */
I LCD-kontrolleren må du installere ønsket modus partiskhet. For å gjøre dette, i LCD_CR-registeret (LCD-kontrollregister) må du sette verdien 10 i BIAS-gruppen. Før du installerer bits, er det nødvendig å tømme bitene for "søppel". 
Register LCD_CR (LCD-kontrollregister)
Tilbakestill biter:
LCD->CR &= ~LCD_CR_BIAS; eller LCD->CR &= ~0x60;
Velge bias=1/3-modus ved å bruke en bitmaske:
LCD->CR |= LCD_CR_BIAS_1; eller LCD->CR |= 0x40;
Still inn modusen duty=1/4. For å gjøre dette, tilbakestiller vi også først alle biter:
LCD->CR &=~LCD_CR_DUTY; eller LCD->CR &= ~0x1C;
Sett verdien 011 til DUTY-gruppen i LCD_CR-registeret for
modusplikt=1/4:
LCD->CR |= LCD_CR_DUTY_0|LCD_CR_DUTY_1; eller LCD->CR |= 0xС;
Vi aktiverer funksjonen for tildeling av pinner. For å gjøre dette, sett 1 til 7 biter av LCD_CR-registeret:
LCD->CR |= LCD_CR_MUX_SEG; eller
Vi setter verdiene til frekvensdelingskoeffisientene til LCDCLK-klokkesignalet. Koeffisientverdiene settes i LCD_FCR-registeret (LCD-rammekontrollregister). Først fjerner vi også alle bitene, og setter deretter de nødvendige. 
Register LCD_FCR (LCD-rammekontrollregister)
LCD->FCR &= ~LCD_FCR_PS; LCD->FCR &= ~LCD_FCR_DIV; eller LCD->FCR &= ~0x3C00000; LCD->FCR &= ~0x3C0000;
Verdiene til klokkesignalets frekvensdelingskoeffisienter er satt lik ck_ps = LCDCLK/16, ck_div = ck_ps/17. For å gjøre dette, sett 1 til 24 og 18 sifre:
LCD->FCR |= 0x1040000; /*0x1040000 = 1 0000 0100 0000 0000 0000 0000*/
For å stille inn ønsket kontrastnivå, må du sette verdien 010 i CC-gruppen, også først fjerne bitene fra de gamle verdiene:
LCD->FCR &= ~LCD_FCR_CC; LCD->FCR |= LCD_FCR_CC_1; eller LCD->FCR &= ~0x1C00; LCD->FCR |= 0x800; /*0x800 = 1000 0000 0000*/
Etter å ha stilt inn alle verdiene, tar det litt tid å synkronisere LCD_FCR-registeret. Registersynkronisering kontrolleres ved å sette FCRSF-biten i maskinvare i LCD_SR (LCD statusregister) registeret.
Register LCD_SR (LCD-statusregister)
While(!(LCD->SR&LCD_SR_FCRSR));
Som spenningskilde for LCD-skjermen velger vi en intern step-up-omformer for å danne V lcd. For å gjøre dette settes den første biten av LCD_CR-registeret (LCD-kontrollregisteret) til 0:
LCD->CR &= ~LCD_CR_VSEL; eller LCD->CR &= ~0x2;
Operasjonen til LCD-kontrolleren aktiveres ved å sette LCD_CR-registeret (LCD-kontrollregister) bit til 0:
LCD->CR |= LCD_CR_LCDEN; eller LCD->CR |= 0x1;
Etter å ha installert den interne step-up-omformeren som en spenningskilde, må du vente til den er klar. Beredskapen kontrolleres ved maskinvareinnstilling av RDY-biten i LCD_SR-registeret (LCD-statusregister):
while(!(LCD->SR&LCD_SR_RDY));
Etter å ha latt LCD-kontrolleren fungere, må du vente til den er klar. Beredskapen kontrolleres ved maskinvareinnstilling av ENS-biten i LCD_SR-registeret (LCD-statusregister):
while(!(LCD->SR&LCD_SR_ENS));
Dannelse av et bilde på LCD-skjermen
Alle indikatorsegmenter er kombinert i grupper COM0 - COM3 med 24 segmenter hver (SEG0-SEG23). Informasjon om segmenter lagres i LCD_RAM-registrene til LCD-kontrollerminnet. Kabling trykt kretskort er slik at segmentnumrene ikke tilsvarer bitnumrene til LCD_RAM-registrene.
For å vise 1 i det første sifferet på LCD-skjermen, må du tenne segmentene 1B, 1C. Segment 1B tilhører gruppe COM0, segment 1C tilhører gruppe COM1. Derfor må informasjon om dem skrives til henholdsvis RAM (LCD_RAM0), RAM (LCD_RAM2) registre. Segment 1B er ansvarlig for LCD-utgangen LCDSEG22, informasjon om hvilken er lagret i SEG40-biten til RAM-registeret (LCD_RAM1). Ved å bruke remapping-funksjonen vil segment LCDSEG22 bli tildelt bit SEG28 i RAM-registeret (LCD_RAM0). 1C-segmentet er ansvarlig for LCD-utgangen LCDSEG1, informasjon om hvilken er lagret i SEG1-biten til RAM-registeret (LCD_RAM2).
LCD->RAM= 0x10000000; /*0x10000000 = 1 0000 0000 0000 0000 0000 0000 0000 */ LCD->RAM = 0x2; /*0x2= 10 */
Før du skriver verdier til minneregistre, er det nødvendig å sjekke om den forrige dataoverføringen til LCD-skjermen er fullført. For å gjøre dette sjekkes UDR-biten (Update display request) i LCD_SR (LCD-statusregisteret). LCD-kontrolleren har to utgangsbuffere, informasjon legges inn i den første bufferen og sendes ut til LCD-en fra den andre bufferen. UDR-biten settes under overføring fra den første bufferen til den andre, og beskytter LCD_RAM-registrene mot å skrive:
while(LCD->SR & LCD_SR_UDR);
Etter å ha skrevet informasjon til LCD_RAM-registrene, må du sette UDR-biten i LCD_SR-registeret (LCD-statusregister) (sett 1 til 2 bit):
LCD->SR |= LCD_SR_UDR; eller LCD->SR |= 0x4; /*0x4 = 100 */
For pine og studier av denne enheten. Ikke før sagt enn gjort. Skjerfet ble samlet og vi dro. Å ja! Temaet for samtalen vår dreide seg om å sammenligne de to MK-ene. Den over er mot ATmega328. Hvorfor akkurat dem? Begge MK-ene er i TQFP-32-pakken. (Sant, ATmega328 kommer også i en DIP-pakke)
La oss nå se nærmere på innsiden deres. For større forståelse har jeg samlet alle nødvendige data i en tabell.
| Alternativer | ATmega328 | STM32F030K6T6 |
| Litt dybde | 8 bit | 32 biter |
| BLITS | 32 kb | 32 kb |
| SRAM | 1 kb | 4kb |
| EEPROM | 512b | - |
| Timer 8 bit | 2 stk | - |
| Timer 16 bit | 1 PC | 16 stk |
| PWM | 3 kanaler | 6 kanaler |
| USART | 1 PC | 1 PC |
| SPI | 1 PC | 1 PC |
| I2C | 1 stk (TWI) | 1 PC |
| ADC | 8 kanaler 10 bit | 16 kanaler 12 bit |
| Ernæring | 2,7 - 5,5 | 2,4 - 3,6 |
| Hastighet | 0 - 16MHz | 48MHz med ekstern 4 - 32MHz |
| Pris | 160 - 170 gni. | 80 - 140 gni. |
Opplegg. Større
Jeg laget dette brettet som en modul for feilsøkingskortet mitt for AVR. Men du kan gjenta det ved å distribuere brettet etter eget skjønn (jeg vil legge ut et prosjekt for DipTrace på slutten av artikkelen). Hva står på diagrammet. Og diagrammet viser en enkel sele som for AVR. 8 MHz kvarts med to 20p kondensatorer. Akkurat som i AVR, er strømforsyningskretsen for ADC-støtten satt sammen. Tilbakestill krets som AVR. Den eneste forskjellen er BOOT-kretsen. I motsetning til AVR-er, har alle STM32-er en maskinvare-bootloader om bord. Som standard er den koblet til USART. Det vil si at hvis du trykker BOOT0-pinnen til strømforsyningen og starter MK på nytt, så kan du ved å bruke Flash Loader Demonstrator-programmet flashe MK uten programmerer. Denne funksjonen nyttig hvis du allerede har en klar og fungerende enhet og trenger å oppdatere fastvaren, så trenger du bare en USB USART-adapter. Mange vil ikke rote med STM32 på grunn av at strømforsyningen ikke er mer enn 3,6 volt. Tull. Hvis du ser på pinnetabellen vil du legge merke til at alle ben kan motta 5 volt uten konsekvenser. La oss gå videre.
Og slik ser det ut installert på brettet.
Nå kobler vi ST-LINK-GA-programmereren til SWD-kontakten.
Nå som alt er klart, last ned siste versjon fra ST-nettstedet (lenke helt nederst på siden). Installer og start.
Klikk på Nytt prosjekt. Og i vinduet som dukker opp finner vi kontrolleren vår. Klikk OK.
Etter en liten tanke. Programmet vil vise et vindu som dette.
Jeg vil ikke beskrive hva og hvorfor, siden dette er tema for en egen artikkel. Nå, for eksempel, bare gjør det jeg viser deg. Hva skal vi gjøre. Vi vil lansere operativsystem og i en enkelt tråd vil vi blinke LED-en. Et slags "Heloy Word" fra en kanon.))) For å gjøre dette, i venstre vindu, klikk på plusstegnet ved siden av inskripsjonen "FREERTOS" og sett en hake i rullegardinlisten.
Videre, så snart den eksterne kvartsen er valgt, vil bena som du trenger å henge den på, bli uthevet i grønt på høyre side av kontrolleren. Det neste du må gjøre er å velge benet som LED-en skal henge på. Jeg valgte port B og pinne 0. Og jeg fant en rake. Av frykt, jeg vet ikke hvorfor, snudde jeg utgangskammen til de fire første pinnene opp ned. Derav forvirringen på port B. Dette problemet påvirker bare brettet mitt. Men ingenting, dette stoppet ikke MK fra å jobbe. Og så konfigurer pinnen. Faktum er at med STM kan alle pinner ta på seg en haug med verdier, men hvis du trykker på diskret input/output, så kan det være tre alternativer for utgangen. Utgang i luft, utgang med pull-up til strømforsyning pluss, utgang med pull-up til felles buss. Som standard henger STM32CubeMX beinet i været. Vel, la det være, vi trenger bare å sjekke arbeidet og demonstrere kraften til STM32. For å konfigurere benet, må du venstreklikke på det og velge GPIO_Output i vinduet som vises. Hvis MK er for liten, kan du snu hjulet og forstørre det.)))
Neste trinn er å justere MK-klokken. Faktum er at STM32 er veldig uklar med denne saken. I motsetning til AVR har STM32 kvarts ved inngangen med en frekvens på 4 til 32 MHz, og på bussene kan den overklokkes til 48 MHz. Inne i MK er det et veldig komplekst klokkesystem, men STM32CubeMX kommer oss til hjelp igjen. Gå til fanen Klokkekonfigurasjon og konfigurer den som på bildet nedenfor.
Det er alt. Klikk på tannhjulikonet øverst.
Et vindu som dette vil dukke opp.
Og her glemte jeg å si. Last ned og installer IAR selv. Den kan lastes ned fra myndighetene, men reduseres i mengde kode, eller finnes i torrents. Eller hvis du har mye ekstra penger, kan du kjøpe en lisens. Vel, jeg tror mange vil følge veien med CodeVisionAVR. Generelt lar jeg dette være opp til ditt skjønn. Jeg har versjon 7.40. La oss gå tilbake til kuben. Navngi prosjektet i vinduet, men bare på latin, IAR liker ikke russiske bokstaver i stier. Og spesifiser hvor prosjektet skal lagres. I IDE-vinduet må du velge (og det er som standard) EWARM. Klikk OK. Programmet tenker, og viser deretter et vindu som dette. Bla bla bla. Generelt klikker du på åpne prosjektet (for de som er i tanken, den midterste knappen).
Vinduet vil forsvinne, og IAR og prosjektet vårt vil starte i stedet. Til venstre går du til Applikasjon->Bruker og kjør main.c. Denne haugen med kode er det STM32CubeMX genererte for oss.
Og hva skal man gjøre med denne redselen? Men for dette trenger vi en hel serie med artikler))) Og nå finner vi bare denne kodebiten.
Dette er vår eneste flyt. I kroppen for løkke(;;) vi sletter den eneste funksjonen osDelay(1);, og skriver i stedet denne koden. HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_SET);
osDelay(500);
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_RESET);
osDelay(500);
Herlig. Nå klikker du bare på knappen med den grønne pilen øverst til høyre og venter på kompilering og nedlasting.
Hvis alt er riktig og uten feil, vil programmet sette sammen hele prosjektet, lage alt som trengs og laste fastvaren inn i MK. Etter dette vil den gå inn i feilsøkingsmodus. Her er han. En AVR-manns drøm. Hvis du har et uimotståelig ønske om å bruke det, kan du bare gå steg for steg på maskinvaren, linje for linje. Og hvis du vil se hvordan programmet fungerer, så trykk på krysset øverst til venstre og nyt blinkingen av LED.
Det er alt. Mikrokontrollere kan kjøpes til den laveste prisen, så mye som 78 rubler stykket i ChipResistor-butikken. Vel, hvis du vil ha det billigere, er det også liten engros. Fra 35 stykker allerede for 50 rubler.
Prosjekt for DipTrace.
Og selvfølgelig videoen.
gjest 31.12.15 10:35
Nylig ønsket jeg å lage en frekvensmåler på ATMEGA16 pluss en ekstern 8-bits teller på 74-logikk, men den var ikke rask nok. Jeg takler ikke å skrive i assembler; å gjerde en ekstern teller med 16 bits er en smerte i ass. AVR er forrige århundre, ikke en billig kontroller. Jeg vil støtte forfatteren, AVR er Stadiet har gått, jeg kjøpte også en stm32f100-brikke pluss en CP2103 USB-adapterbrikke, snart vil alle gi opp AVR.
Alexey 31.12.15 12:26
Jeg er uenig. Arduino er fortsatt i utvikling og mange er hekta på det, og sistnevnte fungerer på sin side på AVR. Å gå til STM er som å gå til neste nivå. Så å si fra barnehage til skole.
ANONYM 12.02.16 10:44
AVR og STM32 er prosessorer som ikke konkurrerer med hverandre. Tallerkenen din inneholder ikke den viktigste parameteren - dette er strømforbruket!! Og ser på dem, kan du felle en tåre. Atmega 328 - – Aktiv modus: 0,2 mA – Avslåingsmodus: 0,1 µA – Strømsparingsmodus: 0,75 µA (inkludert 32 kHz RTC) STM32F030K6T6 48 MHz - Aktiv modus: periferiutstyr på 23,3 mA Stopp: 1 mA. 0,048 mA STM32 bruker nådeløst strøm - grovt sett 100 ganger mer enn AVR. Du kan ikke drive en STM32-enhet fra et batteri. Men AVR-er vil fungere i flere måneder. Så det er vanskelig å gi opp AVR. Lykke til alle sammen.
Alexey 02/12/16 10:54
Og ingen foreslår at vi skal forlate AVR. Jeg viser bare forskjellen i periferien. Jeg opprettholder fortsatt AVR-biblioteket og har fortsatt en ATMega8A som hoved-MCU.
Sergey 24.02.16 18:02
Etter min mening er det på en eller annen måte rart å sammenligne den ferske STM32 med den pensjonerte AVR. Hvis du vil sammenligne STM32 med ATMEL-kontrollere, så sammenlign dem med ATSAM-familien, men ikke med AVR.
Andrey 24.02.16 18:06
Hvem er denne pensjonisten? AVR er i live og vil fortsette å leve hvem vet hvor lenge. Og ser på tabellen, etter min mening er sammenligningen mer på periferien, og ikke på arkitekturen.
Alexey 24.02.16 19:04
Vel det begynner. La oss nå diskutere AMD og Intel.
Sergey 24.02.16 22:02
På huben skrev en "ekspert" at AVR ikke har en parallell buss for å koble til en standard LCD, men STM32 gjør det...
Alexey 24.02.16 22:36
Hva betyr standard LCD? Handler dette om FSMC? Så dette er ikke bare for skjermen, det er også for minnet. Bare en parallellbuss. AVR har det også, for eksempel Mega8515. SRAM kan kobles til den via et låseregister.
Sergets 25.02.16 06:24
Alexey, hva snakker jeg om?! Det ser ut til at du ikke engang prøver å forstå betydningen av meldingene mine.
Alexey 25.02.16 09:38
Vel, hva er vitsen med å sammenligne to identiske mikrokontrollere fra forskjellige selskaper? Begge er på ARM-kjernen. Hvis du virkelig er kresen, må du virkelig sammenligne AVR med STM8. Jeg holdt meg da til periferiens nærhet, formfaktor og pris. Og bare annerledes arkitektur.
Adlan 03.06.16 17:40
Hallo. Hjelp, vær så snill, hvem kan. Installert siste versjon Cuba 4.15, F1-biblioteker 1.4.0. Det opprettede tomme prosjektet i EWARM kompilerer ikke - det er mer enn hundre feil. Hva kan det være? Takk skal du ha [e-postbeskyttet]
Alexey 06/03/16 20:48
Adlan, det første du må gjøre er å laste opp et prosjekt som ikke vil kompilere.
Dok 18.07.16 21:51
"Det er sant at AVR kan skryte av Arduino og enkel programmering." HVA kan han skryte av? ;D
Alexey 19.07.16 11:41
Dette er en dum sammenligning. For det første har STM en analog av Arduino kalt nucleo. Programmer skrives i online IDE direkte gjennom nettleseren. Men hvis fordelene med steinen personlig, da. Kjernedriftsfrekvensen er 72 MHz, AVR kunne ikke engang drømme om en slik hastighet. Selvfølgelig, hvis du blinker LED-en, er det ingen forskjell, men hvis du starter aksen og en haug med periferiutstyr, vil AVR-en blåse bort. Bitkapasitet, 32 er langt fra 8. Periferiutstyr på STM kan inneholde 3 I2C, 3 SPI, 6 UART, USB, CAN, Ethernet. Nesten alt har evnen til å bli gjenopprettet, det vil si overføres til andre ben av mk. Det finnes også DMA, dette er en uavhengig koprosessor for arbeid med periferiutstyr. Så AVR-avbruddene ryker nervøst på sidelinjen. Det er en hardware SDIO for fullverdig arbeid med CD-kort, og ikke en krykke-ISP i AVR. Generelt er det mye mer der, men den største steinen i AVR-hagen er støyimmunitet. Å slå ut AVR-en med en kabel som går i nærheten fra den elektriske motoren er enkelt, men STM-en må prøves. Så jeg vil ikke anbefale å være sarkastisk med Arduino.
gjest 08/11/16 23:27
MICROCHIP absorbert AVR!)))))))))))
Alexey 08/12/16 08:35
Vi var sent ute med nyhetene, som for fem år siden.
Vladimir 17.08.16 22:56
Alexei! I januar 2016 kjøpte Microchip Atmel for 3,56 milliarder dollar. Hvilke 5 år?
Alexey 18.08.16 10:30
Dette er de jure, men de facto har det pågått siden 2008. Så jeg gjorde virkelig en feil, ikke for 5 år, men for 8 år siden.))))
Vladimir 18.08.16 23:53
Alexey! Jeg begynte å bytte til stm32! Og når det gjelder forbruk i autonom modus, anbefaler han å ikke klokke alt, da vil forbruksstrømmen reduseres.
Oleg 09.11.16 22:31
I dataarket på STM fant jeg ikke grafer over systemklokke CLK-forbruk som i AVR - og i følge de platene som er der taper STM32 direkte både i normal modus og i hvilemodus. Ja, og denne STM32 har ikke en klokke på 72 MHz - bare 48 maks, det er alt, så selv med 32 bits 8 beatnik AVR - viser det seg bedre, og forresten, produsenten i dataarket skrev ikke hvor mange klokkesykluser i STM32-maskinsyklusen den har, så hvis det viser seg å være 2 klokkesyklus mot 1 for AVR - så tenk på at 48/2 = 24 reelle MHz - nesten det samme som 20 MHz for AVR. Så spørsmålet er - hvor er miraklet med denne STM32 som dere alle snakker om?
ANONYMT 09.11.16 23:03
Alexey 11/10/16 00:23
Jeg vil ikke engang krangle. Hva er bedre Intel eller AMD? Eller Zhiguli eller Volga? STM har maskinvare USB, CAN, Ethernet, SDIO og en haug med annet periferiutstyr som AVR bare kan drømme om. Til slutt er det en DMA som en uavhengig koprosessor med direkte minnetilgang, foran som alle AVR-avbruddene røyker nervøst på sidelinjen. For eksempel har den første serien 3 UART, 2 SPI, 3 I2C ombord. Det er en remap av porter, og du trenger ikke å bekymre deg for hvordan du demonterer brettet. Hvis du liker å jobbe med AVR, så jobb den som plager deg. Den dag i dag tjener jeg mega åttedeler for små prosjekter og klager ikke. Å ja, stikk AVR-en ved siden av starteren og se hvordan den blåser hodet av med forstyrrelser. AVR har ikke EMI-beskyttelse. Derfor ble PIK alltid installert i bilalarmer, siden AVR dør under slike forhold. Hvorfor krangle, det er et dødt tall.
Kornett 27.11.16 21:22
Vel, forresten, det er allerede en Arduino på STM32. Dette er Amperka og alle slags Espruino i JS) Dessuten, hvis mikrobrikken ble tatt av Atmel, vel, skru dem
Alexey 27.11.16 21:44
Navnet Espruino parodierer Arduino, den mest kjente hobbyplattformen på den tiden, men Espruino er ikke kompatibel med klassikeren Arduino Uno verken mekanisk eller programmatisk.(sitat fra Amperka)
Jeg har også et Nucleo-brett, og det har heller ingenting med Arduino å gjøre, bortsett fra geometrien til selve brettet)))
Generelt, i hovedsak, bruker jeg MK som passer for den aktuelle oppgaven.
Andrey 20.12.16 22:50
Hvem liker å betale for mye: det er verdt attiny2313-20 - 2Kb-flash /128bit-ram/16bit_ timer -1/8bit_ timer -1 =2.1$ vs stm32f103c8t6 64Kb-flash/20Kb-sram/16BIT tidskontroll for dual -kanal PWM-modus ) -4/ADC-2/72MHz CPU/=2.3$. Etter min mening er det nesten umulig å lage en impedansmåler for en RLC-krets ved hjelp av en AVR, eller det er 10 steiner. Men du kan gjøre det med STM og FFT (DMA hjelper) Jeg prøvde det på en eller annen måte å lage en frekvensmåler på Mega10 (nøyaktighet 1 hertz) - den var rett og slett ikke rask nok (eller installer en ekstern 32-bit teller med skiftregister - hvor dimensjonene kommer fra Jeg ga opp AVR for et år siden, AVR er, viser det seg, for velstående mennesker.
Andrey 20.12.16 22:53
ANONYM skrev - "Og her er et annet sitat fra beskrivelsen av STM32 på russisk - "...Med
øyeblikk
mottar
avbryter
før
startet
henrettelse
først
lag
handler
avbryter
er brukt
bare
tolv
sykluser
klokke
signal"
Dette er sant. Men multipliser to 32-bit tall med avr - helt klart 8-10 klokkesykluser!
Alexey 20.12.16 23:31
Ja, jeg angrer allerede på at denne halivaren startet.))))
Alexander 21.12.16 00:27
Jeg leste kommentarene og husket.
To barn i sandkassen
En duduka!
For det andre, pip!
Først Duduka! (intonasjon mer truende)
For det andre, BIBIKA! (Med enda mer uttrykksfull intonasjon)
Den første DUDUKA! (Allerede skriker)
Andre BIBIKA!!! (Nesten gråter)
....
Denne kampen er over, begge står og gråter, den ene høyere enn den andre.)))
Val 02/10/17 01:43
Hvilken frekvens vil det være hvis du looper uten forsinkelse?
mens (1)
{
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_RESET);
}
Alexey 10.02.17 10:07
Den på APB-bussen
Igor 06/08/17 22:33
Så la oss umiddelbart integrere bærbare datamaskiner i innebygde systemer, de er hundrevis av ganger bedre enn STM, og det er bare en helvetes masse periferiutstyr der, det er allerede Wi-Fi og bluetooth og til og med programmerere er ikke nødvendig, med en gang er det en skjerm med et tastatur for å skrive et program og kjøre umiddelbart, og programmerere og debuggere er ikke nødvendig.
Det er som å kjøpe en gravemaskin til personlig bruk på hytten din for å NOEN GANG grave et par hull en halv meter dype.
Å sette STM i en termostat, klokke, vekter, vel, etter min mening er dette ikke normalt. Forresten ja, hva med ikke-flyktig minne, så jeg lager en termostat, stiller inn temperaturen, så slukker lysene, så hva, innstillingene går tapt. Men i innebygde systemer som må konfigureres én gang for videre drift, må verdiene lagres for alltid
Alexey 06/09/17 08:25
Vel, for eksempel koster STM32F030F4P6 chip-dip 48 rubler, og den direkte analoge ATtiny2313 koster 98 rubler. Jeg tror noen av dem vil være nok til å bygge en termostat. Og minnekompensasjon for STM kan være i hvilken som helst temperatursensor. Ja, i hvert fall i samme DS18B20. Når det gjelder bærbare datamaskiner, har enhver betalingsmottaksterminal en PC installert med et OS og en skjerm. Så det finnes til og med slike systemer. Når du velger en MK, velg først den som er billigere. Hvis dette er en hobby, så kan du kjøpe en Arduino for ikke å bry deg med lodding, og når systemet planlegges satt i produksjon og produsert i hundrevis, så teller hver krone. Og å betale for mye 50 rubler for en MK når prisen er 48 er en uoverkommelig luksus.
Ruslan 17.06.17 21:46
Alexey, hvorfor valgte du IAR-programmeringsmiljøet?
Hvilket miljø er bedre for en nybegynner å velge (slik at det er mange hint som i Atmel Studio)?
Alexey 17.06.17 22:07
Ruslan 17.06.17 22:56
Hvis jeg ikke så "dårlig ut", så gi meg en lenke hvor jeg kan se eller lese hvordan du gjør det!Enda bedre, lag en video, jeg tror mange nybegynnere (og ikke bare) vil være interessert i å se den!
Takk på forhånd!
Alexey 08/05/17 10:19
Ruslan 22.11.17 12:17
Jeg mente dette https://www.youtube.com/watch?v=wOIlhRd-vN8
5 - 7 minutter!!!
Ruslan 22.11.17 12:18
Alexey, vennligst fortell meg hvordan jeg jobber med "enum"-oppregninger, ellers er det ingen slik informasjon noe sted, og i videoene dine er "C for the little ones" heller ikke der, men jeg trenger det virkelig!
Da jeg lekte med AVR-er, hadde jeg aldri sett et slikt mirakel som oppregning, men nå er jeg interessert i STM-er, og det er mange av dem! Og det er ingen informasjon om hvordan du jobber med dem!
Her er et eksempel fra ekte kode:
StatusCode MIFARE_Read(byte blockAddr, byte * buffer, byte * bufferSize);
Hvor er StatusCode-oppregningen:
enum Statuskode: byte (
STATUS_OK , // Vellykket
STATUS_ERROR , // Kommunikasjonsfeil
STATUS_COLLISION , // Kollisjon oppdaget
STATUS_TIMEOUT , // Tidsavbrudd i kommunikasjon.
STATUS_NO_ROOM , // En buffer er ikke stor nok.
STATUS_INTERNAL_ERROR , // Intern feil i koden. Burde ikke skje ;-)
STATUS_INVALID , // Ugyldig argument.
STATUS_CRC_WRONG , // CRC_A samsvarer ikke
STATUS_MIFARE_NACK = 0xff // En MIFARE PICC svarte med NAK.
};
Dette er fra Arduino-biblioteket (C++), men Keil sverger til det!
Hvordan skrive returen til en opptellingsfunksjon riktig?
Ruslan 22.11.17 12:29
Og hvordan erklære et av argumentene i en funksjon som er en oppregning:
void PCD_WriteRegister(PCD_Register reg, byteverdi);
Hvor PCD_Register er oppført:
enum PCD_Register: byte (
// Side 0: Kommando og status
// 0x00 // reservert for fremtidig bruk
CommandReg = 0x01<< 1, // starts and stops command execution
ComIEnReg = 0x02<< 1, // enable and disable interrupt request control bits
DivIEnReg = 0x03<< 1, // enable and disable interrupt request control bits
ComIrqReg = 0x04<< 1, // interrupt request bits
...
};
Og reg, slik jeg forstår det, er en oppregning, men det er ikke deklarert noe sted i koden, og jeg forstår ikke hvor det kom fra!
Jeg leste mange sider på Internett og fant informasjon om at disse oppregningene kan erstattes med definisjoner, men jeg ville likevel vite hvordan jeg skulle jobbe med dem!!!
Ruslan 22.11.17 12:35
Jeg ser frem til svaret ditt!
Kanskje lage en video om hvordan du jobber med dem, slik at det fungerer for andre, jeg tror videoen vil være veldig nyttig fordi det ikke finnes slike videoer (jeg har i alle fall ikke funnet dem)!
Dmitry 28.11.17 22:02
"enkel programmering"
Et interessant organ for programmering av kontrollere. Generelt er det ikke klart hvordan det var mulig å sammenligne 32-bit med 8-bit. Som en Porsche Cayenne med Zarporozhets.
Alexey 29.11.17 10:24
Du kan sammenligne, du kan. Du må bare ta i betraktning at i denne sammenligningen er Porsche billigere enn Zaporozhets. Når det gjelder urologi, er det mer pikant. Så jeg vil ikke fikse det.
Konstantin 23.12.17 00:06
Ruslan, jeg forstår ikke hvordan du søker og ikke finner noe (tilsynelatende leter du ikke). Dette er det helt grunnleggende i C-språket (ikke bare for MKs, men også for datamaskiner). Les boken av Kernighan og Ritchie, hele C er perfekt beskrevet der.
Og ingen vil svare på spørsmålene dine, dette er elementære greier.
ANONYMT 11.02.18 16:27
Hvorfor sammenligner du 32-bit ST MK med 8-bit Atmel. Dum sammenligning. Det tilsvarer å sammenligne 32-biters Atmel AT91SAM med 8-biters STM8, selv med tanke på at Atmel har 32 enda kraftigere utladere
Alexey 13.02.18 12:18
For i skrivende stund var ikke 8-bånds ST-er på salg, og mega og STM32 er priset det samme.
STM32_Dev 19.06.19 13:59
Vel, AVR tar 4-5 klokkesykluser for å gjøre det samme!!! Bare. Og her viser det seg igjen at AVR er laget bedre enn STM32, med sin oppblåste klokke, og STM32 har ikke en EEPROM inni som AVR
AVR-klokke på 16 MHz - 1/16000000 = 0,0000000625 s = 62,5 ns * 5 klokker = 312,5 ns.
ARM-klokke ved 48 MHz - 1/48000000 = 0,0000000208 s = 20,8 ns * 12 klokker = 250 ns.
Det ser ut til at museet atmega teller sine 5 klokkesykluser lengre enn STM32s 12 klokkesykluser)))
Har ikke STM32 en eprom? Sikker? STM32L152 - 8kB eprom! Hva med atmega? 512 byte? Å så mange!!! Jeg vet ikke engang hva jeg skal skrive der. La oss tenke... mmm... 16 variabler på 4 byte hver)) Vel, det er bare et tordenvær blant kontrollere))
SIM31 30.06.19 19:29
Når det gjelder forbruk kan du også sammenligne, de nye atmega og attiny er veldig økonomiske.
Og alt har sin bruk. Hvis du trenger strøm, ta en Raspbery Pi 4 og ikke bekymre deg, Python har enda flere muligheter, til og med sette opp en fullverdig webserver, til og med kjør Quake 3D.
Hvis du trenger å behandle datastrømmer, er det et lurt (se prosjektet "Mars Rover" "Mars Rover 2")
Forfatteren har massevis av positive sider, men det faktum at Arduina er mer levende enn alle de levende betyr at ikke alt er så enkelt.
I mange år har radioamatører brukt åtte-bits mikrokontrollere fra PIC- og AVR-familiene. De er populære på grunn av lav pris, detaljert dokumentasjon, enkel programmering og enkel installasjon. Imidlertid er det ofte tilfeller der kraften til en slik mikrokontroller ikke er nok til å løse oppgaven. Det enkleste eksemplet er en frekvensmåler eller signalgenerator på en mikrokontroller, der den maksimale målte eller genererte frekvensen direkte avhenger av hastigheten på prosessering eller utmating av informasjon.
I tillegg til hastighet har åtte-bits mikrokontrollere andre begrensninger, for eksempel har mange AVR-modeller bare én maskinvareserieport, som ikke tillater å motta informasjon fra en ekstern enhet og samtidig sende resultatene av behandlingen til forbrukeren. For ikke å nevne slike "banale" ting som å vise informasjon på en grafisk indikator, som krever store ressurser av både hastighet og minne. Etter å ha analysert en rekke slike begrensninger, kom forfatteren på ideen om å bytte til mikrokontrollere i STM32-familien.
Vurder for eksempel to mikrokontrollere i samme priskategori - STM32F103C6 og ATmega328P.
Tabell 1
| Mikrokontroller type | ||
| Prosessorstørrelse | ||
| Blystigning, mm | ||
| Klokkefrekvens, MHz | ||
| FLASH-minnevolum. KB | ||
| Mengde RAM, KB | ||
| USART-nummer | ||
| Antall 16-bits timere | ||
| Antall I/O-linjer | ||
| Omtrentlig pris, gni. |
Deres komparative parametere er gitt i tabell. 1. Sammenligningsresultatene er til og med noe overraskende. En 32-bits mikrokontroller er ikke bare kraftigere enn en åtte-bits mikrokontroller på nesten alle måter, men den er også billigere. Å lodde en mikrokontroller med en pinnestigning på 0,5 mm hjemme er selvfølgelig ikke så lett. Heldigvis er dette i de fleste tilfeller ikke nødvendig - det finnes mange typer utviklingskort med STM32-familiemikrokontrollere på markedet, tilstrekkelig for ulike bruksområder. La oss se på dem mer detaljert.
STM32F4-DISCOVERY
Dette brettet (vist i fig. 1) er kanskje det mest praktiske for nybegynnere som studerer STM-mikrokontrollere. For det første har den et stort sett med periferiutstyr. I tillegg til mikrokontrolleren inneholder brettet et mikroelektromekanisk akselerometer, en mikrofon, en lyd-DAC, to USB-kontakter, en knapp og fire lysdioder.
Mikrokontrollerpinnene bringes ut på kontaktputer for montering av pinnekontakter på venstre og høyre kant av kortet, noe som gjør det enkelt å koble alle nødvendige eksterne enheter til dem. STM32F407VGT6-mikrokontrolleren installert på brettet har veldig gode parametere: 1 MB FLASH-minne, 192 KB RAM og en klokkefrekvens på 168 MHz.
Til slutt er brettet utstyrt med en innebygd ST-LINK/V2 debugger, som kan brukes til å feilsøke programmer ikke bare på mikrokontrolleren på brettet, men også på mikrokontrollere av samme familie plassert på andre brett. Bytte til dem gjøres ved hjelp av en flyttbar jumper og SWD-kontakten.
Prisen på brettet er omtrent 800 rubler, noe som kan betraktes som ganske akseptabelt.
STM32F103RBT6 Development Board
Det neste interessante alternativet er et utviklingskort med en STM32F103RBT6 mikrokontroller (fig. 2).
Det er noe svakere enn det som er installert på det forrige kortet - en klokkefrekvens på 72 MHz, 128 KB FLASH-minne og 20 KB RAM, men de perifere enhetene er veldig interessante. Det er en TFT-berøringsskjerm med en oppløsning på 320x240 piksler og en diagonal på 2,8", en innebygd USB-port for utveksling av informasjon med en datamaskin, et spor for et SD-minnekort, en 32768 Hz kvartsklokke, et rom for en sanntidsklokkebatteri og en ST-LINK-kontakt for feilsøking av programmer.
Prisen på dette brettet er også omtrent 800 rubler, men det skal bemerkes at det ikke har en innebygd debugger. For å laste ned programmer, må du enten kjøpe en separat ST-LINK debugger, eller bruke STM32F4-DISCOVERY-tavlen diskutert ovenfor i stedet
Maple Mini
Den eksterne likheten til dette brettet (fig. 3) med de velkjente Arduino-modulene er slående. Og dette er ingen tilfeldighet.
Maple Mini-brettet ble designet som en erstatning for Arduino Nano. Programmeringsspråket og utviklingsmiljøet for AVR-familien av mikrokontrollere installert i Arduino er tilpasset STM-familien. Gå til http://leaflabs.com/docs/maple-q uickstart.html for detaljert informasjon om Maple IDE-programmeringsspråket og utviklingsmiljøet.
Utviklingskortet har en STM32F103CBT6 mikrokontroller som kjører på 72 MHz, 128 KB FLASH-minne og 20 KB RAM, som utvilsomt er mer enn noen Arduino-modul. Og det er enda mer et pluss at utviklingsmiljøet har holdt seg praktisk talt uendret.
Separat bemerker vi at til tross for sin miniatyrstørrelse, tilbyr Maple Mini svært variert periferiutstyr: 34 I/O-linjer, to SPI- og to I2C-grensesnittkanaler, tre serielle porter. Dette gjør at den kan brukes med hell i ulike amatørutviklinger. Takket være sin lille størrelse kan Maple Mini bygges direkte inn i enheten som utvikles.
Det originale Maple Mini-brettet kan kjøpes for $35 på nettstedet til utviklerne. Frakt vil koste ytterligere $5. En kopi av brettet laget i Kina vil koste halvparten så mye.
Programvare
Det er flere alternativer for utviklingsmiljøer som kan brukes til å forberede programmer for mikrokontrollere i STM32-familien:
Commercial IAR Embedded Workbench, AtollicTrueSTUDIO, Keil, etc. Disse fullfunksjonsproduktene er ganske dyre, med en lisenspris som starter fra 1000 euro, men det finnes også gratis demoversjoner med en begrensning på volumet til programmet som utvikles; enkle prosjekter de er ganske nok;
Den gratis Eclipse med ARM-GCC-kompilatoren krever ikke-triviell konfigurasjon av kompilatoren før bruk. Det eneste pluss for i dag er muligheten til å jobbe ikke bare i Windows, men også i Linux;
Gratis CooCox IDE (CoIDE) basert på samme Eclipse-editor. Laster og feilsøker programmer via ST-LINK. I motsetning til det forrige alternativet, krever ikke CoIDE noen spesielle innstillinger og fungerer umiddelbart etter installasjon. Dette alternativet er det mest praktiske og er verdt å bruke.
La oss bruke CooCox IDE til å lage et eksempelprogram for STM32F4-DISCOVERY-kortet som implementerer den klassiske LED-blinkingen til det første programmet for enhver mikrokontroller. Det er fire lysdioder på STM32F4-DIS-COVERY-kortet, de er koblet til pinnene PD12-PD15 på mikrokontrolleren. La oss få dem til å blinke vekselvis.
Trinn 1. Start CoIDE-utviklingsmiljøet og lag et prosjekt. Fra rullegardinlisten vist i fig. 4, velg STM32F407VG mikrokontroller.
Trinn 2. Som vist i fig. 5, velg komponentene som skal brukes i prosjektet. De viktigste er GPIO (input-output), C Library (grunnleggende funksjoner i C-språket) og M4 Core (prosessor kjernefunksjoner). Når du aktiverer en komponent, kopierer CoIDE automatisk de nødvendige filene til prosjektmappen, noe som er veldig praktisk.
Trinn 3. Skrive inn programtekst. Den er ganske kort og er gitt i tabellen. 2.
Som du kan se, er alt enkelt og åpenbart. De som har skrevet programmer for AVR-mikrokontrollere vil sannsynligvis se kjente design - initialisering av porter som indikerer retningen (inngang eller utgang), hovedsløyfen der de nødvendige handlingene utføres. Generelt tilsvarer programmets syntaks fullt ut C-språket, som det er mer enn nok litteratur for. Det er også mange artikler om programmering for STM32 på Internett. Mange eksempler følger med utviklingsbrettet og kan også brukes som prøver.
Etter å ha lagt inn programteksten ved å klikke på "Last ned for å blinke"-skjermknappen, lastes den ned til mikrokontrolleren. LED-ene på brettet begynner å blinke. Separat er det verdt å merke seg feilsøkingsmulighetene - et bruddpunkt kan settes hvor som helst i programmet, du kan kjøre programmet trinn for trinn, se verdiene til variabler.
Dette eksemplet er selvfølgelig ikke ideelt. Du kan for eksempel bruke timeravbrudd for å kontrollere blinking av lysdioder, noe som frigjør hovedprogramsløyfen for andre oppgaver. De som ønsker kan finne ut av dette på egenhånd.
Konklusjon
Generelt, etter det første bekjentskapet, etterlot mikrokontrollerne til STM32-familien et veldig hyggelig inntrykk. Alt viste seg å ikke være så komplisert, og bekvemmeligheten av utviklingsmiljøet, feilsøkingsprosessen og et stort antall standardfunksjoner minnet til og med noe om overgangen fra Ms DOS til Windows - de generelle punktene ser ut til å være de samme, men alt er mye mer praktisk og funksjonell.
Men den største ulempen med denne familien for amatørutvikling er fortsatt den for liten pin-pitch. Å designe og lodde et brett med en pinnestigning på 0,5 mm hjemme er en veldig ikke-triviell oppgave. Men til gjeldende priser er feilsøkingstavler med allerede monterte mikrokontrollere ganske tilgjengelige for enhver radioamatør.
Er det verdt å konvertere alt til STM og 32-bits arkitektur? Selvfølgelig ikke. Det er oppgaver som ATtiny er ganske tilstrekkelig for. Men for for eksempel å analysere spekteret i en hjemmelaget SDR-mottaker eller motta og overføre store mengder informasjon over et nettverk, er det mye mer effektivt å umiddelbart bruke en kraftig mikrokontroller for ikke å støte på mangel på minne eller ytelse når å forbedre enheten.
Basert på Cortex-kjernen begynte de aktivt å få popularitet blant både profesjonelle og nybegynnere av enheter på mikrokontrollere. Det er flere grunner til dette:
- lav pris sammenlignet med konkurrenter;
- et stort antall innebygde grensesnitt;
- enkel programmering og høy pålitelighet.
Men det er også en viktig ulempe - alle STM-mikrokontrollere er ikke produsert i DIP-pakker, noe som ofte bare skremmer nybegynnere, fordi det er problematisk å lage et brett med spor mindre enn 0,3 mm hjemme. Denne tilstanden har ført til at det dukker opp et stort antall feilsøkingstavler på markedet, både fra ST Microelectronics (Discovery) og brett produsert av tredjepartsselskaper (Olimex, Pinboard). Jeg valgte Discovery av tre grunner:
- relativt lav pris (brettet kan kjøpes fra 300 rubler);
- godt utførelse (selv om det er noen klager på ledningene, men de er ikke så viktige);
- mange kilder og eksempler er lagt ut på produsentens nettsted;
- tilstedeværelsen av en innebygd programmerer (du trenger ikke å kjøpe den separat).
Hensikten med den første leksjonen er å hjelpe en nybegynnerutvikler med å velge et feilsøkingstavle, og i fremtiden - å lære det grunnleggende om programmering.
Så la oss gå.
STM32F0DISCOVERY
Dette brettet ble utgitt i februar 2012 for å tiltrekke utviklere som tidligere hadde brukt 8-bits mikrokontrollere, og dermed fylt denne nisjen. Jeg kan ikke si noe dårlig eller godt om henne. Et vanlig brett, billig, er flott for å komme i gang. Har følgende egenskaper:
- mikrokontroller: STM32F051R8T6 (Cortex M0, 48 MHz, flash 64 KB, RAM 8 KB);
- innebygd ST-link/V2, som kan brukes separat fra brettet;
- drevet fra USB eller fra en ekstern 3/5V-kilde;
- 4 lysdioder og 2 knapper;
- grensesnitt: USART, SPI, I2C, HDMI;
- timere 16 og 32 biter;
- alle utganger rutes til to enrads kammer.
Egentlig er et slikt brett allerede ganske utdatert, og det anbefales å ta det bare for begynnelsen av treningen.
STM32VLDISCOVERY
Det skiller seg fra det forrige kortet bare i STM32F100RBT6B-prosessoren (Cortex M3, 24 MHz, flash 128 KB, RAM 8 KB) og utformingen av de perifere kammene. Akkurat som den som er diskutert ovenfor, er den egnet for nybegynnere. Det er ikke mer å si om henne.
STM32LDOPP
STM32LDISCOVERY er en verdig videreutvikling av det forrige styret. Her er det som er interessant med det:
- mikrokontroller STM32L152RBT6 (Cortex M3, 32 MHz, flash 128Kb, RAM 8Kb, EEPROM 4Kb)
- grensesnitt: USB, USART, SPI, I2C;
- 8 timere;
- 24-kanals 12-bits ADC;
-12-bits DAC;
- sanntidsklokke;
- LCD-kontroller 8x40
- innebygd ST-link/V2.
Følgende er installert på brettet:
- LCD-skjerm 24x8;
- 4 lysdioder;
- 2 knapper;
- berøringstastatur;
- 2 enrads kammer med ledige ledninger.
Jeg vil gjerne si separat om USB: kontrolleren støtter USB 2.0 full hastighet, verts- og enhetsmodus, noe som sjelden sees i en MK av denne klassen.
Faktisk er brettet det beste alternativet for å jobbe med Cortex-M3-kjernen, så du kan trygt ta det, siden prisen er lav.
STM32F3DISCOVERY
STM32F3DISCOVERY tilhører neste generasjon utviklingskort fra STM og har følgende egenskaper:
- mikrokontroller STM32F303VCT6 (Cortex M4, 72 MHz, flash 256 KB, RAM 48 KB)
- sanntidsklokke;
- innebygd ST-link/V2;
- 13 tidtakere;
- 12-kanals DMA-kontroller;
- 4 ADC-er;
- 4 operasjonsforsterkere;
- grensesnitt: CAN, USB 2.0, USART/UART, SPI, I2C;
- 87 GPIO-linjer.
- tilpasset USB-port;
- 3-akset akselerometer og 3-akset geomagnetisk sensor i ett hus;
- 3-akset gyroskop;
- 10 lysdioder;
- 2 knapper;
- 2 dobbeltrads kammer.
Et veldig interessant styre, mange muligheter for eksperimentering. Generelt er oppfatningen om det fortsatt god, men fokuset på å spore den fysiske tilstanden og posisjonen reduserer muligheten for eksperimentering betraktelig, selv om du enkelt kan lage et utvidelseskort selv.
Jeg hadde muligheten til å jobbe mest med dette styret, og jeg likte det mer enn de andre - dets omfattende fokus påvirket det.
Her er hva det er:
- mikrokontroller STM32F407VGT6 (Cortex M4, 168 MHz, flash 1 MB, RAM 192 KB)
- innebygd ST-link/V2;
- tidtakere;
- DMA-kontroller;
- ADC/DAC;
- grensesnitt: CAN, USB 2.0, USART/UART, SPI, I2C, GPIO;
Brettet inneholder følgende periferiutstyr:
- tilpasset USB-port;
- 3-akset akselerometer;
- 8 lysdioder;
- 2 knapper;
- 2 kammer med dobbel rad;
- Audio DAC med klasse D forsterker;
- rundstrålende digital mikrofon.
Som jeg skrev ovenfor, ble dette brettet det viktigste for meg; jeg var fornøyd med evnen til å jobbe med lyd og akselerometeret.
Videre leksjoner vil være basert på denne tavlen.
Sammendrag.
Hvis du bestemmer deg for å begynne å jobbe med STM-feilsøkingstavler, anbefaler jeg deg å ta STM32F4DISCOVERY, etter min mening har den størst funksjonalitet. Ytterligere artikler vil være spesifikt basert på arbeidet med det. Det vil bli skrevet artikler om følgende emner i nær fremtid:
- arbeid med GPIO, tidtakere, avbrudd, etc.;
- arbeide med UART, SPI, I2C og 1-wire grensesnitt ved å bruke eksempler på ekte enheter, som skjermer, GPS og GSM moduler, temperatursensorer, kommunikasjon med en datamaskin via RS-232 og mye mer.
Det endelige målet med denne syklusen er å lage et utvidelseskort for STM32F4. All fastvare og kretsdiagrammer vil være offentlig tilgjengelig.
