[ Arduino 204] Un simple bouton

Dans cette partie, vous allez pouvoir interagir de manière simple avec votre carte. A la fin de ce chapitre, vous serez capable d’utiliser des boutons ou des interrupteurs pour interagir avec votre programme.

Qu’est-ce qu’un bouton ?

Derrière ce titre trivial se cache un composant de base très utile, possédant de nombreux détails que vous ignorez peut-être. Commençons donc dès maintenant l’autopsie de ce dernier.

Mécanique du bouton

Vous le savez sûrement déjà, un bouton n’est jamais qu’un fil qui est connecté ou non selon sa position. En pratique, on en repère plusieurs, qui diffèrent selon leur taille, leurs caractéristiques électriques, les positions mécaniques possibles, etc.

Le bouton poussoir normalement ouvert (NO)

Dans cette partie du tutoriel, nous allons utiliser ce type de boutons poussoirs (ou BP). Ces derniers ont deux positions :

  • Relâché : le courant ne passe pas, le circuit est déconnecté ; on dit que le circuit est « ouvert« .
  • Appuyé : le courant passe, on dit que le circuit est fermé.
Retenez bien ces mots de vocabulaire !

Habituellement le bouton poussoir a deux broches, mais en général ils en ont 4 reliées deux à deux.

Le bouton poussoir normalement fermé (NF)

Ce type de bouton est l’opposé du type précédent, c’est-à-dire que lorsque le bouton est relâché, il laisse passer le courant. Et inversement :

  • Relâché : le courant passe, le circuit est connecté ; on dit que le circuit est « fermé« .
  • Appuyé : le courant ne passe pas, on dit que le circuit est ouvert.

Les interrupteurs

A la différence d’un bouton poussoir, l’interrupteur agit comme une bascule. Un appui ferme le circuit et il faut un second appui pour l’ouvrir de nouveau. Il possède donc des états stables (ouvert ou fermé). On dit qu’un interrupteur est bistable. Vous en rencontrez tous les jours lorsque vous allumez la lumière 😉 .

L’électronique du bouton

Symbole

Le BP et l’interrupteur ne possèdent pas le même symbole pour les schémas électroniques. Pour le premier, il est représenté par une barre qui doit venir faire contact pour fermer le circuit ou défaire le contact pour ouvrir le circuit. Le second est représenté par un fil qui ouvre un circuit et qui peut bouger pour le fermer. Voici leurs symboles, il est important de s’en rappeler :

symbole BP NO symbole BP NF symbole d'un interrupteur
Bouton Poussoir NO
Bouton Poussoir NF
Interrupteur

Tension et courant

Voici maintenant quelques petites précisions sur les boutons :

  • Lorsqu’il est ouvert, la tension à ses bornes ne peut être nulle (ou alors c’est que le circuit n’est pas alimenté). En revanche, lorsqu’il est fermé cette même tension doit être nulle. En effet, aux bornes d’un fil la tension est de 0V.
  • Ensuite, lorsque le bouton est ouvert, aucun courant ne peut passer, le circuit est donc déconnecté. Par contre, lorsqu’il est fermé, le courant nécessaire au bon fonctionnement des différents composants le traverse. Il est donc important de prendre en compte cet aspect. Un bouton devant supporter deux ampères ne sera pas aussi gros qu’un bouton tolérant 100 ampères (et pas aussi cher 😛 )

Il est très fréquent de trouver des boutons dans les starters kit.

Bouton poussoir

Souvent ils ont 4 pattes (comme sur l’image ci-dessous). Si c’est le cas, sachez que les broches sont reliées deux à deux. Cela signifie quelles fonctionnent par paire. Il faut donc se méfier lorsque vous le brancher sinon vous obtiendrez le même comportement qu’un fil (si vous connectez deux broches reliés). Utilisez un multimètre pour déterminer quels broches sont distinctes. Pour ne pas se tromper, on utilise en général deux broches qui sont opposées sur la diagonale du bouton.

Contrainte pour les montages

Voici maintenant un point très important, soyez donc attentif car je vais vous expliquer le rôle d’une résistance de pull-up !

C’est quoi st’animal, le poule-eup ?

Lorsque l’on fait de l’électronique, on a toujours peur des perturbations (générées par plein de choses : des lampes à proximité, un téléphone portable, un doigt sur le circuit, l’électricité statique, …). On appelle ça des contraintes de CEM. Ces perturbations sont souvent inoffensives, mais perturbent beaucoup les montages électroniques. Il est alors nécessaire d’en prendre compte lorsque l’on fait de l’électronique de signal. Par exemple, dans certains cas on peut se retrouver avec un bit de signal qui vaut 1 à la place de 0, les données reçues sont donc fausses. Pour contrer ces effets nuisibles, ont place en série avec le bouton une résistance de pull-up. Cette résistance sert à « tirer » (« to pull » in english) le potentiel vers le haut (up) afin d’avoir un signal clair sur la broche étudiée. Sur le schéma suivant, on voit ainsi qu’en temps normal le « signal » à un potentiel de 5V. Ensuite, lorsque l’utilisateur appuiera sur le bouton une connexion sera faite avec la masse. On lira alors une valeur de 0V pour le signal. Voici donc un deuxième intérêt de la résistance de pull-up, éviter le court-circuit qui serait généré à l’appui !

Résistance Pull up

Filtrer les rebonds

Les boutons ne sont pas des systèmes mécaniques parfaits. Du coup, lorsqu’un appui est fait dessus, le signal ne passe pas immédiatement et proprement de 5V à 0V. En l’espace de quelques millisecondes, le signal va « sauter » entre 5V et 0V plusieurs fois avant de se stabiliser. Il se passe le même phénomène lorsque l’utilisateur relâche le bouton. Ce genre d’effet n’est pas désirable, car il peut engendrer des parasites au sein de votre programme (si vous voulez détecter un appui, les rebonds vont vous en générer une dizaine en quelques millisecondes, ce qui peut-être très gênant dans le cas d’un compteur par exemple). Voilà un exemple de chronogramme relevé lors du relâchement d’un bouton poussoir :

Pour atténuer ce phénomène, nous allons utiliser un condensateur en parallèle avec le bouton. Ce composant servira ici « d’amortisseur » qui absorbera les rebonds (comme sur une voiture avec les cahots de la route). Le condensateur, initialement chargé, va se décharger lors de l’appui sur le bouton. S’il y a des rebonds, ils seront encaissés par le condensateur durant cette décharge. Il se passera le phénomène inverse (charge du condensateur) lors du relâchement du bouton. Ce principe est illustré à la figure suivante :

Filtre anti-rebond

Schéma résumé

En résumé, voilà un montage que vous pourriez obtenir avec un bouton, sa résistance de pull-up et son filtre anti-rebond sur votre carte Arduino :

Schéma exemple Circuit exemple

Les pull-ups internes

Comme expliqué précédemment, pour obtenir des signaux clairs et éviter les courts-circuits, on utilise des résistances de pull-up. Cependant, ces dernières existent aussi en interne du microcontrôleur de l’Arduino, ce qui évite d’avoir à les rajouter par nous mêmes par la suite. Ces dernières ont une valeur de 20 kilo-Ohms. Elles peuvent être utilisés sans aucune contraintes techniques. Cependant, si vous les mettez en marche, il faut se souvenir que cela équivaut à mettre la broche à l’état haut (et en entrée évidemment). Donc si vous repassez à un état de sortie ensuite, rappelez vous bien que tant que vous ne l’avez pas changée elle sera à l’état haut. Ce que je vient de dire permet de mettre en place ces dernières dans le logiciel :

Depuis la version 1.0.1 d’Arduino, une pull-up peut etre simplement mis en oeuvre en utilisant le deuxieme argument de pinMode. La syntaxe devient pinMode(unBouton, INPUT_PULLUP) et il n’y a plus besoin de faire un digitalWrite() ensuite.

Schéma résumé

Schéma exemple Circuit exemple

Récupérer l’appui du bouton

Montage de base

Pour cette partie, nous allons apprendre à lire l’état d’une entrée numérique. Tout d’abord, il faut savoir qu’une entrée numérique ne peut prendre que deux états, HAUT (HIGH) ou BAS (LOW). L’état haut correspond à une tension de +5V sur la broche, tandis que l’état bas est une tension de 0V. Dans notre exemple, nous allons utiliser un simple bouton. Dans la réalité, vous pourriez utiliser n’importe quel capteur qui possède une sortie numérique. Nous allons donc utiliser :

  • Un bouton poussoir (et une résistance de 10k de pull-up et un condensateur anti-rebond de 10nF)
  • Une LED (et sa résistance de limitation de courant)
  • La carte Arduino

Voici maintenant le schéma à réaliser :

Schéma avec 1 bouton et 1 LED Montage avec 1 bouton et 1 led

Montage simple avec un bouton et une LED

Paramétrer la carte

Afin de pouvoir utiliser le bouton, il faut spécifier à Arduino qu’il y a un bouton de connecté sur une de ses broches. Cette broche sera donc une entrée. Bien entendu, comme vous êtes de bons élèves, vous vous souvenez que tous les paramétrages initiaux se font dans la fonction setup(). Vous vous souvenez également que pour définir le type (entrée ou sortie) d’une broche, on utilise la fonction : pinMode(). Notre bouton étant branché sur la pin 2, on écrira :

Pour plus de clarté dans les futurs codes, on considérera que l’on a déclaré une variable globale nommée « bouton » et ayant la valeur 2. Comme ceci :

Voilà, maintenant notre carte Arduino sait qu’il y a quelque chose de connecté sur sa broche 2 et que cette broche est configurée en entrée.

Récupérer l’état du bouton

Maintenant que le bouton est paramétré, nous allons chercher à savoir quel est son état (appuyé ou relâché).

  • S’il est relâché, la tension à ses bornes sera de +5V, donc un état logique HIGH.
  • S’il est appuyé, elle sera de 0V, donc LOW.

Un petit tour sur la référence et nous apprenons qu’il faut utiliser la fonction digitalRead() pour lire l’état logique d’une entrée logique. Cette fonction prend un paramètre qui est la broche à tester et elle retourne une variable de type int. Pour lire l’état de la broche 2 nous ferons donc :

Observez dans ce code, on appelle deux fonctions qui dépendent de l’état du bouton. Ces fonctions ne sont pas présentes dans ce code, si vous le testez ainsi, il ne fonctionnera pas. Pour ce faire, vous devrez créer les fonctions actionAppui().

Test simple

Nous allons passer à un petit test, que vous allez faire. Moi je regarde ! 😈

But

L’objectif de ce test est assez simple : lorsque l’on appuie sur le bouton, la LED doit s’éteindre. Lorsque l’on relâche le bouton, la LED doit s’allumer. Autrement dit, tant que le bouton est éteint, la LED est allumée.

Correction

Allez, c’est vraiment pas dur, en plus je vous donnais le montage dans la première partie… Voici la correction :

  • – Les variables globales

  • – La fonction setup()

  • – La fonction loop()

J’espère que vous y êtes parvenu sans trop de difficultés ! Si oui, passons à l’exercice suivant…

Interagir avec les LEDs

Nous allons maintenant faire un exemple d’application ensemble.

Montage à faire

Pour cet exercice, nous allons utiliser deux boutons et quatre LEDs de n’importe quelles couleurs.

  • Les deux boutons seront considérés actifs (appuyés) à l’état bas (0V) comme dans la partie précédente. Ils seront connectés sur les broches 2 et 3 de l’Arduino.
  • Ensuite, les 4 LEDs seront connectées sur les broches 10 à 13 de l’Arduino.

Voilà donc le montage à effectuer :

Schéma avec 2 boutons et 4 LEDs Montage avec 2 boutons et 4 leds Montage de l’exercice, avec deux boutons et quatre LEDs

Objectif : Barregraphe à LED

Dans cet exercice, nous allons faire un mini-barregraphe. Un barregraphe est un afficheur qui indique une quantité, provenant d’une information quelconque (niveau d’eau, puissance sonore, etc.), sous une forme lumineuse. Le plus souvent, on utilise des LEDs alignées en guise d’affichage. Chaque LED se verra allumée selon un niveau qui sera une fraction du niveau total. Par exemple, si je prends une information qui varie entre 0 et 100, chacune des 4 LED correspondra au quart du maximum de cette variation. Soit 100 / 4 = 25. En l’occurrence, l’information entrante c’est l’appui des boutons. Par conséquent un appui sur un bouton allume une LED, un appui sur un autre bouton éteint une LED. En fait ce n’est pas aussi direct, il faut incrémenter ou décrémenter la valeur d’une variable et en fonction de cette valeur, on allume telle quantité de LED.

Cahier des charges

La réalisation prévue devra :

  • – posséder 4 LED (ou plus pour les plus téméraires)
  • – posséder 2 boutons : un qui incrémentera le nombre de LED allumées, l’autre qui le décrémentera

Vous devrez utiliser une variable qui voit sa valeur augmenter ou diminuer entre 1 et 4 selon l’appui du bouton d’incrémentation ou de décrémentation.

Vous pouvez maintenant vous lancer dans l’aventure. Pour ceux qui se sentiraient encore un peu mal à l’aise avec la programmation, je vous autorise à poursuivre la lecture qui vous expliquera pas à pas comment procéder pour arriver au résultat final. 😉

Correction

Initialisation

Pour commencer, on créer et on initialise toutes les variables dont on a besoin dans notre programme :

Détection des différences appuyé/relâché

Afin de détecter un appui sur un bouton, nous devons comparer son état courant avec son état précédent. C’est-à-dire qu’avant qu’il soit appuyé ou relâché, on lit son état et on l’inscrit dans une variable. Ensuite, on relit si son état à changé. Si c’est le cas alors on incrémente la variable nombre_led. Pour faire cela, on va utiliser une variable de plus par bouton :

Détection du changement d’état

Comme dit précédemment, nous devons détecter le changement de position du bouton, sinon on ne verra rien car tout se passera trop vite. Voilà le programme de la boucle principale :

Nous avons terminé de créer le squelette du programme et la détection d’évènement, il ne reste plus qu’à afficher le résultat du nombre !

L’affichage

Pour éviter de se compliquer la vie et d’alourdir le code, on va créer une fonction d’affichage. Celle dont je viens de vous parler : affiche(int le_parametre). Cette fonction reçoit un paramètre représentant le nombre à afficher. A présent, nous devons allumer les LEDs selon la valeur reçue. On sait que l’on doit afficher une LED lorsque l’on reçoit le nombre 1, 2 LEDs lorsqu’on reçoit le nombre 2, …

Donc, si la fonction reçoit le nombre 1, on allume la LED 1. Si elle reçoit le nombre 2, elle allume la LED 1 et 2. Si elle reçoit 3, elle allume la LED 1, 2 et 3. Enfin, si elle reçoit 4, alors elle allume toutes les LEDs. Le code au grand complet :

Secret: Réponse SelectionnerAfficher
Une petite vidéo du résultat que vous devriez obtenir, même si votre code est différent du mien :

Les interruptions matérielles

Voici maintenant un sujet plus délicat (mais pas tant que ça ! :ninja: ) qui demande votre attention.

Comme vous l’avez remarqué dans la partie précédente, pour récupérer l’état du bouton il faut surveiller régulièrement l’état de ce dernier. Cependant, si le programme a quelque chose de long à traiter, par exemple s’occuper de l’allumage d’une LED et faire une pause avec delay() (bien que l’on puisse utiliser millis() ), l’appui sur le bouton ne sera pas très réactif et lent à la détente. Pour certaines applications, cela peut gêner. Problème : si l’utilisateur appuie et relâche rapidement le bouton, vous pourriez ne pas détecter l’appui (si vous êtes dans un traitement long). Solution : Utiliser le mécanisme d’interruption.

Principe

Dans les parties précédentes de ce chapitre, la lecture d’un changement d’état se faisait en comparant régulièrement l’état du bouton à un moment avec son état précédent. Cette méthode fonctionne bien, mais pose un problème : l’appui ne peut pas être détecté s’il est trop court. Autre situation, si l’utilisateur fait un appui très long, mais que vous êtes déjà dans un traitement très long (calcul de la millième décimale de PI, soyons fous), le temps de réponse à l’appui ne sera pas du tout optimal, l’utilisateur aura une impression de lag (= pas réactif). Pour pallier ce genre de problème, les constructeurs de microcontrôleurs ont mis en place des systèmes qui permettent de détecter des évènements et d’exécuter des fonctions dès la détection de ces derniers. Par exemple, lorsqu’un pilote d’avion de chasse demande au siège de s’éjecter, le siège doit réagir au moment de l’appui, pas une minute plus tard (trop tard).

Qu’est-ce qu’une interruption ?

Une interruption est en fait un déclenchement qui arrête l’exécution du programme pour faire une tâche demandée. Par exemple, imaginons que le programme compte jusqu’à l’infinie. Moi, programmeur, je veux que le programme arrête de compter lorsque j’appuie sur un bouton. Or, il s’avère que la fonction qui compte est une boucle for(), dont on ne peut sortir sans avoir atteint l’infinie (autrement dit jamais, en théorie). Nous allons donc nous tourner vers les interruptions qui, dès que le bouton sera appuyé, interromprons le programme pour lui dire : « Arrête de compter, c’est l’utilisateur qui le demande !« . Pour résumer : une interruption du programme est générée lors d’un événement attendu. Ceci dans le but d’effectuer une tâche, puis de reprendre l’exécution du programme. Arduino propose aussi ce genre de gestion d’évènements. On les retrouvera sur certaines broches, sur des timers, des liaisons de communication, etc.

Mise en place

Nous allons illustrer ce mécanisme avec ce qui nous concerne ici, les boutons. Dans le cas d’une carte Arduino UNO, on trouve deux broches pour gérer des interruptions externes (qui ne sont pas dues au programme lui même), la 2 et la 3. Pour déclencher une interruption, plusieurs cas de figure sont possibles :

  • LOW : Passage à l’état bas de la broche
  • FALLING : Détection d’un front descendant (passage de l’état haut à l’état bas)
  • RISING : Détection d’un front montant (pareil qu’avant, mais dans l’autre sens)
  • CHANGE : Changement d’état de la broche

Autrement dit, s’il y a un changement d’un type énuméré au-dessus, alors le programme sera interrompu pour effectuer une action.

Créer une nouvelle interruption

Comme d’habitude, nous allons commencer par faire des réglages dans la fonction setup(). La fonction importante à utiliser est attachInterrupt(interrupt, function, mode). Elle accepte trois paramètres :

  • – interrupt : qui est le numéro de la broche utilisée pour l’interruption (0 pour la broche 2 et 1 pour la broche 3)
  • – function : qui est le nom de la fonction à appeler lorsque l’interruption est déclenchée
  • – mode : qui est le type de déclenchement (cf. ci-dessus)

Si l’on veut appeler une fonction nommée Reagir() lorsque l’utilisateur appuie sur un bouton branché sur la broche 2 on fera :

Vous remarquerez l’absence des parenthèses après le nom de la fonction « Reagir »

Ensuite, il vous suffit de coder votre fonction Reagir() un peu plus loin.

Attention, cette fonction ne peut pas prendre d’argument et ne retournera aucun résultat.

Lorsque quelque chose déclenchera l’interruption, le programme principal sera mis en pause. Ensuite, lorsque l’interruption aura été exécutée et traitée, il reprendra comme si rien ne s’était produit (avec peut-être des variables mises à jour).

Mise en garde

Si je fais une partie entière sur les interruptions, ce n’est pas que c’est difficile mais c’est surtout pour vous mettre en garde sur certains points. Tout d’abord, les interruptions ne sont pas une solution miracle. En effet, gardez bien en tête que leur utilisation répond à un besoin justifié. Elles mettent tout votre programme en pause, et une mauvaise programmation (ce qui n’arrivera pas, je vous fais confiance 😉 ) peut entraîner une altération de l’état de vos variables. De plus, les fonctions delay() et millis() n’auront pas un comportement correct. En effet, pendant ce temps le programme principal est complètement stoppé, donc les fonctions gérant le temps ne fonctionneront plus, elles seront aussi en pause et laisseront la priorité à la fonction d’interruption. La fonction delay() est donc désactivée et la valeur retournée par millis() ne changera pas. Justifiez donc votre choix avant d’utiliser les interruptions. 😉

Et voilà, vous savez maintenant comment donner de l’interactivité à l’expérience utilisateur. Vous avez pu voir quelques applications, mais nul doute que votre imagination fertile va en apporter de nouvelles !

125 commentaires

  1. Salut,
    J’ai une question concernant sur les boutons.
    Pour un boutons NO, lorsqu’il est relâché le courant ne passe pas, donc son état est « LOW ». Mais lorsqu’il est appuyé, le courant passe, donc son état est « HIGH ».

    Inversement pour les boutons NF

    c’est ça ?

  2. Dans le tuto mes boutons sont NO.
    Pour ce qui est du HIGH et LOW, ca va dépendre où tu mesures le signal et si tu utilises une résistance de pull-up ou de pull-down (tirage à l’état haut ou a l’état bas). Ainsi, dans un cas tu pourras donner un état de reponse à Haut ou sinon à bas selon ton besoin.
    Dans les schémas de la page, on utilise une pull-up, le signal au repos est haut. Maintenant imagine que l’on inverse le 5V et le GND sur les boutons, la pull-up devient pull-down et le signal mesuré au repos sera un état bas.

      • Enfaite j’aimerais dans le cadre d’un projet de fin d’année allumer le programme et l’éteindre (complètement) en appuyant juste sur un bouton poussoir par exemple allumer le programme en début de journée en appuyant une fois sur le BP et en fin de journée appuyer une nouvelle fois sur le BP pour l’éteindre jusqu’au lendemain ainsi de suite…

          • Oui c’est vrai ce n’est pas bête mais ça facilite trop les choses ^^ il n’y aurai pas des solutions de programme pour ça? Merci beaucoup pour vos réponses

          • Mais pourquoi faire simple quand on peut faire compliqué 😀
            La solution avec le while proposé ci-dessus devrait fonctionner… C’est brutal mais ca marche !

  3. Re-bonjour,
    je continue la discussion dans le bon forum (en tout cas je l’espère…;- ) ). donc je disais… en relisant le début de la partie 2, je comprend bien qu’une led peut être connectée en « polarisation inverse » mais vue que le courant ne passe pas c’est quoi l’intérêt dans le montage pour « incrémentation/décrémentation ? d’autant que j’ai du le remettre en « polarisation normal » pour que ça fonctionne. 😮

    • En fait le courant passera lorsque ta broche Arduino sera à 0 (la led s’allume) et ne passera pas lorsque la broche sera à 1/HIGH (la led est éteinte). C’est un vieil enseignement que j’ai appliqué, mais s’il te gêne tu peux brancher la led dans l’autre sens (de l’arduino vers la masse) et la piloter HIGH=allumé et LOW=éteinte

  4. Bonjour re-moi (le type chiant ^^) je n’arrive pas a mettre mon programme en pause avec le bouton poussoir (j’utilise a afficheur et non une led) Sachant qu’il est impossible ou barbare d’arrêter un programme le mettre en pause parait être une meilleurs solution mais le problème c’est que je n’arrive pas a le mettre sur pause, mon soue et de mettre sur pause le programme grâce au BP et le relancer en n’appuyant une nouvelle fois sur celui-ci, pouvais vous m’aider svp, Merci beaucoup!

  5. Salut je viens de faire le tuto un bouton et une LED mais j’ai le comportement inverse, j’ai don un bouton NF ? on peut le vérifier comment ? avec un multimètre ?

    Sinon il n’y a pas une erreur ?

    digitalWrite(led,LOW); //le bouton est appuyé, la LED est allumée (dans ta vidéo est est éteinte)

    • Le chapitre ayant été revu (c’est un des premiers, il a subi plusieurs révisions 😀 ) c’est possible que la vidéo ne soit malheureusement plus à jour… Il faudrait que je vérifie !

      Pour ton bouton c’est assez simple.
      Si c’est un NF, alors ton multimetre t’indiquera une résistances très faible lorsque tu mesures sa résistances entre ses deux broches.
      Si c’est un NO c’est le contraire, la résistance sera infinie !

      Après si tu es sur de ton code et de ton câblage tu peux aussi le déterminer via le comportement du circuit.

      Sinon, test tout simple. Tu mets en série le bouton, la résistance et la led. Si la led s’allume sans action, c’est un NF. S’il faut appuyer pour l’allumer, c’est un NO !

  6. Bonjour,
    Petite question sur l »interruption matérielle avec AttachInterrupt : si j’écris dans setup « attachInterrupt(0, reagir(), CHANGE), le programme est interrompu jusqu’à ce que la fonction réagir soit terminée, ou de manière définitive? Si c’est le premier cas de figure, la fonction reprend-elle la ou elle s’était arrêtée ou au début de la fonction loop()?

    • Normalement oui. Il suffit d’attacher la fonction une bonne fois pour toute dans le setup et après elle devrait s’exécuter a chaque fois que la condition d’interruption est rencontrée. Ton événement d’interruption est très rapide ? Tu n’as pas mis de boucles bloquant tout dans la fonction d’interruption ?

      • Le fichier consiste en un enregistrement de données sur carte SD ; j’ai mis deux interruptions, l’une pour lire le fichier enregistrer et l’afficher sur le moniteur série, l’autre pour effacer le fichier.

        L’ordinateur affiche parfois un message du type « Crête d’alimentation du port usb atteint » ; j’ai donc mis une alimentation externe mais ca n’a pas l’air de régler le problème…

      • Dans le cas ou la broche 2 est sur HIGH, alors le 5V n’est effectivement plus nécessaire puisque le 5V sera relie en interne (visible sur le schéma « Les pull-ups internes »). Seulement par défaut la broche en entrée est a LOW et donc non relie via la pull-up interne.
        Un schéma en particulier te pose problème a ce sujet ?

        • C’est le schéma « Récupérer l’appui du bouton » que je ne comprends pas. Si le bouton est appuyé, la broche est sur HIGH et la broche 5V est inutile. Mais si il est relâché alors elle est sur LOW et à quoi sert celle de 5V ?

          • Dans ce schéma et ce code, la pull-up interne n’est pas active. Autrement dit, si on enlevait la résistance et la connexion au 5V, la broche se contenterait de lire « le bruit ambiant » tant que le bouton n’est pas appuyé (ce qui aurait pour conséquence de tirer la broche a la masse). En mettant la broche au 5V (au travers de la résistance) on impose un potentiel de repos, donc on lit bien l’état haut quand le bouton est relâché.

            Attention, le courant ne traverse pas le condensateur. Ce dernier doit être vu comme un circuit ouvert ! Essaie d’imaginer le schéma sans si tu préfères.

    • Admettons on ne met pas de connexion vers le 5V. A l’état de repos, quel devrait être la valeur lue ? 5V ? 0V ? Il n’y a pas de réponse, on se contenterait de lire les parasites électromagnétiques qui traîne. On va donc imposer un état en reliant l’entrée au 5V (ou a la masse selon l’état de repos que l’on veut). Mais si on ne met pas de résistance, il y aura un court-circuit quand le bouton sera appuyé. On met donc une résistance pour limiter le courant lors de l’appui (et définir clairement les états actifs / repos).

  7. Bonjour, il manque un petit graphique pour voir la différence de rebonds une fois qu’un condensateur a été associé au bouton. Et un peu plus loin tu parles d’ajouter un condensateur anti-rebonds de 10nf, mais à ce stade l’unité n’a pas été décrite, ni comment cette valeur a été choisie.
    Sinon dans le le format pdf un petit sommaire pour la navigation serait pratique.
    Merci.

  8. Bonjour
    Je suis débutant en électronique et je suis très content d’avoir (enfin) trouvé un site avec autant d explication BRAVO.J ai lu également l électronique pour les nuls qui m’a permis d’apprendre les bases.
    Par contre je n’arrive pas à trouver de résistances de pull-up et condensateurs anti-rebond,est ce que la résistance est la même que pour une LED et le condensateur en quelle matière est-il?Je ne trouve aucune info
    sur le net à propos de se montage pour un bouton poussoir.
    J’ai écris une variante de votre programme,mais je n ose pas l essayer car j ai peur de cramer mon arduino.
    Pourriez vous m’en dire un peu plus sur ses 2 composants.
    Merci (de votre patience).

    • Salut !

      Pour le condensateur, c’est un modèle tout simple plastique de quelques nano Farads (une dizaine devrait faire l’affaire, mais ca peut se calculer). C’est grâce a sa charge/décharge que l’on va lisser la tension lue.
      Pour la résistance, c’est un modèle tout ce qu’il y a de plus classiques. Cependant, la valeur est différente. Une résistance de quelques kilo-omhs (10k par exemple) est bien.

      Bien que le condensateur de filtrage soit dans la plupart des cas facultatifs, la résistance elle ne l’est pas (sauf si tu utilises la résistance interne à l’Arduino, comme explique dans le morceau « Les pull-ups internes »)

      • Bonjour,
        Un grand merci pour ce tuto qui a résolu un problème qui restait pour moi insoluble : Gérer une interruption externe avec un capteur pluviomètre LEXCA001.

        Bien sûr, on trouve sur plusieurs sites spécialisés des tutoriels expliquant comment programmer les interruptions sur un Arduino avec les codes et fonctions afférentes. Mais malgré de nombreuses recherches, personne ne parle du condensateur de filtrage ! Et pourtant , pour certains type de capteurs, comme ce capteur pluviomètre iLS, les résistances pull-up ne suffisent pas !

        Avec ce capteur, que ce soit sur NANO, UNO ou MEGA, les interruptions sont instables et générées même s’il n’y a pas de basculement de l’auget et qu’il fait bien sec !

        J’ai essayé de pallier ce problème avec du code, sans succès. C’est en mettant un drapeau dans la fonction appelée par l’interruption, que je me suis rendu compte qu’en dehors des incréments de comptage liées aux basculements de l’auget, la variable s’incrémentait de manière totalement alléatoire soit de +1 ou +2… Votre idée de mettre un condensateur de 10nf à solutionné le problème et le comptage des basculement d’auget est désormais exact.

        Un petit tuto expliquant le mode de calcul de la valeur du condensateur serait un plus…

        Merci !

        Cordialement.

  9. Comme dit sur le site d’Arduino, la façon d’activer les résistances pull-ups internes a changé et fonctionne maintenant avec le mode INTERNAL_PULLUP de pinMode. Cela n’est donc plus possible avec la manière « bizarre » du digitalWrite() 😉

    Source sur la page Arduino de la fonction pinMode() (http://arduino.cc/en/Reference/pinMode) :
    « As of Arduino 1.0.1, it is possible to enable the internal pullup resistors with the mode INPUT_PULLUP. Additionally, the INPUT mode explicitly disables the internal pullups. »

    • Par contre, je viens aussi de me rendre compte que :
      « An output pin that is left in a HIGH state will have the pullup resistors set if switched to an input with pinMode(). »
      Ce qui veut dire que ta méthode du « digitalWrite(pin, HIGH) » marche aussi x)

      • En voyant ceci, je ne sais plus tellement quoi penser :
        « An output pin that is left in a HIGH state will have the pullup resistors set if switched to an input with pinMode().
        Prior to Arduino 1.0.1, it was possible to configure the internal pull-ups in the following manner:
        pinMode(pin, INPUT); // set pin to input
        digitalWrite(pin, HIGH); // turn on pullup resistors »

        Ça marche toujours ou pas ? Je comprends pas 😉

  10. J’ai essayé « pinMode(unBouton, INTERNAL_PULLUP) » mais ce n’est pas reconnu par le logiciel, j’ai vu sur internet que c’était plutot « pinMode(unBouton, INPUT_PULLUP) » Voila en espérant avoir aidé 😀

  11. bonjour

    je débute sur arduino uno et pour bien comprendre, j’essaie de modifié le programme du Barregraphe à LED.
    voilà je voudrais faire le même chose mais avec un seul BP, c’est à dire on incrémente comme dans le programme de départ mais on décrémente avec le même BP.
    je sais ça sert à rien, mais c’est pour essayer de comprendre la syntaxe de la programmation avec arduino car je dois dire que ce n’est pas très clair pour moi.
    merci

      • ben c’est peut-être ça qui m’échappe, parce que j’ai suivi les premiers schémas proposer sur le site,
        c’est très bien expliquer, mais avant d’attaquer les moteurs et tout le reste, je me suis dis essaie déjà de comprendre avec un bp et des LED. donc essaie de modifié la programmation et là je me suis aperçu que j’avais rien compris.
        ben au départ je me suis dis avec un compteur j’appuie 4 fois de suite ça allume les LED une à une et 4 fois de plus et elle s’éteignent une à une.
        j’avais aussi penser à un truc du genre : les leds s’allument et s’éteignent en fonction du temps que je reste appuyer sur le bp, 5s=1led , 10s=2led etc.
        bref y a un turc que j’ai pas compris dans tout ça si vous pouviez m’éclairer.
        merci

        • Bon j’ai bidouiller un truc en essayant de mixer le programme du site et le programme Button State Change Detection du site arduino.
          c’est loin d’être parfait mais j’essaie de comprendre et j’ai du boulot.
          ça fonctionne à peu près mais après 8 impulsions sur le bp ça redémarre pas à zéro, et pour la partie décrémentation c’est pas parfait
          je vous mets le programme que j’ai bidouiller

          Secret SelectionnerAfficher

          si vous pouviez me dire ce qui ne va pas et comment je peux l’améliorer
          merci

          • Attention, dans ton dernier if il semble manquer une parenthèse fermante a la fin et surtout tu sembles melanger l’utilisation de simple ‘=’ (assignation de valeur) et du double ‘=’ (comparaison de valeurs).

            PS: Je me suis permis de mettre ton code dans un bloc adapte pour faciliter la lecture :)

  12. bonjour
    merci pour le bloc, je savais pas comment faire. et oui je pense bien mélanger plein de chose et c’est bien ce qui est pas clair dans mon esprit.
    bon je vais continuer à chercher
    merci

  13. Bonjour,
    je voulais savoir si je pouvais faire ton premier montage (celui avec la Pull-Up et le condensateur) en utilisant une carte « arduino Ethernet » car dans le cadre d’un projet que je réalise, je dois récupérer l’appui d’un BP pour mettre en route un système de mesure (odomètre) et enregistrer les mesures effectuées (exemple : 126m et dénivelé de 12%) sur une carte SD et ensuite les retransmettre ultérieurement via la carte SD sur une page web (d’où le nom « Ethernet » bien-sur).
    Merci pour les nombreuses explications sur ce site car elles me sont vraiment utiles !
    PS: je suis débutant en électronique

      • Je te remercie !
        Autre question : Savez-vous comment je peux enregistrer mes mesures faites dans un format .csv (Format Tableur -> Excel par exemple) ?? Via un programme bien sur.
        Merci encore

          • D’accord, merci & je pourrais te transmettre mon programme fait d’ici une semaine maximum par exemple ? Pour une vérification, je n’aimerai pas mettre hors service une arduino de mon lycée :rire:
            Merci à vous

          • Pour ce genre de requête, je te demanderais de passer par un forum comme ceux de Zeste de Savoir (rubrique « Systèmes et Matériel » par exemple). J’y passe souvent. Je préfère garder cette zone de commentaire pour parler du tuto et les questions qui s’y rapportent.

  14. Bonjour,

    Je viens de m’heurter à un petit problème de programmation.

    Imaginons que je souhaite récupérer l’information d’un bouton, je tape : « digitalRead(n°Pin).

    Mais si je souhaite récupérer le n°Pin avec une variable, comme puis-je faire ?

    ex :

    void test(int bouton); //prototype de la fonction test

    const int bouton = A0;

    void setup()
    {
    pinMode(bouton, INPUT);
    }

    void loop()
    {
    test(« bouton »); //appel de la fonction test
    }

    void test(int bouton)
    {
    digitalRead(bouton); // on récupère l’information du pin « bouton »
    }

    L’utilité d’un tel programme serait de faire tourner un moteur jusqu’à la présence d’un capteur. Il suffirait donc d’appeler la fonction test qui déplacerais le moteur jusqu’à un certain capteur précisé en parametre.

    Par avance merci

    Yvan

  15. Bonjour 😀
    Alors là, je bloque :( Je ne comprend rien au montage, malgré plusieurs essais.. Y aurait-il un moyen de voir ton montage en photo? Je suis perdu et je tourne en rond depuis 1h :(

      • Sur le premier, pour introduire les boutons. Enfin j’ai essayé de faire celui grâce auquel, lorsque tu appuies sur le bouton, la led s’allume (ou s’éteint) et j’avoue avoir du mal à piger le branchements que je dois faire sur la breadboard :/ J’ai essayé deux trois trucs mais sans succès :( Pourtant ça doit être simple, mais je ne comprend pas ^^

        • Désolé pour le flood mais j’ai réussi à faire en sorte que quand tu reste appuyé sur le bouton, la led s’allume, mais je n’ai pas utilisé de condensateur, c’est pas grave?

          • Non ce n’est pas grave, le condensateur est juste la pour filtrer les perturbations, ce n’est pas dramatique de ne pas l’avoir

          • Au final je l’ai quand même utilisé ^^ Dire que je viens de galérer pendant 30 bonnes minutes parce-que j’ai oublié de mettre pinMode(led, OUTPUT) xD

  16. Pingback: Arduino circuit - tests | Pearltrees

  17. salut, j’ai du mal a comprendre ton 1er shema sur la résistance pull-up.Tu dit qu’on met un bouton pour pouvoir mettre la tension a 0V quand on appuie dessus, et la résistance sert uniquement a éviter le court circuit.

    Lorsqu’on appui pas sur le bouton, les 4.99 V vont vers la broche 3 normalement.Tu dit que lorsqu’on appui sur le bouton, alors les 4.99V vont dans la masse et que donc la broche 3 reçoit 0V.Est ce bien ce qui se produit?car j’ai fait le montage est ce n’est pas le resultat que j’obtiens (j’ai mis une led sur chaque sortie pour voir par ou passe le courant et je constate que le courant se divise en 2 lorsque j’appuie sur le bouton).Voila le montage que j’ai fait, et la led qui va vers le microcontrôleur s’allume même quand j »appuie sur le bouton.
    http://www.hostingpics.net/viewer.php?id=416801Sanstitre.png

    • Ton schéma ne peut pas marcher. La broche 3 (en entrée) a une caractéristique que l’on appelle « haute impédance ». Elle ne consomme pas de courant et n’est ni vraiment a 5V ou 0V. Du coup tu n’auras pas de différence de potentiel et ta LED ne s’allumera pas. C’est aussi cette haute impédance qui fait que les 5V ne « vont » pas dans l’entrée, le microcontrôleur se contente de lire sans consommer. Si tu mettais un ampèremètre entre le 5V et l’entrée tu ne verrais pas de consommation de courant (ou juste quelque nA).

  18. Bonjour,

    Dans le tuto du bouton poussoir vous donnez comme but:

    « lorsque l’on appuie sur le bouton, la LED doit s’éteindre. Lorsque l’on relâche le bouton, la LED doit s’allumer »

    sauf erreur (je suis débutant) le code qui a été donné en exemple fait le contraire: la LED est éteinte en position repos puisque sur état « HIGH »

  19. Bonsoir, je me posais quelques question sur la formule R=U/I:
    en effet j’ai fait le calcul pour mettre ma résistance pour une led, j’ai donc fait R=5/0.020=250ohms.Jusque la tout vas bien mais on sait qu’une résistance diminue la tension d’un courant, j’ai donc voulus savoir qu’elle est la tension aux bornes de la résistance: U=R*I=250*0.020=5V, mais ce résultat n’est pas possible, alors je voudrais savoir pourquoi j’ai ce résultat?

    • ok merci j’ai trouvé les réponses a mes interrogations.Je voudrais savoir une dernière chose, dans ces deux schémas: http://hpics.li/7e071ee dans le schéma 2 les deux diodes s’allument mais dans le schéma 1 il y en a qu’une qui s’allume (toujours la rouge). Je ne comprend pas pourquoi car les deux schémas sont en dérivations donc l’intensité est distribuée de manière équitable (donc soit aucune s’allume soit les deux s’allume faiblement)

      • Il faudrait avoir les caractéristiques des leds pour être sur… Résumons. On va avoir deux courants (un par led), qui se cumulent dans la résistance. Donc on a une chute de tension X dans la résistance (U=RI). Maintenant, si 5-X est supérieur a la tension de seuil d’une des deux leds, alors cette dernière ne s’allumera pas (ou alors tres tres peu si la différence de tension est faible).

        Sinon es tu sur d’avoir bien branche les leds (dans le bon sens) ?

        • oui, en faite dans le schéma 1 les deux diodes s’allument, elles s’allument toutes les deux faiblement, et dès que j’en retire une, l’autre s’allume plus fort ( son intensité lumineuse augmente ce qui est logique car on stop la division du courant). Mais dès que je met une diode rouge, quelque soit la couleur de l’autre il n’y a qu’elle qui va s’allumer (sauf si l’autre aussi est rouge).
          Et pour le schéma 2, si je retire l’une des deux leds, l’intensité lumineuse de l’autre reste inchangée même avec une diode rouge, ce qui est normal.

          donc je comprend pas pourquoi dans le schéma 1 la diode rouge aspire tout le courant pour elle seule, contrairement au schéma 2.

  20. Pingback: Compteur d’utilisation CPU/RAM | Clemaul

  21. Bonsoir Eskimon, je suis en train de faire un petit robot, et lorqu’il tape dans un obstacle (microrupteur enfoncé), il devrait s’arêter et changer de direction. J’ai essayé ton truc avec le pull-up mais rien n’y fait, alors je ne sais pas si c’est dû à mon programme ou à mon circuit, pourrais tu m’aider stp ?

    • Bonjour,

      Je devrais pouvoir t’aider oui ^^ . Essaie d’ouvrir un sujet sur le forum « Système et Matériel » de Zeste de Savoir et je pourrais essayer de voir ce que je peux faire (ça sera plus confortable de rédiger la bas, les outils sont meilleurs que cette zone de commentaires que j’essai de garder pour les questions sur le tuto lui-même ^^ ). Il suffira d’expliquer ce qui ne marche pas et ce que tu as essaye et plein de gens viendront voir comment résoudre le souci :)

  22. Bonjour, je dois réaliser un compteur de clique qui va de 0 jusqu’a 99 clique, sur un 7 segment, donc j’ai un problème c’est que le compteur avance si je reste appuyé sur le bouton alors que moi je voudrais que le compteur avance à chaque clique uniquement. Je ne sais pas si le problème vient du code ou du bouton. J’utilise proteus pour la simulation. Pourriez-vous m’aider, merci d’avance.

  23. Lors du premier exercice, écrire  » etatbouton = HIGH » ne sert à rien non? C’est un fait si le niveau est haut ou bas, on ne choisit pas (il me semble). En tout cas, enlever la ligne ne change rien, le programme fonctionne toujours.

  24. bonjour,
    et en 1er merci pour les explications.
    j’ai donc utiliser le tuto pour utiliser un bouton interrupteur, le soucis et que mon ecran 20/4 change de luminosité suivant si j’utilise ou pas le bouton
    il commande un relai de puissance

    mon installation et pour piloter un bassin naturel, pompe, electrovanne , temperature Air / eau, eclairage. soit manuellement soit automatiquement.

  25. Pingback: Labview-arduino | Pearltrees

  26. Pingback: Arduino | Pearltrees

  27. Bonjour et merci pour l’article ! J’ai besoin d’utiliser un interrupteur 3 broches dans un circuit et demander à l’arduino d’allumer un émetteur IR lorsque l’interrupteur est en position 1 et de ne pas l’allumer lorsque l’interrupteur est en position 2. Mais comment se traduit en programmation la position de cet interrupteur ? Je pense que ce n’est pas HIGH ou LOW car LOW devrait correspondre à la broche du milieu, la masse

  28. Bonjour , article très intéressant ,

    j’ai une petite question …

    j’aurai un besoin au niveau de attachInterrupt(interrupt, function, mode)

    j’utilise des fonctions VOID dans mes programmes , si je met un attachinterrup dans une de ces fonctions , l’interruption n’interviendra que quand je serai dans cette fonction ou c’est obligatoirement dans le programme entier ?
    merci d’avance

      • bonjour je parcours le net depuis plusieurs jour et je n’arrive pas à trouver un site où on explique de façon compréhensive pour moi la programmation de l’arduino , mais à lire tes commentaires je pense que tu va pouvoir me venir en aide.
        j’aimerai faire un comptage qui mette une sortie à 1 pendant un temps défini puis que cette sortie repasse à 0 .
        bien entendu après avoir atteint le nombre voulu au comptage on repasse à zéro : exp 1 2 3 et puis 0 pour pouvoir recommencer à compter
        dans l’attente , salutations G A

          • bonjour
            peux tu m’indiquer où lire le tuto dont tu parles?
            d’autre part je vais voir si je peux mettre le programme que j’ai écrit et qui ne fait pas ce que j’aimerais qu’il fasse
            à savoir : après la troisième détection si je maintien celle ci il n’y a pas de problème la sortie passe bien de 1 à 0 mais dès que je relâche la détection j’ai une micro impulsion sur la sortie et cela ne me convient pas .
            bien sur je peux corriger physiquement par un contact de fin de course mais je préfère la solution par programme

            #define loc 3
            #define loco 2
            # define led 14
            int locoState = 0;
            int lastlocoState = 0;
            int locoPushCounter = 0;

            void setup()
            {
            // affectation des pins , entrée/sortie
            pinMode (loco, INPUT);
            pinMode (led, OUTPUT);
            pinMode(loc , INPUT);
            }

            void loop()
            {
            locoState = digitalRead(loco);
            if ( locoState != lastlocoState)
            {
            if (locoState == HIGH)
            {
            locoPushCounter ++;
            }
            delay(5);
            lastlocoState = locoState;
            if (locoPushCounter % 3 == 0)
            {
            digitalWrite (led, HIGH);
            delay( 50);
            digitalWrite (led, LOW);
            }

            }
            }

          • bon en attendant vu que le soleil pointe son nez je vais en profiter pour m’aérer

  29. Pingback: Un simple bouton - Tuto Arduino - Le blog d'Esk...

  30. Bonjour,

    Merci pour ce tuto!
    Une question tout de même:
    Y a t.il un risque à utiliser des interrupteurs (plutôt que des boutons) qui feraient donc passer le courant pendant admettons 5h? Quel choix de résistance dans ce cas? Quid de la consommation?
    Merci 😉

  31. bonjour
    je souhaite contrôler l’allumage d’une led avec deux boutons, chaque bouton doit allumer la led pendant un temps donné.

    est ce que je suis sur la bonne piste ?

    merci d’avance

    const int bouton1 = 2;
    const int bouton2 = 3;
    const int led = 13;
    int etatBouton;

    void setup()
    {
    pinMode(led, OUTPUT); //la led est une sortie
    pinMode(bouton1, INPUT); //le bouton est une entrée
    pinMode(bouton2, INPUT); //le bouton est une entrée
    etatBouton1 = HIGH; //le courant passe
    etatBouton2 = HIGH; //le courant passe
    }

    void loop()
    {
    etatBouton1 = digitalRead(bouton1);
    etatBouton2 = digitalRead(bouton2);

    if(etatBouton1 == HIGH && etatbouton2 == LOW) //le courant passe
    {

    // allume la LED
    digitalWrite(led,HIGH); //le courant passe, la LED est allumée
    // allumage pendant 12 heures
    delay(43200000);

    // éteint la LED
    digitalWrite(led, LOW);
    // on éteint pendant 12 heures
    delay(43200000);
    }

    if(etatBouton2 == HIGH && etatbouton1 == LOW) //le courant passe
    {
    // allume la LED
    digitalWrite(led,HIGH);
    // allumage pendant 13 heures
    delay(46800000);

    // éteint la LED
    digitalWrite(led, LOW);
    // on éteint pendant 11 heures
    delay(39600000);

    }

    else if (etatbouton1 == LOW && etatbouton2 == LOW) //le courant ne passe pas
    {
    digitalWrite(led,LOW); //la LED reste éteinte
    }
    else (etatbouton1 == HIGH && etatbouton2 == HIGH) //on allume pas
    {
    digitalwrite(led,LOW) //la LED reste éteinte
    }
    }

  32. bonjour
    je peut faire un commande de deux moteur avec l293D avec 4 bouton poussoir 2 pour les sens de rotation et 2 pour le commande et l arrett des moteurest ce que vous pouvais m aider a la programmation svp.

  33. Bonjour

    Je ne suis pas d’accord avec la présentation qui est faite de l’anti-rebond, à plus d’un titre.

    1) Il convient d’abord de préciser que dans la plupart des cas, les rebonds ne sont pas un problème, notamment lorsqu’il s’agit juste de lire l’état du bouton occasionnellement, ou à des intervalles de temps supérieurs à la durée maximale des rebonds. Il n’y alors pas de confusion possible entre ces rebonds et des appuis volontaires successifs.

    S’il s’agit d’une lecture à une fréquence assez élevée, il est possible de traiter le problème logiciellement, en attendant un temps suffisant pour que le bouton se stabilise avant de tenir compte d’un nouveau changement d’état. La durée minimale à prendre en compte dépend du modèle et de l’état d’usure du bouton.

    La question d’un circuit extérieur ne se pose finalement que si le changement d’état du bouton doit générer une interruption, car les rebonds successifs provoqueraient autant d’interruptions que le programme devra traiter.

    2) Les valeurs de composant indiquées (C=10 nF et R=10 kΩ) risquent de conduire très souvent à une solution inefficace pour traiter les rebonds.

    En effet, le filtre RC n’élimine que les changements d’état d’une durée inférieure à 73 µs, alors que les rebonds mécaniques d’une durée plus de 10 fois supérieure ne sont pas rares.

    Toutefois, augmenter la valeur du condensateur ne constitue pas une solution acceptable.

    3) Avec le schéma proposé, le condensateur de décharge violemment au travers du contact du bouton lors de sa fermeture. Le courant généré n’est limité que par les éléments électriques parasites présentés par les fils et les composants, et l’impulsion électromagnétique produite est susceptible de perturber les circuits électroniques environnants (à commencer par les circuits analogiques).

    Pire, si le bouton est relié au filtre RC et à l’Arduino via quelques décimètres de fils, l’inductance parasite de ces fils absorbe l’énergie du condensateur lors de la fermeture du contact, puis la transmet à l’entrée de l’Arduino, qui la dissipe. Même avec un petit condensateur de 10 nF, le courant injecté sur l’entrée peut dépasser 0,5 A, soit plus de dix fois la limite absolue autorisée.

    Il convient donc d’adopter un schéma un peu différent, en insérant par exemple une résistance de 1 kΩ en série entre le condensateur et le bouton, le condensateur (de 100 nF ou plus) étant toujours relié à l’entrée de l’Arduino et la résistance de rappel (de 10 kΩ ou plus) étant toujours connectée au bouton.

  34. bjr. je veux écrire un programme sur l’arduino ( bibliothèque virtualwire). qui permet d’allumer 2 LED s. ona 4 entrée F B I D. l’entrée f permet d’allumer le LED 1 et l’entrée b permet d’allumer le LED 2, l’entré i fait l’incrémentation de LED que s’allume de (10% 20%…) et l’entré D permet de faire la décrémentation de LED que s’allume (20% 10%)

  35. Bonjour,
    J’essaye d’utiliser la fonction interruption sur mon arduino UNO, mais elle n’accepte pas d’appeler des sous fonction autre que blink(). Si je peux avoir de l’aide je suis preneur.
    Merci et bonne journée.

  36. Bonjour, ma question est sûrement bête mais j’ai beau me creuser la tête je ne trouve pas la réponse. Sur le premier schéma l’entrée de l’arduino est relier au 5V avant l’interrupteur. L’arduino ne va pas toujours recevoir une tension de 5v? Merci.

Laisser un commentaire