Mini clavier 12 touches

Le clavier officiel Raspberry est compact et joli, mais quand on a l’habitude d’utiliser le pavé numérique, c’est difficile d’y renoncer. Evidement, je pourrais simplement en acheter un, mais c’est certainement plus amusant de le fabriquer soi-même.

Clavier officiel Raspberry avec un pavé numérique DIY

Surtout que c’est très facile, il suffit de relier quelques boutons poussoirs à un Arduino Leonardo (ou Arduino Pro Micro). Evidement, si vous utilisez des touches de bonne qualité, le pavé sera plus fiable et la frappe des touches plus agréable.

Au départ, je pensais simplement relier les boutons à l’Arduino avec des fils soudés. Mais en voyant cette vidéo d’Abrège, je me suis rendu compte qu’il était beaucoup plus facile de concevoir un circuit électronique sur mesure avec JLCPCB.

Je me suis donc lancé dans la conception du PCB en suivant le très bon tuto de François MOCQ

Je ne vais pas vous expliquer toutes les étapes parce que je ne maitrise pas suffisamment le sujet. J’ai pas mal tâtonné au début, mais après quelques heures d’effort, j’ai quand même réussi à placer 12 touches mécaniques sur une carte shield au format l’Arduino Uno ou Leonardo (il y avais tout juste la place).

J’aurais pu faire une matrice, mais pour seulement 12 boutons, j’ai préféré faire simplement une entrée par bouton. Voilà donc le schéma :

Montage du pavé

J’ai imprimé les touches et les supports, puis j’ai commandé les boutons et le PCB. Une fois tout les élément réunis, on peut procéder au montage (vous trouverez le lien vers les fichiers STL au bas de la page).

Les différents composants du mini clavier

On commence par l’insertion des boutons dans le support. Il n’est pas indispensable, mais permet de solidifier le clavier (puisqu’ainsi, tous les boutons sont solidaires). Vous pouvez remarquer que j’ai raboté le bouton (en haut, à droite sur la photo) parce que j’avais peur que la prise d’alimentation de l’Arduino ne gène la mise en place de la carte, mais finalement, c’était inutile (tant pis).

Vient ensuite, l’étape de soudure des connecteurs.

Et celle des boutons. Là, je me suis rendu compte que j’aurais plutôt dû mettre mon logo de ce coté puisque maintenant il est caché par les boutons. Dommage, ce sera pour la prochaine version (s’il y en a une).

Ensuite, on passe à l’installation de l’Arduino sur son support incliné

On ajoute la carte shield

Et les touches…
Bon j’avoue que je ne suis pas vraiment fier de cette étape. Les touches font un peu « cracra » et ça gâche tout le reste. Les symboles sont creusés et j’ai essayé de peindre l’intérieur, pour qu’ils ressortent un peu plus, mais il y a eu des bavures qui se sont infiltrées dans les irrégularités du plastique (et cela ressort encore plus sur la photo, que dans la réalité). Pour éviter ça, j’aurais dû mettre une couche de vernis incolore pour lisser la surface supérieure des touches avant de colorer les chiffres en noir. Abrège à présenté une solution pour obtenir un meilleur résultat, mais pour ça, il me faudrait une graveuse laser.
Alors, disons que ce sont des touches provisoires et qu’un jour je les remplacerai par d’autres, plus jolies.

Programmation du pavé numérique

Maintenant, il ne reste plus qu’à téléverser le code dans l’Arduino Leonardo. Lancez L’IDE Arduino et n’oubliez surtout pas d’allez dans Outils – Type de carte pour sélectionnez « Arduino Leonardo« . Ensuite il suffit de branchez la carte, de sélectionner le port et bien sûr, de téléverser votre sketch.

Dans ce premier exemple, j’ai défini un délai de répétition fixe de 250 millisecondes (pour éviter les fautes de frappe), mais évidement, vous pouvez l’ajuster en fonction de vos besoins.

// Pave_Numerique
// Appel de la bibliothèque
#include "Keyboard.h"
// Ports des boutons
const int BOUTON0 = 7 ;
const int BOUTONPoint = 3 ;
const int BOUTONEn = 2 ;
const int BOUTON1 = 8 ;
const int BOUTON2 = 4 ;
const int BOUTON3 = 11 ;
const int BOUTON4 = 9 ;
const int BOUTON5 = 5 ;
const int BOUTON6 = 12 ;
const int BOUTON7 = 10 ;
const int BOUTON8 = 6 ;
// D18 pour l'Arduino Leonardo et D14 pour l'Arduino Uno
const int BOUTON9 = 18 ; 
const int delaiDeRepetion = 250; // Délai de répétition des touches

void setup() {
  // Initialisation les entrées (boutons)
  for (int i = 2; i <= 12; i++){
    pinMode(i, INPUT_PULLUP);
  }
  pinMode(18, INPUT_PULLUP); // D14 pour l'Arduino Uno
  // Initialisation du clavier
  Keyboard.begin();
}

void loop() {
  if (digitalRead(BOUTON0) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x30); // Chiffre 0
    relachementTouche();
  }
  if (digitalRead(BOUTONPoint) == LOW) {
    Keyboard.press(0x3C); // Point    
    relachementTouche();
  }
  if (digitalRead(BOUTONEn) == LOW) {
    Keyboard.press(0xB0); // Entrée
    relachementTouche();
  }
  if (digitalRead(BOUTON1) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x31); // Chiffre 1
    relachementTouche();
  }
  if (digitalRead(BOUTON2) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x32); // Chiffre 2
    relachementTouche();
  }
  if (digitalRead(BOUTON3) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x33); // Chiffre 3
    relachementTouche();
  }
  if (digitalRead(BOUTON4) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x34); // Chiffre 4
    relachementTouche();
  }
  if (digitalRead(BOUTON5) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x35); // Chiffre 5
    relachementTouche();
  }
  if (digitalRead(BOUTON6) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x36); // Chiffre 6
    relachementTouche();
  }
  if (digitalRead(BOUTON7) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x37); // Chiffre 7
    relachementTouche();
  }
  if (digitalRead(BOUTON8) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x38); // Chiffre 8
    relachementTouche();
  }
  if (digitalRead(BOUTON9) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x39); // Chiffre 9
    relachementTouche();
  }
  delay(20);
}

void relachementTouche(){  
  Keyboard.releaseAll();
  delay(delaiDeRepetion);
}

Sinon, il est également possible d’empêcher toutes répétitions en bloquant l’exécution du programme dans une boucle qui s’exécute aussi longtemps que la touche reste appuyée. Le pavé numérique est un peu plus réactif et s’adapte à votre vitesse de frappe pour ne jamais répéter la même touche (quand on laisse trop longtemps son doigt appuyé dessus).

// Pave_Numerique_v2
// Appel de la bibliothèque
#include "Keyboard.h"
// Ports des boutons
const int BOUTON0 = 7 ;
const int BOUTONPoint = 3 ;
const int BOUTONEn = 2 ;
const int BOUTON1 = 8 ;
const int BOUTON2 = 4 ;
const int BOUTON3 = 11 ;
const int BOUTON4 = 9 ;
const int BOUTON5 = 5 ;
const int BOUTON6 = 12 ;
const int BOUTON7 = 10 ;
const int BOUTON8 = 6 ;
// D18 pour l'Arduino Leonardo et D14 pour l'Arduino Uno
const int BOUTON9 = 18 ;

void setup() {
  // Initialisation les entrées (boutons)
  for (int i = 2; i <= 12; i++){
    pinMode(i, INPUT_PULLUP);
  }
  pinMode(18, INPUT_PULLUP); // D14 pour l'Arduino Uno
  // Initialisation du clavier
  Keyboard.begin();
}

void loop() {
  if (digitalRead(BOUTON0) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x30); // Chiffre 0
    relachementTouche(BOUTON0);
  }
  if (digitalRead(BOUTONPoint) == LOW) {
    Keyboard.press(0x3C); // Point    
    relachementTouche(BOUTONPoint);
  }
  if (digitalRead(BOUTONEn) == LOW) {
    Keyboard.press(0xB0); // Entrée
    relachementTouche(BOUTONEn);
  }
  if (digitalRead(BOUTON1) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x31); // Chiffre 1
    relachementTouche(BOUTON1);
  }
  if (digitalRead(BOUTON2) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x32); // Chiffre 2
    relachementTouche(BOUTON2);
  }
  if (digitalRead(BOUTON3) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x33); // Chiffre 3
    relachementTouche(BOUTON3);
  }
  if (digitalRead(BOUTON4) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x34); // Chiffre 4
    relachementTouche(BOUTON4);
  }
  if (digitalRead(BOUTON5) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x35); // Chiffre 5
    relachementTouche(BOUTON5);
  }
  if (digitalRead(BOUTON6) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x36); // Chiffre 6
    relachementTouche(BOUTON6);
  }
  if (digitalRead(BOUTON7) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x37); // Chiffre 7
    relachementTouche(BOUTON7);
  }
  if (digitalRead(BOUTON8) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x38); // Chiffre 8
    relachementTouche(BOUTON8);
  }
  if (digitalRead(BOUTON9) == LOW) {
    Keyboard.press(0x81); // Shift (gauche)
    Keyboard.press(0x39); // Chiffre 9
    relachementTouche(BOUTON9);
  }
  delay(10);
}

int relachementTouche(int bouton){
  Keyboard.releaseAll();
  while(digitalRead(bouton) == LOW){
    delay(10);
  }
}

La version « Gamer »

J’ai fais cette 2ème version pour mon fils qui voulais jouer à un jeu de combat conçu pour un clavier QWERTY (il n’était pas possible de modifier les touches dans le jeu). Cette fois ci, je n’ai pas fait l’erreur d’inscrire quelque chose sur les touches et je trouve le résultat final est beaucoup plus joli.

J’ai renommé les touches de 1 à 12 en partant du haut. Dans cet exemple, la plupart des touches sont désactivées et la répétition des touches n’est pas bloquée. Mais comme toujours, vous pouvez modifier cela en fonction de vos besoins.

// Pave_Numerique_v3
// Appel de la bibliothèque
#include "Keyboard.h"
// Ports des boutons
const int BOUTON1 = 7 ;
const int BOUTON2 = 8 ;
const int BOUTON3 = 9 ;
const int BOUTON4 = 10 ;
const int BOUTON5 = 3 ;
const int BOUTON6 = 4 ;
const int BOUTON7 = 5 ;
const int BOUTON8 = 6 ;
const int BOUTON9 = 2 ;
const int BOUTON10 = 11 ;
const int BOUTON11 = 12 ;
// D18 pour l'Arduino Leonardo et D14 pour l'Arduino Uno
const int BOUTON12 = 18 ;

void setup() {
  // Initialisation les entrées (boutons)
  for (int i = 2; i <= 12; i++){
    pinMode(i, INPUT_PULLUP);
  }
  pinMode(18, INPUT_PULLUP); // D14 pour l'Arduino Uno
  // Initialisation du clavier
  Keyboard.begin();
}

void loop() {
  if (digitalRead(BOUTON1) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON1);
  }
    if (digitalRead(BOUTON2) == LOW) {
    Keyboard.press(0x20); // Espace
    relachementTouche(BOUTON2);
  }
    if (digitalRead(BOUTON3) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON3);
  }
    if (digitalRead(BOUTON4) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON4);
  }
  if (digitalRead(BOUTON5) == LOW) {
    Keyboard.press(0x51); // Q    
    relachementTouche(BOUTON5);
  }
    if (digitalRead(BOUTON6) == LOW) {
    Keyboard.press(0x53); // S
    relachementTouche(BOUTON6);
  }
    if (digitalRead(BOUTON7) == LOW) {
    Keyboard.press(0x44); // D
    relachementTouche(BOUTON7);
  }
    if (digitalRead(BOUTON8) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON8);
  }  
  if (digitalRead(BOUTON9) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON9);
  }
  if (digitalRead(BOUTON10) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON10);
  }
  if (digitalRead(BOUTON11) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON11);
  }
  if (digitalRead(BOUTON12) == LOW) {
    // Touche inutilisée
    relachementTouche(BOUTON12);
  }
  delay(1);
}

int relachementTouche(int bouton){
  Keyboard.releaseAll();
  //while(digitalRead(bouton) == LOW){
    //delay(10);
  //}
}

La liste des principaux caractères est disponible ici et les autres touches sont ici.

Autres utilisations

Il est possible d’ajouter les touches qui manquent à votre clavier (Ω, É, Ç, æ …), les raccourcis claviers les plus courant (COPIER, COUPER, COLLER…), ceux que vous n’arrivez jamais à retenir, voir même fabriquer un clone de Stream Deck beaucoup moins cher (voir les liens ci-dessous).

	Prusa MMU3 – a… dans Mini clavier 12 touches
	GaelJ dans Filament flexible avec la Prus…
	Jacques Leprof dans Arduino UNO R4
	jcquetin dans Arduino UNO R4
	Jacques dans Arduino UNO R4

arduiblog

Infos, tests, tutos sur l'Arduino, le Microbit, la Pyboard, l'impression 3D etc… le Raspberry Pi, l'électronique, la programmation, l'impression 3D…