Je suis un peu handicapé. Je suis gaucher et suite à un accident il me manque des doigts à cette main, ce qui n’est pas gênant au quotidien, pour travailler notamment, mais qui peut parfois être compliqué pour jouer. Ma configuration de jeu est la suivante : main gauche sur la souris (et donc je ne peux pas changer cette habitude) et main droite sur le clavier. J’utilise les touches fléchées, le petit pavé au dessus, les touches CTRL et SHIFT droite et parfois le pavé numérique. C’est une certaine gymnastique, parfois fatigante mais je me suis habitué. Et puis, en lurkant sur le net, je suis tombé sur des communautés de gens qui fabriquent leur propre clavier mécanique aux formes diverses ! Parce que je suis un peu comme ça, je viens donc de me lancer dans la création d’un clavier gaming adapté à ma main droite. C’est parti.

---

Bien qu’il existe de nombreux pavés gaming (gaming pad en anglais), très rares sont ceux adaptés pour la main droite, et lorsque c’est le cas, ils sont souvent plus chers, comme c’est le cas avec cet engin (plus vraiment un clavier à ce niveau là), l’Azeron, qui a l’air d’être absolument génial, mais très cher, 160€ pour la version gaucher.

Tout est imprimé en 3D, et l’ensemble est fait main.

Si d’autres y arrivent, pourquoi pas moi ?

Cet article sera en plusieurs parties, au fur et à mesure de mes avancées. Je ferai probablement un récapitulatif une fois terminé.

1ère étape : L’outillage et l’électronique

Je ne disposais d’absolument aucun équipement ni outil pour l’électronique. Je suis passé par Amazon qui vend tout ce dont j’avais besoin, a un prix raisonnable et livré très rapidement.

• Un kit de soudure avec fer à souder et soudure, multimètre, pinces, pompe à dessouder (c’est ce qui m’a décidé vu que je vais cannibaliser un vieux clavier), une pince fine, une pince à découper etc. pour 24€.
• Un Arduino Pro Micro. C’est un tout petit composant permettant, notamment, d’émuler un équipement USB type Souris, Clavier, Joystick et autre. Il est programmable plutôt facilement. Il existe plein de clones et il n’est pas cher, 9€.
• Une loupe avec des pinces parce que j’y vois rien. Cela s’appelle une troisième main et ça m’a bien servi pour dessouder. 23€. Si vous avez déjà des pinces et bonnes lunettes, c’est inutile.
• Un kit de débutant en électronique avec plein de composant pour jouer avec. Il y a un breadboard (une carte pour brancher des composer sans souder), des fils de toutes sortes, des diodes, des interrupteurs, bref plein de petits trucs pour démarrer et prototyper. 16€.
• Des diodes 1N4148 dont je vais reparler plus tard. 7€

Ça fait un total de 79€, juste pour démarrer le prototype. Tout sera évidemment réutilisable pour d’autres projets, mais clairement ce n’est pas pour éviter de payer cher que je fais ça. C’est principalement pour le plaisir d’apprendre et d’avoir un objet spécialement adapté.

• 

• 

• 

• 

• 

Je répète : se construire un clavier personnalisé n’est pas un projet économique !

2ème étape : Prototype

Logiciels

Une fois le matériel reçu, j’ai voulu tester tout ça.

D’abord télécharger l’IDE d’Arduino et l’installer. C’est fondamental.

Ensuite, biiiien lire la page d’info du contrôleur Pro Micro et surtout, installer l’add-on pour l’IDE sinon le programme ne reconnaitra pas la carte (j’ai testé pour vous).

• Choisir dans Outil, le type de carte « Sparkfun Pro Micro »
• Choisir le processeur ATMega32U4 (5V, 16 Mhz)

Vérifier que le contrôleur fonctionne

• Brancher le Pro Micro sur l’ordinateur via un câble USB
• Lancer le test Blinkie permettant de voir les leds clignoter. Il se trouve sur la page de Sparkfun, juste après l’installation de l’add-on

Si ça clignote c’est que le Pro Micro fonctionne. Il peut arriver d’en recevoir des défectueux, d’où le test.

Premier proto

J’avais déjà dessoudé quelques touches mécaniques d’un vieux clavier qui ne me servait plus. Il est tout à fait possible d’acheter les touches que vous voulez, il y a plein de sites pour ça, mais j’ai fait avec ce que j’avais sous la main.

Après avoir soudé les pattes de l’arduino, je l’ai branché sur le breadboard puis j’ai posé deux interrupteurs. Le GND est commun et branché sur une des pins GND de l’arduino, et les deux autres pins des interrupteurs sont branchés sur deux autres pins du contrôleur.

Lancez l’IDE, puis testez les boutons.

include "Keyboard.h"
int Pin = 5; //Indiquez la broche/pin du bouton à tester

bool STATES;
void setup()
{
Keyboard.begin();
pinMode(Pin, INPUT_PULLUP); 
STATES = digitalRead(Pin);
}
void loop()
{
bool state;
state = digitalRead(Pin);
if (STATES != state) {
if (state == LOW) {
Keyboard.press('a');
} else {
Keyboard.release('a');
}
STATES = state;
}
}

Ce code permet simplement d’imprimer la lettre « a » quand le bouton indiqué est enfoncé. Plus précisément, il enverra un « z » parce que le système est en QWERTY et que je n’ai pas encore trouvé comment changer ça (probablement dans le Keyboard.h).

Second proto

Utiliser une pin par bouton n’est pas très efficace. Du coup, on va utiliser un système de matrice. Mon deuxième proto aura deux lignes de deux boutons. Avec un tel système on utilise uniquement une pin par ligne et une par colonne.

Ici, on a 2×2 donc 4 pins utilisés. Ok, exactement pareil que si on avait branché en direct. Mais au moins, ça me permet de tester le code et de l’étendre par la suite. Si ça marche pour 2×2, ça marchera pour 4×5 par exemple.

On deux boutons Cherry MX et deux interrupteurs tout bête. Les deux Cherry forment une ligne et les deux interrupteurs une autre ligne. Chaque ligne est reliée à une pin de l’arduino avec les diodes.

Je me suis basé sur cet article ainsi que celui-ci pour la construction de la matrice. Les photos m’ont permis d’en comprendre l’organisation.

Pour le code, j’ai piqué celui-ci et l’ai adapté à ma matrice.

include "Keyboard.h"
byte row[] = {18,14};
byte col[] = {6,8};
byte rowSize = sizeof(row);
byte colSize = sizeof(col);
byte keysState[2][2];
char keys[2][2] = {{'f', 'g'},
{'h', 'i'}};

void setup()
{
Serial.begin(9600);
Keyboard.begin();
//resets all pins
for(int i = 0; i < rowSize+1; i++){
pinMode(row[i], INPUT);
}
for(int i = 0; i < colSize; i++){
pinMode(col[i], INPUT_PULLUP);
}
}
void loop()
{
readBoard(); //reads and stores which switches are released and pressed
pressKeys(); //sends keypress to device
}
void readBoard(){
for(int i = 0; i < rowSize; i++){ //iterate over each row
pinMode(row[i], OUTPUT);
digitalWrite(row[i], LOW); //allows current to flow through row
for(int j = 0; j < colSize; j++){ //interate over each switch in the row
pinMode(col[j], INPUT_PULLUP); //open the column pin up for reading
keysState[j][i] = digitalRead(col[j]); //checks the state of the switch in the row
//and stores it in keysState
pinMode(col[j], INPUT);//closes the switch for reading
} //runs until it has checked all switches in the row
//finishes checking the row
pinMode(row[i], INPUT); //stop current from flowing through the row
//move to the next row
}
}
void pressKeys(){
//interate over the keyState array
for(int i = rowSize - 1; i >= 0; i--){
for(int j = colSize - 1; j >= 0; j--){
//switch at current point is pressed
if(keysState[j][i] == 0){
//Serial.print("Pressed: ");
//Serial.println(keys[i][j]);
//sends pressed value based keys array
Keyboard.press(keys[i][j]);
}
else{ //switch at current point is not pressed //Serial.print("Released: "); //Serial.println(keys[i][j]); //sends release value based on keys array Keyboard.release(keys[i][j]); } }
}
Serial.println();
}

Hop, on balance dans l’arduino, puis on appuie sur les touches et ça fait les lettres. On peut appuyer sur plusieurs lettres en même temps, rester appuyé sur une ou plusieurs, bref ça à l’air de marcher. Il faudra que j’essaie en jeu, pour être sûr que tout est bien pris en compte. Quatre boutons, ça permet de se déplacer.

Voilà où j’en suis pour le moment.

Prochaine (grosse) étape, dessiner le clavier, positionner les touches et éventuellement créer un fichier d’impression 3D pour supporter tout ça.