Un LED y un botón

Aquí tu programa empieza a manejar cosas de fuera: enciende un LED, lo cambia con un botón y le regula el brillo. Primero en Windows, con el simulador GPIO, que hace de placa con un LED y un pulsador que tocas con el ratón. Después, en tu placa, con un LED y un botón de verdad. El programa es el mismo en los dos sitios.

Usa el proyecto de Tu primer programa o crea otro con Home › Project › New. Cada programa de esta página va en el fichero principal, Code/Tutorial.aru (o el de tu proyecto), en lugar de lo que tenga.

Encender y apagar un LED

use GPIO

const PIN_LED = 2                    // el pin del LED

GPIO.pinmode(PIN_LED, GPIO.OUTPUT)   // un pin de salida
for (var vez = 1; vez <= 5; vez++)
    GPIO.write(PIN_LED, HIGH)        // encendido
    pause(500)
    GPIO.write(PIN_LED, LOW)         // apagado
    pause(500)
end
println("Fin")

• use GPIO trae el módulo de los pines, GPIO.
• GPIO.pinmode hace del pin una salida, y GPIO.write lo pone a nivel alto (HIGH: el LED se enciende) o bajo (LOW: se apaga).
• pause(500) espera medio segundo.

En Windows, el LED es una tarjeta del simulador:

1. Abre el simulador con Build › Debug › GPIO Sim.
2. Pulsa Add GPIO Pin, escribe 2 en GPIO Number (0-48) y pulsa OK. El pin sale en la tabla, libre.
3. Haz clic en su columna Connected to, elige Red LED y pulsa Intro. A la derecha sale su tarjeta, Red LED · GP2.
4. Pulsa Run. El LED de la tarjeta se enciende y se apaga cinco veces, y al lado dice ON (HIGH) u OFF (LOW). Al acabar, la consola del programa escribe Fin.

El simulador guarda sus pines con el proyecto, en Config/jaru_sim.json: la próxima vez seguirán ahí.

No llames a un pin como un módulo

Usa nombres como PIN_LED o PIN_BOTON, no LED ni GPIO: con una variable o una constante que se llama como un módulo, el programa se para al usarla, sin ningún mensaje, y el compilador no avisa.

Cambiar el LED con un botón

Ahora, un botón: cada vez que lo pulsas, el LED cambia.

use GPIO

const PIN_LED = 2
const PIN_BOTON = 4

GPIO.pinmode(PIN_LED, GPIO.OUTPUT)
GPIO.pinmode(PIN_BOTON, GPIO.PULLUP)     // suelto da HIGH; pulsado, LOW

var encendido = false
var antes = HIGH
while (true)
    var ahora = GPIO.read(PIN_BOTON)
    if (antes == HIGH and ahora == LOW) then     // se acaba de pulsar
        encendido = not(encendido)
        if (encendido) then
            GPIO.write(PIN_LED, HIGH)
        else
            GPIO.write(PIN_LED, LOW)
        end
        println("LED encendido: ", encendido)
    end
    antes = ahora
    pause(20)
end

• Con GPIO.PULLUP, el pin es una entrada con su resistencia de pull-up: el botón va entre el pin y GND. Suelto, GPIO.read da HIGH; pulsado, LOW.
• El programa no acaba: while (true) lee el botón cada 20 milisegundos. Compara cada lectura con la anterior, y solo cuando el botón pasa de suelto a pulsado cambia el LED. Así, tenerlo pulsado cuenta una sola vez.
• El estado del LED lo guarda encendido: el programa no necesita leer el pin del LED.

En Windows:

1. En el simulador, añade el pin 4 con Add GPIO Pin y conéctalo a Pushbutton.

2. Pulsa Run y haz clic en el botón de la tarjeta Pushbutton · GP4. Mientras lo tienes pulsado, la tarjeta dice PRESSED (LOW).

3. Cada clic enciende o apaga el LED, y la consola lo cuenta:

   LED encendido: true
   LED encendido: false

4. Para acabar, pulsa Stop.

El brillo, con PWM

Un LED no solo se enciende y se apaga: con PWM le das un brillo intermedio. Aquí, cada pulsación sube el brillo un paso.

use GPIO

const PIN_LED = 2
const PIN_BOTON = 4

GPIO.resolution(PIN_LED, 8)              // brillo de 0 a 255, en Windows y en la placa
GPIO.pinmode(PIN_BOTON, GPIO.PULLUP)

var brillo = 0
var antes = HIGH
GPIO.awrite(PIN_LED, brillo)
while (true)
    var ahora = GPIO.read(PIN_BOTON)
    if (antes == HIGH and ahora == LOW) then
        brillo = brillo + 85                     // 0, 85, 170, 255 y vuelta a 0
        if (brillo > 255) then
            brillo = 0
        end
        GPIO.awrite(PIN_LED, brillo)
        println("Brillo: ", brillo)
    end
    antes = ahora
    pause(20)
end

• GPIO.awrite saca por el pin una señal que se enciende y se apaga muy deprisa. Cuanto más tiempo pasa encendida, más brilla el LED. No hace falta pinmode.
• GPIO.resolution(PIN_LED, 8) pone la escala de 0 a 255. De serie es de 0 a 255 en Windows y de 0 a 1023 en la placa: así, el mismo número da el mismo brillo en las dos.

Pulsa Run y haz clic en el botón unas cuantas veces: el LED de la tarjeta brilla más en cada paso, y la tarjeta dice cuánto, como Duty: 170 / 255 (67%). La consola escribe Brillo: 85, Brillo: 170, Brillo: 255 y Brillo: 0.

En la placa

1. Elige dos pines libres de tu placa: ni los de la pantalla, la tarjeta SD, el sonido o el bus I2C, ni los de la consola serie. Cuáles son, en Pines que no valen para un botón. En el ESP32, del 34 al 39 son solo de entrada y no tienen pull-up interna: no valen ni para el LED ni para este botón.
2. Conecta el LED del pin a GND, con su resistencia en serie y la pata larga hacia el pin, y el botón entre el otro pin y GND.
3. Cambia PIN_LED y PIN_BOTON por tus pines.
4. Con tu placa en Target, pulsa Run y abre el monitor serie para ver lo que imprime, como en Tu programa en una placa.

En la placa, el programa del LED que parpadea vuelve a empezar al acabar: la VM lo repite. Los otros dos no acaban nunca; se quedan en la placa hasta que le envíes otro programa.

Siguientes pasos

• Un sensor en la red: lee un valor analógico, como un potenciómetro, y mándalo por internet con MQTT.
• Módulo GPIO: todas las funciones de los pines, las diferencias entre placas y las interrupciones.
• Simulador GPIO: todas sus tarjetas, del interruptor a la tira de LEDs de colores.