AVR Microcontroller. Mga LED Flasher Gamit ang Timer. Nakagambala ang Mga timer. Timer CTC Mode: 6 na Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Kamusta po kayo lahat!

Ang timer ay isang mahalagang konsepto sa larangan ng electronics. Ang bawat elektronikong sangkap ay gumagana sa isang batayan sa oras. Nakakatulong ang base ng oras na ito upang mapanatili ang lahat ng trabaho na naka-synchronize. Ang lahat ng mga microcontroller ay gumagana sa ilang paunang natukoy na dalas ng orasan, lahat sila ay may probisyon upang mag-set up ng mga timer. Ipinagmamalaki ng AVR na magkaroon ng isang timer na kung saan ay napaka-tumpak, tumpak at maaasahan. Nag-aalok ito ng maraming mga tampok dito, kaya ginagawa itong isang malawak na paksa. Ang pinakamagandang bahagi ay ang timer ay ganap na independiyente sa CPU. Sa gayon, tumatakbo ito kahilera sa CPU at walang interbensyon ng CPU, na ginagawang tumpak ang timer. Sa seksyong ito ipinapaliwanag ko ang pangunahing mga konsepto ng Mga Timer ng AVR. Sumusulat ako ng simpleng programa sa C code upang makontrol ang LED flasher, gamit ang mga timer.

Hakbang 1: Paglalarawan

Sa ATMega328 mayroong tatlong uri ng timer:

Timer / Counter0 (TC0) - ay isang pangkalahatang layunin 8-bit Timer / Counter module, na may dalawang independiyenteng OutputCompare Units, at suporta ng PWM;

Timer / Counter1 (TC1) - Pinapayagan ng unit ng 16-bit Timer / Counter na tumpak na oras ng pagpapatupad ng programa (pamamahala ng kaganapan), pagbuo ng alon, at pagsukat ng tiyempo ng signal;

Timer / Counter2 (TC2) -is isang pangkalahatang layunin, channel, 8-bit Timer / Counter module na may PWM at Asynchronous Operation;

Hakbang 2: Pahayag ng Suliranin 1: Mag-flash muna tayo (berde) Tuwing 50 Ms

Pamamaraan:

- Paggamit ng isang Timer0 prescaler upang mabawasan ang isang mataas na dalas ng de-koryenteng signal sa isang mas mababang dalas ng integer division;

- Paggamit ng isang nakakagambala sa tuwing umaapaw ang Timer0;

Timer0 (8 bit) binibilang ito mula 0 hanggang 255 pagkatapos nito, umapaw ang mga ito, nagbabago ang halagang ito sa bawat pulso ng orasan.

F_CPU = 16MHz: Oras ng oras ng orasan = 1000ms / 16000000Hz = 0.0000625ms

Bilang ng timer = (Kinakailangan na Pag-antala / Oras ng Oras ng Orasan) -1 = (50ms / 0.0000625ms) = 799999

Ang orasan ay nai-tick 799999 beses upang magbigay ng isang pagkaantala ng 50 ms lamang!

Maaari naming gamitin ang diskarteng dibisyon ng dalas ay tinatawag na prescaling upang bawasan ang bilang ng timer. Inaalok sa amin ng AVR ang mga sumusunod na halaga ng prescaler upang pumili mula sa: 8, 64, 256 at 1024. Tingnan ang talahanayan na nagbubuod ng mga resulta ng paggamit ng iba't ibang mga prescaler.

Ang halaga ng counter ay dapat palaging isang integer. Pumili tayo ng isang prescaler 256!

Sa karamihan ng mga microcontroller, mayroong tinatawag na Interrupt. Ang pagkakagambala na ito ay maaaring matanggal sa tuwing natutugunan ang ilang mga kundisyon. Ngayon tuwing ang isang pagkagambala ay pinaputok, ang AVR ay tumitigil at nai-save ang pagpapatupad nito ng pangunahing gawain, dumadalo sa makagambalang tawag (sa pamamagitan ng pagpapatupad ng isang espesyal na gawain, na tinatawag na Interrupt Service Routine, ISR) at kapag tapos na ito, bumalik sa pangunahing gawain at patuloy na isinasagawa ito.

Dahil ang kinakailangang pagkaantala (50ms) ay mas malaki kaysa sa maximum na posibleng pagkaantala: 4, 096ms = 1000ms / 62500Hz * 256, malinaw na ang timer ay mag-uumapaw. At tuwing umaapaw ang timer, ang isang nakakagambala ay pinaputok.

Gaano karaming beses dapat tanggalin ang nagagambala?

50ms / 4.096ms = 3125/256 = 12.207 Kung ang timer ay umapaw ng 12 beses, 12 * 4.096ms = 49.152ms ay maaaring lumipas. Sa ika-13 na pag-ulit, kailangan namin ng pagkaantala ng 50ms - 49.152ms = 0.848ms.

Sa dalas ng 62500Hz (prescaler = 256), ang bawat tick ay tumatagal ng 0.016ms. Kaya upang makamit ang isang pagkaantala ng 0.848ms, mangangailangan ito ng 0.848ms / 0.016ms = 53 ticks. Kaya, sa ika-13 na pag-ulit, pinapayagan lamang namin ang timer na bilangin hanggang sa 53, at pagkatapos ay i-reset ito.

Simulan ang Timer0 / Counter (tingnan ang larawan):

TCCR0B | = (1 << CS02) // set up timer with prescaler = 256 TCNT0 = 0 // initialize counter TIMSK0 | = (1 << TOIE0) // paganahin ang overflow makagambala sei () // paganahin ang mga pandaigdigang pagkagambala tot_overflow = 0 // ipasimula ang variable ng overflow counter

Hakbang 3: Pahayag ng Suliranin 2: Mag-flash tayo ng Pangalawang LED (asul) Tuwing 1s

Pamamaraan:

- Paggamit ng isang Timer1 prescaler upang mabawasan ang isang mataas na dalas ng signal ng elektrikal sa isang mas mababang dalas ng dibisyon ng integer;

- gamit ang Clear Timer on Compare (CTC) Mode;

- Paggamit ng Nakagambala sa CTC Mode;

Timer1 (16 bit) binibilang ito mula 0 hanggang 65534 pagkatapos nito, umaapaw sila. Nagbabago ang halagang ito sa bawat pulso ng orasan.

F_CPU = 16MHz: Oras ng oras ng orasan = 1000ms / 16000000Hz = 0.0000625msTimer count = (Kinakailangan na Pag-antala / Panahon ng Oras ng Oras) -1 = (1000ms / 0.0000625ms) = 15999999

Ang orasan ay nai-tick nang 15999999 beses upang magbigay ng isang pagkaantala ng 1s!

Maaari naming gamitin ang diskarteng dibisyon ng dalas ay tinatawag na prescaling upang bawasan ang bilang ng timer. Inaalok sa amin ng AVR ang mga sumusunod na halaga ng prescaler upang pumili mula sa: 8, 64, 256 at 1024. Tingnan ang talahanayan na nagbubuod ng mga resulta ng paggamit ng iba't ibang mga prescaler. Ang halaga ng counter ay dapat palaging isang integer. Pumili tayo ng isang prescaler 256!

Sa Clear timer sa Compare (CTC) mode, ginagamit ang rehistro ng OCR1A o ICR1 upang manipulahin ang resolusyon ng counter. Sa mode ng CTC ang counter ay malinis sa zero kapag ang counter halaga (TCNT1) ay tumutugma sa alinman sa OCR1A o ICR1. Tinutukoy ng OCR1A o ICR1 ang nangungunang halaga para sa counter, samakatuwid din ang resolusyon nito. Pinapayagan ng mode na ito ang higit na kontrol ng ihambing ang dalas ng output ng tugma Pinapasimple din nito ang pagpapatakbo ng pagbibilang ng mga panlabas na kaganapan. Dapat nating sabihin sa AVR na i-reset ang Timer1 / Counter sa sandaling ang halaga nito ay umabot sa halaga 62500, sa gayon upang makamit ang isang pagkaantala ng 1s.

Simulan ang Timer1 / Counter (tingnan ang larawan):

TCCR1B | = (1 << WGM12) | (1 << CS12) // set up timer with prescaler = 256 and CTC mode TCNT1 = 0 // initialize counter TIMSK1 | = (1 << OCIE1A) // paganahin ang ihambing ang abala OCR1A = 62500 // ipasimula ang halaga ng paghahambing

Hakbang 4: Pahayag ng Suliranin 3: Mag-flash tayo ng Third LED (pula) Tuwing 16ms

Pamamaraan:

- Paggamit ng isang Timer2 prescaler upang mabawasan ang isang mataas na dalas ng de-koryenteng signal sa isang mas mababang dalas ng dibisyon ng integer;

- gamit ang Clear Timer on Compare (CTC) Mode;

- Paggamit ng Hardware CTC Mode nang walang nakakagambala;

Timer2 (8 bit) binibilang ito mula 0 hanggang 255 pagkatapos nito, umaapaw sila. Nagbabago ang halagang ito sa bawat pulso ng orasan.

F_CPU = 16MHz: Oras ng oras ng orasan = 1000ms / 16000000Hz = 0.0000625ms

Bilang ng timer = (Kinakailangan na Pag-antala / Oras ng Oras ng Orasan) -1 = (16ms / 0.0000625ms) = 255999

Ang orasan ay nai-tick nang 255999 beses upang magbigay ng isang pagkaantala ng 16ms!

Tingnan ang talahanayan na nagbubuod ng mga resulta ng paggamit ng iba't ibang mga prescaler. Ang halaga ng counter ay dapat palaging isang integer. Pumili tayo ng isang prescaler 1024!

Sa mode ng CTC ang counter ay nalilimas sa zero kapag ang counter halaga (TCNT2) ay tumutugma sa alinman sa OCR2A o sa ICR2. Ang Pin PB3 din ang Output Compare pin ng TIMER2 - OC2A (tingnan ang diagram).

Pagrehistro ng Timer / Counter2 Control A - TCCR2A Bit 7: 6 - COM2A1: 0 - Ihambing ang Output Mode para sa Paghambingin ang Unit A. Dahil kailangan naming i-toggle ang LED, pipiliin namin ang pagpipilian: I-toggle ang OC2A sa Paghambingin ng Tugma Sa tuwing magaganap ang isang tugma, ang Ang pin ng OC2A ay awtomatikong na-toggle. Hindi kailangang suriin ang anumang flag bit, hindi na kailangang dumalo sa anumang mga nakakagambala.

Pasimulan ang Timer2 / Counter

TCCR2A | = (1 << COM2A0) | (1 << WGM21) // i-set up ang timer OC2A pin sa toggle mode at CTC mode TCCR2B | = (1 << CS22) | (1 << CS21) | (1 << CS20) // set up timer na may prescaler = 1024 TCNT2 = 0 // ipasimuno ang counter OCR2A = 250 // ipasimula ang ihambing na halaga

Hakbang 5: Pagsulat ng Code para sa isang Program sa C. Pag-upload ng HEX File Sa Microcontroller Flash Memory

Pagsulat at pagbuo ng aplikasyon ng AVR microcontroller sa C Code gamit ang Integrated Development Platform - Atmel Studio.

Tinutukoy ng F_CPU ang dalas ng orasan sa Hertz at karaniwan ito sa mga program na gumagamit ng avr-libc library. Sa kasong ito ginagamit ito ng mga gawain sa pagkaantala upang matukoy kung paano makalkula ang mga pagkaantala sa oras.

#ifndef F_CPU

#define F_CPU 16000000UL // sinasabi sa dalas ng kristal ng controller (16 MHz AVR ATMega328P) #endif

#include // header upang paganahin ang kontrol ng daloy ng data sa mga pin. Tinutukoy ang mga pin, port, atbp.

Ang unang isama ang file ay bahagi ng avr-libc at gagamitin sa halos anumang proyekto sa AVR na iyong pinagtatrabahuhan. Tutukuyin ng io.h ang CPU na iyong ginagamit (kung kaya't tinukoy mo ang bahagi kapag nag-iipon) at kasama namang isama ang naaangkop na header ng kahulugan ng IO para sa chip na ginagamit namin. Tinutukoy lamang nito ang mga pare-pareho para sa lahat ng iyong mga pin, port, espesyal na rehistro, atbp.

#include // header upang paganahin ang makagambala

pabagu-bago ng isip uint8_t tot_overflow; // global variable upang mabilang ang bilang ng mga overflow

Pamamaraan ng Pahayag ng Suliranin: Flash Una (Green) LED bawat 50 ms

- Paggamit ng isang Timer0 prescaler upang mabawasan ang isang mataas na dalas ng de-koryenteng signal sa isang mas mababang dalas ng dibisyon ng integer;

- Paggamit ng isang nakakagambala sa tuwing umaapaw ang Timer0;

void timer0_init () // initialize timer0, makagambala at variable

{TCCR0B | = (1 << CS02); // set up timer with prescaler = 256 TCNT0 = 0; // initialize counter TIMSK0 | = (1 << TOIE0); // paganahin ang overflow nterrupt sei (); // paganahin ang mga pandaigdigang nakakagambala tot_overflow = 0; // ipasimula ang variable ng overflow counter}

Pamamaraan ng Pahayag ng Suliranin: Flash Pangalawang LED (asul) tuwing 1s

- Paggamit ng isang Timer1 prescaler upang mabawasan ang isang mataas na dalas ng signal ng elektrikal sa isang mas mababang dalas ng dibisyon ng integer;

- gamit ang Clear Timer on Compare (CTC) Mode;

- Paggamit ng Nakagambala sa CTC Mode;

void timer1_init () // initialize timer1, interrupt and variable {TCCR1B | = (1 << WGM12) | (1 << CS12); // set up timer with prescaler = 256 and CTC mode TCNT1 = 0; // initialize counter OCR1A = 62500; // ipasimula ihambing ang halaga TIMSK1 | = (1 << OCIE1A); // paganahin ang ihambing makagambala}

Pamamaraan ng Pahayag ng Suliranin: Flash pangatlong LED (pula) bawat 16ms

- Paggamit ng isang Timer2 prescaler upang mabawasan ang isang mataas na dalas ng de-koryenteng signal sa isang mas mababang dalas ng dibisyon ng integer;

- gamit ang Clear Timer on Compare (CTC) Mode;

- Paggamit ng Hardware CTC Mode nang walang nakakagambala;

void timer2_init () // initialize timer2 {TCCR2A | = (1 << COM2A0) | (1 << WGM21); // set up timer OC2A pin sa toggle mode at CTC mode TCCR2B | = (1 << CS22) | (1 << CS21) | (1 << CS20); // set up timer with prescaler = 1024 TCNT2 = 0; // initialize counter OCR2A = 250; // ipasimula ihambing ang halaga}

Ang pag-overflow ng TIMER0 ay nakakagambala sa gawain sa serbisyo na tinatawag tuwing umaapaw ang TCNT0:

ISR (TIMER0_OVF_vect)

{tot_overflow ++; // subaybayan ang bilang ng mga umaapaw}

Ang ISR na ito ay pinaputok tuwing may nagaganap na tugma mula rito, ang toggle ay pinangunahan dito mismo:

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

int main (walang bisa)

{DDRB | = (1 << 0); // ikonekta ang 1 (berde) na humantong sa pin PB0 DDRC | = (1 << 1); // ikonekta ang 2 (asul) na humantong sa pin PC1 DDRB | = (1 << 3); // ikonekta ang 3 (pula) na humantong sa pin PB3 (OC2A) timer0_init (); // initialize timer0 timer1_init (); // initialize timer1 timer2_init (); // initialize timer2 habang (1) // loop magpakailanman {

Kung ang Timer0 ay umapaw nang 12 beses, 12 * 4.096ms = 49.152ms ay maaaring lumipas. Sa ika-13 na pag-ulit, kailangan namin ng pagkaantala ng 50ms - 49.152ms = 0.848ms. Kaya, sa ika-13 na pag-ulit, pinapayagan lamang namin ang timer na bilangin hanggang sa 53, at pagkatapos ay i-reset ito.

kung (tot_overflow> = 12) // suriin kung hindi. ng overflows = 12 TANDAAN: '> =' ang ginamit

{if (TCNT0> = 53) // suriin kung ang bilang ng timer ay umabot sa 53 {PORTB ^ = (1 << 0); // toggles the led TCNT0 = 0; // reset counter tot_overflow = 0; // reset overflow counter}}}}

Pag-upload ng HEX file sa microcontroller flash memory:

i-type sa DOS prompt window ang utos:

avrdude –c [pangalan ng programmer] –p m328p –u –U flash: w: [pangalan ng iyong hex file] Sa aking kaso ito ay: avrdude –c ISPProgv1 –p m328p –u –U flash: w: Timers.hex

Nagsusulat ang utos na ito ng hex file sa memorya ng microcontroller. Panoorin ang video na may detalyadong paglalarawan ng microcontroller flash memory burn:

Nasusunog ang memory ng microcontroller flash…

Ok! Ngayon, gumagana ang microcontroller alinsunod sa mga tagubilin ng aming programa. Tignan natin!

Hakbang 6: Paggawa ng Electrical Circuit

Ikonekta ang mga sangkap alinsunod sa diagram ng eskematiko.