Cours:ArduinoBoutons

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 UNO qui possède 3 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 rouge sur la carte.

La première étape consiste à trouver la position physique d'une led rouge :

Sur la page de référence du shieldinfo, vous trouvez facilement le tableau suivant :

Numéro	f5	f4	f3	f2	f1	f0	p1	p0
Couleur	r	o	v	r	o	v	v	r
Arduino Pin	13	12	11	10	9	8	7	6
Port Arduino UNO	PB5	PB4	PB3	PB2	PB1	PB0	PD7	PD6
Port Arduino LEONARDO	PC7	PD6	PB7	PB6	PB5	PB4	PE6	PD7

On constate qu'il y a 3 leds rouges sur la carte, repérées f5, f2 et p0.

Choisissons la led "f2" et retenons la valeur importante : 10 qui correspond au numéro de la patte de la carte arduino sur laquelle est connectée la led.

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(10,OUTPUT); // on précise ici que la patte 10 est une sortie
}

On peut ensuite décrire le comportement souhaité :

void loop()
{
  digitalWrite(10,0); // extinction de la led
  digitalWrite(10,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(10,OUTPUT); // on précise ici que la patte 10 est une sortie
}

void loop()
{
  digitalWrite(10,0); // extinction de la led
  delay(100);
  digitalWrite(10,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 :

unsigned char ledPin = 10;

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.

Comment apprendre à programmer ? L'apprentissage d'un langage de programmation nécessite un fonctionnement de votre cerveau dans deux sens (comme pour l'apprentissage d'une langue étrangère) : On vous donne un programme, vous le lisez et vous devez deviner ce qu'il réalise On vous donne un cahier des charges et vous devez réaliser le programme Au tout début ces deux apprentissages sont difficiles mais absolument indispensable au fur et à mesure de l'avancement des TPs.

Ex avec les leds

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

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

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

Allumer en alternance une led rouge et une led verte, chacune étant allumée 1s

Allumer une led rouge puis verte puis orange en changeant toutes les 500ms

Programme plus complet

Vous disposez sur le shieldinfo de toutes les leds nécessaires à la simulation d'un carrefour routier avec 2 voies et un passage piéton (on utilisera les 8 leds à disposition).

On utilisera des feux de circulation à 4 états.

Le cycle pour les feux routier sera :

• rouge (durée à déterminer, minimum 13s)
• rouge+orange (1 s)
• vert (10s)
• orange (2s)

Écrire un programme répondant à ces contraintes.

Remarque : vous penserez à avoir dans le cycle un état dans lequel les 2 voies sont au rouge !

Ajouter à ce cycle la gestion d'un feu pour les piétons.

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 !