Activité 2: Entrées digitales - le bouton poussoir

De Enseignement secondaire.
Aller à : Navigation, rechercher

Retouner à la page principale

Sommaire

Introduction

De nombreux appareils électroniques utilise les boutons poussoirs: le clavier de l'ordinateur, la souris, votre calculatrice, la télécommande de la télévision, le téléphone portable, etc. Dans chacun de ces appareils, un microcontrôleur scanne ces boutons poussoirs et attend que leur état change, c'est-à-dire qu'ils soient pressés ou relâchés. Quand c'est le cas, le microcontrôleur le détecte et agit en conséquence.

A la fin ce cette activité, vous saurez comment utiliser les boutons poussoirs et comment vérifier leur changement d'état et que faire quand le bouton est pressé ou relâché.

Dans l'activité 1, vous avez programmé le Basic Stamp pour envoyer des signaux haut et bas (Vdd et Vss) et vous avez utilisé des LED pour voir concrètement l'effet que cela a. Envoyer un signal signifie programmer une patte du microcontrôleur comme sortie.

Dans cette activité, nous allons voir comment utiliser une patte du microcontrôleur comme entrée. Dans ce cas, le Basic Stamp "écoute" les changement de signaux haut/bas au lieu de les envoyer lui-même. Ces signaux seront envoyé à l'aide d'un bouton poussoir et vous allez programmer le Basic Stamp pour vérifier si le bouton poussoir est pressé ou non.

Fonctionnement

Le bouton poussoir est comme un interrupteur et il peut donc être utiliser pour allumer ou éteindre une LED. Vous pouvez voir ci-dessous à quoi ressemble le bouton poussoir:

BoutonPoussoir1.png

Son fonctionnement est simple: le bouton poussoir agit comme un interrupteur entre les pattes 1, 2 et 3, 4. Si on presse le bouton poussoir, les pattes 1, 2 et 3, 4 sont donc mises en contact.

Le schéma ci-dessous représente schématiquement les deux positions possibles du bouton poussoir, pressé et non pressé:

BoutonPoussoir2.png

Votre premier circuit avec le bouton poussoir

Vous allez réaliser le montage suivant:

Acitivite2Circuit1.png

Voici maintenant la représentation schématique du montage:

Acitivite2Circuit2.png

Quand on appuie sur le bouton poussoir, le circuit est fermé et le courant circule de Vdd vers Vss.

Voici maintenant un autre circuit:

Acitivite2Circuit3.png

Cette fois-ci, quand le bouton poussoir est relâché, le courant circule à travers la LED. Mais quand il est pressé, le courant prend le chemin où il y a le moins de résistance (le courant est fénéant !!!) et passe par le bouton poussoir (c'est moins fatiguant que d'allumer une LED).

Lire l'état d'un bouton avec le Basic Stamp

Voici le montage que vous allez réaliser:

Acitivite2Circuit4.png

Quand le bouton poussoir est pressé, le Basic Stamp détecte que Vdd est connecté à P3. Ici encore, le courant est fénéant et il va aller là où il y a le moins de résistance.

A l'intérieur, cela a pour effet de placer la valeur 1 dans la mémoire qui stocke les informations relatives aux pattes d'entrées/sorties.

Quand le bouton poussoir est relâché, le courant ne peut plus aller avec P3 et donc le Basic Stamp ne détecte plus que Vdd est connecté à P3 mais Vss qui passe à travers les résistances de 10 kΩ et 220 Ω.

A l'intérieur, cela a pour effet de placer la valeur 0 dans la mémoire qui stocke les informations relatives aux pattes d'entrées/sorties.

Voici schématiquement ce qui se passe:

Acitivite2Circuit5.png

Programmer le Basic Stamp pour lire une entrée

Vous allez utiliser le code suivant:

' Vérifie l'état du bouton poussoir tous les 1/4 de seconde.

' {$STAMP BS2}
' {$PBASIC 2.5}

DO
  DEBUG ? IN3
  PAUSE 250
LOOP

Ce code est très simple: il envoie dans la fenêtre de débug de l'ordinateur la valeur de IN3 qui est l'espace mémoire qui stocke l'état 0 ou 1 du bouton poussoir que nous avons vu plus haut.

Cette méthode est appelé méthode de "pull-up" car le Basic Stamp détecte un 1 (Vdd) quand le bouton poussoir est pressé et un 0 (Vss) quand il est relâché.

Circuit "pull-down"

Réalisez le montage suivant et notez ce que vous remarquez comme changement:

Acitivite2Circuit6.png

Quand le bouton poussoir est relâché, c'est Vdd qui arrive à P3 et quand il est pressé, c'est Vss.

Ceci est un circuit "pull-up": le Basic Stamp détecte un 0 (Vss) quand le bouton poussoir est pressé et un 1 (Vdd) quand il est relâché.

Contrôler une LED avec le bouton poussoir

Nous allons maintenant utiliser le bouton poussoir pour allumer et éteindre une LED en fonction de l'état dans lequel il se trouve.

C'est bien sûr le Basic Stamp qui va s'occuper de cela.

Le circuit

Vous allez réaliser le circuit suivant:

Acitivite2Circuit7.png

Nous avons ici deux circuits: un premier avec le bouton poussoir relié à P3 et un deuxième avec une LED reliée à P14.

Le programme

Vous allez utiliser ici une nouvelle instruction: IF...THEN...ELSE qui est une condition.

Le programme que vous allez écrire fera la chose suivante:

Voici le code à compléter:

' Vérifie l'état du bouton poussoir tous les 1/4 de seconde et allume ou éteint la LED en fonction.

' {$STAMP BS2}
' {$PBASIC 2.5}

DO
  DEBUG ? IN3
  
  IF ( IN3 = 1 ) THEN 'Si le bouton poussoir est pressé
    ' Votre code pour allumer la LED
  ELSE
    ' Votre code pour éteindre la LED
  ENDIF

  'Votre code pour attendre 1/4 de seconde
LOOP

Contrôler deux LED avec deux boutons poussoirs

Vous allez maintenant réaliser le montage suivant qui contient deux boutons poussoirs et deux LED:

Acitivite2Circuit9.png

Maintenant un bouton poussoir est connecté à P3 et un à P4 et une LED est connectée à P14 et l'autre à P15.

Le programme

Vous allez réaliser un programme qui:

Vous aurez besoin pour cele d'utiliser l'instruction ELSEIF qui permet d'imbriquer plusieurs conditions ensemble.

Voici le code à compléter:

' Vérifie l'état des boutons poussoirs toutes les 1/4 de seconde et allume ou éteind les LED en fonction.

' {$STAMP BS2}
' {$PBASIC 2.5}

DO
  DEBUG HOME  'Fait revenir le curseur en haut à gauche dans le fenêtre de débug.
              'Cela évite avoir des valeurs qui défilent.
  DEBUG ? IN3
  DEBUG ? IN3
  
  IF ( ... ) THEN 'Si le bouton poussoir P3 est pressé
    ' Votre code pour allumer la LED P14
  ELSEIF ( ... )  'Si le bouton poussoir P4 est pressé
    ' Votre code pour allumer la LED P14
  ELSE
    ' Votre code pour éteindre la LED
  ENDIF

  'Votre code pour attendre 1/4 de seconde
LOOP

Allumer les deux LED si les deux boutons sont pressés en même temps

En liant deux conditions par un opétateur logique, il est possible d'allumer les deux LED en même temps si les deux boutons poussoirs sont pressés en même temps.

Il faut pour cela utiliser l'opérateur logique AND qui permet de vérifier si deux conditions sont vérifiée simultanément Par exemple: IF (IN3 = 1) AND (IN4 = 1) THEN ....

Ajoutez cette ligne tout au début de la série de vérification des conditions et complétez votre code pour que les deux LED s'allume alors.

Il existe également l'opérateur OR qui permet de vérifier si l'une ou l'autre condition est vérifée.

Jeu de rapidité

Vous allez ici créer un jeu de rapidité en utilisant une LED bicouleurs.

La LED sera éteinte jusqu'à ce que le joueur presse sur le bouton poussoir. When le bouton poussoir est pressé, la LED deviendra rouge pendant une courte durée. Après un moment, elle deviendra verte et le joueur devra relâcher le bouton poussoir le plus rapidement possible. Le programme mesurera le temps que le joueur aura mis avant de relâcher le bouton.

Le circuit

Vous allez tout d'abord réaliser le circuit du jeu:

Activite2Circuit10.png

Le programme

Voici le code à compléter:

' Jeu de réaction.

' {$STAMP BS2}
' {$PBASIC 2.5}

compteurTemps VAR Word  ' Variable pour stocker le temps de réaction.

DEBUG 'Complétez pour afficher les régles du jeu

DO
  DO                  ' Boucle à exécuter ...
  LOOP UNTIL IN3 = 1  ' jusqu'à ce que le bouton soit pressé.
  
                      ' Allumer LED bicouleur en rouge.
  ' Compléter

                      ' Attendre 1 seconde.
  ' Compléter
  
                      ' Allumer LED bicouleur en vert.
  ' Compléter

  compteurTemps = 0     ' Mettre timeCounter à zéro.

  DO                  ' Compter le nombre de millisecondes jusqu'à
    PAUSE 1           ' ce que le bouton soit relâché.
    compteurTemps = compteurTemps + 1
  LOOP UNTIL IN3 = 0

  LOW 15	      ' Eteindre la LED
  
                      ' Affiche le temps de réaction 
  DEBUG "Votre temps ", DEC compteurTemps,
        " ms.", CR, CR
 
LOOP

L'instruction DO...LOOP UNTIL condition exécute la boucle jusqu'à ce que la condition donnée soit réalisée (ici jusqu'à ce que le bouton soit pressé au début du programme puis jusqu'à ce qu'il soit relâché à la fin du programme).

L'instruction DEC timeCounter indique à la fenêtre de débug qu'il faut afficher la valeur de timeCounter comme nombre entier.

Quelques problèmes à corriger

Problème #1

Quand un joueur presse le bouton pendant 30 secondes, son score est 14000ms soit 14 secondes.

Le problème ici est que l'exécution de la boucle prend du temps. Pendant que le code timeCounter = timeCounter + 1 s'exécute, le temps continue de s'écouler.

Pour corriger cela, il suffirait d'afficher le temps calculé multiplié par 2 pour avoir une valeur plus exacte. A vous de jouer.

Problème #2

Les joueurs s'aperçoivent rapidement que le temps entre rouge et vert est de 1 seconde.

Le Basic Stamp peut générer des nombres aléatoires à l'aide de l'instruction RANDOM.

Il vous faudra tout d'abord créer une variable nbreAlea de type Byte pour stocker la valeur aléatoire générée par le Basic Stamp.

Pour générer et stocker un nombre aléatoire dans nbreAlea, il faut exécuter le code RANDOM nbreAlea. Vous placerez cette commande juste avant le code PAUSE 1000.

Pour que la durée d'attente soit aléatoire, vous pouvez ensuite modifier le code PAUSE 1000 par PAUSE 1000 + (nbreAlea * 4). nbreAlea étant de type Byte, elle peut prendre des valeur entre 0 et 255 et donc en multipliant par 4, cela donne des valeur entre 0 et 1000 environ soit entre 0 et 1 seconde.

A vous de modifier le code.

Problème #3

Un joueur qui lâche le bouton avant que la LED devienne verte obtient un score de 1ms ce qui est de la triche !

Il est impossible d'avoir un temps de réaction aussi rapide.

Il faudrait donc vérifier si (IF...THEN...ELSE) le temps de réaction est inférieur à 2ms et afficher un message indiquant au joueur qu'il doit attendre que la LED devienne verte avant de relâcher le bouton sinon afficher le message standard.

A vous de modifier le code.

Résumé

Dans cette activité, nous avons introduit le bouton poussoir et plusieurs circuits l'utilisant. Vous avez également vu comment il est possible de lire la valeur d'une entrée du Basic Stamp à l'aide de l'instruction IN. Le Basic Stamp a été programmé afin de prendre des décisions en fonction de l'état du ou des boutons poussoirs utilisés. Au final, vous avez créé un jeu de rapidité.

Plusieurs concepts de programmation on été introduits: comment compter le temps qui s'écoule, prendre des décisions et la notion de temps qui s'écoule également pendant que le Basic Stamp fait des calculs ou exécute des instructions.

Les instructions IN3, IN4, etc permettent de lire l'état d'une patte.

Les instructions IF...THEN...ELSE et IF...ELSEIF...ELSE permettent de prendre des décisions.

Les opétateurs AND et OR permettent de vérifier plusieurs conditions en même temps.

Et enfin, l'instruction RANDOM a été introduite pour générer un temps aléatoire dans le jeu de rapidité.

Questions

1. Quelle est la différence entre envoyer et recevoir HIGH et LOW sur le Basic Stamp?

2. Quelle est la valeur de IN3 quand un bouton poussoir le connecte à Vdd? Et quand il le connecte à Vss?

3. Que fait l'instruction DEBUG?

4. Quel type d'instruction permet de prendre de décisions?

5. Que fait l'instruction HOME?

Projet

Modifiez le jeu de rapidité pour que deux joueurs puissent y jouer en même temps.

Il vous faudra ajouter un bouton poussoir et avoir deux compteurs, un pour le joueur A et un pour le joueur B.

Le programme devra s'arrêter quand les deux joueurs auront relâchés leur bouton et afficher le gagnant.

Outils personnels
Espaces de noms
Variantes
Actions
Navigation
Boîte à outils