Guias · 11 min de leitura

Calculadora com Arduino: teclado 4x4 e LCD I2C para as quatro operações

Monte uma calculadora com Arduino, teclado 4x4 e LCD I2C: ligações, mapeamento das teclas, números com vários dígitos, quatro operações, verificação de divisão por zero e código para Uno, ESP32 e Pico.

Uma calculadora com Arduino é um projeto que você pode montar com um teclado 4x4, um LCD I2C 16x2 e alguns jumpers. Ele é divertido e também é uma ótima forma de aprender programação de verdade. Você digita os números nas teclas, escolhe somar, subtrair, multiplicar ou dividir com as teclas A, B, C e D e vê o resultado na tela com a tecla #. A tecla * apaga tudo. Neste guia você vai aprender, passo a passo, a montar o circuito, associar as teclas às operações, formar um número de vários dígitos a partir das teclas pressionadas, tratar erros como a divisão por zero e levar o mesmo projeto para o ESP32 e o Raspberry Pi Pico.

A calculadora parece um projeto pequeno, mas reúne quase todos os fundamentos do software embarcado: leitura de entrada por varredura de matriz, armazenamento de estado em variáveis, estruturas de decisão, os limites dos números de ponto flutuante e um retorno claro ao usuário. É por isso que ela aparece tanto em projetos escolares, feiras de ciências e aulas de programação. Vou explicar cada linha importante do código. No final, você vai conseguir acrescentar seus próprios recursos, como vírgula decimal, tecla de memória ou bipe nas teclas.

Teclado matricial de membrana 4x4
Teclado de membrana 4x4: 16 teclas e 8 pinos (4 linhas + 4 colunas). É a unidade de entrada da calculadora.

Como funciona uma calculadora com Arduino?

Dividir o projeto em três partes facilita muito o trabalho. Na entrada, o teclado informa qual tecla foi pressionada como um único caractere (por exemplo '7', 'A', '#'). No processamento, o Arduino guarda em variáveis o número que está sendo digitado, o primeiro número (ou o resultado parcial) e a operação escolhida. Na saída, o LCD I2C mostra o primeiro número e a operação na linha de cima, e o número que você está digitando ou o resultado na linha de baixo. As calculadoras de bolso funcionam exatamente assim: cada tecla muda um pequeno estado dentro da máquina, e o display mostra como esse estado está naquele momento.

ComponenteQtd.Função
Arduino Uno (ou Nano)1Lê as teclas, faz as contas e controla o display
Teclado de membrana 4x41Dígitos 0–9, quatro operações e teclas de igual e limpar
LCD 16x2 + módulo I2C (PCF8574)1Mostra a operação e o resultado; só 2 fios de dados
Jumper macho-macho128 ligações do teclado + 4 do LCD
Cabo USB1Carregamento do código e alimentação

Como o teclado é lido? Varredura de linhas e colunas

Um teclado 4x4 tem 16 botões separados, mas só 8 pinos. Os botões ficam organizados em uma grade de 4 linhas e 4 colunas. Quando você pressiona uma tecla, ela liga uma linha a uma coluna. A biblioteca Keypad configura os pinos das linhas como entradas com pull-up interno, puxa as colunas para LOW uma de cada vez e verifica qual linha está em LOW. Por exemplo, se a linha 3 também estiver em LOW enquanto a coluna 2 está em LOW, a tecla pressionada é o '8', na linha 3, coluna 2. Essa varredura acontece centenas de vezes por segundo, então você não percebe nenhum atraso. A biblioteca também aplica cerca de 10 ms de debounce interno, para que um único toque não seja contado duas vezes. Os detalhes da varredura estão no artigo sobre o teclado matricial.

TeclaFunção na calculadora
0–9Entrada de dígitos; o número cresce dígito a dígito
AAdição (+)
BSubtração (-)
CMultiplicação (*)
DDivisão (/)
#Igual (=), mostra o resultado
*Limpar (C), zera tudo
Display LCD I2C 16x2
LCD 16x2 com um módulo I2C PCF8574 soldado atrás: a operação aparece na linha de cima, e o número e o resultado na de baixo.

Esquema de ligação: pinos do Uno, ESP32 e Pico

LigaçãoArduino UnoESP32Raspberry Pi Pico
Teclado R1D9GPIO 13GP6
Teclado R2D8GPIO 14GP7
Teclado R3D7GPIO 27GP8
Teclado R4D6GPIO 26GP9
Teclado C1D5GPIO 25GP10
Teclado C2D4GPIO 33GP11
Teclado C3D3GPIO 32GP12
Teclado C4D2GPIO 4GP13
LCD GNDGNDGNDGND
LCD VCC5VVIN (5 V)VBUS (5 V, do USB)
LCD SDAA4GPIO 21GP4
LCD SCLA5GPIO 22GP5
Na maioria dos teclados de membrana, os 8 pinos seguem a ordem R1, R2, R3, R4, C1, C2, C3, C4 da esquerda para a direita, mas alguns modelos são diferentes. Se você pressiona '1' e aparece '4', 'A' ou 'D' na tela, as linhas e colunas estão trocadas ou invertidas. Em vez de mexer nos fios, corrija os arrays rowPins e colPins no código. Não use os pinos 0 e 1 do Uno: eles são reservados para a comunicação serial via USB e impedem o carregamento do código.

O módulo LCD I2C tem só quatro fios: GND, VCC, SDA e SCL. No Uno, o SDA vai no A4 e o SCL no A5. A maioria dos módulos usa o endereço 0x27; os que têm o chip PCF8574A usam 0x3F. Se a luz de fundo acende, mas nenhum texto aparece, primeiro gire com uma chave de fenda pequena o potenciômetro azul de contraste na parte de trás do módulo. Se você não tiver certeza do endereço, rode o sketch scanner I2C do artigo Como usar um display LCD I2C. Se quiser entender como dois fios conseguem atender tantos dispositivos, O que é I2C é um bom ponto de partida.

Montagem passo a passo

  1. Abra o Gerenciador de Bibliotecas no Arduino IDE e instale as bibliotecas Keypad (Mark Stanley, Alexander Brevig) e LiquidCrystal I2C (Frank de Brabander). Se não souber como fazer isso, veja o artigo sobre como instalar bibliotecas.
  2. Ligue os 8 pinos do teclado aos pinos digitais do Uno, do D9 ao D2, na ordem mostrada na tabela.
  3. Ligue o GND e o VCC do módulo LCD ao GND e ao 5V do Uno, o SDA ao A4 e o SCL ao A5.
  4. Carregue o código abaixo. Ao ligar, você deve ver “Hesap Makinesi” (“Calculadora” em turco) na tela.
  5. Pressione 1, 2, A, 5 e #, nessa ordem. Se a tela mostrar 17 como resultado, o circuito e o código estão funcionando corretamente.
  6. Se nenhum texto aparecer, ajuste o contraste e tente o endereço 0x3F. Se as teclas estiverem trocadas, confira os arrays de pinos.

Código da calculadora para Arduino Uno

O código não forma o número digitado como texto (String). Ele vai direto para um inteiro do tipo long, o que é rápido e não pesa nos 2 KB de RAM do Uno. O primeiro número e os resultados ficam em um tipo que chamamos de Number (float no Uno), para que possam ter parte fracionária. Escrevemos uma função separada para cada tipo de tecla. Assim, o loop() fica como um distribuidor curto, que só encaminha a tecla pressionada para a função certa, e o código fica fácil de ler.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <LiquidCrystal_I2C.h>
3#include <Keypad.h>
4
5using Number = float;                 // ESP32'de double yapılabilir / can be double on ESP32
6const byte MAX_DIGITS = 7;            // float ~7 basamak / float ~7 digits
7const Number LIMIT = 99999999.0;      // taşma sınırı / overflow limit
8
9const byte ROWS = 4;
10const byte COLS = 4;
11char keys[ROWS][COLS] = {
12  {'1', '2', '3', 'A'},
13  {'4', '5', '6', 'B'},
14  {'7', '8', '9', 'C'},
15  {'*', '0', '#', 'D'}
16};
17byte rowPins[ROWS] = {9, 8, 7, 6};    // R1-R4
18byte colPins[COLS] = {5, 4, 3, 2};    // C1-C4
19
20Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
21LiquidCrystal_I2C lcd(0x27, 16, 2);   // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
22
23long entry = 0;                       // yazılan sayı / number being typed
24byte digits = 0;                      // girilen hane / digits typed
25Number first = 0;                     // ilk sayı ya da ara sonuç / first operand or running result
26bool hasFirst = false;
27char op = 0;                          // '+', '-', '*', '/' ya da 0 / or 0
28bool justCalculated = false;          // sonuç ekranda mı? / is a result shown?
29
30void printNumber(Number v) {
31  long n = (long)(v >= 0 ? v + 0.5 : v - 0.5);
32  if (fabs(v - n) < 0.0005) lcd.print(n);   // tam sayı / whole number
33  else lcd.print(v, 3);                     // 3 ondalık / 3 decimals
34}
35
36void showScreen() {
37  lcd.clear();
38  if (hasFirst) {                     // üst satır: ilk sayı ve işlem / top row: first operand and operator
39    printNumber(first);
40    if (op) {
41      lcd.print(' ');
42      lcd.print(op);
43    }
44  }
45  lcd.setCursor(0, 1);                // alt satır: yazılan sayı / bottom row: number being typed
46  if (digits > 0) lcd.print(entry);
47  else if (!hasFirst) lcd.print('0');
48}
49
50void clearState() {
51  entry = 0;
52  digits = 0;
53  first = 0;
54  hasFirst = false;
55  op = 0;
56  justCalculated = false;
57}
58
59void clearAll() {
60  clearState();
61  showScreen();
62}
63
64void showError(const char *msg) {
65  lcd.clear();
66  lcd.print("Hata / Error");
67  lcd.setCursor(0, 1);
68  lcd.print(msg);
69  delay(1500);
70  clearAll();
71}
72
73bool applyOp(Number b) {              // first = first (op) b
74  if (op == '/' && b == 0) {
75    showError("Sifira bolunmez");     // sıfıra bölme / division by zero
76    return false;
77  }
78  Number r;
79  switch (op) {
80    case '+': r = first + b; break;
81    case '-': r = first - b; break;
82    case '*': r = first * b; break;
83    case '/': r = first / b; break;
84    default:  r = b; break;
85  }
86  if (fabs(r) > LIMIT) {
87    showError("Tasma");               // taşma / overflow
88    return false;
89  }
90  first = r;
91  return true;
92}
93
94void handleDigit(char k) {
95  if (justCalculated) clearState();   // yeni hesap / new calculation
96  if (entry == 0) digits = 0;         // baştaki sıfırları sayma / ignore leading zeros
97  if (digits >= MAX_DIGITS) return;
98  entry = entry * 10 + (k - '0');     // sayı biriktirme / build the number
99  digits++;
100  showScreen();
101}
102
103void handleOperator(char newOp) {
104  if (digits > 0) {
105    if (!hasFirst) {
106      first = entry;
107      hasFirst = true;
108    } else if (!applyOp(entry)) {
109      return;                         // hata oldu / an error occurred
110    }
111    entry = 0;
112    digits = 0;
113  } else if (!hasFirst) {
114    return;                           // henüz sayı yok / no number yet
115  }
116  op = newOp;
117  justCalculated = false;
118  showScreen();
119}
120
121void handleEquals() {
122  if (!hasFirst || op == 0 || digits == 0) return;   // eksik işlem / incomplete operation
123  if (!applyOp(entry)) return;
124  entry = 0;
125  digits = 0;
126  op = 0;
127  justCalculated = true;
128  lcd.clear();
129  lcd.print("Sonuc:");
130  lcd.setCursor(0, 1);
131  printNumber(first);
132}
133
134void setup() {
135  lcd.init();
136  lcd.backlight();
137  lcd.print("Hesap Makinesi");
138  lcd.setCursor(0, 1);
139  lcd.print("BlueGrays");
140  delay(1500);
141  clearAll();
142}
143
144void loop() {
145  char k = keypad.getKey();
146  if (!k) return;                     // tuş yok / no key
147  if (k >= '0' && k <= '9') handleDigit(k);
148  else if (k == 'A') handleOperator('+');
149  else if (k == 'B') handleOperator('-');
150  else if (k == 'C') handleOperator('*');
151  else if (k == 'D') handleOperator('/');
152  else if (k == '#') handleEquals();
153  else if (k == '*') clearAll();
154}

Como o código funciona?

Função / variávelO que faz
entry, digits (número em digitação)O número que está sendo digitado e a quantidade de dígitos; no máximo 7 dígitos no Uno
first, hasFirst (primeiro número)O primeiro número, ou o resultado parcial nas operações encadeadas
op (operação)A operação escolhida: '+', '-', '*', '/' ou 0 (nenhuma)
handleDigit() (tecla de dígito)Acrescenta o dígito ao número: entry = entry × 10 + dígito
handleOperator() (tecla de operação)Passa o número para first, aplica a operação pendente, se houver, e guarda a nova operação
applyOp() (aplica a operação)Faz as quatro operações; acusa erro na divisão por zero e no estouro
handleEquals() (tecla de igual)Calcula o resultado e mostra na linha de baixo
clearAll() (limpar tudo)Tecla *: zera todas as variáveis e limpa a tela

O segredo para formar um número é uma única fórmula: entry = entry × 10 + dígito. Imagine que você pressiona 4, 7 e 2, em sequência. No primeiro toque, entry vira 0 × 10 + 4 = 4; no segundo, 4 × 10 + 7 = 47; no terceiro, 47 × 10 + 2 = 472. Para transformar o caractere pressionado em número, usamos a expressão k - '0': na tabela ASCII, o código de '0' é 48 e o de '7' é 55, e a diferença entre eles é exatamente 7. O contador de dígitos é zerado enquanto entry vale 0, para que zeros à esquerda não gastem o limite de dígitos. Assim, digitar 0, 0, 5 resulta no número 5 e conta como um só dígito. O motivo do limite de 7 dígitos é a precisão do float, que explicamos na próxima seção.

A parte mais esperta do código são as operações encadeadas. Se você digita 5 + 3 e pressiona B (subtração) em vez de #, o handleOperator() primeiro faz a soma pendente, grava o resultado parcial 8 em first e depois guarda a subtração. Assim, 5 + 3 - 2 é calculado da esquerda para a direita, como em uma calculadora de bolso, e dá 6. Lembre-se de que não existe precedência de operadores: 2 + 3 × 4 dá 20, e não 14, e a maioria das calculadoras simples se comporta do mesmo jeito. Se você pressiona uma tecla de operação depois de um resultado aparecer, o resultado vira o primeiro número e você continua a conta. Se pressiona uma tecla de dígito, começa um cálculo novo. A flag justCalculated, que controla esse comportamento, é na verdade uma pequena máquina de estados. Para se aprofundar, confira Máquinas de estados no Arduino.

Verificação de divisão por zero e estouro

Dividir um número por zero é indefinido na matemática, e o Arduino não impede isso por conta própria. Na divisão com float, um número positivo dividido por zero dá inf (infinito) e zero dividido por zero dá nan (não é um número), e aparece um valor sem sentido na tela. Por isso, o applyOp() verifica se o divisor é zero antes de dividir. Se for, mostra a mensagem “Sifira bolunmez” (“não divide por zero” em turco) por 1,5 segundo e reinicia a calculadora. A segunda proteção é contra estouro. No Uno, o float tem 32 bits e oferece cerca de 6–7 dígitos significativos de precisão. Inteiros acima de 16.777.216 já não podem ser armazenados com exatidão, e o último dígito pode ser arredondado. Além disso, a função print do Arduino mostra como “ovf” os valores float acima de cerca de 4,29 bilhões. O código acusa erro “Tasma” (estouro) se o valor absoluto do resultado passar de 99.999.999. Assim, o usuário nunca vê resultados que não cabem na tela de 16 caracteres ou que não são confiáveis.

A tabela de caracteres do LCD não tem letras acentuadas, por isso as mensagens enviadas para a tela usam apenas caracteres ASCII simples, como “Sonuc” e “Sifira bolunmez”. Se quiser letras especiais, você pode definir até 8 caracteres personalizados com createChar(). Se notar cintilação, atualize só a linha que mudou a cada tecla, em vez de chamar lcd.clear(). O comando clear() leva cerca de 2 ms e apaga a imagem por um instante.

Calculadora com o ESP32

O mesmo código roda no ESP32. Você só precisa mudar os arrays de pinos e, se quiser, o tipo do número. Para o LCD, são usados os pinos I2C padrão do ESP32, GPIO 21 (SDA) e GPIO 22 (SCL); a biblioteca LiquidCrystal I2C inicia o Wire com esses pinos sozinha. E há mais uma vantagem: no ESP32, o double tem 64 bits de verdade e oferece cerca de 15 dígitos significativos. Se você trocar Number para double, pode aumentar o limite para 9 dígitos e calcular multiplicações grandes corretamente até o último dígito. No Uno, double e float são o mesmo tipo de 32 bits, então essa mudança não faz diferença lá. Se é a primeira vez que você usa o ESP32, explicamos a configuração da placa em O que é o ESP32?.

C++ (Arduino IDE)
1// ESP32: Uno kodunda yalnız bu satırları değiştir / change only these lines in the Uno code
2using Number = double;                  // 64 bit, ~15 basamak / 64-bit, ~15 digits
3const byte MAX_DIGITS = 9;              // 9 haneli giriş / 9-digit input
4const Number LIMIT = 999999999.0;       // long sınırına sığar / fits in a long
5
6byte rowPins[ROWS] = {13, 14, 27, 26};  // R1-R4
7byte colPins[COLS] = {25, 33, 32, 4};   // C1-C4
8// LCD: SDA = GPIO 21, SCL = GPIO 22 (Wire varsayılanı / Wire default)
Os pinos do ESP32 trabalham com 3,3 V e, oficialmente, não toleram 5 V. Quando você alimenta o módulo LCD pelo VIN (5 V), os resistores de pull-up da placa do PCF8574 puxam as linhas SDA e SCL para 5 V. Em testes curtos isso costuma não dar problema, mas em um dispositivo permanente coloque um conversor de nível lógico no meio. Não use os GPIO 34–39 no teclado: esses pinos são somente de entrada e não têm resistores de pull-up internos. Também é mais seguro evitar pinos de strapping como GPIO 0, 2, 12 e 15, que afetam o comportamento da placa na inicialização.

Calculadora com Raspberry Pi Pico e MicroPython

No Pico, nós mesmos escrevemos a varredura, no lugar da biblioteca Keypad do Arduino. É um ótimo exercício para entender de verdade a varredura de matriz. As linhas são ligadas aos pinos GP6–GP9 como entradas com pull-up, as colunas aos GP10–GP13 como saídas, e cada coluna é colocada em LOW por vez. Como o MicroPython não tem um módulo de LCD pronto, você precisa copiar os arquivos de driver lcd_api.py e pico_i2c_lcd.py para o Pico com o Thonny. No Pico, o float também tem 32 bits, então o limite volta a ser de 7 dígitos. Por outro lado, em Python é muito fácil formar o número como texto e convertê-lo com float(). O aviso sobre 5 V que demos para o ESP32 vale também para o Pico. Se você está começando com o Pico, dê uma olhada em O que é o Raspberry Pi Pico? e Fundamentos de MicroPython.

MicroPython
1from machine import Pin, I2C
2import time
3from pico_i2c_lcd import I2cLcd          # lcd_api.py + pico_i2c_lcd.py Pico'da olmalı / must be on the Pico
4
5KEYS = [["1", "2", "3", "A"],
6        ["4", "5", "6", "B"],
7        ["7", "8", "9", "C"],
8        ["*", "0", "#", "D"]]
9OPS = {"A": "+", "B": "-", "C": "*", "D": "/"}
10
11rows = [Pin(p, Pin.IN, Pin.PULL_UP) for p in (6, 7, 8, 9)]     # R1-R4
12cols = [Pin(p, Pin.OUT, value=1) for p in (10, 11, 12, 13)]    # C1-C4
13
14i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=100000)
15lcd = I2cLcd(i2c, 0x27, 2, 16)           # adres, satır, sütun / address, rows, columns
16
17def get_key():
18    for c, col in enumerate(cols):
19        col.value(0)                     # bu sütunu LOW yap / drive this column LOW
20        for r, row in enumerate(rows):
21            if row.value() == 0:
22                time.sleep_ms(20)        # debounce
23                if row.value() == 0:
24                    while row.value() == 0:   # bırakılmasını bekle / wait for release
25                        time.sleep_ms(5)
26                    col.value(1)
27                    return KEYS[r][c]
28        col.value(1)
29    return None
30
31def fmt(x):
32    if abs(x - round(x)) < 0.0005:
33        return str(int(round(x)))        # tam sayı / whole number
34    return "{:.3f}".format(x)            # 3 ondalık / 3 decimals
35
36def show(top, bottom):
37    lcd.clear()
38    lcd.putstr(top[:16])
39    lcd.move_to(0, 1)
40    lcd.putstr(bottom[:16])
41
42def calc(a, o, b):
43    if o == "+":
44        r = a + b
45    elif o == "-":
46        r = a - b
47    elif o == "*":
48        r = a * b
49    else:
50        if b == 0:
51            raise ValueError("Sifira bolunmez")   # sıfıra bölme / division by zero
52        r = a / b
53    if abs(r) > 99999999:
54        raise ValueError("Tasma")                  # taşma / overflow
55    return r
56
57def screen():
58    top = ""
59    if first is not None:
60        top = fmt(first) + (" " + op if op else "")
61    show(top, entry or ("0" if first is None else ""))
62
63first, op, entry, done = None, None, "", False
64show("Hesap Makinesi", "Pico hazir")
65time.sleep(1.5)
66screen()
67
68while True:
69    k = get_key()
70    if k is None:
71        time.sleep_ms(10)
72        continue
73    try:
74        if k == "*":                     # temizle / clear
75            first, op, entry, done = None, None, "", False
76        elif k.isdigit():
77            if done:                     # yeni hesap / new calculation
78                first, op, done = None, None, False
79            if entry == "0":
80                entry = ""               # baştaki sıfırı at / drop leading zero
81            if len(entry) < 7:
82                entry += k
83        elif k in OPS:
84            if entry:
85                b = float(entry)
86                first = b if (first is None or op is None) else calc(first, op, b)
87                entry = ""
88            if first is not None:
89                op = OPS[k]
90                done = False
91        elif k == "#" and first is not None and op and entry:
92            first = calc(first, op, float(entry))
93            entry, op, done = "", None, True
94    except ValueError as e:
95        show("Hata / Error", str(e))
96        time.sleep(1.5)
97        first, op, entry, done = None, None, "", False
98    if done:
99        show("Sonuc:", fmt(first))
100    else:
101        screen()

Ideias para melhorar a calculadora

  • Vírgula decimal: transforme uma combinação de teclas não usada em vírgula decimal e acrescente cada dígito depois da vírgula ao número com multiplicadores decrescentes, como 0,1 e 0,01.
  • Teclas de memória (M+, MR): grave o resultado na EEPROM; o último resultado não se perde nem quando o Arduino é desligado.
  • Bipe nas teclas: adicione um buzzer para um bipe curto a cada toque. Para um buzzer no D10, basta a linha tone(10, 2000, 30).
  • Modo científico: acrescente raiz quadrada (sqrt), potência (pow) e porcentagem com uma segunda camada de teclas.
  • Display maior: use um display OLED no lugar do LCD 16x2 e mostre o histórico de cálculos linha por linha.
  • Registro de cálculos: envie cada resultado também para o Monitor Serial e mantenha um histórico de cálculos no computador.
  • Fechadura com senha: monte uma fechadura com teclado matricial usando o mesmo teclado e o mesmo LCD; a lógica de formar números funciona do mesmo jeito.

Erros comuns e como resolver

ProblemaCausa provávelSolução
LCD aceso, mas sem textoContraste não ajustado ou endereço I2C erradoGire o potenciômetro atrás do módulo; tente 0x3F em vez de 0x27
Blocos pretos na linha de cimaLCD não inicializado ou linha I2C interrompidaConfira se lcd.init() é chamado e se SDA/SCL estão no A4/A5
As teclas dão o caractere erradoPinos de linha e coluna trocadosTroque entre si ou inverta os arrays rowPins e colPins
Uma tecla é contada duas vezesRepique dos contatosAumente o tempo de debounce com keypad.setDebounceTime(50)
Nenhuma tecla funcionaPinos 0/1 usados no Uno ou GPIO 34–39 no ESP32Use os pinos da tabela
Último dígito errado em uma multiplicação grandeNo Uno, o float guarda só 6–7 dígitosMantenha o limite de dígitos ou use double no ESP32
O resultado da divisão sai sem casas decimaisA operação foi feita com dois inteiros (int/long)Converta pelo menos um dos lados para float; neste código, first já é do tipo Number
Para caçar bugs, teste o código por partes. Primeiro, apenas mostre no Monitor Serial a tecla pressionada com keypad.getKey(). Depois, apenas envie um texto fixo para o LCD. Se as duas partes funcionam separadamente, o problema está na lógica do cálculo. Acompanhando os valores de entry, first e op com Serial.print a cada tecla, você encontra o bug com facilidade.

Esta calculadora com teclado e LCD I2C reúne em um único projeto a leitura de entradas, o controle de estado, o tratamento de erros e os limites dos números na memória. Você vai usar a mesma lógica muitas vezes em fechaduras com senha, contadores e sistemas de menu. No app BlueGrays você pode explorar projetos como uma calculadora I2C, um sistema de senha com teclado 4x4 e LCD e um cofre eletrônico inteligente, com esquema do circuito passo a passo e código pronto, e criar a sua própria versão.

Perguntas frequentes

Como fazer uma calculadora com Arduino?

Bastam um Arduino Uno, um teclado 4x4 e um LCD I2C 16x2. Os 8 pinos do teclado vão nos pinos digitais, e o SDA e o SCL do LCD vão no A4 e no A5. Com as bibliotecas Keypad e LiquidCrystal I2C, você lê as teclas, forma os números com a fórmula entry = entry × 10 + dígito e aplica a operação escolhida com a tecla #.

Quantos pinos um teclado 4x4 usa?

Um teclado 4x4 usa 8 pinos digitais no total, para 4 linhas e 4 colunas. No Arduino Uno, normalmente se escolhem os pinos D2–D9, porque o D0 e o D1 são reservados para a comunicação serial. Se faltarem pinos, um módulo de teclado I2C baseado no PCF8574 reduz a ligação a dois fios de dados.

Como mostrar resultados com casas decimais em uma calculadora com Arduino?

Guarde o resultado em uma variável float e informe o número de casas decimais como segundo parâmetro, como em lcd.print(result, 3). Quando você divide dois inteiros (int ou long), a parte fracionária se perde: 7 / 2 dá 3. Se converter pelo menos um dos números para float antes de dividir, você obtém 3,5.

O que acontece quando se divide por zero no Arduino?

A divisão por zero com inteiros é indefinida e pode gerar valores inconsistentes; na divisão com float, o resultado é inf ou nan. O Arduino continua funcionando, mas você vê um valor sem sentido na tela. Por isso, antes de dividir, verifique com um if se o divisor é zero e mostre uma mensagem de erro ao usuário.

Por que meu LCD I2C não mostra texto?

As duas causas mais comuns são contraste mal ajustado e endereço I2C errado. Gire o potenciômetro atrás do módulo para ajustar o contraste e depois tente os endereços 0x27 e 0x3F. Se o problema continuar, use um sketch scanner I2C para verificar se o módulo aparece no barramento.

A calculadora com Arduino respeita a precedência de operadores?

O código deste guia, como a maioria das calculadoras de bolso, faz as operações da esquerda para a direita: 2 + 3 × 4 dá 20. Para ter precedência de operadores, você precisaria escrever um analisador que primeiro guarda a expressão em um array e calcula a multiplicação e a divisão antes da adição e da subtração. É um bom exercício de programação para o próximo nível.

Ver todos os projetos
Calculadora I2C com Arduino
AR-94Intermediário
Premium

Calculadora I2C com Arduino

Projeto de calculadora com Arduino que faz operações de adição, subtração, multiplicação e divisão usando um teclado de membrana 4x4 e um display LCD I2C 16x2. Com I2C, a conexão do display usa apenas 2 fios, reduzindo a quantidade de cabos e deixando mais pinos livres. Também permite inserir números decimais e negativos.

5.0(31)
43
Uso do teclado matricial 4x4
AR-63Iniciante
Premium

Uso do teclado matricial 4x4

No teclado matricial 4x4, parecido com as teclas de um telefone, o Arduino identifica na hora qual tecla você pressionou e a mostra na tela do computador.

4.5(27)
35
Fechadura com senha, teclado 4x4 e LCD
AR-64Avançado
Premium

Fechadura com senha, teclado 4x4 e LCD

Uma pequena fechadura eletrônica que impede a entrada de quem não sabe a senha. Você pressiona a cerquilha e digita a senha no teclado.

4.8(59)
75
Uso do teclado matricial 3x4
AR-61Iniciante

Uso do teclado matricial 3x4

O Arduino identifica na hora qual tecla você pressiona em um teclado de 12 teclas parecido com o de um telefone e a mostra na tela do computador.

4.5(24)
32
Controle de LEDs com teclado matricial 3x4
AR-62Intermediário
Premium

Controle de LEDs com teclado matricial 3x4

Com um teclado parecido com o de um telefone, você controla três luzes separadas. As teclas 1, 2 e 3 acendem os LEDs verde, azul e amarelo; as teclas 4, 5 e 6 apagam essas mesmas luzes.

4.6(29)
38
Uso do display LCD com I2C
AR-32Iniciante
Premium

Uso do display LCD com I2C

Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

4.8(53)
70
Cofre eletrônico inteligente
AR-92Avançado
Premium

Cofre eletrônico inteligente

Um pequeno cofre para guardar seus objetos de valor, que abre com uma senha. Você digita sua senha de quatro dígitos no teclado; se estiver correta, o servo motor abre a trava, a luz verde acende e o…

4.7(42)
63
Display LCD I2C com ESP32 (16x2)
ES-17Intermediário
Premium

Display LCD I2C com ESP32 (16x2)

Neste projeto, exibimos texto conectando um display LCD de 16x2 caracteres ao ESP32 pelo protocolo I2C. Com o I2C, controlamos o display usando apenas dois pinos de dados (SDA e SCL), dispensando o uso de seis ou mais pinos da conexão paralela tradicional. O código mostra uma mensagem fixa na primeira linha e um contador que aumenta a cada segundo na segunda linha. Na inicialização, também executamos um scanner I2C para mostrar o endereço do display no Monitor Serial (geralmente 0x27 ou 0x3F).

4.9(23)
40