Matrice carrée triple

C'est dommage de ne pas l'utiliser plus, au prix d'un programme un peu plus complexe, on peut économiser des broches. Et le fait d'utiliser une bibliothèque déjà écrite supprimerait un défaut.

Extrait de la matrice triangulaire triple

En fait, c'est une partie de la matrice triangulaire triple. Sur une matrice triangulaire 6 bits, sur les 45 possibilités on ne va en utiliser que 27. C'est donc suffisant pour un clavier matriciel 4x4 ou 3x4. Voici un clavier 27 touches avec 6 broches.

Ce qui correspond à la matrice:

Si c'est pour économiser les broches, la matrice triangulaire est plus intéressante, voir la matrice triangulaire double ou triple. Pour moi, il y a deux utilisations: diminuer le nombre de broches pour un clavier matriciel vendu tout fait ou mettre 2 ou 3 claviers sans augmenter le nombre de broches.

Avec un clavier pré-câblé 16 touches

Voici le schéma d'un câblage classique avec 8 fils:

Et voici le câblage du même clavier mais en utilisant que 6 broches:

Comme on peut le constater, c'est une matrice carrée 2x4 double. On peut mettre les diodes dans l'autre sens, les mettre sur les colonnes plutôt que sur les lignes, mettre les diodes sur une ligne sur deux ou toutes en haut, toutes en bas... On aura toujours 6 broches, mais le programme de lecture est différent d'une configuration à l'autre. On peut aussi mettre une diode dans un sens et une diode dans l'autre, mais cela complique le programme pour rien.

Le code suivant est assez semblable à la lecture d'une matrice triangulaire triple. On appelle deux fois la lecture pour les mêmes coordonnés à cause de l'ordre d'affichage:

// Matrice carrée double pour lire un pavé 16 touches standard
// Colonnes broches 2 à 5, lignes broches 6 et 7 avec deux diodes

//   B2   B3   B4   B5
//   │    │    │    │
//   ├─1  ├─2  ├─3  ├─A
//   │ └──│─┴──│─┴──│─┴──────┐
//   ├─4  ├─5  ├─6  ├─B      ├─ B6
//   │ └──│─┴──│─┴──│─┴──▷├─┘
//   ├─7  ├─8  ├─9  ├─C
//   │ └──│─┴──│─┴──│─┴──────┐
//   └─*  └─0  └─#  └─D      ├─ B7
//     └────┴────┴────┴──▷├─┘


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 colonne, byte ligne)
// Cette fonction retourne 0 si le bouton sans diode est appuyé,
// 1 si le bouton avec diode est appuyé, 3 si aucun n'est appuyé
// Avec la matrice double, lire 2 est impossible
{
  byte resultat = 0;

  // lecture dans un sens
  digitalWrite(ligne, LOW); pinMode(ligne, OUTPUT); // Mettre la ligne à LOW et la colonne étant déjà 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;
}


char touche[16] = {'1', '2', '3', 'A', '4', '5', '6', 'B', '7', '8', '9', 'C', '*', '0', '#', 'D'}; // Caractères associés àux touches
void loop()
{
  Serial.println();

  // Parcours de la matrice, ligne par ligne
  for (byte ligne=6; ligne<=7; ligne++)
  {
    Serial.println();
    for (byte colonne=2; colonne<=5; colonne++) // Boutons sans diodes (première des deux lignes)
    {
      if (lecture(colonne, ligne) == 0) Serial.print(touche[colonne+8*ligne-50]); // Bouton appuyé, on affiche le nom
      else Serial.print("-"); // Bouton non appuyé
    }
    Serial.println();
    for (byte colonne=2; colonne<=5; colonne++) // Boutons avec diodes (deuxième ligne)
    {
      if (lecture(colonne, ligne) == 1) Serial.print(touche[colonne+8*ligne-46]);
      else Serial.print("-");
    }
  }
  
  delay(500); // Pas trop souvent
}

Par contre pour économiser le code, on peut utiliser 4 diodes au lieu de deux. C'est toujours une matrice double mais sans besoin de mémorisation pour la lecture (voir matrice triangulaire triple, Variante: matrice double à 2 diodes):

Le programme est un peu plus simple, o ne lit qu'une seule fois, dans un seul sens pour un bouton:

// Matrice carrée double pour lire un pavé 16 touches standard
// Colonnes broches 2 à 5, lignes broches 6 et 7 avec quatre diodes


//   B2   B3   B4   B5
//   │    │    │    │
//   ├─1  ├─2  ├─3  ├─A
//   │ └──│─┴──│─┴──│─┴──┤◁─┐
//   ├─4  ├─5  ├─6  ├─B      ├─ B6
//   │ └──│─┴──│─┴──│─┴──▷├─┘
//   ├─7  ├─8  ├─9  ├─C
//   │ └──│─┴──│─┴──│─┴──┤◁─┐
//   └─*  └─0  └─#  └─D      ├─ B7
//     └────┴────┴────┴──▷├─┘


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
}



boolean lecture(byte colonne, byte ligne)
// Cette fonction retourne true si le bouton est appuyé
{
  boolean resultat = true;

  // 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 = false; // Bouton non appuyé
  pinMode(ligne, INPUT_PULLUP); // Remettre la ligne en entrée
  
  // Fin
  return resultat;
}


char touche[16] = {'1', '2', '3', 'A', '4', '5', '6', 'B', '7', '8', '9', 'C', '*', '0', '#', 'D'}; // Caractères associés àux touches
void loop()
{
  Serial.println();

  // Parcours de la matrice, ligne par ligne
  for (byte ligne=6; ligne<=7; ligne++)
  {
    Serial.println();
    for (byte colonne=2; colonne<=5; colonne++) // Boutons sans diodes (première des deux lignes)
    {
      if (lecture(ligne, colonne)) Serial.print(touche[colonne+8*ligne-50]); // Bouton appuyé, on affiche le nom
      else Serial.print("-"); // Bouton non appuyé
    }
    Serial.println();
    for (byte colonne=2; colonne<=5; colonne++) // Boutons avec diodes (deuxième ligne)
    {
      if (lecture(colonne, ligne)) Serial.print(touche[colonne+8*ligne-46]);
      else Serial.print("-");
    }
  }
  
  delay(500); // Pas trop souvent
}

Il peut y avoir un petit inconvénient, si on souhaite passer par interruption, le deuxième schéma ne le permet plus.

Avec un clavier pré-câblé 12 touches

On peut utiliser la même astuce que pour le clavier 16 touches en utilisant une colonne en moins:

On pourrait aussi n'utiliser qu'une seule colonne en utilisant la matrice triple:

Mais cela ne permet pas la lecture par interruption, il n'y a pas d'avantage par rapport au schéma précédent.

Trois pavés numériques standards

Les matrices triples permettent aussi de lire trois pavés numériques standards sans augmenter le nombre de broches. Par exemple pour trois pavés 12 broches:

Ici, j'ai mis les diodes sur les colonnes car il n'en faut que 3 par pavé contre 4 si je les mets sur les lignes. Comme précédemment, il y a plusieurs solutions.

Pour deux pavés numériques, on peut économiser les diodes (et garder la possibilité d'utiliser les interruptions) en supprimant le pavé 1 ou 2, ou simplifier le soft en supprimant le pavé 3.

Mono?

La lecture est effectivement mono, comme pour la matrice triangulaire triple (stéréo si on a des diodes partout).

Bilan

- lecture plus simple qu'une matrice triangulaire
- on trouve des claviers 4x3 ou 4x4 déja câblés qui peuvent quand même être utilisés
- lecture par interruption possible avec une matrice carrée double
- permet d'économiser deux broches pour les claviers pré-câblés par rapport au montage classique
MAIS
- quelques diodes en plus
- je ne connais pas de bibliothèques prévues pour les matrices carrées triples
- moins de boutons qu'avec une matrice triangulaire
- lecture mono

Montage très intéressant, mais peu ou pas utilisé. Allez savoir pourquoi.