Arbeta med LCD-indikatorn på STM32L-Discovery-utvecklingskortet. Träning på STM32 till massorna Frekvensdelarblock
Allmän information
STM32L-Discovery-utvecklingskortet har en flytande kristallskärm (LCD) med sex 14 segmenttecken, 4 kolon (kolon), 4 punkter (DP), 4 ränder (bar). Alla segment kombineras till grupperna COM0, COM1, COM2, COM3 med 24 segment. Varje grupp har sin egen separata "gemensamma tråd".
Mikrokontrollern STM32L152RBT6 är installerad på felsökningskortet. Mikrokontrollern har en inbyggd LCD-kontroller som styr de monokroma LCD-indikatorerna.
LCD-kontroller:
- Låter dig konfigurera uppdateringsfrekvensen (bildhastighet - frekvensen med vilken information på LCD-skärmen uppdateras)
- Stöder statiskt och multiplex kontrollläge
- Stödjer Mjukvaruinstallation kontrast
- Tillåter flera styrspänningsnivåer (upp till fyra)
- Använder dubbelbuffring, vilket gör att data i LCD_RAM-register kan uppdateras när som helst under programkörning utan att kränka integriteten hos den visade informationen
LCD-kontroller minnesregister
Mikrokontrollern STM32L152RB har speciella LCD_RAM-register, den information som lagras i motsvarar gruppen av segment COM0 - COM3. Varje grupp motsvarar två 32-bitars register. Detta antal register tillåter mikrokontrollern att styra LCD-skärmen c stor mängd segment än de som är installerade på utvecklingskortet.För att styra en LCD med 176 segment används 4 grupper COM0 - COM3 med vardera 44 segment, för att styra en LCD med 320 segment används 8 grupper COM0 - COM7 med vardera 40 segment.
Utvecklingskortet STM32L-Discovery använder en LCD med 96 segment, uppdelade i 4 grupper COM0 - COM3 med 24 segment vardera. 
LCD-skärmen på STM32L-Discovery-utvecklingskortet är ansluten på ett sådant sätt att bitarna S40, S41 i de andra LCD_RAM-registren i varje grupp och bitar S0-S27 i de första LCD_RAM-registren används. För att minska antalet använda register kommer information från bitarna S40-S43 att skrivas till fria bitar S28-S31 med hjälp av ommappningsfunktionen.
Frekvensdelarblock
Frekvensdelarblocket (frekvensgenerator) låter dig uppnå olika bildhastigheter på LCD-skärmen i intervallet från 32 kHz till 1 MHz. Följande kan användas som en tidssignalkälla:- Extern lågfrekvensgenerator med en frekvens på 32 kHz (LSE. Låghastighet extern)
- Intern lågfrekvensgenerator med en frekvens på 37 kHz (LSI. Låghastighet intern)
- Extern RF-generator med frekvensdelare på 2,4,8 och 16 och en maximal frekvens på 1 MHz. (HMS. Höghastighet extern)
F ck_div =F LCDCLK / (2 PS *(16+DIV))
Bildfrekvensen beräknas med formeln:
F Ram =f ck_div *plikt
När drift är arbetscykeln - förhållandet mellan pulsens varaktighet och dess period. Under en bildruta visas information från registren LCD_RAM[x], LCD_RAM, etc. sekventiellt på LCD-skärmen. För en LCD installerad på ett utvecklingskort måste LCD-styrenheten i en ram mata ut information från 4 grupper av segment COM0 - COM3, därför kommer varaktigheten av kontrollpulsen för en grupp att vara 1/4 av ramvaraktigheten, dvs. tull=1/4.
LCD-kontroll
Det finns två sätt att styra LCD-skärmen - statiskt kontrollläge och multiplexkontrollläge. Med statisk indikering är varje segment av indikatorbiten ansluten till mikrokontrollerns utgång. I förhållande till LCD-skärmen, på STM32LDiscovery-felsökningskortet, krävs 6 * 14 = 84 mikrokontrollerstift (exklusive kolon, punkter och ränder). På grund av användningen av ett sådant antal stift blir det omöjligt att ansluta andra kringutrustningar. STM32L152RB mikrokontroller har 64 stift. I multiplexstyrningsläge (dynamiskt styrläge) kombineras identiska segment av indikatorsiffror i grupper. Informationen visas på grund av den alternativa belysningen av segment av indikatorsiffrorna, med en frekvens som inte är märkbar för det mänskliga ögat.Multiplexkontroll låter dig styra ett stort antal segment. Istället för att styra varje element separat, kan de adresseras med rader och kolumner (COM och SEG), vilket förenklar styrkretsen, eftersom varje segment kräver ingen egen kontrolllinje. För att aktivera det valda segmentet måste potentialskillnaden COM och SEG appliceras på det. Ett exempel på hur den första siffran i indikatorn fungerar (indikatorn visar "1:"): 
Den första siffran i indikatorn vid tidpunkten t 0
Den första siffran i indikatorn vid tidpunkten t 1
Den första siffran i indikatorn vid tidpunkten t 2
Allmänt diagram över anslutning av segment till LCD-stift
Anslutningsschema för LCD-stift till mikrokontrollerportar
För SEG-ledningar används en styrspänning, vars antal nivåer bestäms av förspänningskoefficienten. LCD-skärmen på utvecklingskortet använder ett multiplexkontrollläge med duty=1/4 och bias=1/3. Duty- och biasvärdena ställs in via LCD_CR-registret (Control Register) i DUTY- och BIAS-bitarna.
Öva
Konfigurera mikrokontrollerportar
För att styra LCD-skärmen måste mikrokontrollerns portar konfigureras enligt följande:- Till utgången
- Använda AF 11 Alternativ funktionen
- Ha utgångsfrekvenser till porten på 400 kHz
- Använd push-pull driftläge
- Inga pull-up motstånd
LCD-stiften är anslutna till GPIOA-portarna (PA1-PA3, PA8-PA10, PA15), GPIOB (PB3-PB5, PB8-PB15), GPIOC (PC0-PC3, PC6-PC11) på mikrokontrollern. För att LCD-skärmen ska fungera måste en klocksignal tillföras de valda portarna. GPIO-portarna på mikrokontrollern klockas från AHB-bussen i RCC-systemet (Reset and Clock Control) - ett klock- och återställningssystem. Klocksignalen tillförs genom inställning av motsvarande bitar i registret RCC_AHBENR (AHB perifer klockaktiveringsregister).
Registrera RCC_AHBENR (bilden visar de första 15 bitarna)
För GPIOA, GPIOB, GPIOC-portar måste du ställa in 1 till 0, 1, 2 bitar av registret.
Därefter kommer jag att ge koden för att skriva information till registret med hjälp av en bitmask och med hexadecimala koder. Att använda bitmasker är bekvämare, men att arbeta med hexadecimala koder låter dig förstå essensen av att arbeta med register.
RCC->AHBENR |=(RCC_AHBENR_GPIOAEN|RCC_AHBENR_GPIOBEN|RCC_AHBENR_GPIOCEN); eller RCC->AHBENR = 0x7; /* 0x7=111 */
För att indikera portens driftlägen används GPIOx_MODER-registret (GPIO-portlägesregister) (x = A..H). Alla registerbitar är grupperade i MODERy-grupper, där y är pinnumret för motsvarande port. Portarna måste konfigureras för alternativt funktionsläge, dvs. i gruppen som ansvarar för stiftet, ställ in värdet till 10. För GPIOA-porten måste du konfigurera stift 1-3,8-10,15, det vill säga ställa in 1 till 3,5,7,17,19, 21,31 siffror. 
Registrera GPIOx_MODER (register för GPIO-portläge)
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_1); eller GPIOA->MODER = 0x802A00A8; /* 0x802A00A8=1000 0000 0010 1010 0000 0000 1010 1000 */
Mikrokontrollerportarna måste växlas till push-pull-läge. För att göra detta måste du ställa in 1 i GPIOx_OTYPER-registret (registret för GPIO-portutgångstyp) i de bitar som ansvarar för stiften. 
Register GPIOx_OTYPER (register för GPIO-portutgångstyp)
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 */
Båda alternativen påverkar de valda stiften. (För GPIOA-porten är stift 1-3.8-10.15 konfigurerade). Om du behöver byta alla portstift till push-pull-läge kan du skriva följande värde till registret:
GPIOA->OTYPER = 0x0;
För att specificera frekvensen för information som matas ut till porten, används registret GPIOx_OSPEEDR (GPIO port output speed register). Alla registerbitar är grupperade i grupper OSPEEDRy, där y är pinnumret för motsvarande port. I detta arbete bör frekvensen sättas till 400 kHz d.v.s. i gruppen som ansvarar för stiftet, ställ in värdet till 00. 
Registrera GPIOx_OSPEEDR (registret för utgångshastighet för GPIO-port)
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 */
Om du behöver ställa in utgångsfrekvensen till porten till 400 kHz för alla stift kan du skriva värdet till registret:
GPIOA->OSPEEDR = 0x0;
För att inaktivera pull-up och pull-down motstånd för valda stift, använd GPIOx_PUPDR register (GPIO port pullup/pulldown register). Alla registerbitar är grupperade i PUPDRy-grupper, där y är pinnumret för motsvarande port. För att inaktivera pull-up-motstånd i gruppen som ansvarar för stiftet, ställ in värdet på 00. 
Registrera 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 */
Om du behöver inaktivera pull-up-motstånd för alla stift kan du skriva värdet till registret:
GPIOA->PUPDR = 0x0;
För att använda en alternativ funktion för mikrokontrollerportar, två register GPIOx_AFRL (GPIO alternativ funktion låg register), ansvarig för de låga stiften (0 till 7) och GPIOx_AFRH (GPIO alternativa funktion hög register), ansvariga för de höga stiften (8 till 15) , används. Alla registerbitar är grupperade i grupper AFRly och AFRHy, där y är pinnumret för motsvarande port. Portarna måste konfigureras för att använda den alternativa funktionen AF11, för detta måste gruppen som ansvarar för stiftet ställas in på 1011. 
Registrera GPIOx_AFRL (GPIO alternativ funktion låg register)
Register GPIOx_AFRH (GPIO alternativ funktion högregister)
För att göra detta måste du skriva följande värden i registren:
GPIOA->AFR = 0xBBB0; /* 0xBBB0 = 1011 1011 1011 0000*/ GPIOA->AFR = 0xB0000BBB; /* 0xB0000BBB=1011 0000 0000 0000 0000 1011 1011 1011*/
AFR = 0xBBB0 – skriver ett värde till GPIOx_AFRL-registret.
AFR = 0xB0000BBB – skriver ett värde till GPIOx_AFRH-registret.
Inställningarna för motsvarande stift för GPIOB- och GPIOC-portarna görs på samma sätt.
Ställa in LCD-kontrollern
När du arbetar med en LCD-styrenhet, som med annan kringutrustning, måste en klocksignal tillföras den. Klocksignalen tillförs även energihanteringssystemet. Styrenheten och strömhanteringssystemet använder APB1-bussen för klockning. För att aktivera klockning i registret RCC_APB1ENR (APB1 peripheral clock enable register) måste du ställa in 1 i bitarna 9 och 28.
Register RCC_APB1ENR (APB1 perifer klockaktiveringsregister)
RCC->APB1ENR |= RCC_APB1ENR_PWREN|RCC_APB1ENR_LCDEN; eller RCC->APB1ENR |= 0x10000200; /* 0x10000200=1 0000 0000 0000 0000 0010 0000 0000 */
För att LCD-styrenheten ska fungera är det nödvändigt att specificera källan för klocksignalerna. Källan anges i RCC_CSR-registret. Som standard är skrivning till detta register inaktiverat. Skrivskyddet i RCC_CSR-registret tas bort i PWR_CR-effektstyrregistret. RCC_CSR-registret styr klockkällorna för RTC- och LCD-styrenheten
Skrivning till RCC_CSR-registret aktiveras genom att sätta bit 8 i PWR_CR-registret till 1. 
Register PWR_CR (PWR power control register)
PWR->CR |= PWR_CR_DBP; eller PWR->CR |= 0x100; /* 0x100 =1 0000 0000 */
För att ändra klockkällan för LCD-styrenheten (och RTC-klockan också) måste du först återställa klockkällan genom att ställa in RTCRST-biten (inställning 1 till bit 23) i RCC_CSR-registret (kontroll-/statusregister). 
Registrera RCC_CSR (kontroll-/statusregister)
RCC->CSR |= RCC_CSR_RTCRST;
Eller genom att skriva ett värde till ett register med operatorn “|=”, eftersom värde av
standardregistret skiljer sig från 0x0:
RCC->CSR |= 0x800000; /* 0x800000 = 1000 0000 0000 0000 0000 0000 */
För att välja en ny klockkälla måste du ta bort RTCRST-biten:
RCC->CSR &= ~RCC_CSR_RTCRST; eller RCC->CSR &= ~0x800000;
En extern lågfrekvensgenerator väljs som klocksignalkälla. För att slå på generatorn i RCC_CSR-registret måste du ställa in LSEON-biten (ställ 1 till 8 bitar):
RCC->CSR |= RCC_CSR_LSEON; eller RCC->CSR |= 0x100; /* 0x100 = 1 000 0000 */
Efter att ha slagit på generatorn tar det lite tid att stabilisera den. Generatorns beredskap kontrolleras genom hårdvaruinställning av LSERDY-biten i RCC_CSR-registret:
while(!(RCC->CSR&RCC_CSR_LSERDY));
Valet av en extern lågfrekvensgenerator som klockkälla utförs genom att ställa in RCC_CSR-registret till 01 i RTCSEL-gruppen:
RCC->CSR |= RCC_CSR_RTCSEL_LSE; eller RCC->CSR |= 0x10000; /* 0x10000 = 01 0000 0000 0000 0000 */
I LCD-kontrollern måste du installera önskat läge partiskhet. För att göra detta måste du i LCD_CR-registret (LCD-kontrollregister) ställa in värdet 10 i BIAS-gruppen. Innan du installerar bitar är det nödvändigt att rensa bitarna från "skräp". 
Register LCD_CR (LCD-kontrollregister)
Återställ bitar:
LCD->CR &= ~LCD_CR_BIAS; eller LCD->CR &= ~0x60;
Välja bias=1/3-läge med hjälp av en bitmask:
LCD->CR |= LCD_CR_BIAS_1; eller LCD->CR |= 0x40;
Ställ in läget duty=1/4. För att göra detta återställer vi också först alla bitar:
LCD->CR &=~LCD_CR_DUTY; eller LCD->CR &= ~0x1C;
Ställ in värdet 011 till DUTY-gruppen i LCD_CR-registret för
mode duty=1/4:
LCD->CR |= LCD_CR_DUTY_0|LCD_CR_DUTY_1; eller LCD->CR |= 0xС;
Vi aktiverar funktionen för omplacering av stift. För att göra detta, ställ in 1 till 7 bitar av LCD_CR-registret:
LCD->CR |= LCD_CR_MUX_SEG; eller
Vi ställer in värdena för frekvensdelningskoefficienterna för LCDCLK-klocksignalen. Koefficientvärdena ställs in i LCD_FCR-registret (LCD-ramkontrollregister). Först rensar vi också alla bitar och ställer sedan in de nödvändiga. 
Register LCD_FCR (LCD ramkontrollregister)
LCD->FCR &= ~LCD_FCR_PS; LCD->FCR &= ~LCD_FCR_DIV; eller LCD->FCR &= ~0x3C00000; LCD->FCR &= ~0x3C0000;
Värdena för klocksignalens frekvensdelningskoefficienter sätts lika med ck_ps = LCDCLK/16, ck_div = ck_ps/17. För att göra detta, ställ in 1 till 24 och 18 siffror:
LCD->FCR |= 0x1040000; /*0x1040000 = 1 0000 0100 0000 0000 0000 0000*/
För att ställa in önskad kontrastnivå måste du ställa in värdet 010 i CC-gruppen, även först rensa bitarna från de gamla värdena:
LCD->FCR &= ~LCD_FCR_CC; LCD->FCR |= LCD_FCR_CC_1; eller LCD->FCR &= ~0x1C00; LCD->FCR |= 0x800; /*0x800 = 1000 0000 0000*/
Efter att ha ställt in alla värden tar det lite tid att synkronisera LCD_FCR-registret. Registersynkronisering kontrolleras genom att ställa in FCRSF-biten i hårdvara i LCD_SR (LCD-statusregister) registret.
Register LCD_SR (LCD-statusregister)
While(!(LCD->SR&LCD_SR_FCRSR));
Som spänningskälla för LCD-skärmen väljer vi en intern step-up-omvandlare för att bilda V lcd. För att göra detta sätts den första biten i LCD_CR-registret (LCD-kontrollregistret) till 0:
LCD->CR &= ~LCD_CR_VSEL; eller LCD->CR &= ~0x2;
LCD-styrenhetens funktion aktiveras genom att ställa in LCD_CR-registret (LCD-kontrollregister) biten till 0:
LCD->CR |= LCD_CR_LCDEN; eller LCD->CR |= 0x1;
Efter att ha installerat den interna step-up-omvandlaren som spänningskälla måste du vänta tills den är klar. Beredskapen kontrolleras genom hårdvaruinställning av RDY-biten i LCD_SR-registret (LCD-statusregister):
while(!(LCD->SR&LCD_SR_RDY));
När du har låtit LCD-kontrollenheten fungera måste du vänta tills den är klar. Beredskapen kontrolleras genom hårdvaruinställning av ENS-biten i LCD_SR-registret (LCD-statusregister):
while(!(LCD->SR&LCD_SR_ENS));
Bildandet av en bild på LCD-skärmen
Alla indikatorsegment kombineras i grupperna COM0 - COM3 med 24 segment vardera (SEG0-SEG23). Information om segment lagras i LCD_RAM-registren i LCD-styrenhetens minne. Kabeldragning tryckt kretskortär sådan att segmentnumren inte motsvarar bitnumren i LCD_RAM-registren.
För att visa 1 i den första siffran på LCD-skärmen måste du tända segmenten 1B, 1C. Segment 1B tillhör grupp COM0, segment 1C tillhör grupp COM1. Därför måste information om dem skrivas till RAM-registren (LCD_RAM0), RAM-registren (LCD_RAM2). Segment IB är ansvarigt för LCD-utgången LCDSEG22, om vilken information lagras i SEG40-biten i RAM-registret (LCD_RAM1). Genom att använda ommappningsfunktionen kommer segment LCDSEG22 att tilldelas bit SEG28 i RAM-registret (LCD_RAM0). 1C-segmentet är ansvarigt för LCD-utgången LCDSEG1, information om vilken lagras i SEG1-biten i RAM-registret (LCD_RAM2).
LCD->RAM= 0x10000000; /*0x10000000 = 1 0000 0000 0000 0000 0000 0000 0000 */ LCD->RAM = 0x2; /*0x2= 10 */
Innan du skriver värden till minnesregister är det nödvändigt att kontrollera om den tidigare dataöverföringen till LCD-skärmen har slutförts. För att göra detta kontrolleras UDR-biten (Update display request) i LCD_SR-registret (LCD-statusregister). LCD-styrenheten har två utgångsbuffertar, information matas in i den första bufferten och matas ut till LCD:n från den andra bufferten. UDR-biten ställs in under överföringen från den första bufferten till den andra, vilket skyddar LCD_RAM-registren från att skriva:
while(LCD->SR & LCD_SR_UDR);
Efter att ha skrivit information till LCD_RAM-registren måste du ställa in UDR-biten i LCD_SR-registret (LCD-statusregister) (ställ 1 till 2 bitar):
LCD->SR |= LCD_SR_UDR; eller LCD->SR |= 0x4; /*0x4 = 100 */
För att plåga och studera denna enhet. Inte tidigare sagt än gjort. Halsduken plockades ihop och vi gick. Åh ja! Ämnet för vårt samtal övergick till att jämföra de två riksdagsledamöterna. Den ovan är mot ATmega328. Varför just dem? Båda MK:erna är med i TQFP-32-paketet. (Det är sant, ATmega328 kommer också i ett DIP-paket)
Låt oss nu titta närmare på deras inre. För större förståelse har jag samlat all nödvändig data i en tabell.
| alternativ | ATmega328 | STM32F030K6T6 |
| Lite djup | 8 bitar | 32 bitar |
| BLIXT | 32 kb | 32 kb |
| SRAM | 1 kb | 4kb |
| EEPROM | 512b | - |
| Timer 8 bitar | 2 st | - |
| Timer 16 bitar | 1 st | 16 st |
| PWM | 3 kanaler | 6 kanaler |
| USART | 1 st | 1 st |
| SPI | 1 st | 1 st |
| I2C | 1 stycke (TWI) | 1 st |
| ADC | 8 kanaler 10 bitar | 16 kanaler 12 bitar |
| Näring | 2,7 - 5,5 | 2,4 - 3,6 |
| Fart | 0 - 16 MHz | 48MHz med extern 4 - 32MHz |
| Pris | 160 - 170 rub. | 80 - 140 rub. |
Schema. Större
Jag gjorde det här kortet som en modul för mitt felsökningskort för AVR. Men du kan upprepa det genom att dela ut tavlan efter eget gottfinnande (jag kommer att lägga upp ett projekt för DipTrace i slutet av artikeln). Vad står på diagrammet. Och diagrammet visar en enkel sele som för AVR. 8 MHz kvarts med två 20p kondensatorer. Precis som i AVR är strömförsörjningskretsen för ADC-stödet monterad. Återställ krets som AVR. Den enda skillnaden är BOOT-kretsen. Till skillnad från AVR:er har alla STM32:er en hårdvarubootloader ombord. Som standard är den ansluten till USART. Det vill säga, om du trycker på BOOT0-stiftet till strömförsörjningen och startar om MK:n, kan du sedan använda Flash Loader Demonstrator-programmet flasha MK:n utan en programmerare. Denna funktion användbart om du redan har en redo och fungerande enhet och behöver uppdatera firmware, då behöver du bara en USB USART-adapter. Många vill inte bråka med STM32 på grund av att strömförsörjningen inte är mer än 3,6 volt. Dumheter. Om du tittar på stiftbordet kommer du att märka att alla ben kan ta emot 5 volt utan konsekvenser. Låt oss gå vidare.
Och så här ser det ut installerat på tavlan.
Nu ansluter vi ST-LINK-GA-programmeraren till SWD-kontakten.
Nu när allt är klart, ladda ner den senaste versionen från ST:s hemsida (länk längst ner på sidan). Installera och starta.
Klicka på Nytt projekt. Och i fönstret som dyker upp hittar vi vår kontroller. Klicka på OK.
Efter lite funderande. Programmet kommer att visa ett fönster som detta.
Jag kommer inte att beskriva vad och varför, eftersom detta är ämnet för en separat artikel. Nu, till exempel, gör bara det jag visar dig. Vad gör vi. Vi kommer att lansera operativ system och i en enda tråd kommer vi att blinka lysdioden. Ett slags "Helojord" från en kanon.))) För att göra detta, i det vänstra fönstret, klicka på plustecknet bredvid inskriptionen "FREERTOS" och sätta en bock i rullgardinsmenyn.
Dessutom, så snart den externa kvartsen har valts, på höger sida av kontrollern kommer benen som du behöver hänga den på att markeras i grönt. Nästa sak du behöver göra är att välja det ben som lysdioden ska hänga på. Jag valde port B och stift 0. Och jag hittade en rake. Av rädsla, jag vet inte varför, vände jag upp och ner på utgångskammen på de fyra första stiften. Därav förvirringen på port B. Det här problemet påverkar bara min styrelse. Men ingenting, detta hindrade inte MK från att arbeta. Och så konfigurera stiftet. Faktum är att med STM kan alla stift anta ett gäng värden, men om du trycker på diskret ingång/utgång, så kan det finnas tre alternativ för utgången. Utgång i luften, utgång med pull-up till strömförsörjningen plus, utgång med pull-up till gemensam buss. Som standard hänger STM32CubeMX benet i luften. Tja, låt det vara, vi behöver bara kontrollera arbetet och demonstrera kraften i STM32. För att konfigurera benet måste du vänsterklicka på det och välja GPIO_Output i fönstret som visas. Om MK är för liten kan du vrida på hjulet och förstora det.)))
Nästa steg är att justera MK-klockningen. Faktum är att STM32 är väldigt otydligt i denna fråga. Till skillnad från AVR har STM32 kvarts vid ingången med en frekvens på 4 till 32 MHz, och på bussarna kan den överklockas till 48 MHz. Inuti MK finns ett mycket komplext klockningssystem, men STM32CubeMX kommer oss till hjälp igen. Gå till fliken Klockkonfiguration och konfigurera den som på bilden nedan.
Det är allt. Klicka på kugghjulsikonen högst upp.
Ett sådant här fönster kommer att dyka upp.
Och här glömde jag säga. Ladda ner och installera IAR själv. Den kan laddas ner från tjänstemännen men reduceras i mängden kod, eller kan hittas i torrents. Eller om du har mycket extra pengar kan du köpa en licens. Jo, jag tror att många kommer att följa vägen med CodeVisionAVR. I allmänhet överlåter jag detta till ditt gottfinnande. Jag har version 7.40. Låt oss återvända till kuben. Namnge projektet i fönstret, men bara på latin, IAR gillar inte ryska bokstäver i banor. Och ange var projektet ska lagras. I IDE-fönstret måste du välja (och det är som standard) EWARM. Klicka på OK. Programmet tänker och visar sedan ett sådant här fönster. Bla bla bla. I allmänhet, klicka på öppna projektet (för de som är i tanken, mittknappen).
Fönstret kommer att försvinna, och IAR och vårt projekt kommer att starta istället. Till vänster går du till Applikation->Användare och kör main.c. Det här gänget med kod är vad STM32CubeMX genererade åt oss.
Och vad ska man göra nu med denna skräck? Men för detta behöver vi en hel serie artiklar))) Och nu hittar vi bara denna kodbit.
Detta är vårt enda flöde. I kroppen för slinga(;;) vi tar bort den enda funktionen osDelay(1);, och skriver istället denna kod. HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_SET);
osDelay(500);
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_RESET);
osDelay(500);
Underbar. Nu är det bara att klicka på knappen med den gröna pilen uppe till höger och vänta på sammanställning och nedladdning.
Om allt är korrekt och utan fel, kommer programmet att montera hela projektet, skapa allt som behövs och ladda den fasta programvaran i MK. Efter detta går den in i felsökningsläge. Här är han. En AVR-mans dröm. Om du har en oemotståndlig önskan att använda den, kan du bara gå steg för steg på hårdvaran, rad för rad. Och om du vill se hur programmet fungerar, tryck sedan på krysset uppe till vänster och njut av att lysdioden blinkar.
Det är allt. Mikrokontroller kan köpas till det lägsta priset, så mycket som 78 rubel per styck i ChipResistor-butiken. Tja, om du vill ha det billigare, det finns också liten grossist. Från 35 stycken redan för 50 rubel.
Projekt för DipTrace.
Och videon förstås.
gäst 12/31/15 10:35
Nyligen ville jag göra en frekvensmätare på ATMEGA16 plus en extern 8-bitarsräknare på 74-logik, men det var inte tillräckligt snabbt. Jag kan inte hantera att skriva i assembler; att stängsla en extern räknare med 16 bitar är jobbigt. ass. AVR är det senaste århundradet, inte en billig kontroller. Jag kommer att stödja författaren, AVR är Stadiet har passerat, jag köpte också ett stm32f100-chip plus ett CP2103 USB-adapterchip, snart kommer alla att ge upp AVR.
Alexey 12/31/15 12:26
Jag håller inte med. Ändå är Arduino fortfarande under utveckling och många har fastnat för det, och den senare fungerar i sin tur på AVR. Att gå till STM är som att gå till nästa nivå. Så att säga från dagis till skola.
ANONYM 12.02.16 10:44
AVR och STM32 är processorer som inte konkurrerar med varandra. Din tallrik innehåller inte den viktigaste parametern - detta är strömförbrukningen!! Och när du tittar på dem kan du fälla en tår. Atmega 328 - – Aktivt läge: 0,2 mA – Avstängningsläge: 0,1 µA – Energisparläge: 0,75 µA (inklusive 32 kHz RTC) STM32F030K6T6 48 MHz - Aktivt läge: kringutrustning på 23,3 mA Stopp: 1 peripherals off 1 mA. 0,048 mA STM32 förbrukar el skoningslöst - grovt sett 100 gånger mer än AVR. Du kan inte driva en STM32-enhet från ett batteri. Men AVR:er kommer att fungera i månader. Så det är svårt att ge upp AVR. Lycka till allihopa.
Alexey 02/12/16 10:54
Och ingen föreslår att vi ska överge AVR. Jag visar bara skillnaden i periferin. Jag underhåller fortfarande AVR-biblioteket och har fortfarande en ATMega8A som min huvudsakliga MCU.
Sergey 24/02/16 18:02
Enligt min mening är det på något sätt konstigt att jämföra den fräscha STM32 med den pensionerade AVR. Om du vill jämföra STM32 med ATMEL-kontroller, jämför dem med ATSAM-familjen, men inte med AVR.
Andrey 24.02.16 18:06
Vem är denna pensionär? AVR lever och kommer att fortsätta leva vem vet hur länge. Och när man tittar på tabellen, enligt min mening är jämförelsen mer i periferin, och inte på arkitekturen.
Alexey 24.02.16 19:04
Det börjar väl. Låt oss nu diskutera AMD och Intel.
Sergey 24/02/16 22:02
På hubben skrev en "expert" att AVR inte har en parallellbuss för att ansluta en vanlig LCD-skärm, men STM32 har...
Alexey 24.02.16 22:36
Vad betyder standard LCD? Handlar det här om FSMC? Så detta är inte bara för displayen, det är också för minnet. Bara en parallellbuss. AVR har det också, till exempel Mega8515. SRAM kan anslutas till den via ett låsregister.
Sergets 25/02/16 06:24
Alexey, vad pratar jag om?! Det verkar som att du inte ens försöker förstå innebörden av mina meddelanden.
Alexey 25/02/16 09:38
Tja, vad är poängen med att jämföra två identiska mikrokontroller från olika företag? Båda är på ARM-kärnan. Om du verkligen är kräsen måste du verkligen jämföra AVR med STM8. Jag fastnade då för närheten till periferin, formfaktor och pris. Och bara annorlunda arkitektur.
Adlan 03.06.16 17:40
Hallå. Hjälp, snälla, vem kan. Installerad senaste versionen Kuba 4.15, F1-bibliotek 1.4.0. Det skapade tomma projektet i EWARM kompilerar inte - det finns mer än hundra fel. Vad kunde det vara? Tack [e-postskyddad]
Alexey 06/03/16 20:48
Adlan, det första du behöver göra är att ladda upp ett projekt som inte kommer att kompileras.
Dok 18/07/16 21:51
"Det är sant att AVR har Arduino och enkel programmering." VAD kan han skryta om? ;D
Alexey 19/07/16 11:41
Det här är en dum jämförelse. För det första har STM en analog av Arduino som kallas nucleo. Program skrivs i online-IDE direkt via webbläsaren. Men om fördelarna med stenen personligen, då. Kärndriftsfrekvensen är 72 MHz, AVR kunde inte ens drömma om en sådan hastighet. Visst, om du blinkar med lysdioden, så är det ingen skillnad, men om du startar axeln och en massa kringutrustning kommer AVR:n att blåsa bort. Bitkapacitet, 32 är långt ifrån 8. Kringutrustning på STM kan innehålla 3 I2C, 3 SPI, 6 UART, USB, CAN, Ethernet. Nästan allt har förmågan att ommappas, det vill säga överföras till andra ben av mk. Det finns även DMA, detta är en oberoende samprocessor för att arbeta med kringutrustning. Så AVR-avbrotten ryker nervöst på sidlinjen. Det finns en hårdvaru-SDIO för fullvärdigt arbete med CD-kort, och inte en krycka ISP i AVR. I allmänhet finns det mycket mer där, men den största stenen i AVR:s trädgård är bullerimmunitet. Att slå ut AVR med en kabel som löper i närheten från elmotorn är en enkel sak, men STM måste provas. Så jag skulle inte rekommendera att vara sarkastisk med Arduino.
gäst 08/11/16 23:27
MICROCHIP absorberad AVR!)))))))))))
Alexey 08/12/16 08:35
Vi var sena med nyheterna, som för fem år sedan.
Vladimir 17/08/16 22:56
Alexei! I januari 2016 köpte Microchip Atmel för 3,56 miljarder dollar. Vilka 5 år?
Alexey 18/08/16 10:30
Detta är de jure, men de facto har det pågått sedan 2008. Så jag gjorde verkligen ett misstag, inte för 5 år, utan för 8 år sedan.))))
Vladimir 18/08/16 23:53
Alexey! Jag började byta till stm32! Och när det gäller förbrukning i autonomt läge, råder han att inte klocka allt, då kommer förbrukningsströmmen att minska.
Oleg 09.11.16 22:31
I databladet på STM:n hittade jag inga grafer över systemklockans CLK-förbrukning som i AVR - och enligt de skyltar som finns där tappar STM32 direkt både i normalt läge och i viloläge. Ja, och denna STM32 har inte en klocka på 72 MHz - bara 48 max, det är allt, så även med 32 bitar 8 beatnik AVR - blir det bättre, och förresten, tillverkaren i databladet skrev inte hur många klockcykler i STM32-maskincykeln den har, så om det visar sig vara 2 klockcykler mot 1 för AVR - tänk då på att 48/2 = 24 verkliga MHz - nästan samma som 20 MHz för AVR. Så frågan är - var är miraklet med denna STM32 som ni alla pratar om?
ANONYM 09.11.16 23:03
Alexey 11/10/16 00:23
Jag vill inte ens argumentera. Vilket är bättre Intel eller AMD? Eller Zhiguli eller Volga? STM har hårdvara USB, CAN, Ethernet, SDIO och en massa annan kringutrustning som AVR bara kan drömma om. I slutändan finns det en DMA som en oberoende coprocessor med direkt minnesåtkomst framför vilken alla AVR-avbrott nervöst ryker på sidlinjen. Till exempel har den första serien 3 UART, 2 SPI, 3 I2C ombord. Det finns en omkarta över portar och du behöver inte oroa dig för hur du tar isär kortet. Om du gillar att arbeta med AVR, arbeta den som stör dig. Än idag tjänar jag mega åttondelar för små projekt och klagar inte. Åh ja, sätt in AVR bredvid startmotorn och se hur den blåser av huvudet med störningar. AVR har inte EMI-skydd. Därför installerades alltid PIK i billarm, eftersom AVR dör under sådana förhållanden. Varför argumentera, det är ett dött nummer.
Kornett 27.11.16 21:22
Jo, förresten, det finns redan en Arduino på STM32. Det här är Amperka och alla sorters Espruino i JS) Dessutom, om mikrochippet togs av Atmel, ja, skruva på dem
Alexey 27.11.16 21:44
Namnet Espruino parodierar Arduino, den mest kända hobbyplattformen på den tiden, men Espruino är inte kompatibel med klassikern Arduino Uno varken mekaniskt eller programmatiskt.(citat från Amperka)
Jag har också en Nucleo-bräda och den har inte heller något med Arduino att göra, förutom geometrin på själva brädan)))
I allmänhet använder jag i huvudsak den MK som är lämplig för den aktuella uppgiften.
Andrey 12/20/16 22:50
Vem gillar att betala för mycket: det är värt attiny2313-20 - 2Kb-flash /128bit-ram/16bit_ timer -1/8bit_ timer -1 =2.1$ vs stm32f103c8t6 64Kb-flash/20Kb-sram/16BIT timer för dual dead time control (+ dead time control) -kanals PWM-läge ) -4/ADC-2/72MHz CPU/=2.3$. Enligt min mening är det nästan omöjligt att göra en impedansmätare för en RLC-krets med hjälp av en AVR, eller så finns det 10 stenar. Men du kan göra den med STM och FFT (DMA hjälper).Jag provade på något sätt göra en frekvensmätare på Mega10 (noggrannhet 1 hertz) - den var helt enkelt inte tillräckligt snabb (eller installera en extern 32-bitarsräknare med ett skiftregister - där måtten Jag gav upp AVR för ett år sedan, AVR är, visar det sig, för rika människor.
Andrey 12/20/16 22:53
ANONYM skrev - "Och här är ett annat citat från beskrivningen av STM32 på ryska - "...Med
ögonblick
tar emot
avbryter
innan
satte igång
avrättning
först
lag
hanterare
avbryter
är förbrukad
endast
tolv
cykler
klocka
signal"
Detta är sant, men multiplicera två 32-bitars tal med avr - helt klart 8-10 klockcykler!
Alexey 20/12/16 23:31
Ja, jag ångrar redan att denna halivar började.))))
Alexander 21/12/16 00:27
Jag läste kommentarerna och kom ihåg.
Två barn i sandlådan
En duduka!
För det andra, pip!
Först, Duduka! (intonationen mer hotfull)
För det andra, BIBIKA! (Med ännu mer uttrycksfull intonation)
Den första DUDUKA! (skriker redan)
Andra BIBIKA!!! (Nästan gråter)
....
Denna strid är över, båda står och gråter, den ena högre än den andra.)))
Val 02/10/17 01:43
Vilken frekvens blir det om du loopar utan fördröjning?
medan (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å låt oss omedelbart integrera bärbara datorer i inbyggda system, de är hundratals gånger bättre än STM, och det finns bara en jäkla massa kringutrustning där, det finns redan Wi-Fi och bluetooth och till och med programmerare behövs inte, direkt finns det en bildskärm med ett tangentbord för att skriva ett program och köra omedelbart, och programmerare och debuggers behövs inte.
Det är som att köpa en grävmaskin för personligt bruk i din dacha för att IBLAND gräva ett par hål på en halv meter djupa.
Att sätta STM i en termostat, klocka, våg, ja, enligt mig är det inte normalt. Förresten ja, vad sägs om icke-flyktigt minne, så jag gör en termostat, ställer in temperaturen, sedan slocknar lamporna, så vad, inställningarna går förlorade. Men i inbyggda system som måste konfigureras en gång för vidare drift, måste värdena sparas för alltid
Alexey 06/09/17 08:25
Tja, till exempel kostar STM32F030F4P6 chip-dip 48 rubel, och den direkta analogen ATtiny2313 kostar 98 rubel. Jag tror att någon av dem kommer att räcka för att bygga en termostat. Och minneskompensation för STM kan finnas i vilken temperatursensor som helst. Ja, åtminstone i samma DS18B20. När det gäller bärbara datorer har alla terminaler för betalningsacceptans en PC installerad med ett OS och en bildskärm. Så det finns till och med sådana system. När du väljer en MK, välj först och främst den som är billigare. Om det här är en hobby så kan du köpa en Arduino för att inte besvära dig med lödning, och när systemet är planerat att sättas i produktion och produceras i hundratal, då räknas varenda krona. Och att överbetala 50 rubel för en MK när priset är 48 är en oöverkomlig lyx.
Ruslan 17/06/17 21:46
Alexey, varför valde du IAR-programmeringsmiljön?
Vilken miljö är bättre för en nybörjare att välja (så att det finns många tips som i Atmel Studio)?
Alexey 17/06/17 22:07
Ruslan 17/06/17 22:56
Om jag inte såg "dåligt ut", ge mig då en länk där jag kan titta eller läsa hur man gör!Ännu bättre, gör en video, jag tror att många nybörjare (och inte bara) kommer att vara intresserade av att se den!
Tack på förhand!
Alexey 08/05/17 10:19
Ruslan 22.11.17 12:17
Jag menade detta https://www.youtube.com/watch?v=wOIlhRd-vN8
5-7 minuter!!!
Ruslan 22.11.17 12:18
Alexey, snälla berätta för mig hur man arbetar med "enum"-uppräkningar, annars finns det ingen sådan information någonstans och i dina videor finns inte heller "C för de små", men jag behöver det verkligen!
När jag lekte med AVR:er hade jag aldrig sett ett sådant mirakel som uppräkning, men nu är jag intresserad av STM:er, och det finns många av dem! Och det finns ingen information om hur man arbetar med dem!
Här är ett exempel från riktig kod:
StatusCode MIFARE_Read(byte blockAddr, byte * buffert, byte * bufferSize);
Var är uppräkningen av StatusCode:
enum StatusCode: byte (
STATUS_OK , // Framgång
STATUS_ERROR , // Fel i kommunikationen
STATUS_COLLISION , // Kollision upptäckt
STATUS_TIMEOUT , // Timeout i kommunikation.
STATUS_NO_ROOM , // En buffert är inte tillräckligt stor.
STATUS_INTERNAL_ERROR , // Internt fel i koden. Borde inte hända ;-)
STATUS_INVALID , // Ogiltigt argument.
STATUS_CRC_WRONG , // CRC_A matchar inte
STATUS_MIFARE_NACK = 0xff // En MIFARE PICC svarade med NAK.
};
Det här är från Arduino-biblioteket (C++), men Keil svär på det!
Hur man korrekt skriver returen av en uppräkningsfunktion?
Ruslan 22.11.17 12:29
Och hur man deklarerar ett av argumenten i en funktion som är en uppräkning:
void PCD_WriteRegister(PCD_Register reg, bytevärde);
Där PCD_Register är listat:
enum PCD_Register: byte (
// Sida 0: Kommando och status
// 0x00 // reserverad för framtida 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
...
};
Och reg, som jag förstår det, är en uppräkning, men den deklareras inte någonstans i koden och jag förstår inte var den kom ifrån!
Jag läste många sidor på Internet och hittade information om att dessa uppräkningar kan ersättas med definitioner, men jag ville ändå veta hur man arbetar med dem!!!
Ruslan 22.11.17 12:35
Jag ser fram emot ditt svar!
Kanske gör en video om hur man arbetar med dem, så att det fungerar för andra, jag tror att videon kommer att vara väldigt användbar eftersom det inte finns några sådana videos (åtminstone jag har inte hittat dem)!
Dmitry 28.11.17 22:02
"enkel programmering"
Ett intressant organ för programmering av kontroller. I allmänhet är det inte klart hur det var möjligt att jämföra 32-bitars med 8-bitars. Som en Porsche Cayenne med Zarporozhets.
Alexey 29/11/17 10:24
Du kan jämföra, du kan. Du behöver bara ta hänsyn till att i denna jämförelse är Porsche billigare än Zaporozhets. När det gäller urologi är det mer pikant. Så jag fixar det inte.
Konstantin 12/23/17 00:06
Ruslan, jag förstår inte hur du söker och inte hittar någonting (uppenbarligen letar du inte). Dessa är själva grunderna i C-språket (inte bara för MKs, utan även för datorer). Läs boken av Kernighan och Ritchie, hela C är perfekt beskrivet där.
Och ingen kommer att svara på dina frågor, det här är elementära grejer.
ANONYM 11.02.18 16:27
Varför jämför du 32-bitars ST MK med 8-bitars Atmel. Dum jämförelse. Det motsvarar att jämföra 32-bitars Atmel AT91SAM med 8-bitars STM8, även med tanke på att Atmel har 32 ännu kraftfullare urladdare
Alexey 13/02/18 12:18
För i skrivande stund fanns inte 8-bands ST till rea, och mega och STM32 har samma pris.
STM32_Dev 06/19/19 13:59
Tja, AVR tar 4-5 klockcykler för att göra samma sak!!! Bara. Och här visar det sig igen att AVR är gjord bättre än STM32, med sin uppblåsta klocka, och STM32 har inte ett EEPROM inuti som AVR
AVR-klocka på 16 MHz - 1/16000000 = 0,0000000625 s = 62,5 ns * 5 klockor = 312,5 ns.
ARM-klocka vid 48 MHz - 1/48000000 = 0,0000000208 s = 20,8 ns * 12 klockor = 250 ns.
Det verkar som att museets atmega räknar sina 5 klockcykler längre än STM32:s 12 klockcykler)))
Har STM32 inte en eprom? Säker? STM32L152 - 8kB eprom! Hur är det med atmega? 512 byte? Åh så många!!! Jag vet inte ens vad jag ska skriva där. Låt oss tänka... mmm... 16 variabler på 4 byte vardera)) Tja, det är bara ett åskväder bland styrenheter))
SIM31 30/06/19 19:29
När det gäller konsumtion kan du också jämföra, de nya atmega och attiny är mycket ekonomiska.
Och allt har sin användning. Om du behöver ström, ta en Raspbery Pi 4 och oroa dig inte, Python har ännu fler möjligheter, till och med konfigurera en fullfjädrad webbserver, till och med kör Quake 3D.
Om du behöver bearbeta dataströmmar finns det ett snällt (se projektet "Mars Rover" "Mars Rover 2")
Författaren har massor av positiva saker, men det faktum att Arduina är mer levande än alla levande gör att allt inte är så enkelt.
I många år har radioamatörer använt åttabitars mikrokontroller från PIC- och AVR-familjerna. De är populära på grund av deras låga pris, detaljerade dokumentation, enkla programmering och enkla installation. Men ganska ofta finns det fall då kraften hos en sådan mikrokontroller inte räcker för att lösa uppgiften. Det enklaste exemplet är en frekvensmätare eller signalgenerator på en mikrokontroller, där den maximala uppmätta eller genererade frekvensen direkt beror på hastigheten för bearbetning eller utmatning av information.
Förutom hastighet har åttabitars mikrokontroller andra begränsningar, till exempel har många AVR-modeller bara en seriell hårdvaruport, som inte tillåter att ta emot information från en extern enhet och samtidigt skicka resultatet av dess bearbetning till konsumenten. För att inte tala om sådana "banala" saker som att visa information på en grafisk indikator, vilket kräver stora resurser av både hastighet och minne. Efter att ha analyserat ett antal sådana begränsningar kom författaren på idén att byta till mikrokontroller i STM32-familjen.
Tänk till exempel på två mikrokontroller i samma priskategori - STM32F103C6 och ATmega328P.
bord 1
| Typ av mikrokontroller | ||
| Processorstorlek | ||
| Blydelning, mm | ||
| Klockfrekvens, MHz | ||
| FLASH minnesvolym. KB | ||
| Mängd RAM, KB | ||
| USART nummer | ||
| Antal 16-bitars timer | ||
| Antal I/O-linjer | ||
| Ungefärligt pris, gnugga. |
Deras jämförande parametrar anges i tabell. 1. Jämförelseresultaten är till och med något överraskande. En 32-bitars mikrokontroller är inte bara kraftfullare än en åttabitars mikrokontroller i nästan alla avseenden, utan den är också billigare. Naturligtvis är det inte så lätt att löda en mikrokontroller med en stiftdelning på 0,5 mm hemma. Lyckligtvis är detta i de flesta fall inte nödvändigt - det finns många typer av utvecklingskort med STM32-familjens mikrokontroller på marknaden, tillräckligt för olika applikationer. Låt oss titta på dem mer i detalj.
STM32F4-DISCOVERY
Detta kort (visat i fig. 1) är kanske det mest bekväma för nybörjare som studerar STM-mikrokontroller. För det första har den en stor uppsättning kringutrustning. Utöver mikrokontrollern innehåller kortet en mikroelektromekanisk accelerometer, en mikrofon, en ljud-DAC, två USB-kontakter, en knapp och fyra lysdioder.
Mikrokontrollerstiften förs ut på kontaktdynor för montering av stiftkontakter på kortets vänstra och högra kant, vilket gör det enkelt att ansluta alla nödvändiga externa enheter till dem. Mikrokontrollern STM32F407VGT6 installerad på kortet har mycket bra parametrar: 1 MB FLASH-minne, 192 KB RAM och en klockfrekvens på 168 MHz.
Slutligen är kortet utrustat med en inbyggd ST-LINK/V2 debugger, som kan användas för att felsöka program inte bara på mikrokontrollern på kortet, utan även på mikrokontroller av samma familj som finns på andra kort. Byte till dem görs med hjälp av en avtagbar bygel och SWD-kontakten.
Priset på brädan är cirka 800 rubel, vilket kan anses vara ganska acceptabelt.
STM32F103RBT6 Utvecklingskort
Nästa intressanta alternativ är ett utvecklingskort med en STM32F103RBT6 mikrokontroller (Fig. 2).
Det är något svagare än det som installerades på det tidigare kortet - en klockfrekvens på 72 MHz, 128 KB FLASH-minne och 20 KB RAM, men kringutrustningen är mycket intressant. Det finns en TFT-pekskärm med en upplösning på 320x240 pixlar och en diagonal på 2,8", en inbyggd USB-port för utbyte av information med en dator, en plats för ett SD-minneskort, en 32768 Hz kvartsklocka, ett fack för en realtidsklockabatteri och en ST-LINK-kontakt för felsökning av program.
Priset på detta bräde är också cirka 800 rubel, men det bör noteras att det inte har en inbyggd debugger. För att ladda ner program måste du antingen köpa en separat ST-LINK debugger eller använda STM32F4-DISCOVERY-kortet som diskuterats ovan istället
Lönn Mini
Den externa likheten mellan detta kort (fig. 3) med de välkända Arduino-modulerna är slående. Och detta är ingen slump.
Maple Mini-brädet designades som en ersättning för Arduino Nano. Programmeringsspråket och utvecklingsmiljön för AVR-familjen av mikrokontroller installerade i Arduino har anpassats till STM-familjen. Gå till http://leaflabs.com/docs/maple-q uickstart.html för detaljerad information om Maple IDEs programmeringsspråk och utvecklingsmiljö.
Utvecklingskortet har en STM32F103CBT6 mikrokontroller som körs på 72 MHz, 128 KB FLASH-minne och 20 KB RAM, vilket utan tvekan är mer än någon Arduino-modul. Och det är ännu mer av ett plus att utvecklingsmiljön har varit praktiskt taget oförändrad.
Separat noterar vi att trots sin miniatyrstorlek tillhandahåller Maple Mini mycket olika kringutrustning: 34 I/O-linjer, två SPI- och två I2C-gränssnittskanaler, tre seriella portar. Detta gör att den framgångsrikt kan användas i olika amatörutvecklingar. Tack vare sin lilla storlek kan Maple Mini byggas in direkt i enheten som utvecklas.
Den ursprungliga Maple Mini-brädet kan köpas för $35 på utvecklarnas webbplats. Frakt kommer att kosta ytterligare $5. En kopia av tavlan tillverkad i Kina kommer att kosta hälften så mycket.
programvara
Det finns flera alternativ för utvecklingsmiljöer som kan användas för att förbereda program för mikrokontroller i STM32-familjen:
Kommersiell IAR Embedded Workbench, AtollicTrueSTUDIO, Keil, etc. Dessa fullfjädrade produkter är ganska dyra, med ett licenspris från 1 000 euro, men det finns också gratis demoversioner med en begränsning av volymen av programmet som utvecklas, för de flesta enkla projekt de är ganska tillräckligt;
Den kostnadsfria Eclipse med ARM-GCC-kompilatorn kräver icke-trivial konfiguration av kompilatorn före användning. Det enda pluset för idag är förmågan att arbeta inte bara i Windows utan även i Linux;
Gratis CooCox IDE (CoIDE) baserat på samma Eclipse-redigerare. Laddar och felsöker program via ST-LINK. Till skillnad från det tidigare alternativet kräver CoIDE inga speciella inställningar och fungerar direkt efter installationen. Det här alternativet är det mest bekväma och är värt att använda.
Låt oss använda CooCox IDE för att skapa ett exempelprogram för STM32F4-DISCOVERY-kortet som implementerar den klassiska LED-blinkningen av det första programmet för vilken mikrokontroller som helst. Det finns fyra lysdioder på STM32F4-DIS-COVERY-kortet, de är anslutna till stiften PD12-PD15 på mikrokontrollern. Låt oss få dem att blinka växelvis.
Steg 1. Starta utvecklingsmiljön CoIDE och skapa ett projekt. Från rullgardinsmenyn som visas i fig. 4, välj STM32F407VG mikrokontroller.
Steg 2. Som visas i Fig. 5, välj de komponenter som kommer att användas i projektet. De viktigaste är GPIO (input-output), C Library (grundläggande funktioner i C-språket) och M4 Core (processorkärnfunktioner). När du aktiverar en komponent kopierar CoIDE automatiskt de nödvändiga filerna till projektmappen, vilket är väldigt bekvämt.
Steg 3. Mata in programtext. Den är ganska kort och anges i tabellen. 2.
Som du kan se är allt enkelt och självklart. De som har skrivit program för AVR-mikrokontroller kommer förmodligen att se välbekanta konstruktioner - initiering av portar som indikerar riktningen (ingång eller utgång), huvudslingan där de nödvändiga åtgärderna utförs. I allmänhet motsvarar programmets syntax helt C-språket, för vilket det finns mer än tillräckligt med litteratur. Det finns också en hel del artiklar om programmering för STM32 på Internet. Många exempel medföljer utvecklingskortet och kan även användas som prov.
Efter att ha skrivit in programtexten genom att klicka på skärmknappen "Ladda ner för att blixt" laddas den ner till mikrokontrollern. Lysdioderna på kortet börjar blinka. Separat är det värt att notera felsökningsmöjligheterna - en brytpunkt kan ställas in var som helst i programmet, du kan köra programmet steg för steg, se värdena för variabler.
Naturligtvis är detta exempel inte idealiskt. Du kan till exempel använda timeravbrott för att styra blinkandet av lysdioder, vilket frigör huvudprogramslingan för andra uppgifter. De som vill kan reda ut detta på egen hand.
Slutsats
I allmänhet, efter den första bekantskapen, lämnade mikrokontrollerna i STM32-familjen ett mycket trevligt intryck. Allt visade sig inte vara så komplicerat, och bekvämligheten med utvecklingsmiljön, felsökningsprocessen och ett stort antal standardfunktioner påminde till och med något om övergången från Ms DOS till Windows - de allmänna punkterna verkar vara desamma, men allt är mycket bekvämare och mer funktionell.
Men den största nackdelen med den här familjen för amatörutveckling är fortfarande den för lilla stiftstigningen. Att designa och löda en bräda med en stiftdelning på 0,5 mm hemma är en mycket icke-trivial uppgift. Men till nuvarande priser är felsökningskort med redan monterade mikrokontroller ganska tillgängliga för alla radioamatörer.
Är det värt att konvertera allt till STM och 32-bitars arkitektur? Självklart inte. Det finns uppgifter som ATtiny är helt tillräckliga för. Men för att till exempel analysera spektrumet i en hemmagjord SDR-mottagare eller ta emot och överföra stora mängder information över ett nätverk, är det mycket effektivare att omedelbart använda en kraftfull mikrokontroller för att inte stöta på brist på minne eller prestanda när förbättra enheten.
Baserat på Cortex-kärnan började de aktivt vinna popularitet bland både professionella och nybörjare utvecklare av enheter på mikrokontroller. Det finns flera anledningar till detta:
- lågt pris jämfört med konkurrenterna;
- ett stort antal inbyggda gränssnitt;
- enkel programmering och hög tillförlitlighet.
Men det finns också en viktig nackdel - alla STM-mikrokontroller tillverkas inte i DIP-paket, vilket ofta helt enkelt skrämmer bort nybörjare, eftersom det är problematiskt att göra en bräda med spår mindre än 0,3 mm hemma. Detta tillstånd har lett till att ett stort antal felsökningskort har dykt upp på marknaden, både från ST Microelectronics (Discovery) och kort som producerats av tredjepartsföretag (Olimex, Pinboard). Jag valde Discovery av tre anledningar:
- relativt lågt pris (brädet kan köpas från 300 rubel);
- bra utförande (även om det finns några klagomål på ledningarna, men de är inte så betydande);
- många källor och exempel publiceras på tillverkarens webbplats;
- närvaron av en inbyggd programmerare (du behöver inte köpa den separat).
Syftet med den första lektionen är att hjälpa en nybörjare att välja ett felsökningskort, och i framtiden - att lära ut grunderna i programmering.
Låt oss gå.
STM32F0DISCOVERY
Det här kortet släpptes i februari 2012 för att locka utvecklare som tidigare hade använt 8-bitars mikrokontroller och därmed fyllt denna nisch. Jag kan inte säga något dåligt eller bra om henne. En vanlig styrelse, billig, är bra för att komma igång. Har följande egenskaper:
- mikrokontroller: STM32F051R8T6 (Cortex M0, 48 MHz, flash 64 KB, RAM 8 KB);
- inbyggd ST-link/V2, som kan användas separat från kortet;
- drivs från USB eller från en extern 3/5V-källa;
- 4 lysdioder och 2 knappar;
- gränssnitt: USART, SPI, I2C, HDMI;
- timers 16 och 32 bitar;
- alla utgångar dirigeras till två enkelradiga kammar.
Egentligen är en sådan bräda redan ganska föråldrad, och det rekommenderas att ta den bara i början av träningen.
STM32VLDITT
Det skiljer sig från det tidigare kortet endast i STM32F100RBT6B-processorn (Cortex M3, 24 MHz, flash 128 KB, RAM 8 KB) och layouten på de perifera kammarna. Precis som den som diskuterades ovan är den lämplig för nybörjarutvecklare. Det finns inget mer att säga om henne.
STM32LDISCOVERY
STM32LDISCOVERY är en värdig vidareutveckling av den tidigare styrelsen. Här är det som är intressant med det:
- mikrokontroller STM32L152RBT6 (Cortex M3, 32 MHz, flash 128Kb, RAM 8Kb, EEPROM 4Kb)
- gränssnitt: USB, USART, SPI, I2C;
- 8 timers;
- 24-kanals 12-bitars ADC;
-12-bitars DAC;
- riktig tids klocka;
- LCD-kontroller 8x40
- inbyggd ST-link/V2.
Följande är installerade på tavlan:
- LCD-skärm 24x8;
- 4 lysdioder;
- 2 knappar;
- pektangentbord;
- 2 enkelradiga kammar med fria ledningar.
Jag skulle vilja säga separat om USB: kontrollern stöder USB 2.0 full hastighet, värd och enhetslägen, vilket sällan ses i en MK av denna klass.
Faktum är att brädet är det bästa alternativet för att arbeta med Cortex-M3-kärnan, så du kan säkert ta det, eftersom priset är lågt.
STM32F3DISCOVERY
STM32F3DISCOVERY tillhör nästa generations utvecklingskort från STM och har följande egenskaper:
- mikrokontroller STM32F303VCT6 (Cortex M4, 72 MHz, flash 256 KB, RAM 48 KB)
- riktig tids klocka;
- inbyggd ST-link/V2;
- 13 timers;
- 12-kanals DMA-kontroller;
- 4 ADC:er;
- 4 operationsförstärkare;
- gränssnitt: CAN, USB 2.0, USART/UART, SPI, I2C;
- 87 GPIO-linjer.
- anpassad USB-port;
- 3-axlig accelerometer och 3-axlig geomagnetisk sensor i ett hus;
- 3-axligt gyroskop;
- 10 lysdioder;
- 2 knappar;
- 2 dubbelradiga kammar.
En mycket intressant tavla, många möjligheter till experiment. Generellt sett är åsikten om den fortsatt god, men dess fokus på att spåra det fysiska tillståndet och positionen minskar utrymmet för experiment avsevärt, även om du enkelt kan göra en expansionskort själv.
Jag hade möjligheten att arbeta med den här styrelsen mest, och jag gillade den mer än de andra - dess omfattande fokus påverkade den.
Så här är det:
- mikrokontroller STM32F407VGT6 (Cortex M4, 168 MHz, flash 1 MB, RAM 192 KB)
- inbyggd ST-link/V2;
- timers;
- DMA-kontroller;
- ADC/DAC;
- gränssnitt: CAN, USB 2.0, USART/UART, SPI, I2C, GPIO;
Tavlan innehåller följande kringutrustning:
- anpassad USB-port;
- 3-axlig accelerometer;
- 8 lysdioder;
- 2 knappar;
- 2 dubbelradiga kammar;
- ljud-DAC med klass D-förstärkare;
- rundstrålande digital mikrofon.
Som jag skrev ovan blev den här brädan den viktigaste för mig; jag var nöjd med förmågan att arbeta med ljud och accelerometern.
Ytterligare lektioner kommer att baseras på denna tavla.
Sammanfattning.
Om du bestämmer dig för att börja arbeta med STM-felsökningskort, råder jag dig att ta STM32F4DISCOVERY, enligt min mening har den störst funktionalitet. Ytterligare artiklar kommer att baseras specifikt på att arbeta med det. Artiklar kommer att skrivas om följande ämnen inom en snar framtid:
- arbeta med GPIO, timers, avbrott, etc.;
- arbeta med UART, SPI, I2C och 1-wire gränssnitt med hjälp av exempel på verkliga enheter, såsom displayer, GPS och GSM moduler, temperatursensorer, kommunikation med en dator via RS-232 och mycket mer.
Det slutliga målet med denna cykel är att skapa ett expansionskort för STM32F4. All firmware och kretsscheman kommer att vara allmänt tillgängliga.
