Cours:ArduinoBoutons : Différence entre versions
(→{{Vert|Détection de changement d'état}}) |
m (→{{Vert|Détection de changement d'état}}) |
||
Ligne 84 : | Ligne 84 : | ||
{{Aide|Etat présent vs passé}} | {{Aide|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. | + | 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. | 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. |
Version du 4 novembre 2013 à 22:16
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
Sommaire
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é bp0.
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
}
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. On détecte non plus un état du bouton, mais un changement d'état de celui-ci.
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=...;
// si appui alors ....
}
Écrire le programme répondant au cahier des charges.
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é) :
2 bps, 1 led
Ex 2: Système "industriel"On considère cette fois un système avec 3 boutons marche(bp0), arrêt(bp2) et stop(bp1), ainsi que 2 voyants, l'un vert et l'autre rouge (on vous laisse choisir les leds) Le fonctionnement est le suivant :
Ex 3: Game over !Certains systèmes pour lesquels la sécurité est primordiale comporte 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. |