Saltar al contenido
Nivel inicial

Encender y apagar el radiador por tiempo

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é: un interruptor accionado eléctricamente que deja pasar o corta la corriente del radiador según lo que le indique la placa.

Esquema de conexión: una placa Arduino UNO con un cable amarillo desde el pin 3 hasta el pin de señal de un módulo relé azul; la alimentación del módulo va a 5V y GND. Del lado de potencia, el relé intercala sus bornes COM y NO entre un enchufe de 220 V y un radiador eléctrico.
Conexión del nivel inicial (figura original del proyecto): el pin 3 del Arduino comanda el módulo relé, y el relé abre o cierra el paso de corriente del radiador. Atención: el lado de potencia trabaja con 220 V (ver la advertencia de seguridad).

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:

  1. Conectar la placa a la computadora con el cable USB.
  2. Chequear que en el selector de placa del Arduino IDE esté seleccionada la placa correcta.
  3. Seleccionar el puerto al que está conectada la placa.
  4. 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.ino Arduino UNO
// 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.ino ESP32
// 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);
}
El temporizador del radiador: PIN_RELE en ALTO durante TIEMPO_ENCENDIDO_MS (10 min) y en BAJO durante TIEMPO_APAGADO_MS (15 min), en un ciclo que se repite. Cambiá esas dos constantes para ajustar los tiempos a tu habitación.

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.

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.