Calculadora con Teclado 4×4 y Arduino

Este artículo describe detalladamente el desarrollo de un proyecto de electrónica enfocado en construir una calculadora funcional utilizando una placa Arduino UNO como unidad de procesamiento central y un teclado matricial de 4×4 como interfaz de entrada de usuario. A diferencia de las calculadoras tradicionales, personalizaremos las teclas de letras para realizar operaciones aritméticas, y el resultado se mostrará en el Monitor Serial del IDE de Arduino, proporcionando una base sólida para futuros proyectos con display.

🔩Funcionamiento

Este proyecto consiste en crear una calculadora utilizando un teclado matricial de 4×4 y una placa Arduino. El teclado matricial utilizará las siguientes letras para realizar operaciones aritméticas:

El objetivo es permitir al usuario introducir expresiones matemáticas utilizando el teclado y obtener el resultado correspondiente.

El Cerebro: La Placa Arduino

El Arduino UNO es un microcontrolador de arquitectura Atmega328P que servirá como la unidad lógica y aritmética (ALU) de nuestra calculadora. Se encargará de:

1. Leer la entrada: Identificar qué tecla del teclado matricial ha sido pulsada.
2. Procesar la lógica: Almacenar números y operadores en una secuencia de cálculo.
3. Ejecutar la operación: Realizar la suma, resta, multiplicación o división al presionar la tecla de igualdad.
4. Generar la salida: Imprimir los resultados en el Monitor Serial.

La Interfaz: El Teclado Matricial 4×4

Un teclado matricial es un dispositivo de entrada de bajo costo que reduce drásticamente el número de pines necesarios en el microcontrolador para leer múltiples botones.

• Estructura: Está compuesto por 4 filas y 4 columnas de interruptores, sumando un total de 16 teclas.
• Principio de Funcionamiento: Utiliza un sistema de escaneo (scanning). Para saber qué tecla se ha pulsado, el Arduino activa una fila a la vez (por ejemplo, enviando un nivel lógico alto) y luego lee las 4 columnas. Si una columna registra el nivel alto, significa que el interruptor en la intersección de esa fila y columna está cerrado. Esto reduce el número de pines requeridos de 16 a solo 8 (4 para filas y 4 para columnas).
• Configuración de Teclas para el Proyecto:

_🔨Componentes

🔌Conexiones

• Fila 1 del teclado matricial a pin 9 del Arduino.
• Fila 2 del teclado matricial a pin 8 del Arduino.
• Fila 3 del teclado matricial a pin 7 del Arduino.
• Fila 4 del teclado matricial a pin 6 del Arduino.
• Fila 5 del teclado matricial a pin 5 del Arduino.
• Fila 6 del teclado matricial a pin 4 del Arduino.
• Fila 7 del teclado matricial a pin 3 del Arduino.
• Fila 8 del teclado matricial a pin 2 del Arduino.

Nota sobre la alimentación: El teclado matricial no requiere alimentación externa; el microcontrolador proporciona la energía lógica necesaria para el escaneo a través de los pines digitales.

0️⃣Código

El código de la calculadora debe manejar la entrada de múltiples dígitos, la identificación de la operación y la ejecución del cálculo final. Utilizaremos la librería Keypad.h para simplificar la lectura del teclado.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#include <Arduino.h>
#include <Keypad.h>

double calculateResult(double num1, double num2, char op);
String getSymbol(char key);
void clearData();

const byte ROWS = 4; // Cuatro filas
const byte COLS = 4; // Cuatro columnas

char keys[ROWS][COLS] = {
  {'1','2','3','a'},
  {'4','5','6','b'},
  {'7','8','9','c'},
  {'*','0','#','d'}
};

byte rowPins[ROWS] = {9, 8, 7, 6}; // Conectar a las salidas de fila del teclado
byte colPins[COLS] = {5, 4, 3, 2}; // Conectar a las salidas de columna del teclado

Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

String inputString = ""; // para almacenar la cadena de entrada
char operation;
double num1, num2, result;

void setup(){
  Serial.begin(9600);
}

void loop(){
  char key = keypad.getKey();
  
  if (key){
    if (key >= '0' && key <= '9'){//Si la tecla pulsada es un numero
      inputString += key;
      Serial.print(key);
    }
    else if (key == 'a' || key == 'b' || key == 'c' || key == 'd'){//Si la tecla pulsada es una letra
      operation = key;
      num1 = inputString.toDouble();
      inputString = "";
      Serial.print(" ");
      Serial.print(getSymbol(key));//convierte las letras en simbolos(+,-,*,/)
      Serial.print(" ");
    }
    else if (key == '*'){//Si la tecla pulsada es un asteristo, realiza la operación
      num2 = inputString.toDouble();
      inputString = "";
      result = calculateResult(num1, num2, operation);
      Serial.print(" = ");
      Serial.println(result);
    }
    else if (key == '#'){
      clearData();
    }
  }
}

double calculateResult(double num1, double num2, char op){
  switch(op){
    case 'a': return num1 + num2;
    case 'b': return num1 - num2;
    case 'c': return num1 * num2;
    case 'd': return num1 / num2;
    default: return 0;
  }
}

String getSymbol(char key){
  switch(key){
    case 'a': return "+";
    case 'b': return "-";
    case 'c': return "*";
    case 'd': return "/";
    default: return " ";
  }
}

void clearData(){
  inputString = "";
  operation = 0;
  num1 = 0;
  num2 = 0;
  result = 0;
  Serial.println(" Datos borrados");
}

🖌️Diseños

🎬Videos

📑Conclusión

El proyecto de la Calculadora con Arduino y Teclado Matricial 4×4 es una demostración exitosa de cómo un microcontrolador básico puede ser la base de una herramienta funcional de procesamiento de datos.

Hemos logrado implementar una interfaz de usuario compacta mediante el teclado matricial y la librería Keypad.h, lo cual permitió asignar funciones aritméticas específicas (a, b, c, d, *) de manera eficiente. La clave del éxito radica en la lógica de programación, que gestiona la entrada de números de múltiples dígitos mediante concatenación de strings y realiza la conversión a tipo double solo al momento de la operación. Finalmente, la implementación de un mecanismo robusto de gestión de errores (específicamente la prevención de la división por cero) asegura la estabilidad y confiabilidad del sistema.

En esencia, este proyecto valida la capacidad del Arduino para manejar la entrada/salida digital compleja y realizar cálculos de precisión (usando double para el manejo de decimales), sentando las bases esenciales para el desarrollo de dispositivos electrónicos portátiles y sistemas de control interactivos que requieran la introducción y el procesamiento de comandos numéricos.