Cours:ArduinoBoutonsNano

Retour à la liste des Tps

Éléments de correction

Carte d'extension arduino pour les Tps d'info

Ce Tp va permettre d'introduire quelques éléments indispensables à la programmation d'une carte arduino, et surtout d'apprendre à se servir d'une documentation, en l'occurrence celle disponible sur le site arduino.

Il convient de bien comprendre qu'une carte arduino (et plus exactement toute carte utilisant un microcontrôleur) peut servir à faire de multiples tâches. On utilise nécessairement des extensions (shields) et nous devrons spécifier dans le programme la façon de "communiquer"/gérer cette carte. Physiquement, cette communication s'opère à travers de connexions dont le nombre dépend de la carte utilisée. Nous utiliserons une carte arduino NANO qui possède 2 connecteurs pour l'échange de données, numérotés de 0 à 13 et de A0 à A5, soit un total de 20 connexions.

Si nous nous considérons à la place de la carte arduino, chaque connexion peut être :

• une entrée/INPUT (mesure, observation). Par ex,
  • capteur de température
  • interrupteur
  • mesure de tension
  • microphone
• une sortie/OUTPUT (action). Par ex,
  • résistance chauffante
  • lampe, voyant lumineux
  • haut parleur

Notions fondamentales

Gestion des sorties

On souhaite allumer et éteindre une led sur la carte.

Nous utiliserons les 2 leds (sérigraphie L1 et L2 sur la carte) qui sont reliées sur la carte arduino :

Led	numéro arduino
L1	D5
L2	D8

Principe

Nous pouvons maintenant écrire le programme qui comporte nécessairement une partie configuration ( setup() ) et une boucle ( loop() ) :

• le setup() exécuté une seule fois
• le loop() exécuté en boucle (loop veut dire boucle en anglais)

On commence par la partie configuration qui nous permet de définir les entrées et sorties :

void setup()
{
  pinMode(5,OUTPUT); // on précise ici que la patte 10 est une sortie
}

On peut ensuite décrire le comportement souhaité :

void loop()
{
  digitalWrite(5,0); // extinction de la led
  digitalWrite(5,1); // éclairement de la led
}

Saisir le programme, l'exécuter et constater que ....

ça ne marche pas !

En effet, les instructions étant exécutées très rapidement, il est impossible d'observer le clignotement.

Ajoutons donc une temporisation ce qui nous donne le programme suivant :

void setup()
{
  pinMode(5,OUTPUT); // on précise ici que la patte 10 est une sortie
}

void loop()
{
  digitalWrite(5,0); // extinction de la led
  delay(100);
  digitalWrite(5,1); // éclairement de la led
  delay(100);
}

Vous trouverez des détails sur la fonction delay() sur cette page.

Utilisons maintenant une variable pour la position de la led afin de rendre notre code plus facilement lisible et modifiable :

const unsigned int ledPin = 5;

void setup()
{
  pinMode(ledPin,OUTPUT); // on précise ici que la patte 10 est une sortie
}

void loop()
{
  digitalWrite(ledPin,0); // extinction de la led
  delay(100);
  digitalWrite(ledPin,1); // éclairement de la led
  delay(100);
}

Avec cette structure, vous pouvez maintenant facilement changer de led.

Ex avec les leds

Écrire les programmes répondant aux cahiers des charges suivants :

Allumer une led pendant 1s et l'éteindre pendant 3s.

Allumer 2 leds pendant 100ms et les éteindre pendant 3s.

Allumer en alternance la led L1 puis la led L2, chacune étant allumée 1s

Allumer la led L1 puis les 2 leds puis seulement la led L2 puis tout éteint, en changeant toutes les 500ms

Clignotement

Nous allons essayer de faire clignoter les leds à des rythmes différents.

Commençons par utiliser une variable pour changer l'état de la led :

bool etatLed1 = false; //variable booléenne pour mémoriser l'état de la led
const unsigned int pinLed1 = 5;

void setup()
{
  pinMode(pinLed1,OUTPUT);        // déclarer la broche en sortie
}

void loop()
{
  etatLed1 = ! etatLed1;          // inverser l'état de la variable booléenne
  digitalWrite(pinLed1,etatLed1); // modifier l'état de la sortie
  _delay_ms(200);                 // attendre 200ms avant de recommencer -> rythme de clignotement
}

Vérifier le bon fonctionnement et comprendre ce programme

On souhaite réduire la valeur du delay tout en conservant la même vitesse de clignotement :

• réduire le delay à 20ms
• déclarer une variable cptLed1 de type int
• incrémenter ce compteur à chaque itération
• si le compteur vaut 10 :
  • remettre le compteur à 0
  • changer l'état de la variable etatLed1
  • modifier l'état de la sortie

Faire les modifications demandées

Maintenant que nous avons préparé la structure du programme, il est assez simple d'ajouter une 2ème led qui clignotera à un rythme différent :

• ajouter les variables nécessaires pour cette 2ème led :
  • etatLed2
  • pinLed2
  • cptLed2
• ajouter la 2ème led en sortie
• modifier le loop pour que la 2ème led change d'état toutes les 140ms

Gestion d'une entrée

Nous souhaitons maintenant observer l'état d'un bouton sur la carte. Il s'agit donc d'une entrée : la carte arduino observe l'état du bouton, ce n'est pas elle qui modifie son état !

De façon analogue à la partie précédente, trouvons sur la page de documentation le tableau suivant :

Bouton	Position	Arduino Pin	Port	Interruption	Niveau logique de l'entrée arduino si bouton appuyé
A	Bas Gauche	2	PD2	int0	1
D	Haut Gauche	3	PD3	int1	1
B	Bas Droite	A0	PC0		0
C	Haut Droite	A1	PC1		0

Nous choisissons le bouton référencé A et retenons donc le numéro de patte arduino associé : 2

On utilisera astucieusement 2 variables comme :

• bpPin : qui représentera la position physique du bouton
• etatBp : qui représentera la valeur du bouton

Il suffit de configurer la patte du bouton en entrée ( pinMode() ) et de lire l'état de cette patte ( digitalRead() ) :

unsigned char bpPin = 2;
unsigned char etatBp;

void setup()
{
  pinMode(bpPin,INPUT); // le bouton est connecté sur la patte représentée par la variable bpPin
}

void loop()
{
   etatBp = digitalRead(bpPin); // lecture de l'état de l'entrée
   .....                        // la variable etatBp sera utilisée dans la suite de l'algorithme pour tenir compte de l'état du bouton
   .....                        // ex : if ( etatBp == 0) {....;}
}

Ex 1: Entrée, sortie ???

1 bp, 1 led

Commençons tout simplement par commander une sortie tout ou rien (2 états possibles) à l'aide d'un bouton poussoir.

On prendra la led R repérée p0, et le bouton poussoir repéré A.

On se servira des fonctions suivantes :

• pinMode() permettant de configurer les entrées et sorties(e/s).
• digitalWrite() permettant de modifier l'état d'une sortie.
• digitalRead() permettant de lire l'état d'une entrée.

Compléter le programme suivant pour que la led ne s'allume que si le bouton est appuyé.

unsigned char ledPin= ... ;   // qques variables pour la position
unsigned char bpPin = ... ;   // des e/s
unsigned char etatBp;         // et récupérer l'état du bouton

void setup()
{
     pinMode(...,INPUT);      // configuration des e/s
     pinMode(...,OUTPUT);
}

void loop()
{
     etatBp = ..........;     // "Lecture" de l'état de l'entrée
     ...................;     // "Écriture" de l'état de la sortie
}

2 bps, 1 led

On ajoute un deuxième bouton, noté D sur la carte.

Écrire un programme qui allume la led uniquement si les 2 boutons sont appuyés

Écrire un programme qui allume la led si au moins l'un des 2 boutons est appuyé

Écrire un programme qui allume la led s'il n'y a qu'un bouton appuyé

Ex 2: Détection de changement d'état

Modifions légèrement le comportement. Nous souhaitons désormais que l'état de la led change à chaque appui sur le bouton A. On détecte non plus un état du bouton, mais un changement d'état de celui-ci.

Par interruption

Sans entrer dans le détail pour le moment et sans être exhaustif, nous utiliserons les interruptions de la façon suivante (uniquement pour les boutons A et D):

Mise en place

Dans la fonction setup(), nous utiliserons la fonction attachInterrupt() qui permettra d'exécuter une fonction particulière lors d'un événement parmi :

• CHANGE  : la fonction d'interruption est exécutée sur une changement d'état de l'entrée
• RISING  : la fonction d'interruption est exécutée sur un passage de l'état 0 à 1 de l'entrée
• FALLING : la fonction d'interruption est exécutée sur un passage de l'état 1 à 0 de l'entrée

On précise également le numéro de l'interruption qui nous intéresse comme indiqué dans le tableau.

Exemple :

void setup()
{
   pinMode(13,OUTPUT);               // On précise que la pin (patte) 13 est une sortie dans la suite de l'exemple.
   attachInterrupt(0,reagir,RISING); // La fonction {{Rouge|reagir()}} sera exécutée lorsque le bouton A (int0) sera relâché.
}

Utilisation

Il convient bien entendu de déclarer la fonction d'interruption (reagir ici) qui permettra par exemple de placer un drapeau (flag) dans un état particulier :

char appui;
char etatLed = 0;

void reagir()
{
   appui = 1;
}

void loop()
{
   if ( appui == 1)
   {
      etatLed = !etatLed ;
      digitalWrite(13,etatLed);
      appui = 0 ;
   }
   delay(1);
}

Test

Recopier le programme, vérifier son fonctionnement et profitez en pour tester les différents mode de déclenchement de l'interruption.

En observant le changement de valeur du bouton

Pour ce faire, il convient de remarquer que juste avant l'appui, la valeur lue sur l'entrée correspondant au bouton est à l'état 0, et que dès l'appui la valeur passe à l'état 1.

Vous utiliserez 2 variables de type char (par exemple etatPresent et etatPasse), qui permettront de détecter cette transition.

On utilisera également une variable etatSortie de type unsigned char pour mémoriser l'état de la sortie.

Le programme ressemblera donc à :

char etatPresent=0,etatPasse=0;
unsigned char etatSortie=0;

void setup()
{
     .....            // configuration des e/s
}

void loop()
{
   etatPasse=etatPresent;                                // mémorise l'état précédent (le présent devient le passé)
   etatPresent=digitalRead(??);                          // lecture de la valeur actuelle
   if ( ( etatPresent == ?? ) && ( etatPasse == ?? ) )   // si appui alors ....
   {
         .....
   }
}

Écrire le programme répondant au cahier des charges.

Etat présent vs passé Pour simplifier, a chaque nouvelle boucle, la valeur de etatPresent correspond à l'état pendant cette boucle du bouton poussoir, tandis que etatPasse correspond à l'état du bouton lors de la boucle précédente. Au tout début de la boucle, etatPresent n'étant pas encore modifiée, sa valeur correspond donc à l'état du bouton lors de la boucle précédente ... qui est désormais le Passé ! On modifie donc la valeur de etatPasse (qui prend donc la valeur de etatPresent de la boucle précédente), et on peut ensuite regarder l'état actuel du bouton. Considérons la chronologie d'événement suivante (r : relâché, a : appuyé) : Etat Bouton r r r r a a a a r r a etatPresent avant digitalRead 0 0 0 0 0 1 1 1 1 0 0 etatPresent après digitalRead 0 0 0 0 1 1 1 1 0 0 1 EtatPasse 0 0 0 0 0 1 1 1 1 0 0 On constate bien que etatPasse correspond à la valeur de etatPresent avant exécution de digitalRead.

2 bps, 1 led

A l'aide d'une des 2 méthodes précédentes, ajouter un deuxième bouton (D) pour que :

• la led s'allume lors de l'appui sur A.
• la led s'éteint lors du relâchement de D.

Ex 3: Système "industriel"

On considère cette fois un système avec 2 boutons départ cycle (bp0) et stop(bp2) et un commutateur marche/arrêt(bp1), ainsi que 2 voyants, l'un vert et l'autre rouge (on vous laisse choisir les leds)

La carte utilisée ne disposant pas de commutateur, on utilisera un bouton poussoir.

Le fonctionnement est le suivant :

1. Tant que le commutateur m/a est en position arrêt, le voyant rouge s'allume (dans tous les autres cas il est éteint), et le bouton vert (indiquant la mise en marche) est éteint.
2. Si le bouton stop est appuyé, le système s'arrête (voyant vert éteint).
3. A l'appui sur le bouton dcy (départ cycle), le système démarre, le voyant vert s'allume (il restera allumé jusqu'à l'appui sur le bouton arrêt ou stop).

Écrire le programme.

Ex 4: Game over !

Certains systèmes pour lesquels la sécurité est primordiale comportent un interrupteur de type "homme mort" permettant de vérifier la présence et l'état de conscience de l'opérateur.

Nous allons utiliser l'un des boutons poussoirs de notre carte pour réaliser cette fonction.

Le principe est le suivant : toute les 3s on allume une led orange. L'opérateur doit alors appuyer sur un bouton poussoir (que vous choisirez) dans les 3s suivantes. Dès l'appui, la led orange doit s'éteindre et une led verte s'allume.

Si l'opérateur n'a pas appuyé dans le délais imparti, toutes les leds rouges s'allument.

On pourra utiliser la fonction millis(), un exemple d'utilisation étant donné sur ce lien. Vous pouvez ajouter dans votre programme une ligne delay(1), qui permettra de rythmer le programme.

A vous de jouer !