Calculadora con Arduino: teclado 4x4 y LCD I2C paso a paso
Crea una calculadora con Arduino: conexión del teclado 4x4 y LCD I2C, cuatro operaciones, control de división entre cero y código para Uno, ESP32 y Pico.
Una calculadora con Arduino es un proyecto divertido que enseña programación de verdad, y solo necesitas un teclado matricial 4x4, una pantalla LCD I2C de 16x2 y unos cuantos cables. Escribes números con las teclas, eliges suma, resta, multiplicación o división con A, B, C y D, ves el resultado con # y borras todo con *. En esta guía aprenderás a montar el circuito, asignar teclas a operaciones, formar números de varias cifras, controlar errores como la división entre cero y llevar el proyecto a ESP32 y Raspberry Pi Pico.
Aunque parezca un proyecto pequeño, contiene casi todos los temas básicos del software embebido: lectura de entradas por matriz, estado en variables, estructuras de decisión, límites de los números de coma flotante y retroalimentación clara al usuario. Por eso se usa mucho en proyectos escolares, ferias de ciencias y clases de programación. Te explicaré cada línea importante del código; al terminar podrás añadir tus propias mejoras, como el punto decimal, una tecla de memoria o un sonido al pulsar.

¿Cómo funciona una calculadora con Arduino?
Dividir el proyecto en tres partes lo hace mucho más fácil. En la entrada, el teclado te devuelve la tecla pulsada como un único carácter ('7', 'A', '#'...). En el proceso, Arduino guarda en variables el número que estás escribiendo, el primer número (o resultado parcial) y la operación elegida. En la salida, la LCD I2C muestra arriba el primer número con la operación y abajo el número que escribes o el resultado. Las calculadoras de bolsillo funcionan exactamente así: cada tecla cambia un pequeño estado interno y la pantalla refleja ese estado.
| Componente | Cantidad | Función |
|---|---|---|
| Arduino Uno (o Nano) | 1 | Lee las teclas, calcula y controla la pantalla |
| Teclado de membrana 4x4 | 1 | Dígitos 0–9, cuatro operaciones, igual y borrar |
| LCD 16x2 + módulo I2C (PCF8574) | 1 | Muestra la operación y el resultado; solo 2 cables de datos |
| Cable jumper macho-macho | 12 | 8 del teclado + 4 de la LCD |
| Cable USB | 1 | Carga del código y alimentación |
¿Cómo se lee un teclado? Escaneo de filas y columnas
Un teclado 4x4 tiene 16 pulsadores pero solo 8 pines. Los botones forman una cuadrícula de 4 filas y 4 columnas; al pulsar una tecla, une una línea de fila con una de columna. La librería Keypad configura las filas como entradas con pull-up interno, pone las columnas en LOW una a una y mira qué fila lee LOW. Por ejemplo, si con la columna 2 en LOW la fila 3 también lee LOW, la tecla pulsada es la '8'. Este escaneo se repite cientos de veces por segundo, así que no notas ningún retraso. La librería también aplica un antirrebote interno de unos 10 ms, de modo que una pulsación no se cuenta dos veces. Tienes más detalles del escaneo en Cómo usar un teclado matricial (keypad).
| Tecla | Función en la calculadora |
|---|---|
| 0–9 | Entrada de dígitos; el número crece cifra a cifra |
| A | Suma (+) |
| B | Resta (-) |
| C | Multiplicación (*) |
| D | División (/) |
| # | Igual (=), muestra el resultado |
| * | Borrar (C), lo reinicia todo |

Esquema de conexión: pines de Uno, ESP32 y Pico
| Conexión | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Keypad R1 | D9 | GPIO 13 | GP6 |
| Keypad R2 | D8 | GPIO 14 | GP7 |
| Keypad R3 | D7 | GPIO 27 | GP8 |
| Keypad R4 | D6 | GPIO 26 | GP9 |
| Keypad C1 | D5 | GPIO 25 | GP10 |
| Keypad C2 | D4 | GPIO 33 | GP11 |
| Keypad C3 | D3 | GPIO 32 | GP12 |
| Keypad C4 | D2 | GPIO 4 | GP13 |
| LCD GND | GND | GND | GND |
| LCD VCC | 5V | VIN (5 V) | VBUS (5 V, desde USB) |
| LCD SDA | A4 | GPIO 21 | GP4 |
| LCD SCL | A5 | GPIO 22 | GP5 |
El módulo LCD I2C tiene solo cuatro cables: GND, VCC, SDA y SCL. En el Uno, SDA va a A4 y SCL a A5. La mayoría de los módulos usan la dirección 0x27; los que llevan el chip PCF8574A usan 0x3F. Si la luz de fondo se enciende pero no se ve texto, gira primero el potenciómetro azul de contraste de la parte trasera con un destornillador pequeño. Si no estás seguro de la dirección, ejecuta el escáner I2C de Cómo usar una pantalla LCD I2C; y si te preguntas cómo dos cables mueven tantos dispositivos, qué es I2C es un buen comienzo.
Montaje paso a paso
- Abre el Gestor de bibliotecas del IDE de Arduino e instala Keypad (Mark Stanley, Alexander Brevig) y LiquidCrystal I2C (Frank de Brabander). Si no sabes cómo, mira cómo añadir bibliotecas.
- Conecta los 8 pines del teclado a los pines digitales del Uno de D9 a D2, en el orden de la tabla.
- Conecta GND y VCC del módulo LCD a GND y 5V del Uno, SDA a A4 y SCL a A5.
- Carga el código de abajo; al arrancar deberías ver el texto "Hesap Makinesi" en la pantalla.
- Pulsa 1, 2, A, 5 y #; si en pantalla aparece 17 como resultado, el circuito y el código funcionan bien.
- Si no se ve texto, ajusta el contraste y prueba la dirección 0x3F; si las teclas salen mezcladas, revisa los arrays de pines.
Código de la calculadora para Arduino Uno
El código no acumula el número escrito como texto (String), sino directamente como un entero long; es rápido y no sobrecarga los 2 KB de RAM del Uno. El primer número y los resultados, en cambio, usan un tipo llamado Number (float en el Uno) para poder tener parte decimal. Hemos escrito una función para cada tipo de tecla, así loop() queda como un pequeño despachador que envía cada tecla a su función y el código se lee con facilidad.
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}¿Cómo funciona el código?
| Función / variable | ¿Qué hace? |
|---|---|
| entry, digits | Número que se está escribiendo y su cantidad de cifras; máximo 7 en el Uno |
| first, hasFirst | Primer número o resultado parcial en operaciones encadenadas |
| op | Operación elegida: '+', '-', '*', '/' o 0 (ninguna) |
| handleDigit() | Añade el dígito al final del número: entry = entry × 10 + dígito |
| handleOperator() | Pasa el número a first, aplica la operación pendiente si hace falta y guarda la nueva |
| applyOp() | Realiza las cuatro operaciones; da error en división entre cero y desbordamiento |
| handleEquals() | Calcula el resultado y lo muestra en la fila inferior |
| clearAll() | Tecla *: pone todas las variables a cero y limpia la pantalla |
El secreto para acumular un número es una sola fórmula: entry = entry × 10 + dígito. Imagina que pulsas 4, 7 y 2. A la primera pulsación entry vale 0 × 10 + 4 = 4, a la segunda 4 × 10 + 7 = 47 y a la tercera 47 × 10 + 2 = 472. Para convertir el carácter pulsado en número usamos k - '0': en la tabla ASCII el código de '0' es 48 y el de '7' es 55, y su diferencia es exactamente 7. Para que los ceros iniciales no gasten el límite de cifras, cuando entry es 0 el contador se reinicia; así, si escribes 0, 0, 5 el número es 5 y cuenta como una sola cifra. El límite de 7 cifras se debe a la precisión del float, que explicamos en la siguiente sección.
Lo más ingenioso del código son las operaciones encadenadas. Si escribes 5 + 3 y pulsas directamente B (resta) en lugar de #, handleOperator() primero hace la suma pendiente, guarda el resultado parcial 8 en first y después registra la resta; es decir, 5 + 3 - 2 se calcula de izquierda a derecha, como en una calculadora de bolsillo, y da 6. Recuerda que no hay prioridad de operadores: 2 + 3 × 4 da 20, no 14, y así se comportan casi todas las calculadoras simples. Si tras mostrar un resultado pulsas una operación, el resultado pasa a ser el primer número y sigues calculando; si pulsas un dígito, empieza un cálculo nuevo. La bandera justCalculated, que controla este comportamiento, es en realidad una pequeña máquina de estados; para profundizar, consulta Máquina de estados en Arduino.
Control de división entre cero y desbordamiento
Dividir un número entre cero no está definido en matemáticas y Arduino no lo impide por sí solo: en una división float, un número positivo entre cero da inf (infinito) y cero entre cero da nan (no es un número), y en pantalla aparece un valor sin sentido. Por eso applyOp() comprueba antes de dividir si el divisor es cero; si lo es, muestra el mensaje "Sifira bolunmez" durante 1,5 segundos y reinicia la calculadora. La segunda protección es contra el desbordamiento. En el Uno, el float es de 32 bits y ofrece unas 6–7 cifras significativas; los enteros por encima de 16.777.216 ya no se pueden guardar con exactitud y la última cifra puede redondearse. Además, la función print de Arduino escribe "ovf" para valores float superiores a unos 4.290 millones. El código da el error "Tasma" si el valor absoluto del resultado supera 99.999.999, de modo que nunca muestra al usuario resultados que no caben en las 16 columnas o que no son fiables.
Calculadora con ESP32
El mismo código funciona en el ESP32; lo único que debes cambiar son los arrays de pines y, opcionalmente, el tipo numérico. Para la LCD se usan los pines I2C por defecto del ESP32, GPIO 21 (SDA) y GPIO 22 (SCL); la librería LiquidCrystal I2C inicia Wire con ellos. Hay otra ventaja: en el ESP32 double es realmente de 64 bits y ofrece unas 15 cifras significativas. Si cambias Number a double, puedes subir el límite a 9 cifras y calcular multiplicaciones grandes con exactitud hasta la última cifra. En el Uno, double y float son el mismo tipo de 32 bits, así que allí el cambio no aporta nada. Si es tu primera vez con el ESP32, la configuración de la placa está en ¿Qué es el 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 con Raspberry Pi Pico y MicroPython
En la Pico escribimos nosotros el escaneo en lugar de usar la librería Keypad de Arduino; es un ejercicio excelente para entender de verdad el escaneo matricial. Las filas se conectan a GP6–GP9 como entradas con pull-up, las columnas a GP10–GP13 como salidas, y cada columna se pone en LOW por turnos. Como MicroPython no trae un módulo de LCD, debes copiar a la Pico con Thonny los archivos de controlador lcd_api.py y pico_i2c_lcd.py. En la Pico el float también es de 32 bits, así que el límite sigue siendo de 7 cifras; eso sí, en Python es muy fácil acumular el número como texto y convertirlo con float(). El aviso de 5 V que dimos para el ESP32 también vale para la Pico. Si acabas de conocer la Pico, echa un vistazo a ¿Qué es la Raspberry Pi Pico? y a los 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()Ideas para mejorar la calculadora
- Punto decimal: usa una combinación de teclas libre como punto decimal; añade cada cifra tras el punto al número con multiplicadores decrecientes como 0,1 y 0,01.
- Teclas de memoria (M+, MR): guarda el resultado en la EEPROM; el último resultado no se pierde aunque se apague el Arduino.
- Sonido al pulsar: añade un buzzer para un pitido corto en cada pulsación; para un buzzer en D10 basta la línea tone(10, 2000, 30).
- Modo científico: añade raíz cuadrada (sqrt), potencias (pow) y porcentajes con una segunda capa de teclas.
- Pantalla más grande: usa una pantalla OLED en lugar de la LCD 16x2 y muestra el historial de operaciones línea a línea.
- Registro de cálculos: imprime también cada resultado en el Monitor Serie para guardar un historial en el ordenador.
- Cerradura con contraseña: con el mismo teclado y LCD, crea una cerradura de puerta con contraseña; la lógica de acumular números sirve igual allí.
Errores comunes y cómo solucionarlos
| Problema | Causa probable | Solución |
|---|---|---|
| La LCD se enciende pero no hay texto | Contraste mal ajustado o dirección I2C incorrecta | Gira el potenciómetro trasero; prueba 0x3F en lugar de 0x27 |
| Cuadrados negros en la fila superior | LCD sin inicializar o línea I2C cortada | Comprueba que se llama a lcd.init() y que SDA/SCL están en A4/A5 |
| Las teclas dan caracteres incorrectos | Pines de filas y columnas mezclados | Intercambia o invierte los arrays rowPins y colPins |
| Una tecla se cuenta dos veces | Rebote de los contactos | Aumenta el filtro con keypad.setDebounceTime(50) |
| Ninguna tecla funciona | Se usaron los pines 0/1 en el Uno o GPIO 34–39 en el ESP32 | Usa los pines de la tabla |
| La última cifra falla en una multiplicación grande | En el Uno el float solo guarda 6–7 cifras | Mantén el límite de cifras o usa double en el ESP32 |
| La división no da decimales | La operación se hizo con dos enteros (int/long) | Convierte al menos un lado a float; en este código first ya es de tipo Number |
Esta calculadora con teclado e I2C LCD reúne en un solo proyecto la lectura de entradas, el manejo de estados, la gestión de errores y los límites de los números en memoria. Usarás esta misma lógica una y otra vez en cerraduras con contraseña, contadores y sistemas de menús. En la app de BlueGrays puedes explorar proyectos como la calculadora I2C, la aplicación de contraseña con teclado 4x4 y LCD y la caja fuerte electrónica inteligente, con esquemas paso a paso y código listo para crear tu propia versión.
Preguntas frecuentes
¿Cómo hacer una calculadora con Arduino?
Basta un Arduino Uno, un teclado 4x4 y una LCD I2C de 16x2. Los 8 pines del teclado van a pines digitales y SDA y SCL de la LCD a A4 y A5. Con las librerías Keypad y LiquidCrystal I2C lees las teclas, acumulas los números con la fórmula entry = entry × 10 + dígito y aplicas la operación elegida al pulsar #.
¿Cuántos pines usa un teclado 4x4?
Un teclado 4x4 usa 8 pines digitales en total, 4 para filas y 4 para columnas. En el Arduino Uno se suelen elegir los pines D2–D9, porque D0 y D1 están reservados para la comunicación serie. Si te faltan pines, un módulo de teclado I2C basado en PCF8574 reduce la conexión a dos cables de datos.
¿Cómo mostrar resultados decimales en una calculadora con Arduino?
Guarda el resultado en una variable float y usa un segundo parámetro, como lcd.print(resultado, 3), para indicar los decimales. Si divides dos enteros (int o long) se pierde la parte decimal: 7 / 2 da 3. Si conviertes al menos un número a float antes de dividir, obtienes 3,5.
¿Qué pasa en Arduino al dividir entre cero?
Con enteros, la división entre cero es indefinida y puede dar valores incoherentes; con float, el resultado es inf o nan. Arduino sigue funcionando, pero ves un valor sin sentido en pantalla. Por eso conviene comprobar con un if si el divisor es cero antes de dividir y mostrar un mensaje de error.
¿Por qué no se ve texto en la pantalla LCD I2C?
Las dos causas más habituales son un contraste mal ajustado y una dirección I2C incorrecta. Gira el potenciómetro trasero del módulo para ajustar el contraste y prueba después las direcciones 0x27 y 0x3F. Si sigue sin funcionar, usa un escáner I2C para comprobar si el módulo aparece en el bus.
¿Respeta la calculadora con Arduino la prioridad de operaciones?
El código de esta guía, como la mayoría de calculadoras de bolsillo, opera de izquierda a derecha: 2 + 3 × 4 da 20. Para respetar la prioridad tendrías que escribir un analizador que guarde la expresión en un array y calcule multiplicaciones y divisiones antes que sumas y restas. Es un buen ejercicio para el siguiente nivel.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Calculadora Arduino I2C
Se trata de un proyecto de calculadora basado en Arduino que realiza operaciones de suma, resta, multiplicación y división utilizando un teclado de membrana 4x4 y una pantalla LCD 16x2 I2C. Gracias a I2C, la conexión de la pantalla se realiza con sólo 2 cables, reduciendo así el desorden de cables y manteniendo más pines abiertos para su uso. También dispone de entrada de números decimales y soporte de números negativos.

Funcionamiento del teclado 4x4
En el teclado de 4x4, muy parecido a las teclas de un teléfono, el Arduino sabe al instante qué tecla has pulsado y la escribe en la pantalla del ordenador.

Cerradura con contraseña, teclado 4x4 y LCD
Una pequeña cerradura electrónica que no deja pasar a quien no sepa la clave. Pulsas la tecla de almohadilla y escribes la clave en el teclado; si es correcta, la pantalla indica acceso permitido, se…

Funcionamiento del teclado 3x4
El Arduino sabe al instante qué tecla pulsas en un teclado de 12 teclas parecido al de un teléfono, y la escribe en la pantalla de tu ordenador.

Control de LED con teclado 3x4
Con un teclado como el de un teléfono manejas tres luces por separado. Las teclas 1, 2 y 3 encienden los LED verde, azul y amarillo, las teclas 4, 5 y 6 apagan esas mismas luces, la tecla de…

Uso de la pantalla LCD con I2C
Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

Caja fuerte electrónica inteligente
Una pequeña caja fuerte para tus cosas de valor que se abre con un código. Escribes tu código de cuatro cifras en el teclado; si es correcto, el servomotor abre el cierre, se enciende la luz verde y…

Pantalla LCD I2C para ESP32 (16x2)
En este proyecto conectamos una pantalla LCD de caracteres 16x2 al ESP32 por I2C para mostrar texto. Con I2C bastan 2 pines de datos (SDA y SCL), en lugar de los 6+ pines de una conexión paralela clásica. El código escribe un mensaje fijo en la primera línea y un contador que sube cada segundo en la segunda. Al arrancar, un escáner I2C muestra la dirección de la pantalla en el Serial Monitor (normalmente 0x27 o 0x3F).
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

