2 publicaciones etiquetados con "gpio"

Después de hacer parpadear un LED, el siguiente paso natural es leer el mundo exterior. En este tutorial aprenderás a conectar un pulsador, leer su estado con GPIO.read y, finalmente, reaccionar a las pulsaciones con interrupciones — todo probado primero en el simulador de Windows y después en tu ESP32.

Lo que necesitas​

• JARU IDE instalado en tu PC — puedes completar todo el tutorial solo con esto.
• (Opcional) Una placa ESP32, un pulsador, un LED, resistencias y un cable USB.

Paso 1: El código — Lectura por sondeo (polling)​

La forma más directa de leer un pulsador es preguntar constantemente por su estado dentro del bucle principal. Abre JARU IDE, crea un nuevo archivo llamado button.aru y escribe el siguiente código:

// Importamos el módulo GPIO para controlar los pines
use GPIO

println("Iniciando lectura de pulsador...");

// 1. Configuración de pines
// Pin 4: pulsador con resistencia pull-up interna (lee HIGH cuando no se pulsa)
GPIO.pinmode(4, GPIO.PULLUP);

// Pin 2: LED integrado como salida
GPIO.pinmode(2, GPIO.OUTPUT);

println("Hardware configurado. Esperando pulsaciones...");

// 2. Bucle principal — sondeo (polling)
while (true)
    var state = GPIO.read(4);

    if (state == LOW) then
        // El pulsador está presionado (conecta a GND → lee LOW)
        GPIO.write(2, HIGH);
        println("Pulsador presionado  → LED encendido");
    else
        GPIO.write(2, LOW);
    end

    pause(50); // Pequeña pausa anti-rebote
end

Qué hace cada parte​

GPIO.pinmode(4, GPIO.PULLUP) configura el pin 4 como entrada digital con resistencia pull-up interna. El pin lee HIGH en reposo y LOW cuando el pulsador conecta a GND.

GPIO.read(4) devuelve el estado digital actual del pin: HIGH (1) o LOW (0).

state == LOW detecta que el pulsador está presionado. Con pull-up, la lógica es invertida: pulsar = LOW.

pause(50) introduce una espera de 50 ms que actúa como filtro anti-rebote básico, evitando lecturas erráticas por el rebote mecánico del pulsador.

Paso 2: Simulación en Windows​

1. Abre el Simulador GPIO desde el menú Build → GPIO Sim del IDE.
2. Añade el pin 4 manualmente con el botón New GPIO y asocia una tarjeta PushButton.
3. Añade el pin 2 y asocia una tarjeta LED.
4. Haz clic en Run para ejecutar el programa en la VM.
5. En la consola de salida verás los mensajes de arranque.
6. Pulsa el botón en la tarjeta PushButton del simulador y observa cómo la tarjeta LED se enciende mientras mantienes pulsado. Al soltar, se apaga.

Iniciando lectura de pulsador...
Hardware configurado. Esperando pulsaciones...
Pulsador presionado  → LED encendido
Pulsador presionado  → LED encendido

Paso 3: Mejora — Uso de interrupciones​

El sondeo funciona, pero obliga al procesador a estar preguntando constantemente. Las interrupciones son más eficientes: el hardware avisa automáticamente cuando el pin cambia de estado. Crea un nuevo archivo button_int.aru:

// Importamos el módulo GPIO
use GPIO

println("Iniciando lectura con interrupciones...");

// 1. Configuración de pines
GPIO.pinmode(4, GPIO.PULLUP);
GPIO.pinmode(2, GPIO.OUTPUT);

// 2. Variable de estado
var ledOn = false;

// 3. Función callback — se ejecuta cuando el pin cambia
func onButtonPress(pin, val)
    ledOn = !ledOn; // Invertimos el estado

    if (ledOn) then
        GPIO.write(2, HIGH);
        println("LED encendido (toggle)");
    else
        GPIO.write(2, LOW);
        println("LED apagado (toggle)");
    end
end

// 4. Registramos la interrupción en flanco de bajada (HIGH → LOW = pulsación)
GPIO.onInterrupt(4, GPIO.FALLING, onButtonPress);

println("Interrupción registrada. Pulsa el botón...");

// 5. Bucle principal libre para otras tareas
while (true)
    pause(100);
end

Qué hace cada parte nueva​

func onButtonPress() define la función callback que se ejecutará automáticamente cada vez que se detecte una interrupción en el pin.

GPIO.onInterrupt(4, GPIO.FALLING, onButtonPress) asocia la función onButtonPress al pin 4. El modo GPIO.FALLING dispara la interrupción en el flanco de bajada (cuando el pin pasa de HIGH a LOW), es decir, justo cuando presionas el pulsador.

while (true) pause(100); end mantiene el programa vivo. El bucle principal queda libre porque toda la lógica del pulsador la gestiona la interrupción.

Modos de interrupción disponibles​

Paso 4: Simulación de la versión con interrupciones​

1. Repite la configuración del simulador: pin 4 con PushButton y pin 2 con LED.
2. Ejecuta button_int.aru con Run.
3. Haz clic en el pulsador del simulador. Cada clic alternará el LED entre encendido y apagado.
4. Observa la consola: cada pulsación imprime el nuevo estado.

Iniciando lectura con interrupciones...
Interrupción registrada. Pulsa el botón...
LED encendido (toggle)
LED apagado (toggle)
LED encendido (toggle)

Paso 5: Despliegue en el ESP32​

Una vez verificada la lógica en el simulador, el despliegue al hardware es idéntico al tutorial anterior. No necesitas cambiar ni una sola línea de código.

1. Conecta tu ESP32 al puerto USB del PC.
2. Conecta el pulsador entre el GPIO 4 y GND. No necesitas resistencia externa gracias al GPIO.PULLUP.
3. En JARU IDE, selecciona el puerto COM de tu placa desde el menú desplegable.
4. Haz clic en el botón Upload Program.
5. Espera a que el flasheo termine y pulsa el botón físico. El LED del ESP32 responderá exactamente igual que en el simulador.

Desafío extra​

Combina lo que has aprendido en este tutorial y en el anterior. Intenta crear un programa que haga lo siguiente:

• Al pulsar el botón, el LED empieza a parpadear automáticamente.
• Al pulsar otra vez, el LED se detiene y se apaga.

Pista: usa una variable booleana que se alterne en la interrupción y compruébala dentro del bucle principal para decidir si ejecutas la secuencia de parpadeo.

¿Quieres un reto mayor? Añade un segundo pulsador en otro pin que controle la velocidad del parpadeo: cada pulsación reduce el intervalo a la mitad (500 → 250 → 125 ms) y vuelve a empezar.

Resumen​

En este tutorial has aprendido a configurar un pin como entrada digital con GPIO.pinmode y el modo GPIO.PULLUP, leer el estado de un pulsador con GPIO.read, reaccionar a pulsaciones con GPIO.onInterrupt y el modo GPIO.FALLING, distinguir entre lectura por sondeo (polling) y lectura por interrupciones, y probar ambos enfoques en la VM de Windows antes de desplegar al ESP32 sin modificar el código.

El siguiente tutorial introduce la lectura y escritura analógica con PWM y sensores.

El primer paso en el mundo del hardware siempre es hacer parpadear un LED. En este tutorial aprenderás la sintaxis básica de JARU y descubrirás una de sus mejores características: escribir el código una vez y probarlo tanto en el simulador de Windows como en tu placa ESP32 física.

Lo que necesitas​

• JARU IDE instalado en tu PC — puedes completar todo el tutorial solo con esto.
• (Opcional) Una placa ESP32 y un cable USB para el despliegue final.

Paso 1: El código​

En JARU interactuamos con el hardware importando módulos. Abre JARU IDE, crea un nuevo archivo llamado blink.aru y escribe el siguiente código:

// Importamos el módulo GPIO para controlar los pines
use GPIO

println("Iniciando Hola Mundo...");

// 1. Configuración de pines
// Configuramos el pin 2 (donde suele estar el LED integrado) como salida
GPIO.pinmode(2, GPIO.OUTPUT);

println("Hardware configurado. Iniciando bucle...");

// 2. Bucle principal
while (true)
    // Encender LED
    GPIO.write(2, HIGH);
    pause(500); // Esperamos 500 milisegundos

    // Apagar LED
    GPIO.write(2, LOW);
    pause(500); // Esperamos otros 500 milisegundos
end

Qué hace cada parte​

use GPIO importa el módulo de entrada/salida de propósito general. Sin esta línea, las funciones GPIO.* no estarán disponibles.

GPIO.pinmode(2, GPIO.OUTPUT) configura el pin 2 como salida digital. Siempre hay que llamar a esta función antes de escribir en un pin.

GPIO.write(2, GPIO.HIGH) / GPIO.write(2, GPIO.LOW) encienden y apagan el LED escribiendo un nivel alto o bajo en el pin.

pause(500) detiene la ejecución durante 500 ms, creando el efecto de parpadeo.

Paso 2: Simulación en Windows​

Una de las grandes ventajas de JARU es su Máquina Virtual integrada. Puedes ejecutar este código directamente en tu ordenador sin ningún hardware conectado.

1. Abre el Simulador GPIO desde el menú Build → GPIO Sim del IDE.
2. Añade el pin 2 manualmente con el botón New GPIO.
3. Asocia una tarjeta LED al pin 2 desde el panel de dispositivos.
4. Haz clic en Run para ejecutar el programa en la VM.
5. Observa la consola de salida: verás los mensajes de println confirmando que el sistema ha arrancado correctamente.
6. Mira la tarjeta LED en el simulador: el indicador se encenderá y apagará cada 500 ms. ¡Estás simulando hardware directamente en Windows!

Iniciando Hola Mundo...
Hardware configurado. Iniciando bucle...

Paso 3: Despliegue en el ESP32​

Una vez comprobado que la lógica funciona en el simulador, pasarlo al hardware real es cuestión de un clic. No necesitas cambiar ni una sola línea de código.

1. Conecta tu ESP32 al puerto USB del PC.
2. En JARU IDE, selecciona el puerto COM de tu placa desde el menú desplegable de la barra de herramientas.
3. Haz clic en el botón Upload Program.
4. Espera a que el proceso de flasheo termine — la consola mostrará el progreso.
5. El LED físico de tu ESP32 empezará a parpadear exactamente igual que en el simulador.

Desafío extra​

Cambia los valores de pause(500) a pause(100) y ejecuta el código primero en el simulador de Windows. Observa cómo el indicador del pin 2 parpadea mucho más rápido. Ahora flashéalo al ESP32 y comprueba el resultado en el mundo real.

¿Te atreves a ir más lejos? Prueba a hacer que el LED parpadee tres veces rápido y luego haga una pausa larga, como el código Morse de la letra S (· · ·).

Resumen​

En este tutorial has aprendido a importar el módulo GPIO, configurar un pin como salida con GPIO.pinmode, escribir valores digitales con GPIO.write, usar pause para controlar el tiempo, y probar el mismo código en la VM de Windows y en un ESP32 real sin modificarlo.

El siguiente tutorial introduce la lectura de entradas digitales con botones e interrupciones.