Arduino et capteurs

Bonjour tous le monde,

j'ai une question toute couillon (je suis couillon), j'ai épluché pas mal de tutos et je n'arrive pas à comprendre comment connecter par exemple un clavier matrice de 5x5 (10 fils) + deux afficheurs 4x7digit (2x12 fils + deux (2x4 fils) ou plus codeurs sur une uno ou mega aucun tuto ne parle de cela tout le monde s'arrète après avoir branché un de ces éléments et faire une belle démonstration de ce qu'on peut faire avec, quelqu'un aurait la gentillesse de me donner une piste ou m'expliquer.

Et bon j'ai une deuxième question, y'a t'il une assos ou un club arduino ou d'électronique sur le Bas-rhin ?

merci infiniment

on utilise des composants intermédiaires s'il n'y a pas assez de pins. par exemple pour vos 12 fils de l'afficheur 7 segments, on met par exemple un circuit spécialisé TM1637 qui contrôle la valeur des 4 digits et leur luminosité

un exemple

il y a plusieurs bibliothèques pour le TM1637
voici un exemple avec une autre

Bonjour J-M-L

Merci beaucoup pour l'exemple (et le temps que vous prenez pour me répondre).
Là on est encore sous le max de la carte comment on fait quand on dépasse le max de la carte? faut il passer par des éléments contrôlé via i2c ou CANBus ou est ce qu'un Shield existe pour étendre le nombre de pin je ne trouve pas vraiment d'explications à mes questions (ou je ne cherche pas correctement)

Merci beaucoup

On prend une carte plus grande comme la mega ou on utilise des composants plus intelligents qui nécessitent moins de broches

Bonjour J-M-L

Merci pour votre temps.

Bon ben je crois que j'ai pas le choix alors, il va falloir que je me trouve des initiés dans ma région.
Est-ce que quelqu'un est dans le Nord du Bas Rhin (club ou passionnés) qui accueillerais un neewbie ?

merci J-M-L

Salut
Tu peux regarder sur cette carte. Tous le monde n'y est pas, mais c'est asses complet :wink:

Bonne journée

Cordialement
Pandaroux007

Bonjour Pandaroux007,

Aïe personne à moins de 130 bornes, y'a vraiment personne sur le Bas-Rhin ?

Merci beaucoup

Le clavier est-il précâblé? Si non, 5 entrées suffisent.

Branchés comment? pour moi deux afficheurs 4*7 c'est 8 chiffres et 8 segments qui peuvent se commander avec 16 fils, voir 11 fils seulement.

A propos du titre: je suis passé plusieurs fois en comprenant Arduino et capteur (singulier) S (capteur de type S?). Mettre une minuscule à s change tout (édition sur le premier post).

Bonjour vileroi,

Le clavier est "bricolé" avec des boutons sur une breadboard pour le moment, auriez vous un schéma de câblage pour réduire à 5 entrées.

Le S du titre était pour mettre le "capteur" au pluriel en insistant sur le pluriel, comme je le disais plus haut j'ai un souci de compréhension quand aux branchements vu le nombre de fils à utiliser
je souhaite utiliser une UNO et brancher deux afficheurs 7 digit enfin 8 avec le point décimal, mon clavier bricolé (en attendant de savoir si cela peut se faire) quelques Led d'informations, un commutateur rotatif codé, ainsi qu'un certain nombre d'actionneur linéaire et rotatif moteur DC 24v avec codeur et fin de courses, je suis en train de me demander si y'a moyen de multiplexer ou d'utiliser un CanBus (le CanBus c'est sûr mais cela impliquera des éléments de communications et arduinos supplémentaires).
enfin voila ou j'en suis

merci pour votre réponse

Pour n'utiliser que 5 entrées, il faut utiliser le montage dit "matrice triple". Avec 5 entrées, on peut aller jusqu'à 30 boutons.
image

On met toutes les entrées en INPUT_PULLUP et on en met une seule en sortie à LOW. Un tiers des inters se voit si on lit dans un sens, un tiers si on lit dans l'autre sens, et un tiers réagissent quel que soit le sens. On fait donc les deux lectures et on peut en déduire lequel des trois est appuyé.
On ne peut lire qu'un seul bouton à la fois

Voici un programme de test:

// Matrice triangulaire triple, pour chacun des couples d'entrées, trois boutons sont mis:
// (2,3), (2,4), (2,5), (2,6), (2,7), (3,4), (3,5), (3,6), (3,7), (4,5), (4,6), (4,7), (5,6), (5,7) et (6,7)



void setup()
{
  Serial.begin(115200); // Régler aussi la console à 115200 bauds!
  for (byte broche=2; broche <=7; broche++) pinMode(broche, INPUT_PULLUP); // Repos, toutes les broches en INPUT_PULLUP
}



byte lecture(byte ligne, byte colonne)
// Cette fonction retourne 0 si le bouton sans la diode est appuyé, 1 ou 2 si un
// des deux boutons avec une diode est appuyé, 3 si aucun des trois n'est appuyé
// Il faut que ligne > colonne
{
  byte resultat = 0;

  // lecture dans un sens
  digitalWrite(ligne, LOW); pinMode(ligne, OUTPUT); // Mettre la ligne à LOW et la colonne étant déja en INPUT_PULLUP
  if (digitalRead(colonne) == HIGH) resultat = 2; 
  pinMode(ligne, INPUT_PULLUP); // Remettre la ligne en entrée
  
  // lecture dans l'autre sens
  digitalWrite(colonne, LOW); pinMode(colonne, OUTPUT); // Mettre la colonne à LOW et la ligne en INPUT_PULLUP
  if (digitalRead(ligne) == HIGH) resultat += 1; 
  pinMode(colonne, INPUT_PULLUP); // Remettre la colonne en entrée
  
  // Fin
  return resultat;
}



void loop()
{
  Serial.println("\n\n(2,3) (2,4) (2,5) (2,6) (2,7) (3,4) (3,5) (3,6) (3,7) (4,5) (4,6) (4,7) (5,6) (5,7) (6,7)");
  
  // Pour les boutons sans diode
  for (byte ligne=2; ligne<=6; ligne++) for (byte colonne=ligne+1; colonne<=7; colonne++) // Pour tous les couples
    if (lecture(ligne, colonne) == 0) Serial.print("appui ");
    else Serial.print("  -   "); // Bouton non appuyé
  Serial.println();
  
  // Pour les boutons avec une diode anode vers le bouton
  for (byte ligne=2; ligne<=6; ligne++) for (byte colonne=ligne+1; colonne<=7; colonne++) // Pour tous les couples
    if (lecture(ligne, colonne) == 1) Serial.print("appui ");
    else Serial.print("  -   "); // Bouton non appuyé
  Serial.println();
  
  // Pour les boutons avec une diode cathode vers le bouton
  for (byte ligne=2; ligne<=6; ligne++) for (byte colonne=ligne+1; colonne<=7; colonne++) // Pour tous les couples
    if (lecture(ligne, colonne) == 2) Serial.print("appui ");
    else Serial.print("  -   "); // Bouton non appuyé
  Serial.println();
  
  delay(500); // Pas trop souvent
}

Pour ce qui est du multiplexage, je ne sais rien, je ne m'y suis jamais intéressé. En fait une Uno plus multiplexeurs, j'appelle cela un Mega.

Je suis en train de voir la lecture analogique qui permet de mettre 25 boutons sur une seule broche si un seul bouton est appuyé à la fois.

Sinon, il y a aussi la solution de faire une lecture analogique qui n'utilise qu'une seule entrée (mais 26 résistances) d'autres solutions utilisant moins de résistances et une matrice sont possible, mais moins sécure). A s'inspirer du programme suivant:

// Diviseur de tension à N résistances séries, N boutons

// VCC
//  ├── SWN-1 ─┐
// 1kΩ         │
//  ├── SWN-2 ─┤
// 1kΩ         ├── Vers A5
//  ├── SWN-3 ─┤
// 1kΩ         │
//  ├── SWN-4 ─┤
// 1kΩ         │
//     . . .
//  ├── SW2 ───┤
// 1kΩ         │
//  ├── SW1 ───┤
// 1kΩ         │
//  ├── SW0 ───┤
// 1kΩ       100kΩ
//  │          │
// GND        GND

const float N = 25; // Nombre de boutons; A ajuster 
// R=100kΩ Résistance de pull-down
// P=Nx1kΩ Résistance de la chaine complète sans la pull-down
const float PsurR = N*1.0/100.0; // Pour des 1kΩ et 100kΩ; A ajuster
const byte BOUTONS = A5; // Broche de lecture; A ajuster

void setup()
{
  Serial.begin(115200); // Régler aussi la console à 115200 bauds!
}

int valeurLue, // Résultat de la conversion brute puis corrigée
    oldValeurLue, // Mémorisation pour permettre deux lectures consécutives identiques
    touche, // Numéro de la touche
    oldTouche; // Touche précédente appuyé pour ne pas l'afficher plusieurs fois

void loop()
{
  do // Lecture brute
  {
    oldValeurLue = valeurLue; // Sauvegarde de la mesure précédente
    valeurLue = analogRead(BOUTONS); // Nouvelle lecture
  } while (valeurLue!=oldValeurLue); // On recommence jusqu'à avoir deux lectures identiques

  // Correction de la valeur
  float temp=valeurLue*PsurR; // 1024βP/R
  valeurLue=1024.0*(temp-1024.0+sqrt((1024.0-temp)*(1024.0-temp)+4*temp*temp/PsurR))/(2*temp);

  //Extraction
  touche=(valeurLue+(512.0/N))/(1024.0/N); // cela donne le N° de la touche 0..N-1
  
  // Affichage
  if (touche!=oldTouche) // Si changement
  {
    if (touche) // C'est une nouvelle touche
    {
      Serial.print("Bouton SW");
      Serial.print(touche-1); // Boutons numérotés à partir de 0
      Serial.print("   (erreur:");
      Serial.print(valeurLue-touche*1024.0/N,0); // Valeur de l'erreur
      Serial.print("/");
      Serial.print(512.0/N,0); // On a le droit d'une erreur de 16 maximum
      Serial.println(")");
      delay(100); // Antirebond
    }
    oldTouche=touche; // Mémorisation pour ne pas afficher plusieurs fois
  }
}

On peut se permettre une erreur de 20, chez moi elle ne dépasse pas 4. Il est fait des lectures jusqu'à avoir 2 valeurs qui se suivent identiques. Passer à 3 valeur apporte plus de sécurité, mais peut être plus long si le convertisseur a la tremblotte.

voir aussi Lire 64 boutons avec une seule broche

Bonjour Vileroi,

Excusez moi pour la réponse tardive j'étais en déplacement cette semaine et pas trop le temps,
je vais essayer la version à matrice triple dès que le materiel complémentaire sera arrivé.

merci beaucoup

1 Like

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.