Programa de Calculadora Arduino

A programação é sempre divertida e o Arduino é uma plataforma maravilhosa se você está apenas começando com a programação Embedded. Neste tutorial vamos construa nossa própria calculadora com Arduino. Os valores podem ser enviados através de um teclado (4×4 teclado) e resultado pode ser visto em um tela de um LCD (Matrix de 16×2). Esta calculadora pode realizar operações simples como adição, subtração, multiplicação e divisão com números inteiros. Mas depois de entender o conceito, você pode implementar até mesmo funções científicas com o Arduino’s funções incorporadas.

No final deste projeto, você saberá como usar um LCD 16x2 e Keypad com Arduino e também como é fácil programá-los usando as bibliotecas prontamente disponíveis. Você também entenderá como programar seu Arduino para realizar uma tarefa específica.

Materiais requisitados:

1. Arduino Uno (Qualquer versão funcionará)
2. Tela de LCD 16×2
3. Teclado de 4×4
4. Bateria de 9V
5. Protoboard e Cabinhos de fios

Diagrama de circuito:

O diagrama de circuito completo deste Projeto Calculadora Arduino é dado acima. A conexão de + 5V e terra mostrada no diagrama de circuito pode ser obtida a partir do 5V e do pino terra do Arduino. O Arduino em si pode ser alimentado a partir do seu laptop ou através do conector DC usando um adaptador de 12V ou bateria de 9V.


 

Estamos operando o LCD no modo de 4 bits com Arduino Portanto, apenas os últimos quatro bits de dados do LCD estão conectados ao Arduino. O teclado terá 8 pinos de saída que devem ser conectados do pino 0 ao pino 7, como mostrado acima. Você pode usar a seguinte tabela de conexão para verificar sua conexão com o Arduino, você também pode verificar o Teclado 4x4 com interface ao Arduino.

Pino nome Arduino:	Conectado a:
D0	1st pino do teclado
D1	2nd pino do teclado
D2	3rd pino do teclado
D3	4th pino do teclado
D4	5th pino do teclado
D5	6th pino do teclado
D6	7th pino do teclado
D7	8th pino do teclado
D8	Registre o pino selecionado do LCD (pino 4)
D9	Ative o pino do LCD (pino 6)
D10	Pino de dados 4 (pino 11)
D11	Pino de dados 4 (pino 11)
D12	Pino de dados 4 (pino 11)
D13	Pino de dados 4 (pino 11)
+5V	Conectado ao pino Vdd do LCD (pino 2)
Ground	Conectado ao pino Vss, Vee e RW do LCD (pino 1,3 e 5)

As placas do Arduino podem mostrar um erro durante o carregamento do programa, se houver algo conectado ao pino 0 e ao pino 1, portanto, se ocorrer algum, apenas remova o teclado enquanto estiver carregando o programa.

Uma vez que suas conexões são feitas, seu hardware será algo como isto abaixo

Programa de Calculadora Arduino:

Completar o programa para Arduino para este projeto é dado no final deste projeto. O código é dividido em pequenos pedaços significativos e explicado abaixo.

Como dito anteriormente, vamos ver interface de um LCD e teclado com Arduino usando bibliotecas. Então, vamos adicioná-los ao nosso Arduino IDE primeiro. A biblioteca para LCD já está incluído no seu Arduino por padrão, então não precisamos nos preocupar com isso. Para a Biblioteca de teclado clique no link para baixá-lo do Github. Você obterá um arquivo ZIP e, em seguida, adicionará essa lib ao Arduino pelo Sketch - > Incluir biblioteca - > Adicione o arquivo .ZIP e aponte o local para esse arquivo baixado. Uma vez feito estamos todos prontos para a programação.

Mesmo que tenhamos usado uma biblioteca para usar um teclado, temos que mencionar alguns detalhes (mostrados abaixo) sobre o teclado para o Arduino.  A variável ROWS e COLS informará quantas linhas e colunas nosso teclado possui e o mapa de teclado mostrará a ordem em que as teclas estão presentes no teclado. O teclado que estou usando neste projeto se parece com isso abaixo para o mapa-chave também representa o mesmo.

Mais abaixo, mencionamos a que os pinosd o teclado está conectado usando a variável array rowPins e colPins.

const byte ROWS = 4; // Quatro linhas
const byte COLS = 4; // Três colunas

// Define the Keymap
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = { 0, 1, 2, 3 };// Conecte o teclado ROW0, ROW1, ROW2 e ROW3 a esses pinos do Arduino.
byte colPins[COLS] = { 4, 5, 6, 7 };// Conecte o teclado COL0, COL1 e COL2 a esses pinos do Arduino.

Uma vez que tenhamos mencionado que tipo de teclado estamos usando e como está conectado, podemos criar o teclado usando esses detalhes usando a linha abaixo

Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );// Crie o teclado

Da mesma forma, também temos que dizer para quais pinos do Arduino o LCD está conectado para. De acordo com nosso diagrama de circuito, as definições seriam como abaixo

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; //Pinos aos quais o LCD está conectado
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); //crie o LCD

Dentro de setup função, nós apenas exibimos o nome do projeto e depois prosseguimos para o loop while onde está o projeto principal.

Basicamente, temos que verificar se algo está sendo digitado no teclado, se for digitado, temos que reconhecer o que está sendo digitado e depois convertê-lo em uma variável quando“=” é pressionado, temos que calcular o resultado e, finalmente, exibi-lo no LCD. Isso é exatamente o que é feito dentro do loop função como mostrado abaixo

key = kpd.getKey(); //armazenar o valor da tecla pressionada em um caractere

if (key!=NO_KEY)
DetectButtons();

if (result==true)
CalculateResult();

DisplayResult(); 

O que acontece dentro de cada função é explicado usando as linhas de comentário, percorrer o código completo abaixo, mexer com ele para entender como ele realmente funciona. Se você tiver alguma dúvida sobre uma linha específica, fique à vontade para usar a seção de comentários ou os fóruns.

Simulação da Calculadora Arduino:

Também podemos tentar simular o projeto usando o software Proteus. Proteus não possui um componente Arduino’é próprio, mas pode ser facilmente baixado e adicionado à sua biblioteca.  Uma vez que você tenha o componente Arduino no Proteus, basta adicionar o LCD alfanumérico e o teclado para fazer a conexão conforme mostrado no diagrama do circuito.

Em seguida, baixe o arquivo hexadecimal a partir daqui e adicione-o ao Arduino clicando duas vezes a bordo no Proteus e aponte o“arquivo de programa” para este arquivo hexadecimal baixado. Um instantâneo da simulação é mostrado abaixo.

Nota: O arquivo hexadecimal não é o mesmo que o original do programa fornecido abaixo. Foi modificado desde que o mapa de teclas do teclado de simulação e o teclado de hardware real é diferente.

Trabalhando de Arduino Calculator:

Faça as conexões conforme o diagrama do circuito e faça o upload do código abaixo. Se mostrar erro, certifique-se de ter adicionado a biblioteca de acordo com as instruções dadas acima. Você também pode tentar a simulação para verificar se o problema está no seu hardware. Se tudo for feito como é suposto ser, então seu hardware será algo como isto abaixo com o LCD exibindo este

Como o teclado usado aqui não tem marcações adequadas, assumi que os Alfabetos são operadores, conforme listado abaixo.

Character on Keypad	Assumed to be
“A”	Addition (+)
“B”	Subtraction (-)
“C”	Multiplication (*)
“D”	Division (/)
“*”	Clear (C)
“#”	Equals (=)

Você pode usar um marcador para escrever sobre o que cada botão realmente representa.

Com isso feito, você pode começar a usar a calculadora diretamente. Digite o número e aparecerá na segunda linha pressione o operando e digite seu segundo número, finalmente pressione o“#” chave para obter o seu resultado. Você também pode tentar construir este Calculadora Arduino baseada em tela sensível ao toque.

Code: 

/*
 * Programa de calculadora Arduino Keypad
 */

#include <LiquidCrystal.h> //Arquivo de cabeçalho para LCD de https://www.arduino.cc/en/Reference/LiquidCrystal
#include <Keypad.h> //Arquivo de cabeçalho para o teclado de https://github.com/Chris--A/Keypad

const byte ROWS = 4; //Quatro linhas
const byte COLS = 4; //Três colunas

//Definir o mapa de chaves
char keys[ROWS][COLS] = {

  {'7','8','9','D'},

  {'4','5','6','C'},

  {'1','2','3','B'},

  {'*','0','#','A'}

};

byte rowPins[ROWS] = { 0, 1, 2, 3 };//Conecte o teclado ROW0, ROW1, ROW2 e ROW3 a esses pinos do Arduino.
byte colPins[COLS] = { 4, 5, 6, 7 }; //Conecte o teclado COL0, COL1 e COL2 a esses pinos do Arduino.

Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); //Crie o teclado

const int rs = 8, en = 9, d4 = 10, d5 = 11, d6 = 12, d7 = 13; //Pinos aos quais o LCD está conectado
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

 long Num1,Num2,Number;
 char key,action;
 boolean result = false;

void setup() {
  lcd.begin(16, 2); //Estamos usando um monitor LCD de 16*2
  lcd.print("DIY Calculator"); //Exibir uma mensagem de introdução
  lcd.setCursor(0, 1);   //coloque o cursor na coluna 0, linha 1
  lcd.print("-CircuitDigest"); //Exibir uma mensagem de introdução 

   delay(2000); //Aguarde até que a exibição mostre uma mensagem de introdução ao infoplay
    lcd.clear(); //Então limpe
}

void loop() {

key = kpd.getKey(); //armazenar o valor da tecla pressionada em um caractere

if (key!=NO_KEY)
DetectButtons();

if (result==true)
CalculateResult();

DisplayResult(); 
}

void DetectButtons()
{
     lcd.clear(); //Então limpe
    if (key=='*') //Se cancelar, o botão é pressionado
    {Serial.println ("Button Cancel"); Number=Num1=Num2=0; result=false;}
 
     if (key == '1') //Se o botão 1 for pressionado
    {Serial.println ("Button 1");
    if (Number==0)
    Number=1;
    else
    Number = (Number*10) + 1; //Pressionado duas vezes
    }
 
     if (key == '4') //Se o botão 4 for pressionado
    {Serial.println ("Button 4");
    if (Number==0)
    Number=4;
    else
    Number = (Number*10) + 4; //Pressionado duas vezes
    }
 
     if (key == '7') //Se o botão 7 for pressionado
    {Serial.println ("Button 7");
    if (Number==0)
    Number=7;
    else
    Number = (Number*10) + 7; //Pressionado duas vezes
    }
  

    if (key == '0')
    {Serial.println ("Button 0"); //Botão 0 é pressionado
    if (Number==0)
    Number=0;
    else
    Number = (Number*10) + 0; //Pressionado duas vezes
    }
 
     if (key == '2') //Botão 2 é pressionado
    {Serial.println ("Button 2");
     if (Number==0)
    Number=2;
    else
    Number = (Number*10) + 2; //Pressionado duas vezes
    }
 
     if (key == '5')
    {Serial.println ("Button 5");
     if (Number==0)
    Number=5;
    else
    Number = (Number*10) + 5; //Pressionado duas vezes
    }
 
     if (key == '8')
    {Serial.println ("Button 8");
     if (Number==0)
    Number=8;
    else
    Number = (Number*10) + 8; //Pressionado duas vezes
    } 
  

    if (key == '#')
    {Serial.println ("Button Equal");
    Num2=Number;
    result = true;
    }
 
     if (key == '3')
    {Serial.println ("Button 3");
     if (Number==0)
    Number=3;
    else
    Number = (Number*10) + 3; //Pressionado duas vezes
    }
 
     if (key == '6')
    {Serial.println ("Button 6");
    if (Number==0)
    Number=6;
    else
    Number = (Number*10) + 6; //Pressionado duas vezes
    }
 
     if (key == '9')
    {Serial.println ("Button 9");
    if (Number==0)
    Number=9;
    else
    Number = (Number*10) + 9; //Pressionado duas vezes
    }  

      if (key == 'A' || key == 'B' || key == 'C' || key == 'D') //Detecting Buttons on Column 4
  {
    Num1 = Number; 
    Number =0;
    if (key == 'A')
    {Serial.println ("Addition"); action = '+';}
     if (key == 'B')
    {Serial.println ("Subtraction"); action = '-'; }
     if (key == 'C')
    {Serial.println ("Multiplication"); action = '*';}
     if (key == 'D')
    {Serial.println ("Devesion"); action = '/';}  

    delay(100);
  }

}

void CalculateResult()
{
  if (action=='+')
    Number = Num1+Num2;

  if (action=='-')
    Number = Num1-Num2;

  if (action=='*')
    Number = Num1*Num2;

  if (action=='/')
    Number = Num1/Num2;
}

void DisplayResult()
{
  lcd.setCursor(0, 0);   // set the cursor to column 0, line 1
  lcd.print(Num1); lcd.print(action); lcd.print(Num2);

  if (result==true)
  {lcd.print(" ="); lcd.print(Number);} //Exibir o resultado

  lcd.setCursor(0, 1);   //coloque o cursor na coluna 0, linha 1
  lcd.print(Number); //Exibir o resultado
}