Il y a quelque temps, nous avons publié plus d'informations sur le fonction millis() de ArduinoNous allons maintenant approfondir la Minuterie Arduino, pour commencer avec cette fonctionnalité pour la fonctionnalité, comprenez comment cette carte gère le temps avec le MCU, ainsi que d'autres fonctions au-delà de millis().
Qu'est-ce que la minuterie Arduino ?
El Minuterie Arduino, ou minuterie, est une fonction implémentée par le matériel (dans le microcontrôleur, à l'aide du cristal de quartz qui génère les impulsions d'horloge et qui définit le "rythme", sans avoir besoin de matériel externe ou de CI 555) qui permet de contrôler des événements temporaires grâce à des horloges interne. Par exemple, faire en sorte qu'une tâche se produise à intervalles réguliers, effectuer des mesures de temps précises, etc., indépendamment du code d'esquisse.
Imaginez que vous utilisez le fonction delay(), cela bloquera l'exécution sur le MCU Arduino jusqu'à ce que le temps spécifié se soit écoulé, puis poursuivra le programme, mais la minuterie ne bloquera pas. Ce sera le moment où le MCU continuera d'exécuter d'autres instructions simultanément. C'est le grand avantage.
La minuterie est liée à interruptions d'Arduino, car ils seront exécutés à travers eux pour assister à une tâche spécifique. En d'autres termes, l'Arduino Timer est une fonction qui se déclenche à un certain moment, exécutant une fonction d'interruption. C'est pourquoi il est également important de connaître ces interruptions.
modes
La minuterie Arduino a 2 modes de fonctionnement, pouvant l'utiliser dans :
- Signal PWM: Vous pouvez contrôler le Broches Arduino (~).
- CTC (effacer le minuteur lors de la comparaison): compte le temps à l'intérieur d'un compteur et lorsqu'il atteint la valeur spécifiée dans un registre des temporisateurs, l'interruption est exécutée.
Combien de minuteries a-t-il ? Types de minuteries
Là 3 minuteries sur les assiettes Arduino UNO, bien qu'il puisse y en avoir plus sur d'autres plaques supérieures :
- Minuterie 0: 8 bits, peut compter de 0 à 255 (256 valeurs possibles). Utilisé par des fonctions telles que delay(), millis() et micros(). Sa modification est déconseillée afin de ne pas altérer les programmes.
- Minuterie 1: égal au Timer 0. Utilisé par la bibliothèque Servo dans UNO (Timer 5 pour MEGA).
- Minuterie 2: 16 bits, et peut aller de 0 à 65.525 65.536 (XNUMX XNUMX valeurs possibles). Utilisé pour la fonction tone(), s'il n'est pas utilisé, il peut être utilisé librement pour votre application.
- Minuterie 3, 4, 5 (uniquement sur Arduino MEGA): tous 16 bits.
Comment fonctionne la minuterie Arduino ?
Pour travailler avec une minuterie Arduino, il est vital de savoir comment tout cela fonctionne électroniquement dans le MCU de cette carte de développement :
- Fréquence d'horloge: est le nombre de cycles par seconde qu'il est capable de développer, dans le cas d'Arduino c'est 16 Mhz, ou ce qui revient au même, le signal d'horloge oscille 16.000.000 XNUMX XNUMX fois par seconde (cycles).
- Période: est représenté par le T, et est mesuré en secondes, et est l'inverse des cycles. Par exemple, T=1/C, ce qui donnerait 1/16000000 = 0.0000000625, le temps qu'il faudrait pour que chaque cycle se termine. Et la fréquence est l'inverse de la période, donc f = 1/T.
- Cycle: est chacune des répétitions du signal qui se produisent par unité de temps. Sur Arduino, ce serait 16M en une seconde. Ou ce qui revient au même, dans ce cas, lorsque 16 millions de cycles se sont écoulés, une seconde s'est écoulée. Par conséquent, on peut dire qu'un cycle prend 625 ns.
- bord d'un signal: Les signaux d'horloge sont carrés et les fronts peuvent être montants ou descendants. Un front est la ligne droite du signal lorsqu'il passe de :
- 0 (bas) à 1 (haut) : front montant.
- 1 (haut) à 0 (bas) : front descendant.
Les fronts sont importants car les minuteries Arduino mesurent les cycles à partir des fronts de signal. A) Oui le compteur il s'incrémente à chaque cycle et lorsqu'il atteint la valeur du registre, l'interruption est exécutée.
Par conséquent, une fois que vous savez cela, si vous avez 16Mhz sur le microcontrôleur Arduino, et qu'un temporisateur 8 bits est utilisé, on peut dire que les interruptions se produiront toutes les 16 μs (256/16000000) ou 4 ms pour 16 bits (65536/16000000). Par conséquent, si vous définissez le registre du compteur 16 bits au maximum, avec la valeur 65535, l'interruption se produira à 4 ms pour exécuter la tâche quelle qu'elle soit.
Lorsque le compteur atteint la valeur maximale possible, il reviendra à 0. C'est-à-dire qu'un débordement se produit et qu'il compte à rebours depuis le début.
Pour contrôler le taux d'augmentation de la minuterie, vous pouvez également utiliser un prédiviseur, qui prend les valeurs 1, 8, 64, 256 et 1024 et modifie le timing comme ceci :
Vitesse de la minuterie (Hz) = Fréquence d'horloge de l'Arduino/Prescaler
Si c'est 1 le prédiviseur le contrôleur augmentera à 16 Mhz, s'il est de 8 à 2 Mhz, s'il est de 64 à 250 kHz, et ainsi de suite. N'oubliez pas qu'il y aura un comparateur d'état de compteur de minuterie pour comparer la valeur du compteur et du prédiviseur jusqu'à ce qu'ils soient égaux, puis exécuter une action. Pourtant, fréquence d'interruption est donné par la formule :
Vitesse d'interruption (Hz) = Fréquence d'horloge Arduino / Prescaler (valeur du registre du comparateur + 1)
Heureusement, il ne faut pas modifier les enregistrements des temporisateurs Arduino, car il sera pris en charge par les bibliothèques que nous utilisons dans le code. Mais s'ils ne sont pas utilisés, ils doivent être configurés.
Exemples dans l'IDE Arduino
Afin de comprendre un peu mieux tout cela, je montre ici deux codes de croquis pour Arduino IDE avec lesquels vous pouvez faire l'expérience de l'utilisation des minuteries. Le premier est un code qui fera clignoter une LED connectée à la broche 8 d'Arduino toutes les secondes :
#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
}
Programmez le clignotement ou le clignotement de la LED, comme dans le cas précédent toutes les secondes, mais cette fois en utilisant CTC, c'est-à-dire comparaison:
#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
}
En savoir plus sur la programmation Arduino
acheter une assiette Arduino UNO Rév3