Jardin de Conocimiento

Arduino · Módulo 07 · Ej 03 — Conmutar un relé cada 2 s (ON/OFF)

8 min read

Ejercicio 03 — Conmutar un relé cada 2 s (ON/OFF)

Dificultad: amarillo · Módulo 07 (Actuadores y potencia)

Enunciado

Conmutar un relé cada 2 s (ON/OFF). El relé “enciende” una carga; aquí simulamos la carga con un LED.

Cómo se resuelve

Este es el ejercicio con el código más corto del módulo y, sin embargo, el más importante de entender. Míralo:

const int PIN_RELE = 7;
 
void setup() {
    pinMode(PIN_RELE, OUTPUT);
    digitalWrite(PIN_RELE, LOW);
}
 
void loop() {
    digitalWrite(PIN_RELE, HIGH);
    delay(2000);
    digitalWrite(PIN_RELE, LOW);
    delay(2000);
}

Es, línea por línea, el parpadeo del módulo 01 con delay(2000) en vez de delay(1000). No hay ninguna función nueva. Lo que ha cambiado no es el software, es lo que hay al otro lado del pin, y ese es exactamente el punto del ejercicio.

Un relé es un interruptor mecánico de verdad, con contactos metálicos, accionado por un electroimán. Cuando le llega corriente a la bobina, el campo magnético tira de una lámina y el contacto cambia de posición; ese es el “clic” que oyes cada dos segundos. Su gracia es el aislamiento: el circuito que manda y el circuito que se conmuta están físicamente separados, así que una señal de 5 V puede abrir y cerrar un circuito que no tiene nada que ver con el Arduino.

Un módulo relé de un canal tiene dos grupos de pines, y confundirlos es el fallo grave. El lado de control son IN, VCC y GND: IN va al pin 7, VCC a 5 V y GND al GND de la placa. El lado de potencia son COM, NA y NC: por ahí pasa la carga, con su propia alimentación. El pin del Arduino solo toca IN. La carga no toca el Arduino en ningún punto — para eso está el relé.

COM es el común. NA (normalmente abierto) está desconectado de COM mientras el relé descansa y se conecta al activarlo. NC (normalmente cerrado) es lo contrario. Elegir uno u otro es una decisión de diseño, no un capricho: piensa en qué quieres que ocurra si el sistema se queda sin corriente y el relé cae a reposo.

En el ejercicio la carga se simula con un LED y su resistencia de 220 Ω conectados a través del contacto del relé, para practicar el patrón sin manejar tensiones peligrosas. En Wokwi no existe un módulo relé como pieza estándar, así que el ejercicio se simula con un LED directamente en el pin 7: el código es idéntico y lo que se pierde es el clic.

Sobre el código, dos detalles que sí merecen atención.

El primero es la línea de setup() que a primera vista parece redundante:

digitalWrite(PIN_RELE, LOW);

Es una inicialización explícita del estado. Justo después de un pinMode(..., OUTPUT) el pin queda en LOW de todas formas, pero escribirlo declara la intención: este sistema arranca con la carga apagada. Con un LED eso da igual; con un relé que enciende un ventilador o una bomba, arrancar en un estado conocido y seguro es una costumbre que no se negocia. Es la diferencia entre un montaje que se comporta igual en cada encendido y uno que depende de lo que hubiera antes.

El segundo es que este código asume que el módulo es activo en alto: HIGH activa, LOW desactiva. Muchos módulos relé del mercado, sobre todo los que llevan optoacoplador, son activos en bajo y hacen justo lo contrario. Si al probarlo ves que el relé clica nada más encender la placa y se queda quieto donde esperabas que se activara, tienes uno de esos: la lógica está invertida. La solución no es ir cambiando HIGH por LOW a mano por todo el código, sino declarar la convención una vez:

const int RELE_ACTIVO   = LOW;    // o HIGH, según tu módulo
const int RELE_REPOSO   = HIGH;

y usar esos nombres en los digitalWrite. Así el programa se lee por lo que hace (“activar”, “reposo”) y adaptarlo a otro módulo es cambiar dos líneas.

Queda la regla que atraviesa todo el módulo y que aquí conviene repetir aunque el LED del ejercicio no la haga evidente: el pin manda señal, nunca potencia. La bobina del relé la alimenta el VCC de 5 V del módulo, no el pin; la carga la alimenta su propia fuente por los contactos. Y el GND del módulo y el de la placa tienen que estar unidos, porque el HIGH del pin significa “5 V respecto al GND de la placa” y sin esa referencia compartida la entrada IN no sabe interpretar nada.

Un apunte final por si algún día lo llevas fuera del aula: conmutar red eléctrica de 230 V con un relé es lo que hacen los enchufes domóticos comerciales, y es perfectamente posible, pero es material aislado y con supervisión. Aquí trabajamos siempre a baja tensión.

Para practicar — cópialo y complétalo

Pega este esqueleto y completa los TODO. Es la mejor forma de aprender: inténtalo antes de mirar la solución.

/*
 * Curso de Arduino — Módulo 07: Actuadores y potencia
 * Ejercicio 03 — PRÁCTICA (rellena los TODO)
 * Enunciado: Conmutar un relé cada 2 s (ON/OFF). La carga la simula un LED.
 * Dificultad: amarillo
 * Placa: Arduino UNO
 * Montaje: IN del módulo relé -> pin 7, VCC -> 5V, GND -> GND (masa común).
 *
 * IMPORTANTE: el pin solo da la señal; una carga real va con fuente aparte
 *             en los contactos del relé (COM/NA/NC), nunca al pin.
 * Correr: Arduino IDE / Wokwi (wokwi/ej03) / arduino-cli (ver README)
 */
const int PIN_RELE = 7;
 
void setup() {
    // TODO: configura PIN_RELE como salida con pinMode(...)
    // TODO: arranca en reposo -> digitalWrite(PIN_RELE, LOW)
}
 
void loop() {
    // TODO: activa el relé -> digitalWrite(PIN_RELE, HIGH)
    // TODO: espera 2 s -> delay(2000)
    // TODO: desactiva el relé -> digitalWrite(PIN_RELE, LOW)
    // TODO: espera 2 s
}

Solución — cópiala y ejecútala

/*
 * Curso de Arduino — Módulo 07: Actuadores y potencia
 * Ejercicio 03 — MODELO (resuelto)
 * Enunciado: Conmutar un relé cada 2 s (ON/OFF). El relé "enciende" una carga;
 *            aquí simulamos la carga con un LED.
 * Dificultad: amarillo
 * Placa: Arduino UNO
 * Montaje (módulo relé de 1 canal):
 *   - IN  -> pin 7
 *   - VCC -> 5V
 *   - GND -> GND
 *   La carga simulada (LED + 220 ohm) va a 5V/GND a través del contacto del relé.
 *
 * IMPORTANTE (potencia real):
 *   - El pin solo manda la SEÑAL al módulo relé; NO alimenta la carga.
 *   - Una carga real (bombilla, motor, ventilador) va con su PROPIA fuente,
 *     conectada a los contactos del relé (COM/NA/NC), NUNCA al pin.
 *   - Masa común: el GND del módulo relé y el de la placa deben estar unidos.
 *   - Muchos módulos relé son ACTIVOS EN BAJO (LOW = activado). Comprueba el tuyo.
 * Correr: Arduino IDE / Wokwi (wokwi/ej03) / arduino-cli (ver README)
 */
const int PIN_RELE = 7;
 
void setup() {
    pinMode(PIN_RELE, OUTPUT);
    digitalWrite(PIN_RELE, LOW);   // arrancar con el relé en reposo
}
 
void loop() {
    digitalWrite(PIN_RELE, HIGH);  // activar relé -> carga ON (se oye el "clic")
    delay(2000);
    digitalWrite(PIN_RELE, LOW);   // desactivar relé -> carga OFF
    delay(2000);
}

Cómo ejecutar la simulación

Sin instalar nada, en el navegador

  1. Abre wokwi.com y crea un proyecto nuevo de la placa que pide el ejercicio.
  2. Pega la solución (o tu intento) en la pestaña sketch.ino.
  3. Abre la pestaña diagram.json, borra lo que haya y pega el circuito de aquí abajo.
  4. Dale al play. Verás el circuito funcionando: LEDs, pantallas y monitor serie.
Circuito del ejercicio (diagram.json) 
{
  "version": 1,
  "author": "ESIBot",
  "editor": "wokwi",
  "comment": "Wokwi no trae modulo rele estandar; simulamos la carga conmutada con un LED en el pin 7.",
  "parts": [
    { "type": "wokwi-arduino-uno", "id": "uno", "top": 0, "left": 0, "attrs": {} },
    { "type": "wokwi-led", "id": "led", "top": -50, "left": 150, "attrs": { "color": "red" } },
    { "type": "wokwi-resistor", "id": "r1", "top": 100, "left": 150, "attrs": { "value": "220" } }
  ],
  "connections": [
    [ "uno:7", "r1:1", "green", [] ],
    [ "r1:2", "led:A", "green", [] ],
    [ "led:C", "uno:GND.1", "black", [] ]
  ],
  "dependencies": {}
}

En VS Code, con el repo del curso

El paquete de simulación de este ejercicio está en practica/07-actuadores-y-potencia/wokwi/ej03/. Con la extensión Wokwi instalada y la licencia activada (lo cuenta el onboarding del curso):

make sim EJ=07-actuadores-y-potencia/ej03

y después, en VS Code, Ctrl+Shift+P → Wokwi: Start Simulator. La extensión no compila: simula un firmware ya compilado, y de compilarlo se encarga ese make.

Cómo usarlo

Con placa: abre el .ino en el Arduino IDE, elige placa y puerto y pulsa Subir. Sin placa: simulalo en Wokwi con cualquiera de las dos vias de arriba. Antes de mirar la solucion, intenta completar tu el esqueleto: es la mejor forma de aprender.

Conexiones

Graph View

Backlinks