Matrice de clavier de prototypage à 64 touches pour Arduino

Outils et machines nécessaires

Fer à souder (générique)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Mise à jour :j'ai amélioré le code, voir "Mise à jour" à la fin.

Je travaille actuellement sur un projet qui aura un clavier intégré, ce qui a posé un problème :comment inclure un clavier dans le prototype de carte de développement ? Je ne peux pas utiliser un clavier USB ou un clavier Arduino existant, car le clavier du projet actuel est connecté directement au microcontrôleur qui gère toutes les autres fonctions. J'ai donc conçu cette matrice de clavier de prototypage à 64 touches basée sur PCB.

Ce PCB ne contient aucun CI (circuits intégrés). Les lignes et les colonnes de la matrice du clavier sont connectées directement aux en-têtes des broches afin que le clavier puisse être connecté à un Arduino ou à tout autre microcontrôleur. Il est parfait pour le prototypage de vos projets qui comprendront un clavier intégré.

J'ai inclus un code détaillé et fortement commenté pour que cela fonctionne avec n'importe quelle carte de développement compatible Arduino qui a suffisamment de broches d'E/S disponibles - 11 broches sont nécessaires. Le clavier a 64 touches, y compris des modificateurs pour shift, majuscules, ctrl, alt, fn et "special". Il y a aussi six touches supplémentaires qui peuvent être utilisées pour tout ce que vous voulez. Les fonctions de chaque touche peuvent être définies individuellement, y compris la fonction de chaque touche lorsqu'un modificateur est actif. À mon avis, c'est significativement plus utile que le code de clavier existant qui limite considérablement votre capacité à personnaliser le comportement des touches.

Le code fourni imprimera le texte sur Serial. Cela peut facilement être modifié si vous souhaitez que le texte aille ailleurs.

Remarque concernant la taille du programme :

Le code que je fournis est assez volumineux, car il n'utilise aucune bibliothèque existante. J'ai entièrement écrit ce code à partir de zéro afin de permettre la personnalisation dont j'avais besoin. Sur un Arduino UNO, cela utilisera 9100 octets (28%) d'espace de stockage de programme et les variables globales utiliseront 394 octets (19%) de mémoire dynamique.

Mon code pourrait probablement être plus efficace et les bibliothèques et croquis pour claviers sont certainement plus petits, mais c'est la seule façon que je puisse imaginer pour offrir une flexibilité totale sur chaque touche avec chaque modificateur. Il prend également en compte l'utilisation du clavier dans le monde réel. Par exemple, si mon code appuie sur la touche Shift alors que le verrouillage des majuscules est activé, une lettre minuscule apparaîtra comme il se doit. Par défaut, maintenir la touche FN enfoncée tout en appuyant sur ESC ne fera rien. Mais ce comportement est entièrement personnalisable, vous pouvez donc le modifier comme bon vous semble.

Fournitures :

• Le PCB personnalisé
• Boutons poussoirs momentanés tactiles 6x6x5mm (x64)
• Diodes de commutation 1N4148 (x64)
• Embases à 1 x 8 broches, femelle ou mâle (x2)
• registre à décalage 74HC595
• Cavaliers
• Planche à pain
• Arduino Uno ou toute carte de développement de microcontrôleur compatible Arduino

Étape 1 : Comment fonctionne une matrice de clavier

Pourquoi une matrice de clavier est-elle nécessaire ?

Ce clavier a 64 touches. Si vous deviez connecter chacun de ces boutons directement à votre carte de développement, vous auriez besoin de 64 broches d'E/S. C'est beaucoup de broches et plus que la plupart des cartes de développement disponibles. Pour réduire cela à un nombre beaucoup plus raisonnable, nous pouvons utiliser une matrice de clavier, qui ne nécessite qu'un nombre de broches égal à la racine carrée (arrondie) du nombre de touches.

Une matrice de clavier est configurée afin que chaque interrupteur à clé d'une rangée soit connecté et que chaque interrupteur à clé d'une colonne soit connecté. Lorsque nous voulons voir quelles touches sont enfoncées, nous "activons" la première ligne puis vérifions chaque colonne. Si une colonne particulière est active, nous savons que la touche de cette colonne et de la ligne 1 a été enfoncée. Nous désactivons ensuite la ligne 1 et activons la ligne 2, puis vérifions à nouveau toutes les colonnes. Une fois que toutes les lignes ont été activées, nous recommençons simplement à la première ligne.

Comment nous analysons la matrice du clavier :

Parce que nous travaillons avec un microcontrôleur, "activer" signifie régler cette ligne sur LOW ou HIGH. Dans ce cas, nous définissons la ligne sur LOW car nous utilisons les résistances pullup intégrées du microcontrôleur sur nos broches d'entrée de colonne. Sans résistance pullup ou pulldown, une broche d'entrée réagira de manière imprévisible en raison de l'interface, qui enregistrera de fausses pressions sur les boutons.

Le microcontrôleur ATmega328P utilisé dans l'Arduino UNO n'a pas de résistances pulldown intégrées, seulement des résistances pullup. Nous les utilisons donc. Les résistances de rappel connectent chaque broche d'entrée à 5 V, garantissant qu'elles lisent toujours HAUT jusqu'à ce qu'un bouton soit enfoncé.

Toutes les lignes sont également normalement définies sur HAUT, ce qui empêche les broches de colonne de se connecter aux broches de ligne, qu'un bouton ait été enfoncé ou non. Mais lorsque nous sommes prêts à vérifier une ligne, nous pouvons définir cette ligne sur FAIBLE . Si un bouton de cette rangée est enfoncé, cela fournira un chemin pour que la broche d'entrée soit tirée à la terre, ce qui fait que cette colonne est maintenant lue comme FAIBLE .

Donc, pour résumer :nous définissons une ligne sur LOW, puis nous vérifions pour voir quelles broches de colonne lisent maintenant LOW. Ceux-ci correspondent à des boutons enfoncés. Ce processus se produit très rapidement, afin que nous puissions balayer l'ensemble du clavier plusieurs fois par seconde. Mon code limite cela à 200 fois par seconde, ce qui équilibre les performances, les rebonds et garantit que chaque pression sur une touche est captée.

Diodes, images fantômes et rollover n-key :

Les diodes du circuit sont là pour empêcher les pressions involontaires sur les touches lorsque certaines combinaisons de boutons sont maintenues enfoncées. Les diodes ne permettent au courant de circuler que dans un seul sens, ce qui évite les images fantômes. Si nous n'utilisions pas de diodes, le fait d'appuyer sur certaines touches pourrait entraîner l'enregistrement d'une autre touche non enfoncée, car le courant traverse les commutateurs adjacents. Ceci est montré dans le graphique simplifié où le fait d'appuyer sur trois touches adjacentes entraîne l'enregistrement de la touche dans le quatrième coin même lorsqu'elle n'est pas enfoncée. Les diodes empêchent cela et activent le "n-key rollover", ce qui signifie que nous pouvons appuyer sur autant de touches que nous voulons dans la combinaison que nous voulons sans aucun problème.

Enregistrement des broches avec un registre à décalage :

Les astucieux d'entre vous ont probablement remarqué que j'ai dit qu'une matrice de clavier nécessite un nombre de broches égal à la racine carrée du nombre de touches, mais que je aussi dit que la conception de mon clavier ne nécessite que 11 broches. Il devrait avoir 16 ans, non ? Non, car nous utilisons un registre à décalage 74HC595. Ce registre à décalage nous permet d'utiliser seulement trois des broches d'E/S de l'Arduino pour contrôler jusqu'à huit broches de sortie. Ces trois broches nous permettent d'envoyer un octet (huit bits) au registre à décalage, qui définit ses huit broches de sortie sur HIGH ou LOW. En utilisant le registre à décalage pour les broches de la rangée de sortie, nous économisons 5 broches d'E/S entières !

« Alors pourquoi ne pas utiliser un registre à décalage pour les broches d'entrée également ? » tu demandes. La réponse la plus simple est que l'entrée nécessite un autre type de registre à décalage et je n'avais pas ce type sous la main. Mais l'utilisation d'un registre à décalage pour l'entrée complique également la façon dont nous lisons les colonnes et peut causer des problèmes de bruit et de « rebondissement ». Qu'il suffise de dire que c'est un casse-tête que je n'ai pas eu besoin de prendre dans ce cas.

Étape 2 :Conception de circuits imprimés

Conception schématique

Maintenant que vous comprenez comment fonctionne une matrice de clavier, ma conception de PCB devrait être simple. J'ai conçu le PCB dans KiCAD (désolé les juges Eagle) et j'ai commencé par le schéma. J'ai simplement placé un symbole de bouton et un symbole de diode, puis les ai copiés et collés jusqu'à ce que j'aie ma grille de 64 touches. Ensuite, j'ai ajouté deux symboles d'en-tête 1x8 broches, un pour les lignes et un pour les colonnes. Un côté des boutons était connecté en colonnes et l'autre côté des boutons était connecté en rangées.

L'étape suivante consistait à attribuer des empreintes PCB à chacun de ces symboles schématiques. La bibliothèque d'empreintes incluse dans KiCAD avait les empreintes nécessaires intégrées. Lorsque vous concevez vos propres circuits imprimés, vous devez faire très attention à choisir les bonnes empreintes, car ce sont elles qui se retrouveront réellement sur votre circuit imprimé. Il existe de nombreux composants qui ont des empreintes très similaires, mais avec des pas légèrement différents ou autre. Assurez-vous de choisir ceux qui correspondent à vos composants réels.

Empreintes et numéros de broche

Portez une attention particulière aux numéros de broche. KiCAD a un problème étrange où les numéros de broche du symbole de la diode schématique ne correspondent pas aux numéros de broche de l'empreinte. Il en résulte que les diodes sont à l'envers, ce qui est un problème sérieux compte tenu de leur polarité. Je n'ai pas compris cette erreur et j'ai dû jeter le premier lot de PCB que j'ai commandé. Pour résoudre ce problème sur la deuxième révision, j'ai dû créer une empreinte de diode personnalisée avec les numéros de broche échangés.

Disposition PCB

Une fois le schéma terminé et les empreintes attribuées, je suis passé à la disposition réelle du PCB. Le contour de la carte a été créé dans Autodesk Fusion 360, exporté au format DXF, puis importé dans KiCAD sur le calque Edge Cuts. La grande majorité du travail par la suite consistait simplement à organiser les boutons de manière à ce qu'ils aient une disposition similaire à celle d'un clavier normal.

Ensuite, toutes les traces ont été routées. Parce que la disposition réelle des boutons ne correspond pas à la matrice nette et ordonnée du schéma, cette partie est devenue un peu compliquée et j'ai dû recourir à des vias à certains endroits. Les vias vous permettent de router une trace d'une couche à une autre, ce qui est très utile lorsque vous utilisez une carte à 2 couches qui a beaucoup de traces qui se chevauchent. Enfin, j'ai ajouté des régions remplies, car c'est une bonne pratique.

Fabrication de PCB

Une fois le tableau conçu, j'ai simplement tracé toutes les couches et les ai ajoutées à un dossier zip. Ce dossier est fourni ici et peut être téléchargé directement vers un service de fabrication de PCB comme JLCPCB.

Voici le lien vers les fichiers PCB Gerber :https://drive.google.com/file/d/10YriLLtghV0Sb84Wm...

Étape 3 :Assemblage du PCB

C'est l'étape la plus simple mais la plus fastidieuse de tout le projet. Il suffit de souder tous les composants en place. Ce sont tous des composants traversants et faciles à souder. Faites particulièrement attention à l'orientation des diodes. La marque sur les diodes doit correspondre aux marques sur le PCB.

D'après mon expérience, il était plus facile de maintenir le PCB en place avec une troisième main et de mettre toutes les diodes en premier. Ensuite, retournez la carte et soudez-les tous, puis coupez les fils. Ensuite, placez tous les boutons et soudez-les. Puis soudez les en-têtes des broches en place. Vous pouvez utiliser des en-têtes de broches femelles ou mâles, cela dépend entièrement de vous. Si vous utilisez une tête masculine et mettez alors en dessous la planche, l'espacement est correct pour les coller directement dans une planche à pain.

Étape 4 :connectez le clavier à votre Arduino

Le câblage a l'air compliqué, mais ce n'est vraiment pas si mal quand on fait attention à où tout va.

Huit cavaliers iront de l'en-tête de colonne directement aux broches Arduino suivantes :

• Colonne 1 > A0
• Colonne 2 > A1
• Colonne 3 > A2
• Colonne 4 > A3
• Colonne 5 > A4
• Colonne 6 > A5
• Colonne 7 > 5
• Colonne 8 > 6

Ensuite, placez le registre à décalage 74HC595 sur votre maquette à cheval sur la pause du milieu. Attention à l'orientation de la puce ! Le point indique la broche 1

Jetez un œil au schéma de câblage pour voir où vont les connexions 5V et à la terre. Le registre à décalage a deux broches connectées à 5V et deux broches connectées à la masse.

Seuls trois fils sont nécessaires pour connecter le registre à décalage à l'Arduino. Ce sont :

• Maj (Horloge) 11 > 4
• Maj (Verrouillé) 12 > 3
• Maj (Données) 14 > 2

Pour une raison idiote, les broches de sortie du registre à décalage sont disposées de manière contre-intuitive. Portez une attention particulière au schéma de brochage du registre à décalage lors de la connexion de ceux-ci à vos broches de rangée. Ce sont :

• Ligne 1 > Décalage (Q0) 15
• Ligne 2 > Décalage (T1) 1
• Ligne 3 > Shift (Q2) 2
• Ligne 4 > Shift (Q3) 3
• Ligne 5 > Décalage (Q4) 4
• Rang 6> Shift (Q5) 5
• Équipe 7> Équipe (Q6) 6
• Shift 8> Shift (Q7) 7

Rien n'est connecté aux broches Arduino 0 ou 1, car celles-ci sont également utilisées pour le port série et provoquent des conflits.

Étape 5 :Flashez le code Arduino

Flashez votre Arduino avec le code fourni ici. Il n'y a rien de spécial à ce sujet, il suffit de télécharger le code comme vous le feriez avec n'importe quel autre projet Arduino.

Tout dans le code a des commentaires détaillés que vous pouvez lire, donc je n'entrerai pas dans les détails ici. Fondamentalement, les broches sont configurées comme entrées et sorties. La boucle principale contient juste une fonction de minuterie. Toutes les 5 ms, il appelle la fonction pour scanner le clavier. Cette fonction appelle une fonction distincte pour définir le registre à décalage avant que chaque colonne ne soit vérifiée. Les touches enfoncées impriment leur valeur sur Serial.

Si vous souhaitez modifier ce qui est imprimé lorsque vous appuyez sur une touche, modifiez simplement le Serial.print("_"); dans l'instruction if qui correspond à la condition. Par exemple, vous pouvez définir ce qui est imprimé lorsque vous maintenez FN et appuyez sur N. La même chose est vraie pour toutes les autres touches avec chaque modificateur.

De nombreuses touches ne font rien du tout dans ce code, car il imprime simplement en série. Cela signifie que la touche de retour arrière n'a pas d'effet, car vous ne pouvez pas supprimer du moniteur série - ces données ont déjà été reçues. Vous êtes cependant libre d'utiliser le changement si vous le souhaitez.

Utiliser le clavier avec vos propres projets

C'est bien d'imprimer en série, mais ce n'est pas vraiment le but de ce clavier. Le but de ce clavier est de prototyper des projets plus complexes. C'est pourquoi il est facile de modifier la fonctionnalité. Si, par exemple, vous vouliez imprimer le texte tapé sur un écran OLED, vous pourriez simplement remplacer chaque Serial.print( avec display.print( ou tout ce que votre affichage particulier requiert. Remplacer tout de l'IDE Arduino l'outil est idéal pour les remplacer tous en une seule étape rapide.

Merci d'avoir lu ceci et j'espère que ce clavier vous aidera dans vos projets !

Mise à jour 30/01/21 :

Ce nouveau code est complètement réécrit et fonctionne mieux que le code d'origine. Cela a été principalement fait pour résoudre un problème avec mon algorithme qui empêchait la saisie de caractères à chaque fois qu'une touche était enfoncée. Le code d'origine a été vérifié pour s'assurer qu'une clé particulière n'était pas la dernière touche à appuyer. Cela provoquait un problème si 2 touches ou plus étaient maintenues enfoncées, ce qui entraînerait la saisie de quelque chose comme "fgfgfgfgfgfgfgfgfgfg". Cela vous a également empêché d'entrer la même clé encore et encore très rapidement, comme lorsque vous tapez les deux m dans le mot "déception".

Le nouveau code résout ces deux problèmes et est également plus élégant. Au lieu de garder une trace de la dernière touche enfoncée, nous vérifions l'état de l'ensemble du clavier et le comparons à l'état complet du clavier dans la dernière boucle. Cela signifie que la boucle peut s'exécuter beaucoup plus rapidement et que vous pouvez également entrer la même clé à plusieurs reprises très rapidement. Les performances sont considérablement améliorées. Tous les caractères sont également dans des tableaux en haut, vous pouvez donc les trouver et les modifier facilement. Il existe des tableaux indépendants pour chaque modificateur. Le code est également beaucoup plus court.

Le seul inconvénient de cette nouvelle approche est qu'elle utilise plus de mémoire dynamique, bien qu'elle utilise beaucoup moins d'espace de programme. Sur un Arduino Uno, il utilise désormais : 3532 octets (10 %) d'espace de stockage du programme et 605 octets (29 %) de mémoire dynamique.

En prime, ce code fonctionne aussi bien sur des microcontrôleurs rapides comme l'ARM Cortex-M4. L'intervalle de temps pour vérifier le clavier est en microsecondes, il fonctionnera donc de la même manière sur n'importe quelle carte. Vous pouvez également ajuster facilement la fréquence de vérification du clavier. Par défaut, il exécute une boucle toutes les 500 microsecondes. Il faut 8 boucles pour vérifier le clavier, pour un total de 4000 microsecondes (4 millisecondes, ou 250 fois par seconde), bien que cela puisse prendre plus de temps si le micro n'est pas assez rapide pour exécuter le code aussi rapidement.

Code

• ProtoKeyboardV1.1-Shifted.ino
• ProtoKeyboardV1-Bits.ino

ProtoKeyboardV1.1-Shifted.inoArduino

Aucun aperçu (téléchargement uniquement).

ProtoKeyboardV1-Bits.inoArduino

Pièces et boîtiers personnalisés

Schémas