AVR-microcontroller. LED's Flasher met behulp van timer. Timers worden onderbroken. Timer CTC-modus: 6 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

Dag iedereen!

Timers is een belangrijk begrip op het gebied van elektronica. Elk elektronisch onderdeel werkt op tijdbasis. Deze tijdbasis helpt om al het werk gesynchroniseerd te houden. Alle microcontrollers werken op een vooraf gedefinieerde klokfrequentie, ze hebben allemaal een voorziening om timers in te stellen. AVR kan bogen op een timer die zeer nauwkeurig, nauwkeurig en betrouwbaar is. Het biedt heel veel functies, waardoor het een uitgebreid onderwerp wordt. Het beste is dat de timer volledig onafhankelijk is van de CPU. Het loopt dus parallel aan de CPU en er is geen tussenkomst van de CPU, waardoor de timer behoorlijk nauwkeurig is. In dit gedeelte leg ik de basisconcepten van AVR Timers uit. Ik schrijf een eenvoudig programma in C-code om de LED-flitser te bedienen, met behulp van timers.

Stap 1: Beschrijving:

In ATMega328 zijn er drie soorten timers:

Timer/Counter0 (TC0) - is een 8-bits Timer/Counter-module voor algemeen gebruik, met twee onafhankelijke OutputCompare Units en PWM-ondersteuning;

Timer/Counter1 (TC1) - De 16-bit Timer/Counter-eenheid maakt nauwkeurige timing van programma-uitvoering (gebeurtenisbeheer), golfopwekking en signaaltimingmeting mogelijk;

Timer/Counter2 (TC2) - is een 8-bits timer/tellermodule voor algemeen gebruik met PWM en asynchrone werking;

Stap 2: Probleemstelling 1: Laten we de eerste LED (groen) elke 50 Ms knipperen

Methodologie:

- het gebruik van een Timer0-prescaler om een hoogfrequent elektrisch signaal te reduceren tot een lagere frequentie door gehele deling;

- elke keer dat de Timer0 overloopt een interrupt gebruiken;

Timer0 (8 bit) het telt van 0 tot 255 daarna lopen ze over, deze waarde verandert bij elke klokpuls.

F_CPU=16MHz: Kloktijd = 1000ms / 16000000Hz = 0.0000625ms

Timertelling = (Vereiste vertraging / kloktijdperiode)-1 = (50ms / 0.0000625ms) = 799999

De klok heeft al 799999 keer getikt om een vertraging van slechts 50 ms te geven!

We kunnen de techniek van frequentieverdeling gebruiken, prescaling genoemd om het aantal timers te verlagen. De AVR biedt ons de volgende prescaler-waarden om uit te kiezen: 8, 64, 256 en 1024. Zie de tabel met een samenvatting van de resultaten van het gebruik van verschillende prescalers.

De tellerwaarde moet altijd een geheel getal zijn. Laten we een prescaler 256 kiezen!

In de meeste microcontrollers is er iets dat Interrupt wordt genoemd. Deze interrupt kan worden geactiveerd wanneer aan bepaalde voorwaarden is voldaan. Wanneer nu een interrupt wordt afgevuurd, stopt de AVR en slaat de uitvoering van de hoofdroutine op, neemt de interrupt-oproep af (door een speciale routine uit te voeren, de Interrupt Service Routine, ISR genoemd) en keert hij terug naar de hoofdroutine en gaat door met het uitvoeren ervan.

Aangezien de vereiste vertraging (50 ms) groter is dan de maximaal mogelijke vertraging: 4, 096 ms = 1000 ms / 62500 Hz * 256, zal de timer natuurlijk overlopen. En telkens wanneer de timer overloopt, wordt er een interrupt afgevuurd.

Hoe vaak moet de interrupt worden afgevuurd?

50 ms / 4,096 ms = 3125 / 256 = 12,207 Als de timer 12 keer is overgelopen, zou 12 * 4,096 ms = 49,152 ms zijn verstreken. In de 13e iteratie hebben we een vertraging van 50 ms nodig - 49,152 ms = 0,848 ms.

Bij een frequentie van 62500 Hz (prescaler = 256) duurt elke tick 0,016 ms. Dus om een vertraging van 0,848 ms te bereiken, zou er 0,848 ms / 0,016 ms = 53 tikken nodig zijn. Dus in de 13e iteratie laten we de timer alleen tot 53 tellen en resetten deze vervolgens.

Initialiseer Timer0/Counter (zie foto):

TCCR0B |= (1 << CS02) // timer instellen met prescaler = 256 TCNT0 = 0 // teller initialiseren TIMSK0 |= (1 << TOIE0) // overflow interrupt inschakelen sei() // global interrupts inschakelen tot_overflow = 0 // initialiseer de overlooptellervariabele

Stap 3: Probleemstelling 2: Laten we de tweede LED (blauw) elke 1s knipperen

Methodologie:

- het gebruik van een Timer1-prescaler om een hoogfrequent elektrisch signaal te reduceren tot een lagere frequentie door gehele deling;

- de Clear Timer on Compare (CTC)-modus gebruiken;

- Interrupts gebruiken met CTC-modus;

Timer1 (16 bit) het telt van 0 tot 65534 daarna lopen ze over. Deze waarde verandert bij elke klokpuls.

F_CPU=16MHz: Kloktijdperiode = 1000ms / 16000000Hz = 0.0000625ms Timertelling = (Vereiste vertraging / Kloktijdperiode)-1 = (1000ms / 0.0000625ms) = 15999999

De klok heeft al 15999999 keer getikt om een vertraging van 1s te geven!

We kunnen de techniek van frequentieverdeling gebruiken, prescaling genoemd om het aantal timers te verlagen. De AVR biedt ons de volgende prescaler-waarden om uit te kiezen: 8, 64, 256 en 1024. Zie de tabel met een samenvatting van de resultaten van het gebruik van verschillende prescalers. De tellerwaarde moet altijd een geheel getal zijn. Laten we een prescaler 256 kiezen!

In de modus Clear timer on Compare (CTC) wordt het OCR1A- of ICR1-register gebruikt om de tellerresolutie te manipuleren. In de CTC-modus wordt de teller op nul gezet wanneer de tellerwaarde (TCNT1) overeenkomt met de OCR1A of de ICR1. De OCR1A of ICR1 bepalen de topwaarde voor de teller, dus ook de resolutie. Deze modus biedt meer controle over de uitgangsfrequentie van de vergelijkingsovereenkomst. Het vereenvoudigt ook de werking van het tellen van externe gebeurtenissen. We moeten de AVR vertellen om de Timer1/Teller te resetten zodra de waarde 62500 bereikt, om zo een vertraging van 1s te bereiken.

Initialiseer Timer1/Teller (zie foto):

TCCR1B |= (1 << WGM12)|(1 << CS12) // timer instellen met prescaler = 256 en CTC-modus TCNT1 = 0 // teller initialiseren TIMSK1 |= (1 << OCIE1A) // inschakelen vergelijken interrupt OCR1A = 62500 // initialiseer vergelijkingswaarde

Stap 4: Probleemstelling 3: Laten we de derde LED (rood) elke 16 ms knipperen

Methodologie:

- het gebruik van een Timer2-prescaler om een hoogfrequent elektrisch signaal te reduceren tot een lagere frequentie door gehele deling;

- de Clear Timer on Compare (CTC)-modus gebruiken;

- hardware CTC-modus gebruiken zonder onderbrekingen;

Timer2 (8 bit) het telt van 0 tot 255 daarna lopen ze over. Deze waarde verandert bij elke klokpuls.

F_CPU=16MHz: Kloktijd = 1000ms / 16000000Hz = 0.0000625ms

Timertelling = (Vereiste vertraging / kloktijdperiode)-1 = (16ms / 0.0000625ms) = 255999

De klok heeft al 255999 keer getikt om een vertraging van 16ms te geven!

Zie de tabel met een samenvatting van de resultaten van het gebruik van verschillende prescalers. De tellerwaarde moet altijd een geheel getal zijn. Laten we een prescaler 1024 kiezen!

In de CTC-modus wordt de teller op nul gezet wanneer de tellerwaarde (TCNT2) overeenkomt met de OCR2A of de ICR2. Pin PB3 is ook de Output Compare-pin van TIMER2 - OC2A (zie diagram).

Timer/Counter2 Control Register A – TCCR2A Bit 7:6 – COM2A1:0 – Compare Output Mode for Compare Unit A. Aangezien we de LED moeten omschakelen, kiezen we de optie: OC2A op Compare Match schakelen Telkens wanneer een vergelijkingsovereenkomst plaatsvindt, wordt de OC2A-pin wordt automatisch omgeschakeld. U hoeft geen vlagbit te controleren, u hoeft zich niet bezig te houden met onderbrekingen.

Timer2 / Teller initialiseren

TCCR2A |= (1 << COM2A0)|(1 << WGM21) // timer OC2A-pin instellen in toggle-modus en CTC-modus TCCR2B |= (1 << CS22)|(1 << CS21)|(1 << CS20) // timer instellen met prescaler = 1024 TCNT2 = 0 // teller initialiseren OCR2A = 250 // vergelijkingswaarde initialiseren

Stap 5: Code schrijven voor een programma in C. HEX-bestand uploaden naar het flashgeheugen van de microcontroller

Schrijven en bouwen van de AVR-microcontroller-applicatie in C Code met behulp van het Integrated Development Platform - Atmel Studio.

F_CPU definieert de klokfrequentie in Hertz en is gebruikelijk in programma's die de avr-libc-bibliotheek gebruiken. In dit geval wordt het gebruikt door de vertragingsroutines om te bepalen hoe tijdvertragingen moeten worden berekend.

#ifndef F_CPU

#define F_CPU 16000000UL // vertellende controller kristalfrequentie (16 MHz AVR ATMega328P) #endif

#include // header om gegevensstroomcontrole over pinnen in te schakelen. Definieert pinnen, poorten, enz.

Het eerste include-bestand maakt deel uit van avr-libc en wordt gebruikt in vrijwel elk AVR-project waaraan u werkt. io.h bepaalt de CPU die je gebruikt (daarom specificeer je het onderdeel bij het compileren) en neemt op zijn beurt de juiste IO-definitieheader op voor de chip die we gebruiken. Het definieert eenvoudig de constanten voor al uw pinnen, poorten, speciale registers, enz.

#include // header om interrupt in te schakelen

vluchtige uint8_t tot_overflow; // globale variabele om het aantal overlopen te tellen

Methodologie van probleemstelling: Eerste (groene) LED knipperen om de 50 ms

- het gebruik van een Timer0-prescaler om een hoogfrequent elektrisch signaal te reduceren tot een lagere frequentie door gehele deling;

- elke keer dat de Timer0 overloopt een interrupt gebruiken;

void timer0_init() // initialiseer timer0, interrupt en variabele

{ TCCR0B |= (1 << CS02); // timer instellen met prescaler = 256 TCNT0 = 0; // initialiseer teller TIMSK0 |= (1 << TOIE0); // schakel overflow nterrupt sei(); // globale interrupts inschakelen tot_overflow = 0; // initialiseer overlooptellervariabele}

Methodologie van probleemstelling: flits de tweede LED (blauw) elke 1s

- het gebruik van een Timer1-prescaler om een hoogfrequent elektrisch signaal te reduceren tot een lagere frequentie door gehele deling;

- de Clear Timer on Compare (CTC)-modus gebruiken;

- Interrupts gebruiken met CTC-modus;

void timer1_init() // initialiseer timer1, interrupt en variabele {TCCR1B |= (1 << WGM12)|(1 << CS12); // timer instellen met prescaler = 256 en CTC-modus TCNT1 = 0; // initialiseer teller OCR1A = 62500; // initialiseer vergelijk waarde TIMSK1 |= (1 << OCIE1A); // inschakelen vergelijken interrupt}

Methodologie van probleemstelling: flits de derde LED (rood) elke 16 ms

- het gebruik van een Timer2-prescaler om een hoogfrequent elektrisch signaal te reduceren tot een lagere frequentie door gehele deling;

- de Clear Timer on Compare (CTC)-modus gebruiken;

- hardware CTC-modus gebruiken zonder onderbrekingen;

void timer2_init() // initialiseer timer2{ TCCR2A |= (1 << COM2A0)|(1 << WGM21); // stel timer OC2A-pin in in toggle-modus en CTC-modus TCCR2B |= (1 << CS22)|(1 << CS21)|(1 << CS20); // timer instellen met prescaler = 1024 TCNT2 = 0; // initialiseer teller OCR2A = 250; // initialiseer vergelijk waarde}

TIMER0 overlooponderbrekingsserviceroutine aangeroepen wanneer TCNT0 overloopt:

ISR(TIMER0_OVF_vect)

{ tot_overloop++; // houd het aantal overlopen bij }

Deze ISR wordt geactiveerd wanneer er een match plaatsvindt, dus schakel de led hier zelf in:

ISR (TIMER1_COMPA_vect){ PORTC ^= (1 << 1); // toggle led hier}

int hoofd(void)

{ DDRB |= (1 << 0); // sluit 1 (groen) ledje aan op pin PB0 DDRC |= (1 << 1); // sluit 2 (blauwe) leds aan op pin PC1 DDRB |= (1 << 3); // sluit 3 (rode) leds aan op pin PB3 (OC2A) timer0_init(); // initialiseer timer0 timer1_init(); // initialiseer timer1 timer2_init(); // initialiseer timer2 while (1) // loop forever {

Als de Timer0 12 keer is overgevlogen, zou 12 * 4,096 ms = 49,152 ms zijn verstreken. In de 13e iteratie hebben we een vertraging van 50 ms nodig - 49,152 ms = 0,848 ms. Dus in de 13e iteratie laten we de timer alleen tot 53 tellen en resetten deze vervolgens.

if (tot_overflow >= 12) // controleer of nee. van overlopen = 12 OPMERKING: '>=' wordt gebruikt

{if (TCNT0 >= 53) // controleer of het aantal timers 53 bereikt {PORTB ^= (1 << 0); // schakelt de led TCNT0 = 0; // reset teller tot_overflow = 0; // reset overloopteller } } } }

HEX-bestand uploaden naar het flashgeheugen van de microcontroller:

typ in het DOS-promptvenster de opdracht:

avrdude –c [naam van programmeur] –p m328p –u –U flash:w:[naam van je hex-bestand] In mijn geval is dat: avrdude –c ISPProgv1 –p m328p –u –U flash:w:Timers.hex

Deze opdracht schrijft een hex-bestand naar het geheugen van de microcontroller. Bekijk de video met een gedetailleerde beschrijving van het branden van flashgeheugen van de microcontroller:

Microcontroller-flashgeheugen branden…

OK! Nu werkt de microcontroller volgens de instructies van ons programma. Laten we het bekijken!

Stap 6: Het elektrische circuit maken

Componenten aansluiten volgens schema.