Ilang oras na ang nakalipas nag-publish kami ng higit pang impormasyon tungkol sa millis() function de ArduinoNgayon ay susuriin natin nang mas malalim ang Arduino Timer, upang makapagsimula sa feature na ito para sa feature, unawain kung paano pinamamahalaan ng board na ito ang oras sa MCU, pati na rin ang iba pang mga function na lampas sa millis().
Ano ang Arduino Timer?
El Arduino timer, o timer, ay isang function na ipinatupad ng hardware (sa microcontroller, sa tulong ng quartz crystal na bumubuo ng mga pulso ng orasan at nagtatakda ng "ritmo", nang hindi nangangailangan ng panlabas na hardware o ICs 555) na nagpapahintulot sa pagkontrol sa mga pansamantalang kaganapan salamat sa mga orasan panloob. Halimbawa, ang paggawa ng isang gawain sa mga pagitan, paggawa ng tumpak na mga sukat ng oras, atbp., nang hiwalay sa sketch code.
Isipin na ginagamit mo ang delay() function, haharangan nito ang execution sa Arduino MCU hanggang sa lumipas ang tinukoy na oras at pagkatapos ay magpatuloy sa programa, ngunit ang timer ay hindi haharang. Magiging timing ito habang ang MCU ay patuloy na nagsasagawa ng iba pang mga tagubilin nang sabay-sabay. Iyan ang malaking kalamangan.
Ang timer ay nauugnay sa mga pagkagambala ng Arduino, dahil sila ay isasagawa sa pamamagitan ng mga ito upang dumalo sa ilang partikular na gawain. Sa madaling salita, ang Arduino Timer ay isang function na na-trigger sa isang tiyak na oras, na nagpapatupad ng isang interrupt na function. Kaya naman mahalagang malaman ang tungkol sa mga pagkaantala na ito.
Mga mode
Ang Arduino Timer ay mayroon 2 operating mode, na magagamit ito sa:
- PWM signal: Maaari mong kontrolin ang Arduino pin (~).
- CTC (I-clear ang timer sa paghahambing ng tugma): binibilang ang oras sa loob ng isang counter at kapag naabot nito ang halaga na tinukoy sa isang rehistro ng mga timer, ang pagkaantala ay isasagawa.
Ilang timer mayroon ito? Mga Uri ng Timer
doon 3 timer sa mga plato Arduino UNO, bagama't maaaring may higit pa sa iba pang mga top plate:
- timer 0: 8-bit, maaaring mabilang mula 0 hanggang 255 (256 posibleng halaga). Ginagamit ng mga function tulad ng delay(), millis(), at micros(). Ang pagbabago nito ay hindi inirerekomenda upang hindi mabago ang mga programa.
- timer 1: katumbas ng Timer 0. Ginamit ng Servo library sa UNO (Timer 5 para sa MEGA).
- timer 2: 16-bit, at maaaring mula 0 hanggang 65.525 (65.536 na posibleng halaga). Ginagamit para sa tone() function, kung hindi ginagamit, malaya itong magagamit para sa iyong aplikasyon.
- Timer 3, 4, 5 (sa Arduino MEGA lang): lahat ng 16-bit.
Paano gumagana ang Arduino Timer?
Sa gumana sa isang Arduino Timer, mahalagang malaman kung paano gumagana ang lahat ng ito sa elektronikong paraan sa MCU ng development board na ito:
- Kadalasan ng orasan: ay ang bilang ng mga cycle sa bawat segundo na ito ay may kakayahang bumuo, sa kaso ng Arduino ito ay 16 Mhz, o kung ano ang pareho, ang signal ng orasan ay nag-oscillates ng 16.000.000 beses sa isang segundo (cycle).
- panahon: ay kinakatawan ng T, at sinusukat sa mga segundo, at ito ang kabaligtaran ng mga cycle. Halimbawa, T=1/C, na magreresulta sa 1/16000000 = 0.0000000625, ang oras na aabutin para makumpleto ang bawat cycle. At ang dalas ay ang kabaligtaran ng panahon, kaya f = 1/T.
- Ikot: ay ang bawat isa sa mga pag-uulit ng signal na nangyayari sa bawat yunit ng oras. Sa Arduino ito ay magiging 16M sa isang segundo. O kung ano ang pareho, sa kasong ito, kapag lumipas ang 16 milyong cycle, lumipas ang isang segundo. Samakatuwid, ang isang cycle ay masasabing kukuha ng 625 ns.
- gilid ng isang signal: Ang mga signal ng orasan ay parisukat, at ang mga gilid ay maaaring tumaas o bumaba. Ang gilid ay ang tuwid na linya ng signal kapag nagbago ito mula sa:
- 0 (mababa) hanggang 1 (mataas): tumataas na gilid.
- 1 (mataas) hanggang 0 (mababa): bumabagsak na gilid.
Mahalaga ang mga gilid dahil sinusukat ng mga timer ng Arduino ang mga cycle mula sa mga gilid ng signal. A) Oo ang contador ito ay dumadami sa bawat cycle at kapag naabot nito ang halaga ng rehistro, ang interrupt ay isasagawa.
Samakatuwid, kapag alam mo na ito, kung mayroon ka 16Mhz sa Arduino MCU, at gumamit ng 8-bit na Timer, masasabing magaganap ang mga interrupt tuwing 16 μs (256/16000000) o 4 ms para sa 16-bit (65536/16000000). Samakatuwid, kung itinakda mo ang 16-bit na counter register sa maximum, na may halagang 65535, pagkatapos ay magaganap ang interrupt sa 4 ms upang maisagawa ang anumang gawain nito.
Kapag naabot ng counter ang pinakamataas na posibleng halaga, babalik ito sa 0 muli. Iyon ay, ang isang overflow ay nangyayari at ito ay bibilang pabalik mula sa simula.
Upang makontrol ang rate ng pagtaas ng timer maaari mo ring gamitin isang prescaler, na kumukuha ng mga halaga 1, 8, 64, 256 at 1024 at binabago ang timing tulad nito:
Bilis ng Timer (Hz) = Dalas ng Orasan ng Arduino / Prescaler
Kung ito ay 1 ang prescaler ang controller ay tataas sa 16 Mhz, kung ito ay 8 hanggang 2 Mhz, kung ito ay 64 hanggang 250 kHz, at iba pa. Tandaan na magkakaroon ng timer counter state comparator upang ihambing ang halaga ng counter at ang prescaler hanggang sa magkapantay ang mga ito at pagkatapos ay magsagawa ng isang aksyon. Kaya, dalas ng interrupt ay ibinigay ng formula:
Interrupt Speed (Hz) = Arduino / Prescaler Clock Frequency (comparator register value + 1)
Sa kabutihang palad, hindi tayo dapat baguhin ang mga talaan ng Arduino Timers, dahil aalagaan ito ng mga library na ginagamit namin sa code. Ngunit kung hindi sila ginagamit, dapat silang i-configure.
Mga halimbawa sa Arduino IDE
Upang mas maunawaan ang lahat ng ito, narito ako ay nagpapakita ng dalawang sketch code para sa Arduino IDE kung saan maaari mong maranasan ang paggamit ng mga timer. Ang una ay ang code na magpapapikit ng LED na konektado sa Arduino pin 8 bawat segundo:
#define ledPin 8
void setup()
{
pinMode(ledPin, OUTPUT);
// Configurar Timer1
TCCR1A = 0; //Registro control A a 0, pines OC1A y OC1B deshabilitados
TCCR1B = 0; //Limpia el registrador
TCCR1B |= (1<<CS10)|(1 << CS12); //Configura prescaler a 1024: CS12 = 1 y CS10 = 1
TCNT1 = 0xC2F8; //Iniciar timer para desbordamiento a 1 segundo
//65536-(16MHz/1024/1Hz - 1) = 49912 = 0xC2F8 en hexadecimal
TIMSK1 |= (1 << TOIE1); //Habilitar interrupción para Timer1
}
void loop()
{
}
ISR(TIMER1_OVF_vect) //Interrupción del TIMER1
{
TCNT1 = 0xC2F7; // Reniciar Timer1
digitalWrite(ledPin, digitalRead(ledPin) ^ 1); //Invierte el estado del LED
}
I-program ang pagkislap o pagkislap ng LED, tulad ng sa nakaraang kaso bawat segundo, ngunit sa pagkakataong ito ay gumagamit CTC ibig sabihin, paghahambing:
#define ledPin 8
void setup()
{
pinMode(ledPin, OUTPUT);
// Configuración Timer1
TCCR1A = 0; //Registro de control A a 0
TCCR1B = 0; //Limpiar registro
TCNT1 = 0; //Inicializar el temporizador
OCR1A = 0x3D08; //Carga el valor del registro de comparación: 16MHz/1024/1Hz -1 = 15624 = 0X3D08
TCCR1B |= (1 << WGM12)|(1<<CS10)|(1 << CS12); //Modo CTC, prescaler de 1024: CS12 = 1 y CS10 = 1
TIMSK1 |= (1 << OCIE1A); //Habilita interrupción por igualdad de comparación
}
void loop()
{
}
ISR(TIMER1_COMPA_vect) //Interrupción por igualdad de comparación en TIMER1
{
digitalWrite(ledPin, digitalRead(ledPin) ^ 1); //Invierte el estado del LED
}
Higit pa tungkol sa Arduino programming
bumili ng plato Arduino UNO Rev3