Encender y apagar el radiador por tiempo
Recorrido del nivel
Esa barra de arriba te dice en qué paso estás. Tocala para ver el índice completo y saltar a cualquier paso.
Conectar el módulo relé al radiador
Para optimizar el consumo del radiador necesitamos controlar su encendido y apagado desde la placa. Como la placa trabaja con señales de baja tensión y el radiador con tensión de red, entre los dos va un reléReléDispositivo electromagnético que funciona como un interruptor controlado por un circuito eléctrico: un electroimán abre o cierra contactos de otros circuitos independientes. Permite controlar con bajo voltaje dispositivos que utilizan mayor voltaje.: un interruptor accionado eléctricamente que deja pasar o corta la corriente del radiador según lo que le indique la placa.
En el Arduino UNO seguimos el esquema original: el pin de señal del módulo relé va al pin
digital 3 (la constante PIN_RELE del código), VCC al pin 5V y GND a GND. Al
poner el pin 3 en estado ALTO (HIGH), el relé cierra el contacto y el radiador se enciende; en
BAJO (LOW), lo abre y el radiador se apaga.
En el ESP32 la conexión es equivalente, con otros números: el pin de señal del módulo relé va
al GPIO 25 (la constante PIN_RELE del código), y la alimentación del módulo se toma de 5V
(pin VIN, tomado del USB) y GND, porque muchos módulos relé no conmutan de forma confiable
con los 3,3 V del ESP32. La lógica es la misma: GPIO 25 en ALTO enciende el radiador, en BAJO lo
apaga.
El lado de potencia se arma como en la figura: se intercala el relé en uno de los cables del enchufe del radiador. Un cable va del enchufe al borne COM del relé y otro desde el borne NO (normal abierto) de vuelta al radiador; así, el radiador solo recibe energía cuando el relé cierra el contacto.
¡Atención! El radiador funciona con 220 V, que es una tensión peligrosa. En el aula, el relé conmuta una carga de baja tensión (por ejemplo, una lámpara de bajo voltaje) o directamente el LED de prueba del pin 13, y así se practica toda la lógica sin tocar la red. La instalación real de 220 V (desarmar el enchufe, cablear el radiador) es una tarea exclusiva del docente, supervisada y sin participación de estudiantes. Y una regla que el propio original remarca: las conexiones de potencia del relé nunca van sobre la protoboard.
Programar el encendido y apagado del radiador
La programación la haremos directamente en el lenguaje de Arduino (C++), con el Arduino IDE en
su versión 2.x, que se descarga gratis desde
arduino.cc/en/software. Un programa de Arduino se llama
sketch y tiene dos bloques: setup(), que se ejecuta una sola vez al encender, y loop(), que
se ejecuta repetidamente después. Todo lo que sigue a // es un comentario: no afecta al
programa, sirve para que el código sea más fácil de leer.
Antes de manejar tiempos largos, conviene una prueba rápida: hacer que el radiador se encienda
y se apague de forma intermitente cada pocos segundos, para verificar que el relé responde. En el
código, poner PIN_RELE en ALTO (HIGH) enciende el radiador y ponerlo en BAJO (LOW) lo apaga;
intercalando una espera con delay() entre uno y otro, el radiador prende y apaga solo. Vas a
escuchar el clic del relé y, si estás probando con el LED del pin 13 o una lámpara, verlo
titilar. Sobre esta idea básica construimos, en el paso 4, el temporizador con los tiempos reales.
Subir el código a la placa
Para subir el código de nuestro programa a la placa necesitamos:
- Conectar la placa a la computadora con el cable USB.
- Chequear que en el selector de placa del Arduino IDE esté seleccionada la placa correcta.
- Seleccionar el puertoPuerto COMPuerto de comunicaciones por el cual el sistema operativo se comunica con un dispositivo externo, como la placa. Se asigna automáticamente al conectarla por USB y puede cambiar de número; en el IDE hay que indicar cuál usar. al que está conectada la placa.
- Cliquear el botón Subir (la flecha →) en la parte superior de la interfaz.
En el Arduino IDE 2.x, la placa y el puerto se eligen juntos en el menú desplegable de la barra superior: al conectar la placa suele aparecer directamente como opción. Si no aparece, entrá a “Select other board and port” y buscala por nombre.
Para el Arduino UNO: usá el cable USB tipo B, elegí la placa Arduino UNO y el puerto que se
agregó al conectarla (en Windows es un puerto COM numerado; en Linux suele llamarse
/dev/ttyACM0 o similar).
Para el ESP32 hay dos pasos previos que se hacen una sola vez: instalar el soporte de placas ESP32 desde el gestor de placas del IDE (buscá “esp32” e instalá el paquete de Espressif) y, si el puerto no aparece, instalar el driver del conversor USB-serie de tu placa (generalmente CP210x o CH340). Después, elegí la placa ESP32 Dev Module (o “DOIT ESP32 DEVKIT V1”) y el puerto correspondiente. Si al subir el IDE queda esperando en “Connecting…”, mantené apretado el botón BOOT de la placa hasta que empiece la carga.
Al terminar de subir, veremos el mensaje de carga completada en la barra inferior del IDE.
Programar el tiempo de encendido y apagado
Ahora sí, el temporizador de verdad. Para ahorrar energía hay que calcular cuánto tiempo conviene tener el radiador encendido; eso depende de muchos factores, como el tamaño de la habitación y la temperatura exterior. A modo de ejemplo, y como en el original, dejamos el radiador encendido durante 10 minutos (600 segundos) y apagado durante 15 minutos (900 segundos), repitiendo el ciclo indefinidamente.
Esos dos tiempos están al comienzo del código en las constantes TIEMPO_ENCENDIDO_MS (600000
milisegundos) y TIEMPO_APAGADO_MS (900000 milisegundos). Cambiando esos valores, adaptás el
ritmo del radiador a tu habitación sin tocar el resto del programa. En este nivel usamos delay(),
que es lo más simple y hace que el código se lea igual que su comportamiento: encender, esperar el
tiempo de encendido, apagar, esperar el tiempo de apagado, y volver a empezar.
Ver el código completo · calefaccion-temporizada.ino
// Calefaccion temporizada: un modulo rele enciende y apaga un radiador
// electrico siguiendo tiempos fijos, sin sensores. Es el prototipo mas
// simple del sistema: "prender 10 min, apagar 15 min", como un temporizador.
//
// !! SEGURIDAD 220V !! El radiador es una carga de 220V conmutada por el
// rele. En el aula, usar una carga de BAJA TENSION (o directamente el LED de
// prueba del pin 13) para ver el ciclo sin riesgo. La conexion real a 220V
// queda reservada al docente o a una instalacion supervisada, y el rele con
// su cableado de 220V van SIEMPRE fuera de la protoboard (ver README).
//
// Plataforma: Arduino UNO.
// Conexion (la del esquema original): senal del modulo rele -> pin 3 (con su
// alimentacion de 5V y GND). El rele se comporta como el interruptor del
// radiador.
//
// Basado en: Fragmento de codigo del Nivel Inicial (Paso 4) - Sistema de
// Calefaccion Automatico, Saberes Digitales (INET/EDUCAR 2019)
// Modernizacion: se reemplaza el C generado por mBlock3 (_delay, _loop) por
// C++ idiomatico con constantes nombradas; los tiempos quedan como constantes
// claras en milisegundos, y el estado del rele por constantes invertibles.
// Pin de la senal del modulo rele.
const int PIN_RELE = 3;
// El modulo rele de la guia es ACTIVO-ALTO: HIGH cierra el contacto y el
// radiador se enciende. Muchos modulos comerciales son activo-bajo: si el
// tuyo enciende al reves, invertí estas dos constantes (ENCENDIDO = LOW /
// APAGADO = HIGH) y el resto del programa no cambia.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO = LOW;
// Tiempos del ejemplo original: 10 minutos encendido, 15 minutos apagado
// (600 s y 900 s en el PDF, aca expresados en milisegundos).
// NOTA PARA EL AULA: 10 y 15 minutos hacen la demostracion muy lenta. Para
// ver el ciclo en clase, bajá estos valores a algo corto, por ejemplo
// 5000UL / 5000UL (5 s encendido / 5 s apagado); una vez entendido el
// comportamiento, volvé a los tiempos reales.
const unsigned long TIEMPO_ENCENDIDO_MS = 600000UL; // 10 min
const unsigned long TIEMPO_APAGADO_MS = 900000UL; // 15 min
void setup() {
pinMode(PIN_RELE, OUTPUT);
// Arrancamos con el radiador apagado.
digitalWrite(PIN_RELE, RELE_APAGADO);
}
void loop() {
// Encender el radiador y esperar el tiempo de encendido.
digitalWrite(PIN_RELE, RELE_ENCENDIDO);
delay(TIEMPO_ENCENDIDO_MS);
// Apagar el radiador y esperar el tiempo de apagado. En este nivel usamos
// delay(): es la herramienta que ya conocemos y hace que el programa se lea
// de arriba hacia abajo igual que su comportamiento.
digitalWrite(PIN_RELE, RELE_APAGADO);
delay(TIEMPO_APAGADO_MS);
} // Calefaccion temporizada: un modulo rele enciende y apaga un radiador
// electrico siguiendo tiempos fijos, sin sensores. Es el prototipo mas
// simple del sistema: "prender 10 min, apagar 15 min", como un temporizador.
//
// !! SEGURIDAD 220V !! El radiador es una carga de 220V conmutada por el
// rele. En el aula, usar una carga de BAJA TENSION (o directamente un LED de
// prueba) para ver el ciclo sin riesgo. La conexion real a 220V queda
// reservada al docente o a una instalacion supervisada, y el rele con su
// cableado de 220V van SIEMPRE fuera de la protoboard (ver README).
//
// Plataforma: ESP32 (DevKit v1).
// Conexion: senal del modulo rele -> GPIO 25. Nota electrica: el ESP32
// trabaja a 3,3 V; usar un modulo rele con entrada compatible con 3,3 V (o
// con optoacoplador) para que conmute de forma confiable.
//
// Basado en: Fragmento de codigo del Nivel Inicial (Paso 4) - Sistema de
// Calefaccion Automatico, Saberes Digitales (INET/EDUCAR 2019)
// Modernizacion: se reemplaza el C generado por mBlock3 (_delay, _loop) por
// C++ idiomatico con constantes nombradas; los tiempos quedan como constantes
// claras en milisegundos, y el estado del rele por constantes invertibles.
// Pin de la senal del modulo rele (GPIO seguro del contrato ESP32).
const int PIN_RELE = 25;
// El modulo rele de la guia es ACTIVO-ALTO: HIGH cierra el contacto y el
// radiador se enciende. Muchos modulos comerciales son activo-bajo: si el
// tuyo enciende al reves, invertí estas dos constantes (ENCENDIDO = LOW /
// APAGADO = HIGH) y el resto del programa no cambia.
const int RELE_ENCENDIDO = HIGH;
const int RELE_APAGADO = LOW;
// Tiempos del ejemplo original: 10 minutos encendido, 15 minutos apagado
// (600 s y 900 s en el PDF, aca expresados en milisegundos).
// NOTA PARA EL AULA: 10 y 15 minutos hacen la demostracion muy lenta. Para
// ver el ciclo en clase, bajá estos valores a algo corto, por ejemplo
// 5000UL / 5000UL (5 s encendido / 5 s apagado); una vez entendido el
// comportamiento, volvé a los tiempos reales.
const unsigned long TIEMPO_ENCENDIDO_MS = 600000UL; // 10 min
const unsigned long TIEMPO_APAGADO_MS = 900000UL; // 15 min
void setup() {
pinMode(PIN_RELE, OUTPUT);
// Arrancamos con el radiador apagado.
digitalWrite(PIN_RELE, RELE_APAGADO);
}
void loop() {
// Encender el radiador y esperar el tiempo de encendido.
digitalWrite(PIN_RELE, RELE_ENCENDIDO);
delay(TIEMPO_ENCENDIDO_MS);
// Apagar el radiador y esperar el tiempo de apagado. En este nivel usamos
// delay(): es la herramienta que ya conocemos y hace que el programa se lea
// de arriba hacia abajo igual que su comportamiento.
digitalWrite(PIN_RELE, RELE_APAGADO);
delay(TIEMPO_APAGADO_MS);
} Podés ver el comportamiento —el radiador encendiéndose y apagándose según el temporizador— en el simulador, antes de armar el circuito real (y con tiempos acelerados para no tener que esperar los minutos reales):
Simulación del comportamiento
La misma máquina de estados del firmware, portada a TypeScript, maneja el
comportamiento del dispositivo. No se ejecuta el binario real: la ejecución
del .hex con avr8js está en el roadmap.
Simulación lista. Presioná «Iniciar» para arrancar la secuencia.
¿Cuánto prendido, cuánto apagado?
Discutan en grupo: los 10 minutos encendido y 15 apagado son un ejemplo. ¿De qué depende el tiempo ideal en una habitación real? Piensen en el tamaño del ambiente, el aislamiento de las paredes y la temperatura de afuera. ¿Qué problema tiene un temporizador “a ciegas” como este, que no sabe qué temperatura hace realmente adentro? Guarden la respuesta: el nivel intermedio la resuelve midiendo la temperatura con un sensor.
Para el aula
El material original de 2019 enseñaba este paso con bloques en mBlock3, hoy discontinuado. La función didáctica de los bloques —bajar la barrera de entrada— la cumple acá la combinación de un código corto con constantes nombradas, comentado, y el simulador en el navegador. La gran limitación del temporizador es un excelente disparador: enciende y apaga por reloj, sin enterarse de si la habitación ya está caliente o si sigue helada. Que los grupos lo noten ahora hace que el salto al termostato del nivel intermedio se sienta como una necesidad, no como un capricho.
Verificá
Con el programa cargado y probando con el LED del pin 13 o una lámpara de baja tensión (no con
220 V): el radiador tiene que encenderse, mantenerse así el tiempo de TIEMPO_ENCENDIDO_MS,
apagarse y mantenerse apagado el tiempo de TIEMPO_APAGADO_MS, y volver a empezar. Para no
esperar los minutos reales durante la prueba, podés bajar temporalmente esas dos constantes a unos
pocos segundos y confirmar que el ciclo se cumple.
Cierre del nivel
Al terminar este nivel, la calefacción de Martina ya funciona sola: la placa comanda el relé y el relé enciende y apaga el radiador siguiendo un temporizador, con los cuidados de seguridad que exige trabajar cerca de 220 V. Además, ya sabés subir programas desde el Arduino IDE 2.x. Pero el temporizador tiene un punto ciego: enciende por reloj, sin saber qué temperatura hace realmente en la habitación. En el nivel intermedio le sumamos un sensor DHT11 para que el sistema decida según la temperatura, un potenciómetro para fijar la temperatura deseada y un display LCD para verla.
Evidencia de cierre
Al terminar este nivel, esto tiene que estar funcionando:
- El módulo relé está conectado a la placa (pin de señal, VCC y GND) y del lado de potencia conmuta la carga del aula (una lámpara de baja tensión o el LED del pin 13), con el circuito de 220 V reservado al docente y fuera de la protoboard.
- Sabés subir un programa desde el Arduino IDE 2.x: elegir la placa, elegir el puerto y verificar que el código quedó cargado.
- La placa enciende el radiador durante TIEMPO_ENCENDIDO_MS (10 minutos) y lo apaga durante TIEMPO_APAGADO_MS (15 minutos), repitiendo el ciclo.
- Entendés por qué el relé permite que la placa de 5 V comande una carga de mayor tensión, y por qué la instalación de 220 V es una tarea exclusiva del docente.