Comment afficher la saisie du clavier sur l'écran LCD à l'aide d'Arduino Uno
Comment interfacer le clavier avec Arduino
Le clavier est normalement disponible en deux tailles, un est 3 × 3 et l'autre est 4 × 4, donc ici dans ce projet, nous utilisons un clavier 4 × 4. Le schéma du circuit de l'interfaçage du clavier avec Arduino et l'affichage de son entrée sur l'écran LCD est:
Implémentation matérielle
Les composants que nous avons utilisés pour afficher l'entrée du clavier sur l'écran LCD à l'aide d'Arduino sont:
- Arduino Uno
- Fils de connexion
- Potentiomètre
- Un clavier à membrane 4 × 4
- Affichage à cristaux liquides
- Planche à pain
Nous avons utilisé la planche à pain pour interfacer l'écran LCD avec Arduino alors que nous avons directement connecté le clavier avec la carte Arduino Uno. Cela peut être illustré par la figure ci-dessous et nous avons utilisé le potentiomètre pour contrôler la luminosité de l'écran LCD.
Code Arduino pour afficher l'entrée du clavier sur l'écran LCD
Dans ce projet, le programme Arduino calcule un indice de masse corporelle (IMC) en prenant le poids et la hauteur de la personne comme entrée du clavier. Pour calculer l'IMC, nous avons utilisé la formule suivante:
Bmi = (poids [kg] / hauteur [cm] * hauteur [cm]) * 10000;
Pour calculer l'IMC dans un système métrique et surtout la hauteur est mesurée en centimètres, nous avons donc converti la hauteur en mètres en multipliant le résultat entier par 10 000.
#include // bibliothèque pour clavier#include // bibliothèque pour l'écran LCD
LCD LiquidCrystal (A1, A0, 5, 4, 3, 2); // Arduino Pins pour LCD
lignes d'octets const = 4; // initialisation des lignes de clavier
Const Byte Cols = 4; // Initialisation des colonnes du clavier
clés de char [lignes] [cols] = // donnant des valeurs à chaque clé du clavier
'1', '2', '3', '&',
'4', '5', '6', 'B',
'7', '8', '9', 'C',
'*', '0', '=', 'D'
;
BYTE ROWPINS [ROWS] = 13,12,11,10; // broches arduino pour les rangées de clavier
BYTE COLPINS [COLS] = 9,8,7,6; // broches Arduino pour les colonnes de clavier
Keypad myKeyPad = Keypad (Makekeymap (touches), rowpins, colpins, lignes, cols); / * Fonction pour le mappage des valeurs sur les touches * /
// attribuant le type de données booléen aux variables et les initialiser avec zéro
booléen présent = false;
booléen suivant = false;
booléen final = false;
String num1, num2; // Variables pour afficher l'entrée entière du clavier
Float Ans; // variable pour stocker le résultat de l'IMC
char Op; // attribuer le type de données de caractère pour le caractère utilisé pour BMI
void setup()
LCD.commencer (16,2); // initialisation de l'écran LCD
LCD.setCursor (3,0); // Définition de la place pour afficher la première ligne de données
LCD.print ("LinuxHint"); // Données à afficher
LCD.setCursor (1,1); // définir la place pour afficher la deuxième ligne de données
LCD.print ("calculatrice d'IMC"); // Données à afficher
Delay (2000); // temps pour lequel les données seront affichées sur l'écran LCD
LCD.clear (); // effacer le LCD
LCD.setCursor (0,0); // définir la place pour afficher la deuxième ligne de données
LCD.print ("Entrez WGT & HGT"); // Données à afficher
VOID LOOP ()
// Utilisation de la fonction getKey pour obtenir la valeur de la touche
Char Key = MyKeepad.Obtenir la clé();
si (clé != No_key && (key == '1' || key == '2' || key == '3' || key == '4' || key == '5' || key == '6' || key == '7' || key == '8' || key == '9' || key == '0')) // vérifier quelle touche est appuyée en vérifiant sa valeur entière
si présent != vrai)
num1 = num1 + key; // Stockage de la valeur de la touche appuyée dans num1
float numLength = num1.longueur();
LCD.setCursor (0, 1); / * décalage de l'endroit où la première entrée sera affichée * /
LCD.print (num1); // Impression du premier numéro entré
autre
num2 = num2 + touche; // stockant la valeur de la deuxième touche appuyée dans num2
float numLength = num2.longueur();
LCD.setCursor (4, 1); / * décalage de l'endroit où la deuxième entrée sera affichée * /
LCD.print (num2); // Impression du deuxième numéro entré
final = true;
// condition si la touche ayant l'opérateur assigné pour le calcul de l'IMC est enfoncée
else if (présent == false && key != No_key && (key == '&'))
if (présent == false)
présent = true;
op = key; // Enregistrer la touche pressée pour calculer l'IMC
LCD.setCursor (3,1); // Définition de la place pour que les données soient affichées
LCD.print (op); // Affichage du caractère utilisé pour BMI
// Conditions pour calculer l'IMC
else if (final == true && key != No_key && key == '=')
if (op == '&')
ANS = (num1.tofloat () / (num2.tofloat () * num2.tofloat ())) * 10000; // formule pour calculer l'IMC
LCD.setCursor (0,2); // Définition de la place pour que les données soient affichées
LCD.imprimer ("Votre IMC est:"); // Données à afficher
LCD.imprimer (ANS); // Affichage de la réponse pour le calcul de l'IMC
LCD.clear (); // effacer le LCD
Si (Ans<18.5) // if BMI is less than 18.5 then you are under weight
LCD.setCursor (0,0);
LCD.print ("vous êtes");
LCD.setCursor (0,1);
LCD.imprimer ("sous-poids");
Sinon If (Ans<25)// if BMI is less than 25 then you have normal weight
LCD.setCursor (0,0);
LCD.print ("vous avez");
LCD.setCursor (0,1);
LCD.imprimer ("poids normal");
Sinon If (Ans<30) if BMI is less than 30 then you are over weight
LCD.setCursor (0,0);
LCD.print ("vous êtes");
LCD.setCursor (0,1);
LCD.imprimer ("sur poids")
sinon // sinon vous êtes obèse
LCD.imprimer ("vous êtes obèse");
Delay (2000); // temps ou quelles données seront affichées
// condition pour effacer l'écran LCD ou recommencer le code Arduino
sinon si (clé != No_key && key == 'c')
LCD.clair();
présent = false;
final = false;
setup (); // appelle la fonction de configuration pour recommencer le code
num1 = "";
num2 = "";
ANS = 0;
op = ";
Pour calculer l'IMC, nous avons compilé le code Arduino de telle manière que nous avons d'abord défini les bibliothèques du clavier et de l'écran LCD et des broches de l'Arduino sont affectées à l'écran LCD. Ensuite, après avoir initialisé la dimension du clavier, nous avons donné à chaque clé du clavier une valeur en créant une chaîne.
Ensuite, nous avons attribué le clavier des broches à Arduino et en utilisant la fonction du clavier a cartographié les valeurs aux touches du clavier. À l'avenir, nous avons déclaré certaines variables que nous avons utilisées pour prendre l'entrée pour le clavier et stocker le résultat pour le calcul de l'IMC.
Dans la fonction de configuration, nous avons affiché certaines données sur l'écran LCD et en arrivant à la fonction de boucle, nous avons utilisé la condition IF pour les touches ayant des valeurs entières pour reconnaître la valeur saisie.
Le programme prend les deux entrées de l'utilisateur, l'un est le poids, et l'autre est la hauteur et lorsque la clé désignée pour l'IMC, elle calculera l'IMC et racontera l'état en le décidant par la valeur de l'IMC.
Pour réinitialiser le programme, nous avons défini une clé selon laquelle lorsqu'elle sera enfoncée, elle effacera l'écran LCD et la fonction de configuration sera appelée pour redémarrer le code Arduino. Ici, dans le code, nous avons attribué la clé «A» du clavier pour effectuer le calcul de l'IMC et la clé «C» du clavier est utilisée pour effacer le LCD.
Implémentation matérielle pour afficher la saisie du clavier sur l'écran LCD
Nous avons publié l'image ci-dessous de l'implémentation matérielle pour afficher l'entrée du clavier sur l'écran LCD.
Le code Arduino demandera à l'utilisateur le poids et la hauteur et en utilisant le clavier, l'utilisateur entrera des valeurs pour le poids et la hauteur comme dans l'image publiée ci-dessous.
Suivant pour calculer l'IMC, appuyez sur la touche «A» du clavier et l'IMC sera affiché sur l'écran LCD comme sur la figure ci-dessous.
Sur la base de la valeur BMI, le code Arduino donnera le statut du BMI et il peut être vu sur la figure publiée ci-dessous.
Conclusion
Lorsque nous devons donner les entrées au programme Arduino manuellement, nous devons interfacer un clavier avec Arduino. Les claviers sont des versions plus petites des claviers qui peuvent effectuer certaines fonctions de base comme donner des entrées à n'importe quel appareil. Ces entrées peuvent être des caractères ou un entier et les clés du clavier sont facilement configurables. Dans cet article, nous avons affiché une entrée de clavier sur l'écran LCD en compilant un code de calculatrice d'IMC dans laquelle il y a deux entrées requises par le code Arduino: poids et hauteur.