Cours:ArduinoBoutons

De troyesGEII
Révision datée du 18 septembre 2017 à 08:47 par Bjacquot (discussion | contributions) ({{Bleu|Gestion des sorties}})
Aller à : navigation, rechercher
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
}

Todo.jpg 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.


Todo.jpg 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.

Todo.jpg 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.

Bluebg.png
Aidesmall.png
À propos de cette image

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 :

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

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

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

Question.jpg 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)
  • rouge+orange (1 s)
  • vert (10s)
  • orange (2s)

Question.jpg Écrire un programme répondant à ces contraintes.

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

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

Bluebg.png
Aidesmall.png
À propos de cette image

Comment commencer ?


Il est souvent intéressant de réaliser un chronogramme qui vous permettra de représenter les différents états successifs (ainsi que leur durée) que doivent prendre vos sorties.

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.

Question.jpg 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.

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

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

Question.jpg É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

Todo.jpg 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 ....
   {
         .....
   }
}

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


Bluebg.png
Aidesmall.png
À propos de cette image

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

Question.jpg 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).

Question.jpg É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.

Question.jpg A vous de jouer !