5 Exemples de Projets Simples en utilisant les Timers Arduino

Voici cinq exemples de code pour utiliser les timers Arduino :

Clignotement d’une LED avec un temps d’intervalle défini :

Ce code utilise la fonction millis() pour compter le temps écoulé depuis le démarrage du programme. La LED clignote toutes les secondes en changeant son état chaque fois que 1000 millisecondes sont écoulées. La variable previousMillis stocke le temps de la dernière mise à jour de l’état de la LED, et la variable interval définit la période de clignotement.

int LED = 13;
unsigned long interval = 1000; //Intervalle en millisecondes
unsigned long previousMillis = 0;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    //Inverser l'état de la LED
    digitalWrite(LED, !digitalRead(LED));
  }
}

2. Contrôle de la durée d’un signal PWM :

int LED = 9;
int dutyCycle = 128; //Cycle d'utilisation défini à 50%
unsigned long interval = 20; //Intervalle en millisecondes
unsigned long previousMillis = 0;

void setup() {
  pinMode(LED, OUTPUT);
  //Configurer le signal PWM sur le pin 9
  analogWrite(LED, dutyCycle);
}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    //Incrémenter le cycle d'utilisation de 1 à chaque intervalle
    dutyCycle++;
    //Limiter le cycle d'utilisation à la plage de 0 à 255
    if (dutyCycle > 255) {
      dutyCycle = 0;
    }
    //Changer la sortie PWM en fonction du nouveau cycle d'utilisation
    analogWrite(LED, dutyCycle);
  }
}

Ce code utilise la fonction millis() pour compter le temps écoulé depuis le démarrage du programme. La LED clignote à une fréquence régulière en changeant son état chaque fois que 500 millisecondes sont écoulées. La variable previousMillis stocke le temps de la dernière mise à jour de l’état de la LED, et la variable interval définit la période de clignotement.

3. Compteur de secondes avec interruption :

volatile unsigned int secondCounter = 0; //Variable pour compter le nombre de secondes

void setup() {
  TCCR0A = 0; //Configurer le TCCR0A en mode normal
  TCCR0B = (1 << CS02) | (1 << CS00); //Configurer le TCCR0B avec une horloge prescalée de 1024 Hz
  TIMSK0 = (1 << TOIE0); //Activer l'interruption de débordement de timer
  sei(); //Activer les interruptions globales
}

void loop() {
  //Afficher le nombre de secondes sur la console série
  Serial.println(secondCounter);
  delay(1000); //Attendre 1 seconde avant d'afficher à nouveau le compteur
}

ISR (TIMER0_OVF_vect) {
  secondCounter++; //Incrémenter le compteur de secondes lorsque le timer déborde
}

Ce code utilise deux variables previousMillis1 et previousMillis2 pour stocker le temps de la dernière mise à jour de l’état des deux LEDs. Les variables interval1 et interval2 définissent les périodes de clignotement respectives des LEDs. Le code utilise la fonction millis() pour compter le temps écoulé depuis le démarrage du programme, et contrôle l’état des LEDs en fonction de ce temps.

4. Contrôle du temps d’exposition pour la prise de photos :

int shutterPin = 7;
unsigned long exposureTime = 1000; //Temps d'exposition en millisecondes
unsigned long previousMillis = 0;
void setup() {
pinMode(shutterPin, OUTPUT);
}

void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= exposureTime) {
previousMillis = currentMillis;
//Déclencher l'obturateur pour prendre une photo
digitalWrite(shutterPin, HIGH);
delay(10); //Maintenir le signal pendant 10 millisecondes
digitalWrite(shutterPin, LOW);
}
}

Ce code utilise la fonction millis() pour compter le temps écoulé depuis le démarrage du programme. Lorsque exposureTime millisecondes sont écoulées, le code déclenche l’obturateur en envoyant un signal logique haut pendant 10 millisecondes. La variable previousMillis stocke le temps de la dernière mise à jour de l’état de l’obturateur.

Contrôle de la durée d’un bip sonore avec un signal PWM :

int buzzerPin = 8;
unsigned long duration = 500; //Durée du bip sonore en millisecondes
unsigned long previousMillis = 0;

void setup() {
pinMode(buzzerPin, OUTPUT);
}

void loop() {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= duration) {
previousMillis = currentMillis;
//Activer le signal PWM pour générer un bip sonore
analogWrite(buzzerPin, 128);
delay(duration); //Maintenir le signal pendant la durée du bip sonore
analogWrite(buzzerPin, 0);
}
}

Ce code utilise la fonction millis() pour compter le temps écoulé depuis le démarrage du programme. Lorsque duration millisecondes sont écoulées, le code génère un bip sonore en envoyant un signal PWM à une fréquence donnée. La variable previousMillis stocke le temps de la dernière mise à jour de l’état du signal PWM.