Como exibir a entrada do teclado no LCD usando Arduino Uno
Como interface o teclado com Arduino
O teclado normalmente vem em dois tamanhos um é 3 × 3 e o outro é 4 × 4, então aqui neste projeto estamos usando um teclado 4 × 4. O esquema do circuito da interface do teclado com Arduino e exibindo a entrada no LCD é:
Implementação de hardware
Os componentes que usamos para exibir a entrada do teclado no LCD usando Arduino são:
- Arduino Uno
- Conectando fios
- Potenciômetro
- Um teclado de membrana 4 × 4
- Visor de cristal líquido
- Pão de pão
Usamos a placa de ensaio para interface o LCD com Arduino, enquanto que conectamos diretamente o teclado com o Arduino Uno Board. Isso pode ser ilustrado pela figura abaixo e usamos o potenciômetro para controlar o brilho do LCD.
Código Arduino para exibir a entrada do teclado no LCD
Neste projeto, o programa Arduino está calculando um índice de massa corporal (IMC), pegando o peso e a altura da pessoa como uma entrada do teclado. Para calcular o IMC, usamos a seguinte fórmula:
IMC = (peso [kg]/altura [cm]*altura [cm])*10000;
Para calcular o IMC em um sistema métrico e, principalmente, a altura é medida em centímetros, por isso convertemos altura em metros multiplicando todo o resultado por 10.000.
#include // biblioteca para teclado#include // biblioteca para LCD
LiquidCrystal LCD (A1, A0, 5, 4, 3, 2); // pinos Arduino para LCD
Const Byte linhas = 4; // inicializando as fileiras do teclado
const byte cols = 4; // inicializando as colunas do teclado
Char Keys [linhas] [cols] = // dando valores a cada tecla do teclado
'1', '2', '3', '&',
'4', '5', '6', 'b',
'7', '8', '9', 'C',
'*', '0', '=', 'd'
;
byte rowpins [linhas] = 13,12,11,10; // pinos Arduino para fileiras de teclado
byte colpins [cols] = 9,8,7,6; // pinos Arduino para colunas do teclado
Teclado myKeypad = teclado (MakeKyyMap (chaves), rowpins, colpins, linhas, cols); /* função para mapear os valores nas chaves*/
// atribuindo tipo de dados booleanos às variáveis e inicializando -as com zero
booleano presente = false;
booleano próximo = false;
final booleano = false;
String num1, num2; // variáveis para exibir a entrada inteira do teclado
flutuar Ans; // variável para armazenar o resultado do IMC
char op
configuração void ()
LCD.começar (16,2); // inicializando o LCD
LCD.setCursor (3,0); // Definindo o local para exibir a primeira linha de dados
LCD.print ("linuxhint"); // dados a serem exibidos
LCD.setCursor (1,1); // definindo o local para exibir a segunda linha de dados
LCD.print ("calculadora de IMC"); // dados a serem exibidos
atraso (2000); // tempo para o qual os dados serão exibidos no LCD
LCD.claro (); // limpando o LCD
LCD.setCursor (0,0); // Definindo o local para exibir a segunda linha de dados
LCD.print ("Digite WGT & HGT"); // dados a serem exibidos
Void Loop ()
// usando a função getKey para obter o valor da tecla
char chave = myKeypad.getKey ();
se (chave != No_key && (key == '1' || key == '2' || key == '3' || key == '4' || key == '5' || key == '6' || key == '7' || key == '8' || key == '9' || key == '0')) // Verifique qual tecla é pressionada verificando seu valor inteiro
se presente != verdadeiro)
NUM1 = NUM1 + Tecla; // armazenando o valor da tecla pressionado em num1
float numlength = num1.comprimento();
LCD.setCursor (0, 1); /* Decalando o local onde a primeira entrada será exibida*/
LCD.impressão (num1); // imprimindo o primeiro número inserido
outro
num2 = num2 + chave; // armazenando o valor da segunda tecla pressionada em num2
float numlength = num2.comprimento();
LCD.setCursor (4, 1);/*Decalando o local onde a segunda entrada será exibida*/
LCD.impressão (num2); // imprimindo o segundo número inserido
final = true;
// Condição se a tecla com o operador atribuído para o cálculo do IMC for pressionado
else if (presente == false && != No_key && (key == '&')))
if (presente == false)
presente = true;
op = chave; // salvando a tecla pressionada para calcular o IMC
LCD.setCursor (3,1); // definindo o local para que os dados sejam exibidos
LCD.impressão (op); // exibindo o personagem usado para o IMC
// Condições para calcular o IMC
sen if (final == true && tecla != No_key && key == '=')
if (op == '&')
Ans = (num1.tofloat () / (num2.tofloat ()*num2.tofloat ()))*10000; // fórmula para calcular o IMC
LCD.setCursor (0,2); // definindo o local para que os dados sejam exibidos
LCD.print ("Seu IMC é:"); // dados a serem exibidos
LCD.impressão (Ans); // exibindo a resposta para o cálculo do IMC
LCD.claro (); // limpando o LCD
if (Ans<18.5) // if BMI is less than 18.5 then you are under weight
LCD.setCursor (0,0);
LCD.print ("você é");
LCD.setCursor (0,1);
LCD.impressão ("Under Weight");
caso contrário, se (ANS<25)// if BMI is less than 25 then you have normal weight
LCD.setCursor (0,0);
LCD.print ("você tem");
LCD.setCursor (0,1);
LCD.impressão ("peso normal");
caso contrário, se (ANS<30) if BMI is less than 30 then you are over weight
LCD.setCursor (0,0);
LCD.print ("você é");
LCD.setCursor (0,1);
LCD.Imprimir ("Over Weight")
else // senão você é obeso
LCD.print ("Você é obeso");
atraso (2000); // tempo ou quais os dados serão exibidos
// condição para limpar o LCD ou iniciar o código do Arduino novamente
caso contrário, se (chave != No_key && key == 'c')
LCD.claro();
presente = false;
final = false;
setup (); // chamando a função de configuração para iniciar o código novamente
num1 = "";
num2 = "";
Ans = 0;
op = ";
Para calcular o IMC, compilamos o código Arduino de tal maneira que primeiro definimos as bibliotecas do teclado e LCD e os pinos do Arduino são atribuídos para LCD. Em seguida, depois de inicializar a dimensão do teclado, demos um valor a cada tecla, criando uma string.
Em seguida, atribuímos o teclado dos pinos para Arduino e usando a função do teclado mapeou os valores para as teclas do teclado. Avançando, declaramos algumas variáveis que usamos para receber a entrada do teclado e armazenar o resultado para o cálculo do IMC.
Na função de configuração, exibimos alguns dados no LCD e chegando à função Loop, usamos a condição IF para as chaves que têm algum valores inteiros para reconhecer qual valor é inserido.
O programa pega as duas entradas do usuário um é o peso, e o outro é a altura e, quando a chave designada para o IMC, ele calculará o IMC e informará o status, decidindo -o através do valor do IMC.
Para redefinir o programa, definimos uma chave de que, quando for pressionado, ele limpará o LCD e a função de configuração será chamada para reiniciar o código Arduino. Aqui no código, atribuímos a chave "a" do teclado para executar o cálculo do IMC e a chave "C" do teclado é usada para limpar o LCD.
Implementação de hardware para exibir entrada de teclado no LCD
Publicamos a imagem abaixo da implementação de hardware para exibir a entrada do teclado no LCD.
O código Arduino pedirá ao usuário peso e altura e, usando o teclado, o usuário inserirá valores para o peso e a altura, como na imagem postada abaixo.
Em seguida para calcular o IMC, pressione a tecla "A" do teclado e o IMC será exibido no LCD, como na figura abaixo.
Com base no valor do IMC, o código Arduino dará o status do IMC e pode ser visto na figura publicada abaixo.
Conclusão
Quando temos que dar as entradas ao programa Arduino manualmente, temos que interface um teclado com Arduino. Os teclados são versões menores de teclados que podem executar algumas funções básicas, como dar entradas para qualquer dispositivo. Essas entradas podem ser caracteres ou um número inteiro e as teclas do teclado são facilmente configuráveis. Neste artigo, exibimos uma entrada de teclado no LCD compilando um código de calculadora de IMC na qual há duas entradas exigidas pelo Código Arduino: Peso e Altura.