Étape 3: Construire le clavier logiciel Arduino
Tout d’abord je vais passer en revue matrices donc vous pouvez voir la théorie et puis je vais vous montrer comment le pilote est écrit à l’aide de l’IDE Arduino. Si vous êtes un codeur confiant et que vous souhaitez ignorer cela, vous pouvez obtenir une copie du code complet sur la page ressources de mon site, AltoidsDrone.com.
Pour rappel, les informations de clé qui a rédigé le programme que nous nous sommes réunis dans la dernière étape a été :
- Le film avec 5 contacts a les lignes de données
- Les lignes de données utilisent brochesA0-A4 et ont des résistances de pull-up au + 5V
- Le film avec 8 contacts possède les lignes d’adresse et utilise des broches numériques 2-9
- Le clavier est disposé dans une matrice de 5 x 8 (données adresse x)
Comment fonctionne une matrice de clavier
Une matrice de clavier est une grille de fils, tels que les lignes d’adresse et de données formant la grille de 5 x 8 dans le spectre. Chaque touche est une touche qui croise une ligne avec une colonne (la Croix sur la grille) et tous les boutons sont physiquement maintenues ouvertes par défaut. Cela signifie que les lignes et les colonnes ne sont pas connectés, et aucun courant (ou tension) n’est passée d’une ligne à une colonne ou vice versa.
Il existe deux types de matrice, pull-up et pull-down. Vous pouvez trouver plus d’informations sur les différences opérationnelles ici. Le clavier original de spectre utilisé une configuration de pull-up. La chose à retenir est faible dans notre matrice, pas haut. Lorsqu’une touche est enfoncée, il est donc que nous devons déclencher et ensuite chercher à basse tension. La première image montre comment fonctionne la matrice.
Dans les grilles de quatre ci-dessus, le bouton connexion de la deuxième colonne à la deuxième rangée est pressé. À commencer par, tout se tient haut. La première colonne est remplacée par le bas, et le contrôleur vérifie la tension à chaque rang pour voir si il y a une baisse (première grille). Aucuns boutons sur cette colonne ne sont pressées pour toutes les lignes restent à 5V. La première colonne retourne en haute, et la deuxième colonne est envoyée faible (seconde image). Les lignes sont vérifiées dans l’ordre nouveau. La touche pressée sur la deuxième rangée se connecte le + 5V d’alimentation de la deuxième rangée pour le 0 v de la deuxième colonne par l’intermédiaire de la résistance (troisième image). Le contrôleur détecte le 0V sur cette ligne et sait que le deuxième bouton de la deuxième colonne est que la lettre « j » sorties donc une combinaison de touches « j ». Le cycle puis exploite les lignes et sur les colonnes, puis répète ((quatrième image).
En bref, voilà comment fonctionne une matrice. Dans la pratique tout notre pilote de clavier a à faire est donc exécuter le même cycle d’abaisser chaque colonne et de vérification séquentiellement les lignes sur cette colonne pour 0V. Puis il peut look-up qui frappe à la sortie de l’USB.
Le logiciel d’écriture
Je fournis le pilote logiciel complet ici pour vous de regarder que nous avons parcouru : reconstituer. Si vous êtes nouveau au codage pour Arduino, un croquis vierge ouvert et vous pouvez remonter le code que nous allons. Ce tutoriel est également disponible avec syntaxique complète via ce lien.
Ce qui nous donnera ce programme est les lettres A-Z en majuscules et minuscules, les chiffres 0-9, un espace, retour arrière, verrouillage des majuscules et retour. Cela couvre les bases de ce que vous aurez besoin d’utiliser un ordinateur ; Croyez-moi, avec un espace tout petit bouton dans le coin en bas, vous ne voulez pas faire de traitement de texte sur ce clavier. Toutes nos clés seront câblés en et représentaient donc si vous ne souhaitez pas faire toutes les fonctions sur les travaux de clavier, vous pouvez les ajouter dans le programme plus tard.
First, changer votre planche à Leonardo ou le LeoStick. Allez dans Outils > Conseil d’administration et sélectionnez celui que vous utilisez.
Nous allons commencer avec la structure de base d’esquisse :
Ci-dessus la setup(), nous devons déclarer nos variables et écrire nos données de mappage de touches.
Les entiers « données » et « addressNo » spécifient respectivement les numéros de lignes et de colonnes. Ainsi, le tableau de caractères « KeyMap » est 8 dans l’ensemble de 5 vers le bas (correspondant à nos connecteurs de membrane de clavier) et deux profond pour le haut et bas de casse. Les tableaux « dataPin » et « adresse » correspond à notre NIP soudés et sont utilisés pour facilement installer et utiliser les connexions clavier (ou les modifier facilement sans changer le code fonctionnel). Les espaces vides en bas sont l’espace (A4, 2), retour (A4, 3), BACKSPACE (A3, 2) et le verrouillage des majuscules (A4, 4).
Remarque : Ce pilote fonctionne pour n’importe quelle matrice de clavier. Dans le code ci-dessus, tout ce que vous devez faire pour un autre clavier est défini les variables de taille, de goupilles et de mappage de clés de votre clavier. Le reste fonctionnera comme c’est. Si vous utilisez une configuration de menu déroulant, simplement intervertir tous les hauts et les bas, qui nous viendra à bientôt.
Maintenant, nous avons juste besoin de déclarer quelques variables plus pour notre logique de programme. La variable, booléenne « rejeté » contribuera à faire en sorte que le clavier affiche une touche par la presse, qui vous donne « n » au lieu de 'nnnnnnnnnnnnnn'. Pop dans ceux-ci, directement sous le code ci-dessus.
Nous pouvons maintenant passer à la section setup() de l’esquisse. Dans cette section nous besoin de configurer les broches et les mettre dans un état prêt, si nécessaire, puis initier notre fonction de clavier. Plutôt que de spécifier chaque broche individuellement, nous pouvons utiliser pour les boucles pour sauver la répétition, donc ci-dessus les tableaux, les 'dataPin' et 'adresse' contiennent notre NIP que nous pouvons nous référer ici. La première boucle parcourt nos broches numériques (les lignes d’adresses). Ce sont ceux que nous avons mis à haute ou basse, donc nous déclarer chacun en tant que sortie et définissez-la sur son état par défaut.
De même, la deuxième boucle traverse les broches analogiques (nos lignes de données) et déclare chacun en tant qu’entrée.
Enfin, nous initions l’interface USB pour une utilisation comme un dispositif d’interface.
C’est la fin de notre section setup(). Nous pouvons maintenant passer à la loop(), où résidera le reste du code. Comme nous allons, je vais mettre «... » où ira le prochain morceau de code. Le loop() va cycle les lignes d’adresse et vérifier les lignes de données, puis la combinaison de touches appropriée de sortie. Fondamentalement, nous utiliserons à nouveau pour les boucles avec la structure suivante :
A pour la boucle pour passer les lignes d’adresses, dont la ligne d’adresse qu’il utilise faible au départ et retour à haute à la fin de cycles :
Alors que la ligne d’adresse est faible, il faut courir à travers les lignes de données pour voir si un d'entre eux est faible, indiquant une presse de bouton. Cas, lorsque le «... » est, nous allons utiliser une autre boucle for.
Nous avons maintenant besoin de lire chaque ligne de données. Un bouton actionné enverra la ligne de données faible, c'est-à-dire l’entier 0 en binaire (et haute serait donc un 1). Par conséquent, l’entier « pressé » est assignée la valeur binaire de la ligne de données. Nous pouvons alors tester cette valeur avec l’instruction if () de ' if(pressed == 0)'. L’entier « reRelease » est incrémenté pour garder un nombre de ligne de données combien les contrôles sont effectués entre les touches, ce qui nous permet de voir si toutes les clés sont distribués avant d’autoriser des frappes plus.
À ce stade, nous entrons dans une touche étant détectée. Une séquence de touches ne devrait être autorisée une fois par touche (si c’est la première pour cette touche), ce qui nous donne ' n’et pas « nnnnnnnnnnnnn ». Par conséquent, nous testons la booléenne « rejeté » à l’aide d’une autre déclaration if().
Si on envoie une frappe par l’intermédiaire de l’USB, nous devons faire quelques ménage ici. La méthode « Keyboard.releaseAll() » s’assure que les frappes envoyés à USB sont abandonnées. L’entier de la « capitale » déplace les lieux sur la position plus intime du tableau « keyMap ». Par conséquent, s’il est enfoncé pour une deuxième fois pour désactiver, il doit être réinitialisé au poste en minuscules de 0. Enfin, si une touche a été détectée, le programme doit lock-out envoyant plusieurs frappes jusqu'à ce que toutes les clés ont été libérés. Par conséquent, le nombre de « réédition » doit être réinitialisé à 0 et notre « rejeté » la valeur false.
En supposant, le cycle actuel est le premier de cette pression de touche (donc « rejeté » a la valeur true), nous arrivons à l’enregistrement de notre frappe au port USB.
Des caractères spéciaux, des CAPS-LOCK, retour arrière et retour ne rentre pas dans un tableau de caractères et doivent donc être manipulés individuellement. Ainsi, chacun a une déclaration if() pointant vers la combinaison spécifique d’adresse et de données pour cette clé. La première ligne par incréments « capitale » de déplacer l’affaire position lorsque le verrouillage des majuscules est utilisé. Le « else » sur la ligne suivante signifie que le verrouillage des majuscules est CAPS-LOCK et pas de Maj ; Cela correspond à l’étiquette de bouton et simplifie grandement notre logique de pression de touche. Si la touche est une lettre, numéro ou un espace, la dernière ligne références le nombre actuel de données, l’adresse numéro et l’Etat capital pour sélectionner la lettre correspondante de mappage de clés de notre.
Enfin, la dernière chose que nous devons faire est de réactiver nos frappes si toutes les clés ont été libérés, alors ce morceau va avant la finale '}' à la fin de la loop().
Ce vérifie simplement que notre « réédition » compte est supérieure à la taille du tableau 'keyMap' (et donc a eu la clé passée il détecté la dernière fois). Dans l’affirmative, il change « rejeté » à true, la réactivation de frappes pour être envoyé à l’USB.
C’est le pilote de clavier complet. Il suffit de brancher l’Arduino à l’ordinateur via USB et télécharger le croquis sur votre arduino. Une fois redémarré, vous devriez immédiatement être capable de taper à l’aide de vieux clavier de caoutchouc de la gamme.
Pour voir comment j’ai obtenu ce dans mon cadre au moyen d’un Pi de framboise, intégré Wifi et VGA prend en charge de la caisse ce lien à AltoidsDrone.com.
Acknowldgements :
- Merci à 1000bit.it pour leurs schémas et guide complet sur le monde de l’informatique vintage.
