Guías · 10 min de lectura

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.

Teclado de membrana 4x4
Teclado de membrana 4x4: 16 teclas y 8 pines (4 filas + 4 columnas). Es la entrada de la calculadora.

¿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.

ComponenteCantidadFunción
Arduino Uno (o Nano)1Lee las teclas, calcula y controla la pantalla
Teclado de membrana 4x41Dígitos 0–9, cuatro operaciones, igual y borrar
LCD 16x2 + módulo I2C (PCF8574)1Muestra la operación y el resultado; solo 2 cables de datos
Cable jumper macho-macho128 del teclado + 4 de la LCD
Cable USB1Carga 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).

TeclaFunción en la calculadora
0–9Entrada de dígitos; el número crece cifra a cifra
ASuma (+)
BResta (-)
CMultiplicación (*)
DDivisión (/)
#Igual (=), muestra el resultado
*Borrar (C), lo reinicia todo
Pantalla LCD I2C 2x16
LCD 16x2 con módulo I2C PCF8574 soldado detrás: la operación aparece en la fila superior y el número o resultado en la inferior.

Esquema de conexión: pines de Uno, ESP32 y Pico

ConexiónArduino UnoESP32Raspberry Pi Pico
Keypad R1D9GPIO 13GP6
Keypad R2D8GPIO 14GP7
Keypad R3D7GPIO 27GP8
Keypad R4D6GPIO 26GP9
Keypad C1D5GPIO 25GP10
Keypad C2D4GPIO 33GP11
Keypad C3D3GPIO 32GP12
Keypad C4D2GPIO 4GP13
LCD GNDGNDGNDGND
LCD VCC5VVIN (5 V)VBUS (5 V, desde USB)
LCD SDAA4GPIO 21GP4
LCD SCLA5GPIO 22GP5
En la mayoría de los teclados de membrana, los 8 pines van de izquierda a derecha como R1, R2, R3, R4, C1, C2, C3, C4, pero algunos modelos usan otro orden. Si al pulsar '1' ves '4', 'A' o 'D', las filas y columnas están intercambiadas o invertidas; en lugar de desmontar los cables, corrige los arrays rowPins y colPins del código. En el Uno no uses los pines 0 y 1: están reservados para la comunicación serie USB e impiden cargar el código.

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

  1. 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.
  2. Conecta los 8 pines del teclado a los pines digitales del Uno de D9 a D2, en el orden de la tabla.
  3. Conecta GND y VCC del módulo LCD a GND y 5V del Uno, SDA a A4 y SCL a A5.
  4. Carga el código de abajo; al arrancar deberías ver el texto "Hesap Makinesi" en la pantalla.
  5. Pulsa 1, 2, A, 5 y #; si en pantalla aparece 17 como resultado, el circuito y el código funcionan bien.
  6. 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.

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}

¿Cómo funciona el código?

Función / variable¿Qué hace?
entry, digitsNúmero que se está escribiendo y su cantidad de cifras; máximo 7 en el Uno
first, hasFirstPrimer número o resultado parcial en operaciones encadenadas
opOperació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.

La tabla de caracteres de la LCD no incluye letras como ş, ı o ğ, por eso los mensajes de pantalla están escritos con caracteres ASCII, como "Sonuc" y "Sifira bolunmez". Si quieres letras especiales, puedes definir hasta 8 caracteres propios con createChar(). Si notas parpadeo, en lugar de lcd.clear() en cada tecla actualiza solo la fila que cambia; clear() tarda unos 2 ms y borra la imagen un instante.

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?.

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)
Los pines del ESP32 trabajan a 3,3 V y oficialmente no toleran 5 V. Si alimentas el módulo LCD desde VIN (5 V), las resistencias pull-up de la placa PCF8574 suben SDA y SCL a 5 V. En pruebas cortas suele no haber problema, pero en un dispositivo permanente añade un convertidor de nivel lógico. Para el teclado no uses GPIO 34–39: son solo de entrada y no tienen pull-up interno. Lo más seguro es evitar también los pines de arranque (strapping) como GPIO 0, 2, 12 y 15, que afectan al comportamiento de la placa al iniciar.

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.

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

ProblemaCausa probableSolución
La LCD se enciende pero no hay textoContraste mal ajustado o dirección I2C incorrectaGira el potenciómetro trasero; prueba 0x3F en lugar de 0x27
Cuadrados negros en la fila superiorLCD sin inicializar o línea I2C cortadaComprueba que se llama a lcd.init() y que SDA/SCL están en A4/A5
Las teclas dan caracteres incorrectosPines de filas y columnas mezcladosIntercambia o invierte los arrays rowPins y colPins
Una tecla se cuenta dos vecesRebote de los contactosAumenta el filtro con keypad.setDebounceTime(50)
Ninguna tecla funcionaSe usaron los pines 0/1 en el Uno o GPIO 34–39 en el ESP32Usa los pines de la tabla
La última cifra falla en una multiplicación grandeEn el Uno el float solo guarda 6–7 cifrasMantén el límite de cifras o usa double en el ESP32
La división no da decimalesLa 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
Prueba el código por partes cuando busques un fallo: primero imprime en el Monitor Serie solo la tecla de keypad.getKey(), luego envía solo un texto fijo a la LCD. Si ambas partes funcionan por separado, el problema está en la lógica del cálculo; con Serial.print puedes vigilar entry, first y op en cada tecla y encontrar el error fácilmente.

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.

Ver todos los proyectos
Calculadora Arduino I2C
AR-94Intermedio
Premium

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.

5.0(31)
43
Funcionamiento del teclado 4x4
AR-63Principiante
Premium

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.

4.5(27)
35
Cerradura con contraseña, teclado 4x4 y LCD
AR-64Avanzado
Premium

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…

4.8(59)
75
Funcionamiento del teclado 3x4
AR-61Principiante

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.

4.5(24)
32
Control de LED con teclado 3x4
AR-62Intermedio
Premium

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…

4.6(29)
38
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

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…

4.8(53)
70
Caja fuerte electrónica inteligente
AR-92Avanzado
Premium

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…

4.7(42)
63
Pantalla LCD I2C para ESP32 (16x2)
ES-17Intermedio
Premium

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).

4.9(23)
40