Las calculadoras gráficas siguen siendo dispositivos caros para el hardware que realmente incorporan. Muchos modelos educativos de Casio, Texas Instruments o HP superan fácilmente los 100 euros, pese a que internamente emplean arquitecturas bastante modestas si las comparamos con cualquier microcontrolador moderno.

Frente a ese escenario, resulta especialmente interesante el desarrollo de una calculadora científica y gráfica DIY basada en ESP32-S3, pantalla IPS y software de código abierto. La idea no es crear una aplicación móvil ni una página web, sino un dispositivo físico dedicado: una calculadora programable, autónoma y de bajo coste.

El proyecto se apoya en tres pilares técnicos:

• ESP32-S3 como núcleo de proceso.
• LVGL para la interfaz gráfica embebida.
• Giac como motor de cálculo simbólico, el mismo tipo de motor CAS usado en calculadoras avanzadas.

El ESP32-S3 como cerebro de la calculadora

El componente principal es el ESP32-S3, un microcontrolador de Espressif orientado originalmente a aplicaciones IoT, interfaces gráficas, audio, visión ligera y procesamiento embebido.

Sus características lo hacen muy atractivo para una calculadora gráfica:

Aunque el ESP32-S3 no fue diseñado específicamente para calculadoras, ofrece mucha más potencia que muchos chips clásicos usados en calculadoras educativas durante décadas.

El punto clave es que una calculadora gráfica moderna no necesita un procesador enorme. Necesita:

• buena gestión de pantalla;
• cálculo numérico y simbólico eficiente;
• teclado físico;
• consumo contenido;
• arranque rápido;
• sistema cerrado o controlado para entornos educativos.

Arquitectura básica del sistema

Una calculadora DIY con ESP32-S3 podría organizarse así:

+————————————————+
| Interfaz de usuario |
| LVGL |
+————————————————+
| Aplicaciones: cálculo, gráficas, CAS |
+————————————————+
| Motor matemático: Giac / parser |
+————————————————+
| Drivers: pantalla, teclado, almacenamiento |
+————————————————+
| ESP32-S3 |
+————————————————+

El usuario introduce una expresión matemática desde el teclado físico. El firmware la recibe, la procesa con el motor matemático y muestra el resultado en pantalla mediante LVGL.

Por ejemplo:

Entrada:
integrate(sin(x), x)
Salida:
-cos(x)

O bien:

Entrada:
solve(x^2 - 5*x + 6 = 0, x)
Salida:
x = 2, x = 3

Pantalla e interfaz gráfica con LVGL

Para una calculadora gráfica no basta con imprimir texto. Es necesario mostrar menús, fórmulas, resultados, gráficas, cursores, ejes y cuadros de diálogo.

Aquí entra LVGL, una librería gráfica open source muy usada en sistemas embebidos. Permite crear interfaces visuales completas sobre microcontroladores con pocos recursos.

Un esquema mínimo de inicialización con LVGL en ESP32-S3 podría tener esta forma:

#include <lvgl.h>
void setup() {
    Serial.begin(115200);
    lv_init();
    // Inicialización de pantalla
    display_init();
    // Inicialización del driver táctil o teclado, si existe
    input_init();
    // Crear interfaz principal
    create_calculator_ui();
}
void loop() {
    lv_timer_handler();
    delay(5);
}

La función create_calculator_ui() podría crear una pantalla básica con una caja de entrada y una zona de resultados:

lv_obj_t *input_area;
lv_obj_t *result_area;
void create_calculator_ui() {
    lv_obj_t *screen = lv_scr_act();
    input_area = lv_textarea_create(screen);
    lv_obj_set_width(input_area, 300);
    lv_obj_align(input_area, LV_ALIGN_TOP_MID, 0, 10);
    lv_textarea_set_placeholder_text(input_area, "Introduce una expresion");
    result_area = lv_label_create(screen);
    lv_obj_set_width(result_area, 300);
    lv_obj_align(result_area, LV_ALIGN_TOP_MID, 0, 80);
    lv_label_set_text(result_area, "Resultado:");
}

En una versión real, la entrada vendría de un teclado físico matricial, no de una pantalla táctil.

Lectura de teclado físico

Una calculadora necesita teclado dedicado. Lo habitual sería usar una matriz de filas y columnas para reducir pines.

Ejemplo simplificado:

const int rows[] = {4, 5, 6, 7};
const int cols[] = {8, 9, 10, 11};
const char keys[4][4] = {
    {'7', '8', '9', '/'},
    {'4', '5', '6', '*'},
    {'1', '2', '3', '-'},
    {'0', '.', '=', '+'}
};
void keyboard_init() {
    for (int r = 0; r < 4; r++) {
        pinMode(rows[r], OUTPUT);
        digitalWrite(rows[r], HIGH);
    }
    for (int c = 0; c < 4; c++) {
        pinMode(cols[c], INPUT_PULLUP);
    }
}
char scan_keypad() {
    for (int r = 0; r < 4; r++) {
        digitalWrite(rows[r], LOW);
        for (int c = 0; c < 4; c++) {
            if (digitalRead(cols[c]) == LOW) {
                delay(30); // antirrebote básico
                digitalWrite(rows[r], HIGH);
                return keys[r][c];
            }
        }
        digitalWrite(rows[r], HIGH);
    }
    return '\0';
}

Luego, en el bucle principal:

void loop() {
    char key = scan_keypad();
    if (key != '\0') {
        process_key(key);
    }
    lv_timer_handler();
    delay(5);
}

Y una función sencilla para actualizar la entrada:

String expression = "";
void process_key(char key) {
    if (key == '=') {
        evaluate_expression(expression);
    } else {
        expression += key;
        lv_textarea_set_text(input_area, expression.c_str());
    }
}

Integración del motor matemático

La parte realmente interesante es el motor matemático. Una calculadora científica sencilla puede resolver operaciones con un parser propio, pero una calculadora avanzada necesita más:

• derivadas;
• integrales;
• matrices;
• ecuaciones;
• simplificación simbólica;
• representación gráfica de funciones;
• cálculo exacto y aproximado.

Aquí entra un motor CAS como Giac.

La idea general sería:

String evaluate_with_cas(const String& input) {
    // En una implementación real aquí se llamaría al motor CAS.
    // Por ejemplo: Giac, parser propio o motor matemático embebido.
    if (input == "2+2") {
        return "4";
    }
    return "Resultado CAS";
}

Y se conectaría con la interfaz:

void evaluate_expression(const String& expr) {
    String result = evaluate_with_cas(expr);
    String output = "Resultado:\n" + result;
    lv_label_set_text(result_area, output.c_str());
}

En un firmware real, la integración de Giac es mucho más compleja, porque hay que cuidar:

• uso de memoria;
• tamaño del binario;
• pila disponible;
• almacenamiento externo;
• rendimiento;
• conversión entre cadenas, objetos matemáticos y salida formateada;
• compatibilidad con el compilador usado para ESP32-S3.

Este es probablemente uno de los retos principales del proyecto: meter un motor CAS completo en un microcontrolador.

Graficar funciones en una pantalla IPS

La otra parte esencial es la representación gráfica. Para dibujar una función tipo:

y = sin(x)

hay que convertir coordenadas matemáticas a coordenadas de pantalla.

Ejemplo conceptual:

int screen_w = 320;
int screen_h = 240;
float xmin = -10.0;
float xmax = 10.0;
float ymin = -2.0;
float ymax = 2.0;
int map_x(float x) {
    return (int)((x - xmin) * screen_w / (xmax - xmin));
}
int map_y(float y) {
    return screen_h - (int)((y - ymin) * screen_h / (ymax - ymin));
}

Para dibujar sin(x):

void draw_function_sin(lv_obj_t *canvas) {
    for (int px = 0; px < screen_w - 1; px++) {
        float x1 = xmin + (float)px * (xmax - xmin) / screen_w;
        float x2 = xmin + (float)(px + 1) * (xmax - xmin) / screen_w;
        float y1 = sin(x1);
        float y2 = sin(x2);
        int sx1 = map_x(x1);
        int sy1 = map_y(y1);
        int sx2 = map_x(x2);
        int sy2 = map_y(y2);
        // Aquí se dibujaría una línea entre ambos puntos.
        // Con LVGL podría hacerse sobre canvas o mediante objetos gráficos.
    }
}

La versión completa debería añadir:

• ejes X/Y;
• rejilla;
• zoom;
• desplazamiento;
• varias funciones simultáneas;
• detección de discontinuidades;
• ajuste automático de escala;
• cursor de inspección.

Problema importante: WiFi y exámenes

El ESP32-S3 incorpora WiFi y Bluetooth, lo cual es una ventaja en proyectos IoT, pero un problema en una calculadora para exámenes.

En muchos entornos educativos no se permiten dispositivos con conectividad inalámbrica. Por tanto, una calculadora basada en ESP32-S3 tendría que resolver este punto de forma verificable.

Posibles soluciones:

• firmware sin pila WiFi/Bluetooth activa;
• antena no poblada;
• versión hardware sin conectividad accesible;
• modo examen bloqueado;
• carcasa sellada;
• certificación externa;
• diseño auditable.

Este punto es tan importante como el propio software. Para uso personal o educativo libre no supone un gran problema, pero para exámenes oficiales sí.

Ventajas del enfoque open source

El gran atractivo de una calculadora basada en ESP32-S3 no es solo el precio. Es la posibilidad de abrir el diseño:

• firmware modificable;
• hardware documentado;
• teclado reparable;
• pantalla sustituible;
• código auditable;
• posibilidad de añadir aplicaciones;
• independencia de fabricantes cerrados.

Una calculadora de este tipo podría servir también como plataforma educativa para aprender:

• programación en C/C++;
• interfaces gráficas embebidas;
• buses SPI/I2C;
• gestión de memoria;
• diseño de PCBs;
• sistemas operativos ligeros;
• cálculo simbólico;
• representación gráfica.

Ejemplo de estructura de proyecto

Una estructura de firmware razonable podría ser:

NeoCalculator/
├── src/
│ ├── main.cpp
│ ├── display.cpp
│ ├── display.h
│ ├── keyboard.cpp
│ ├── keyboard.h
│ ├── ui.cpp
│ ├── ui.h
│ ├── cas_engine.cpp
│ ├── cas_engine.h
│ ├── grapher.cpp
│ └── grapher.h
├── include/
├── lib/
├── platformio.ini
└── README.md

Y un platformio.ini básico para ESP32-S3 podría ser:

[env:esp32-s3-devkitc-1]

platform = espressif32
board = esp32-s3-devkitc-1
framework = arduino
monitor_speed = 115200

lib_deps =
lvgl/lvgl

En una versión real habría que añadir la librería concreta de la pantalla y ajustar pines, frecuencia SPI, memoria PSRAM y configuración de LVGL.

Conclusión

Una calculadora gráfica basada en ESP32-S3 es técnicamente viable y muy interesante desde el punto de vista educativo. El microcontrolador tiene potencia suficiente para manejar una interfaz gráfica fluida, teclado físico, almacenamiento y cálculo matemático avanzado, siempre que el firmware esté bien optimizado.

El reto principal no está solo en sumar, restar o dibujar funciones. Lo verdaderamente difícil es integrar un motor CAS como Giac, gestionar la memoria del ESP32-S3 y construir una interfaz cómoda y estable.

Aun así, el concepto es potente: una calculadora científica y gráfica de bajo coste, reparable, programable y abierta. Justo el tipo de proyecto que demuestra que con un microcontrolador moderno, una pantalla IPS y buen software se pueden replantear dispositivos educativos que llevan décadas prácticamente inmóviles.