Pour créer la table, voir si la qualité est suffisante, et avoir un programme de test, je conseille d'utiliser un programme d'apprentissage conçu pour MTanalogButtons.

Quelques idées de montages

Je ne peux pas donne tous les montages utilisables, les pages sur les boutons donnent plus de détails, notamment sur le calcul des valeurs des résistances. En résumé:

Diviseur de tension à résistances parallèles

- tous les boutons on une borne commune à la masse
- on peut utiliser une matrice pré-câblée 4x1 par exemple
- peu utilisable si les boutons sont éloignés
- l'incertitude sur les résistance limite le nombre d'interrupteurs
- lecture mono

Diviseur de tension à résistances série

- pas de borne ni commune , ni à la masse
- si les boutons sont espacés, il faut 2 fils pour aller de l'un à l'autre
- même avec des résistances à 10% le montage fonctionne
- c'est le montage qui permet le plus grand nombre de boutons

Sommateur de courants à lecture poly

- borne commune mais pas à la masse
- on peut utiliser une matrice pré-câblée 4x1 par exemple
- peu utilisable si les boutons sont éloignés
- permet une lecture poly
- les tolérances sur les résistances limitent le nombre de boutons
- les valeurs multiples de 2 posent problème

Suppression de résistances poly

- permet une lecture poly
- si les boutons sont espacés, il faut 1 seul fil pour aller de l'un à l'autre
- les tolérances sur les résistances limitent le nombre de boutons
- les valeurs multiples de 2 posent problème

Suppression de résistances mono

- si les boutons sont espacés, il faut 1 seul fil pour aller de l'un à l'autre
- les valeurs multiples de R1 posent problème

Keypad ou matrice carrée à lecture analogique

- on peut utiliser des matrices déjà câblées (keypad)
- c'est le montage qui possède le moins de résistances
- il faut que tous les boutons soient proches

Include à rajouter

#include <MTobjects.h> // Voir http://arduino.dansetrad.fr/MTobjects

Je conseille fortement de laisser le commentaire, si une autre personne voulait essayer le programme, elle aurait directement un lien de téléchargement. C'est valable pour toutes les bibliothèques que vous utilisez.

Constructeur

MTanalogButtons(pin,
      SEUILS,
      onSelectFunction = PAS_D_ACTION,
      onUnselectFunction = PAS_D_ACTION);

• pin (uint8_t): broche sur laquelle est branché l'ensemble de boutons
• SEUILS (const word[]): tableau des seuils (voir plus bas)
• onSelectFunction: ce qui se passe quand on appuie sur un bouton
  • PAS_D_ACTION → rien ne se passe
  • fonction → appel d'une fonction "void fonction(uint8_t touche) {...}" Le paramètre passé est le numéro de la touche.
• onUnselectFunction: ce qui se passe quand on relâche les boutons
  • PAS_D_ACTION → rien ne se passe
  • fonction: → appel d'une fonction "void fonction(void) {...}"

SEUILS

Inspirez vous de:

const word TABLE_DES_SEUILS[] = {982, 920, 880, 840, 797, 754, 710, 665, 619, 571, 523, 471, 421, 369, 316, 260, 204, 145, 87, 28, 0}; // Valeurs des seuils de comparaisons

MTanalogButtons Keypad(PIN, TABLE_DES_SEUILS);

Les seuils doivent être dans un tableau constant de word et classé:
- par ordre croissant si sans appuis sur les boutons le convertisseur donne une valeur proche de 0, et se terminer par 1023
- par ordre décroissant (comme ci-dessus) si sans appuis sur les boutons le convertisseur donne une valeur proche de 1023, et se terminer par 0.

L'ordre croissant ou décroissant bien choisi permet de passer moins de temps si aucun bouton n'est appuyé (le plus souvent).

Si pour le bouton n°N le convertisseur donne entre 96 et 100 et pour le bouton n°N+1 il donne entre 140 et 143, le seuil à utiliser est le milieu de (100, 140) soit 120. Comme c'est un peu fastidieux je conseille d'utiliser le programme d'apprentissage.

erreur de conversion

Quand on lit le convertisseur analogique numérique, il se peut que, un bouton venant d'être appuyé ou relâché, la valeur ne soit pas encore stable au moment de la lecture. On peut aussi avoir du bruit qui vient fausse la mesure. Pour éviter cela, une valeur n'est prise en compte que si on lit deux fois la même valeur à une erreur près:
- si erreur=0 (par défaut) il faut lire deux fois de suite la même valeur. Cela élimine pas mal de fausses lectures
- si erreur=10 si le convertisseur donne 523 puis 533 (ou toute valeur dans [513, 533]), on considérera que c'est pareil
- avec erreur=0 on pourrait lire en théorie 500 boutons, mais avec erreur=10, on ne pourrait plus avoir que 100 boutons
- si erreur est trop grande, on lira un bouton pour un autre.
Plus l'erreur est petite, plus on s’affranchit d'une erreur de lecture. Mais si le système est très bruyant, on risque de ne jamais prendre en compte le bouton. Lassez la valeur par défaut, et augmentez ce nombre.

Fonctions utiles

byte getKey(void);
virtual void onSelect(uint8_t touche);
virtual void onUnselect(void);
void setError(word error = 0);
word getError(void);

getKey: renvoie le numéro de la touche appuyée, 0 si aucune
onSelect: fonction à surcharger appelée quand on appuie sur un bouton
onUnselect: fonction à surcharger appelée quand on relâche tous les bouton setError: permet de fixer la tolérance de la lecture (erreur acceptable) setError: lit la tolérance de la lecture (erreur acceptable)

Fonctions bonus

void setOnSelectFunction(onSelectFunction);
void setOnSelectFunction();
void setOnUnselectFunction(onUnselectFunction);
void setOnUnselectFunction();

setOnSelectFunction: change la fonction appelée lors d'un appui
setOnSelectFunction: sans paramètres supprime la fonction appelée lors d'un appui
setOnUnselectFunction: change la fonction appelée lors du relâchement
setOnUnselectFunction: sans paramètres supprime la fonction appelée lors du relâchement

Exemples

• Apprentissage (création de la table des seuils)
• Exemple 1: Résultat
• Exemple 2: Serrure codée
• Exemple 3: Programme traditionnel
• Test 1: Avec 2 pins analogiques
• Test 2: Numéro ou caractère
• Test 3: getKey
• Test 4: onSelectFunction
• Test 5: onSelect