Premiers montages

Un montage très simple, support de trois applications dont les objectifs sont d'apprendre à :

1. commander une sortie numérique ;
2. faire des actions temporisées ;
3. faire plusieurs actions temporisées asynchrones.

Le schéma électrique est donné à titre indicatif.

Montage

Un montage avec deux LED 5mm, une jaune et une rouge. La première est commandée par le port 6 et la seconde par le port 9. Les deux sont reliées à la masse via une résistance de 330 Ω. Ces résistances sont nécessaires à la création d'un courant suffisant dans les diodes qui vont leur permettre de s'allumer.

Allumer une LED

/**
 * Allumage d'une LED
 */
#define LED_J 6


void setup()
{
  // Initialisation du port en sortie
  pinMode(LED_J, OUTPUT) ;

  // Allumage de la LED
  digitalWrite(LED_J, HIGH) ;
}

void loop()
{
  // Il n'y a rien à faire dans la fonction loop...
}

Ce programme a pour seul intérêt de présenter les fonctions pinMode() et digitalWrite().

La première, pinMode(), permet de définir le mode d'utilisation du port : en lecture (INPUT) ou en écriture (OUTPUT). Pour l'instant nous ne parlons que de ces deux modes.

La seconde fonction, digitalWrite(), permet au travers de son paramètre, d'activer (HIGH ou 5 volts) ou de désactiver (LOW ou 0 volts) l'alimentation sur un port donné.

Ce qui est intéressant c'est le fait de pouvoir commander l'allumage ou l'extinction d'un dispositif au travers d'un programme informatique. Le montage donné en exemple, avec une LED, est présenté pour sa simplicité. On aurait pu, par exemple, remplacer la LED par un relai qui piloterait un moteur destiné à ouvrir une porte.

Faire clignoter une LED

/**
 * Clignotement d'une LED,
 * sans utiliser delay()
 */
#define LED_J 6
#define FREQ 10 // Fréquence de clignotement en Hz

unsigned long cpt_ledj ;
int etat_ledj ;

void setup() {
  // Initialisation du port en sortie
  pinMode(LED_J, OUTPUT) ;

  // Je m'assure que la LED est
  // éteintes au départ
  etat_ledj = LOW ;
  digitalWrite(LED_J, etat_ledj) ;

  // Valeur initiale du compteur
  // au "temps" courant
  cpt_ledj = millis() ;
}

void loop() {
  // La LED va clignoter à
  // une fréquence d'environ FREQ Hz
  if ( (millis() - cpt_ledj) > 1000/FREQ ) {
    cpt_ledj = millis() ;
    if ( etat_ledj == HIGH ) {
      etat_ledj = LOW ;
    } else {
      etat_ledj = HIGH ;
    }
    digitalWrite(LED_J, etat_ledj) ;
  }
}

Ici, nous introduisons le fait de faire des actions à intervalles réguliers, sans pour autant bloquer l'exécution du micro-contrôleur. En effet pour un cas aussi simple, il aurait été tentant de réaliser la temporisation du clignotement avec la fonction delay() qui permet d'attendre un certain nombre de millisecondes. Cependant, cette fonction est bloquante et si on désire faire autre chose en attendant (faire clignoter une autre LED, lire les valeurs de capteurs, faire un calcul, ...) ce n'est pas possible. Pour acquérir de bonnes pratiques dès le début, la méthode non bloquante est présentée.

Cette méthode fait appel à la fonction millis() qui retourne le nombre de millisecondes écoulées depuis la mise en route du micro-contrôleur. Il est important de remarquer que les millisecondes passent rapidement et de fait, les nombres retournés sont souvent assez grands. Il faut donc choisir le bon type pour la variable qui va recueillir cette valeur. Ici, la réponse nous est donnée par la page descriptive de la fonction millis() et c'est un unsigned long, ce qui laisse un peu plus de 49 jours avant un retour à zéro.

Le principe du programme est le suivant : nous avons besoin de connaître l'état de notre LED (allumée ou éteinte). Nous avons besoin également de connaître le temps du dernier changement d'état. À partir de ça, il suffit de dire que l'on change d'état si la différence entre le temps actuel, donné par millis() et le temps du dernier changement, est supérieur ou égal à un constante représentant notre fréquence de clignotement. À chaque fois que ce test est vrai, il faut 1) renseigner le temps du dernier changement avec le temps courant ; 2) changer l'état de la LED ; 3) écrire le nouvel état sur le port sur lequel est branchée la LED.

Faire clignoter deux LED de manière asynchrone

/**
 * Clignotement de deux LED 
 * de manière asynchrone
 */
#define LED_R 9
#define LED_J 6
#define FREQ_LED_J 23
#define FREQ_LED_J 29

unsigned long cpt_ledr, cpt_ledj ;
int etat_ledr, etat_ledj ;

void setup()
{
  // Initialisation des ports en sortie
  pinMode(LED_R, OUTPUT) ;
  pinMode(LED_J, OUTPUT) ;

  // Je m'assure que mes LED sont
  // éteintes au départ
  etat_ledr = LOW ;
  etat_ledj = LOW ;
  digitalWrite(LED_R, etat_ledr) ;
  digitalWrite(LED_J, etat_ledj) ;

  // Valeur initiale des compteurs
  // au "temps" courant
  cpt_ledr = cpt_ledj = millis() ;
}

void loop()
{
  // La LED_R va clignoter à
  // une fréquence d'environ FREQ_LED_R Hz
  if ( (millis() - cpt_ledr) > 1000/FREQ_LED_R ) {
    cpt_ledr = millis() ;
    if ( etat_ledr == HIGH ) {
      etat_ledr = LOW ;
    } else {
      etat_ledr = HIGH ;
    }
    digitalWrite(LED_R, etat_ledr) ;
  }

  // La LED_J va clignoter à
  // une fréquence d'environ FREQ_LED_J Hz
  if ( (millis() - cpt_ledj) > 1000/FREQ_LED_J ) {
    cpt_ledj = millis() ;
    if ( etat_ledj == HIGH ) {
      etat_ledj = LOW ;
    } else {
      etat_ledj = HIGH ;
    }
    digitalWrite(LED_J, etat_ledj) ;
  }
}

Cet exemple est une extension du précédent. La réalisation de plusieurs actions asynchrones se fait grâce à la fonction loop() qui est répétée à l'infini. À chaque tour, il faut vérifier si un certain délai s'est écoulé depuis la dernière execution de nos actions. Il faut réaliser une vérification par action à mener.

Dans le cas où ce délai n'est pas passé, il est possible de faire autre chose. Mais alors il faudra, pour respecter les délais, s'assurer que tout ce qu'on fait d'autre ne prendra pas plus de temps que le délai minimal.