Help : combinaison de bouton-poussoir pour activer LEDs

Bonjour,

Je viens de me procurer un starter kit Arduino pour un projet de cours. Il me semble avoir compris les bases de ce kit, or maintenant je souhaiterais me lancer dans un projet personnel et je suis perdue.

J'ai dans l'idée d'utiliser 10 boutons-poussoirs pour 10 LEDs. Mais la difficulté est la suivante : je souhaiterais enregistrer une série de touche qui amènerait à allumer un LED.

Par exemple :
BP1 + BP2 + BP3 -> allume LED1, puis s'éteint au bout d'un moment
BP1 + BP3 + BP5 -> allume LED2
etc.

Je n'arrive pas à trouver d'infos pour faire le bon chemin de câble qui amènerait à ça et je ne suis pas sûre de la programmation à faire.. C'est pour ça que je fais appel à vous.

Est-ce que quelqu'un aurait déjà fait un projet similaire ou pourrait me rediriger sur un tutoriel?

Merci d'avance !

La machine à états doit sans doute pouvoir répondre à ce type de problème

Un projet de cours ? Pour des élèves, des étudiants ? Ils ont quel niveau ?

Pas besoin de faire un câblage particulier pour ça : tu branches les 10 boutons sur 10 entrées de l'Arduino, les 10 leds sur 10 sorties de l'Arduino, et tu écris le code qui gère le tout.

Pour les boutons, le plus simple serait d'utiliser une bibliothèque qui te simplifie la vie, en gérant des appuis brefs ou long, des appuis multiples, etc. Je te conseille celle de Bricoleau (simplebouton je crois)

Pour la gestion globale, une machine d'états sera certainement la meilleure solution, mais pas forcément la plus simple, surtout si tu n'en as jamais fait auparavant.

Pour moi, il y a trois parties dans ce projet, et quelques questions

1) Acquérir le signal d'entrée des interrupteurs.

  • Soit, comme le dit lesept, brancher chaque interrupteurs sur une pin de l'arduino, et lire leur valeur avec un digitalRead. L'inconvénient, c'est que ça demande beaucoup de pin. Pour 10 interrupteurs, ça occupe 58% des pins d'un arduino UNO. Pour pouvoir ajouter les leds, il faut mieux prendre un arduino avec plus de pin, comme un MEGA
  • Soit brancher les interrupteurs sur un Registre à décalage de type PISO (ex 74HC195 il me semble). Il ne faut que trois pins pour le commander. L'avantage, c'est qu'on peut en câbler plusieurs à la chaine et augmenter facilement le nombre d'interrupteurs.

2) Faire correspondre le signal d'entrée au signal d'entrée
Il faut stocker quelle combinaison d'entrée renvoie quelle sortie. Perso, je préfère utiliser un tableau 10x10 de ce type :
pour chaque LED on indique la combinaison de boutons :

INT1 INT2 INT3 INT4 INT5 INT6 ... INT10
LED1 1 1 1 0 0 0 ... 0
LED2 1 0 1 0 1 0 ... 0
...

Mais pour la gestion de la mémoire et pour l'efficacité du programme il est plus efficace d'utiliser un tableau de 10 cases en binaire :

LED1 LED2 ... LED10
code 1110000000 1010100000

Ensuite on compare le signal d'entrée reçu des interrupteurs avec le tableau pour trouver une éventuelle correspondance, et savoir quelle LED allumer

3) Allumer les leds
Comme pour les interrupteurs, on peut les brancher directement sur l'Arduino s'il y a suffisamment de pins disponible.
Ou alors on peut utiliser un ou plusieurs registre à décalage SIPO (ex : 75HC595) câblés en chaine.
D'après ce que j'ai compris il faudra aussi régler la question de la durée d'allumage

Vous devriez annoncer la couleur sur votre niveau (études, expériences) en électronique / automatismes / programmation pour qu'on puisse vous guider un peu efficacement. Annoncer que c'est "pour un cours" peut laisser supposer que vous êtes élève en BTS et qu'un prof vous a donné ce sujet, ou que vous avez un CAPET et que vous réfléchissez à proposer des TP à vos élèves. On ne va pas vous proposer la même démarche de conception, suivant votre niveau d'une part et éventuellement celui de vos élèves d'autres part.

Bonjour à vous, et merci beaucoup pour vos réponses !

Alors, pour vous parler de mon expérience, je n'en ai pas. Je viens de me lancer dans l'aventure, par grande curiosité. Je ne m'y connait ni en codage, ni en câblage, mais je souhaiterais apprendre pour ma culture.

Le projet que je souhaite faire avec Arduino, c'est pour un exposé que j'ai à rendre avant les vacances de Pâques. Je suis dans l'architecture et je dois rassembler des échantillons de métaux et les présenter de façon "originale", et c'est donc là qu'Arduino intervient.

Je souhaitais utiliser cette technologie pour mon exposé, afin de me familiariser avec ça et concrétiser un premier projet. Mais en tant que débutante je suis un peu perdue et je n'ai pas encore "débloqué" la logique de toutes les démarches à faire.

En fait vous désirez faire une sorte de synoptique interactif. Des échantillons (métaux) sont disponibles sur un présentoir. En bas du même présentoir des boutons poussoirs, avec des étiquettes, correspondant peut être aux métaux, peut-être à des familles de métaux. Et vous voudriez qu'une séquence d'appui sur les boutons amène, par l'éclairage de LEDS, l'utilisateur à valider un concept, une connaissance, etc. Est-ce un bon résumé de votre cahier des charges ?

C'est exactement ça !

Chaque bouton aurait un métaux de base du tableau périodique des éléments, comme par exemple, Fe ; C ; Zn ; etc. Et en appuyant sur Fe + C (ou C + Fe), un LED s'allumerait pour montrer l'alliage de ces deux éléments, soit un échantillon d'acier.

OK. Décomposons les problèmes.

1 - La quincaillerie. Il vous faut déterminer combien de boutons au total vous avez et combien de LEDs. N'hésitez pas à penser un peu large, mais de préférence choisissez des puissances de deux. Par exemple 8 boutons et 16 LED. Souvent les boitiers qu'on va utiliser pour gérer les boutons et les LEDs travaillent par quatre ou huit. Définissez si vous souhaitez n'avoir qu'un élément actif à la fois ou pas, par exemple sur les boutons j'ai une combinaison (comme shift-A sur un clavier d'ordi) ou non. Idem pour les LEDS, bien préciser si il n'y en a qu'une d'éclairée à chaque instant ou pas. Une fois ces éléments déterminés, le type de module arduino que vous avez déjà en votre possession, vous trouverez des exemples sur le forum pour faire un schéma électronique, ou bien quelqu'un vous aidera à le faire.

2 - Le langage utilisateur. Définissez les séquences d'appuis sur les boutons possibles. Soit vous les listez toutes, ce qui peut être un peu longuet soit vous trouvez un moyen de définir des séquences, on appelle cela une "grammaire". Par exemple BP1 . (BP2 | BP3 | BP4) . BP5 signifiera que vous attendez trois appuis, dont le premier doit être BP1, le second au choix BP2 à BP4 et le dernier BP5. Pour faire plus simple, vous pouvez lister toutes les combinaisons possibles et les actions correspondantes sur les LED. Lorsque tout ça est décrit, éventuellement vous pourrez réfléchir à simplifier en écrivant la "grammaire minimale" de votre langage.

3 - La programmation sur Arduino. Vous aurez trois blocs fonctionnels à réaliser et je vous conseille de bien séparer les choses au niveau de l'écriture et du test.
3-1 - La lecture des boutons poussoirs. Du fait que c'est une technologie électro-mécanique et que l'établissement et la suppression du contact donne lieu à des rebonds, il faut gérer ça dans le logiciel. Vous trouverez de nombreux exemples sur le forum pour faire ça. La librairie de Bricoleau comporte ce type de fonction que vous pouvez réutiliser. Cette programmation va dépendre de la structure de l'interface électronique entre les boutons et le logiciel (quel boitier, série ou parallèle, etc.)
3-2 - La reconnaissance du langage utilisateur. Ici il y a des techniques très puissantes qui peuvent être utilisées, puisqu'il y a même des logiciels qui reconnaissent les langues naturelles. Votre problème étant bien plus simple, vous pourrez vous faire conseiller une technique plus simple à mettre en oeuvre. Ne négligez pas ce point cependant, ce type de programme peut devenir un plat de spaghettis infâme si on prend ça sans précaution ou méthode.
3-3 - L'allumage des LEDs. Idem que pour les boutons poussoirs. De nombreuses solutions sur le forum ou ailleurs, à adapter en fonction des choix des boitiers d'interface entre les LED et le micro.

Si vous prenez un peu de recul, que vous fouinez pour des choses toutes faites, que vous vous faites aider, vous allez réussir à faire ça. Mais planifiez le boulot, ne mélangez pas tout, et ne sous-estimez pas la difficulté. Le problème n'est pas trivial pour un débutant complet en informatique industrielle.

Attention dans la définition du projet, j'avais compris qu'il fallait faire une succession de touches pour allumer une led, comme un digicode. Avec ce qui est dit, la machine à état n'est pas adaptée.

Comme le dit Fantoche dans son point "1) Acquérir le signal d'entrée des interrupteurs.", il faut choisir en premier lieu la carte et le type de commande. C'est pas la peine de penser au programme, il dépend du matériel.

Avec 10 boutons et 10 leds, en câblage direct cela fait 20 broches numériques? La carte Uno n'en a que 18 utilisables facilement (les sorties 0 et 1 sont utilisées pour la programmation). Il y a donc plusieurs solutions:

  • utiliser une Mega qui en a 68, on peut voir venir, mais la carte est plus grande.
  • utiliser une nano qui a deux broches d'entrées en plus mais qui se lisent de façon plus complexes (analogiques) mais qui conviennent pour les boutons
  • utiliser les boutons en matrice 25 ou 34 qui économise 3 entrées (gestion par bibliothèque)
  • si il n'y a qu'une seule led allumée à la fois, deux circuits LS138 permettent la gestion.
  • si on veut pouvoir allumer plusieurs leds en même temps, le LS195 est une bonne solution
    Cela va de la solution la plus simple à la plus compliquée à programmer.

Maintenant à choisir, je prendrais la première ou la deuxième parce que matériellement, il n'y a rien à faire. La Méga est plus grosse et plus chère que la Uno, mais peut être pas plus que la Uno + les deux circuits. Sinon au niveau taille, il existe une mega mini (comme une nano

Je pense aussi que c'est un projet assez simple pour commencer.

Réfléchissez aussi à l’ergonomie et à l’acceptabilité psychologique de la chose. Je présume que l’utilisateur ne sera pas un quidam pris au hasard, mais par exemple un étudiant qui pourra grâce à cette manip valider les connaissances acquises dans le cours du professeur X. L’existence de boutons poussoirs disposés dans certaines cases du tableau périodique va constituer une incitation à “essayer tous les boutons” : la génération “jeux video” est entrainée à chercher immédiatement les failles dans une interface homme-machine, à trouver des raccourcis, voire à tenter de “battre la machine” en trichant. J’ai fait une fois une manip de ce genre là et j’ai vu le résultat…

Une suggestion. Plutôt que de disposer des boutons poussoirs, pourquoi ne pas mettre un clou dans chaque case du tableau périodique, dont la tête dépasse en vue de l’utilisateur, ou encore un “boulon poelier” à tête ronde. Seuls ceux qui sont dans les case de vos ingrédients de base sont câblés sur des entrées à détection capacitive. Le geste que vous attendez de vos utilisateurs est de trouver une position des mains et des doigts pour toucher simultanément tous les ingrédients d’un minéral donné. Trois secondes d’appui simultané, pour éviter les tricheurs qui vont balader leurs doigts partout. Un ou deux ingrédients “piège” pour éviter l’appui main à plat du plus grand nombre d’ingrédients possibles.Si vous prenez un ESP32, vous avez des entrées à détection capacitive disponible. La programmation sera grandement simplifiée car vous n’aurez pas à gérer d’anti-rebond ni de séquence d’appui sur les boutons.

Comptez combien d’heures vous avez de disponible pour ce projet, y compris la menuiserie, etc. A mon avis pour un débutant complet comme vous c’est un projet entre 150 et 200h. Si vous ne pouvez y consacrer que 10h par semaine, je doute que vous ayez un résultat en temps voulu.

Merci pour vos réponses, je vais analyser tout ça !

Effectivement le timing va être court et je ne vais pas pouvoir y consacrer 200h, vu qu'il ne me reste que 12 jours pour terminer mon projet.. j'ai sûrement vu trop grand en pensant que ce serait plus facile que ça. Mais je vais quand même tenter le coup, et au pire je trouverai un plan B sans Arduino.

Au niveau de l'ergonomie et de l'accessibilité psychologique, je ne pensais pas mettre tout le tableau en vue, seulement les éléments utilisés (Cu, Pb, Fe, C, Zn, Ti, Cr, Ni, Al -> 9 touches). De plus, ce ne serait pas un "test" pour les élèves, mais plutôt une interaction pour acquérir des connaissances. Je pensais mettre un fascicule qui expliquerait les différents métaux. Sur chaque page, il y aurait la composition du métal (par exemple Acier galvanisé -> Fe + C + Zn), ce qui inciterait la personne à utiliser ces touches afin de savoir quel métal est l'acier galvanisé (en ayant la LED qui s'allume).

Pour répondre à Vileroi, effectivement il n'y a que 18 sorties de disponible avec la Uno, je n'y avais pas pensé. Comme je n'ai que la Uno et que je ne pense pas que les délais à tenir permettent de commander une autre carte, j'ai réfléchis à une manière de n'utiliser que 8 Leds et 9 touches (JiPe38 parlait d'utiliser des puissances de deux, mais est-ce que ce serait possible comme ça?)

Je pensais à utiliser un pavé numérique au lieu d'utiliser les boutons poussoirs, est-ce que ce serait plus simple? (et est-ce que c'est la même chose que les boutons en matrice dont parle Vileroi?) Et est-ce qu'il y aurait aussi des rebonds comme avec les LEDs?

Merci Lesept, je suis en train de regarder la bibliothèque, qui a l'air vraiment pratique et bien présentée !

Fantoche, je fais des tests sur Tinkercard pour éviter de casser ma carte en faisant n'importe quoi, je vais tenter les trois parties proposées, merci beaucoup !

Pour répondre à Vileroi, effectivement il n'y a que 18 sorties de disponible avec la Uno, je n'y avais pas pensé. Comme je n'ai que la Uno et que je ne pense pas que les délais à tenir permettent de commander une autre carte, j'ai réfléchis à une manière de n'utiliser que 8 Leds et 9 touches (JiPe38 parlait d'utiliser des puissances de deux, mais est-ce que ce serait possible comme ça?)

Si c'est branché en direct, le nombre importe peu. Les puissances de 2 sont utiles seulement sui on passe par des décodeurs, mais on peut avoir des "places vides". Mais ici, 8+9 convient.

Je pensais à utiliser un pavé numérique au lieu d'utiliser les boutons poussoirs, est-ce que ce serait plus simple? (et est-ce que c'est la même chose que les boutons en matrice dont parle Vileroi?) Et est-ce qu'il y aurait aussi des rebonds comme avec les LEDs?

Un pavé numérique est un ensemble de poussoirs pré-câblés en matrice. au point de vue logiciel un pavé ou des poussoirs en matrice c'est strictement pareil. Le pave est plus propre (tout est bien aligné).

Il existe une bibliothèque pour les pavés et matrices, mais je ne la connais pas, n'en ayant pas eu besoin.

12 jours c'est très peu. Vu que votre spécialité n'a rien à voir avec l'électronique, le logiciel et l'Arduino, je me demande si vous n'auriez pas intérêt à activer directement le plan B, pour faire un synoptique statique. Si c'est pour votre culture que vous voulez apprendre à vous servir d'un arduino, il vaut peut-être mieux le faire hors d'un projet où votre institution (école d'archi) attend de vous un rendu sur lequel vous serez notée. Une fois vos contraintes de fin d'année passée, vous pouvez vous mettre sur des projets "Arduino dans le bâtiment" qui peuvent vous occuper et constituer pour vous une option perso pour la suite de vos études.

Excellente remarque JiPe38, je vais finalement prendre mon plan B et profiterai de découvrir Arduino dans d'autres circonstances. Et effectivement, découvrir Arduino dans le bâtiment pourrait être très interessant, merci de la suggestion.

Si je peux me le permettre, il est plus aisé pour un débutant de se glisser dans la peau d'un(e) autre débutant(e)!
De plus ce challenge permet de s'exercer à la codification somme toute abordable, quitte à ce que je me fasse remettre sur les rails, mais si cela peut aider Akyrah en plus que d'apprendre, ça en vaut la peine.
Alors voilà, j'ai testé un bout de code qui pourrait s'approcher de ce que tu veux, il fonctionne et peut être modifié en fonction de tes souhaits. Étant disposé même, autant que je le puisse,à codifier les différentes conditions de combinaisons d'appuis boutons .
Suffit de me fournir la liste des métaux , minerais ou autres à associer.
Si tu as une télécommande dans ton kit, elle te simplifiera la vie, remplaçant les boutons, et leur câblage avantageusement, et libérant d'autant quelques sorties supplémentaires de ta carte uno.
A plus....

                              // pour ce test , je me suis limité à 2 boutons, mais l'extension  est possible.

#include "simpleBouton.h"
#include "simpleMinuteur.h"

simpleMinuteur minuteur1(5000);                         // série de chronos annulant l'action bouton dans un temps donné (ici 5 secondes)
simpleMinuteur minuteur2(5000);
simpleMinuteur minuteur3(5000);

bool memo1 = false;                                   // série de mémoires boutons activés
bool memo2 = false;
bool memo3 = false;

bool MC1 = false;                                    // série de mémoires chronos désactivés
bool MC2 = false;
bool MC3 = false;

simpleBouton BP1(11);                                // fonctions appuis boutons
simpleBouton BP2(7);
simpleBouton BP3(10);
void setup() {
  pinMode(12, OUTPUT);             // sortie led test, ici activée par la condition multiple coorespondant aux appuis cumulés boutons BP2 + BP3. 
  pinMode(7, INPUT_PULLUP);
  pinMode(10, INPUT_PULLUP);
  pinMode(11, INPUT_PULLUP);
  pinMode(4, OUTPUT);                        // sortie led test
  pinMode(5, OUTPUT);                       // sortie led test
}

void loop()
{
  if (BP1) {
    minuteur1.demarrer();                     // début chrono
    memo1 = true;
    MC1 = true;
  }
  if (minuteur1.estTermine())                 // fin chrono
  {
    action1();
  }



  if (BP2) {
    minuteur2.demarrer();
    digitalWrite(4, HIGH);
    memo2 = true;
    MC2 = true;
  }
  if (minuteur2.estTermine())
  {
    action2();
  }


  if (BP3) {
    minuteur3.demarrer();
    digitalWrite(5, HIGH);
    memo3 = true;
    MC3 = true;
  }
  if (minuteur3.estTermine())
  {
    action3();
  }


  if ((memo2 == true) && (memo3 == true) && ((MC2 && MC3) == true))             // condition multiple de mémoires actives bouton et chrono
  {
    digitalWrite(12, HIGH);                               // led témoin validation résultat positif suite appuis boutons
    delay(5000);                                          // usage delay pour simplifier, le temps de savourer son plaisir!
    digitalWrite(12, LOW); 
    memo1 = false;                  // extinction led et remise à zéro mémoires boutons nécessaire pour pouvoir recommencer une autre combinaison 
    memo2 = false;
    memo3 = false;
  }
}

void action1()                                //déclaration des fonctions allouées à remise à zéro mémoires activité chronos
{
  MC1 = false;
}
void action2()
{ MC2 = false;
  digitalWrite(4, LOW);                       // led témoin pour test, ligne peut être supprimée
}
void action3 ()
{ MC3 = false ;
  digitalWrite(5, LOW);                      //   "    "      "    "      "   "      "      "
}

Attention, peut-être une petite erreur ici :

if ((memo2 == true) && (memo3 == true) && ((MC2 && MC3) == true))

qui devrait être

if ((memo2 == true) && (memo3 == true) && ((MC2 & MC3) == true))

et peut finir en :

if (memo2 && memo3 && (MC2 & MC3))

Merci Lesept, c'est effectivement plus concret ,j'en prends note.
Je n'ai fait qu'appliquer un code proche de ce que tu proposais précédemment, en moins subtil et moins élaboré, et sans prétention de ma part, juste pour essayer.
Pas sûr d'ailleurs que le chrono soit indispensable.
Apparemment, Akyrah semble être partie à fond dans son plan B, souhaitons lui de réussir et le terminer à temps..