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.

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.
| Componente | Qtd. | Função |
|---|---|---|
| Arduino Uno (ou Nano) | 1 | Lê as teclas, faz as contas e controla o display |
| Teclado de membrana 4x4 | 1 | Dígitos 0–9, quatro operações e teclas de igual e limpar |
| LCD 16x2 + módulo I2C (PCF8574) | 1 | Mostra a operação e o resultado; só 2 fios de dados |
| Jumper macho-macho | 12 | 8 ligações do teclado + 4 do LCD |
| Cabo USB | 1 | Carregamento 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.
| Tecla | Função na calculadora |
|---|---|
| 0–9 | Entrada de dígitos; o número cresce dígito a dígito |
| A | Adição (+) |
| B | Subtração (-) |
| C | Multiplicação (*) |
| D | Divisão (/) |
| # | Igual (=), mostra o resultado |
| * | Limpar (C), zera tudo |

Esquema de ligação: pinos do Uno, ESP32 e Pico
| Ligação | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Teclado R1 | D9 | GPIO 13 | GP6 |
| Teclado R2 | D8 | GPIO 14 | GP7 |
| Teclado R3 | D7 | GPIO 27 | GP8 |
| Teclado R4 | D6 | GPIO 26 | GP9 |
| Teclado C1 | D5 | GPIO 25 | GP10 |
| Teclado C2 | D4 | GPIO 33 | GP11 |
| Teclado C3 | D3 | GPIO 32 | GP12 |
| Teclado C4 | D2 | GPIO 4 | GP13 |
| LCD GND | GND | GND | GND |
| LCD VCC | 5V | VIN (5 V) | VBUS (5 V, do USB) |
| LCD SDA | A4 | GPIO 21 | GP4 |
| LCD SCL | A5 | GPIO 22 | GP5 |
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
- 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.
- Ligue os 8 pinos do teclado aos pinos digitais do Uno, do D9 ao D2, na ordem mostrada na tabela.
- 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.
- Carregue o código abaixo. Ao ligar, você deve ver “Hesap Makinesi” (“Calculadora” em turco) na tela.
- 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.
- 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.
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ável | O 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.
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?.
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)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.
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
| Problema | Causa provável | Solução |
|---|---|---|
| LCD aceso, mas sem texto | Contraste não ajustado ou endereço I2C errado | Gire o potenciômetro atrás do módulo; tente 0x3F em vez de 0x27 |
| Blocos pretos na linha de cima | LCD não inicializado ou linha I2C interrompida | Confira se lcd.init() é chamado e se SDA/SCL estão no A4/A5 |
| As teclas dão o caractere errado | Pinos de linha e coluna trocados | Troque entre si ou inverta os arrays rowPins e colPins |
| Uma tecla é contada duas vezes | Repique dos contatos | Aumente o tempo de debounce com keypad.setDebounceTime(50) |
| Nenhuma tecla funciona | Pinos 0/1 usados no Uno ou GPIO 34–39 no ESP32 | Use os pinos da tabela |
| Último dígito errado em uma multiplicação grande | No Uno, o float guarda só 6–7 dígitos | Mantenha o limite de dígitos ou use double no ESP32 |
| O resultado da divisão sai sem casas decimais | A 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 |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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.

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.

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.

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…

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…

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).
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

