Iluminación AC Inteligente con Arduino UNO y Relé – Control Automático

Componentes y materiales

td style="text-align:center">×

Arduino UNO	×	1
Bombilla bajo consumo (E27)	×	1
Adaptador DC 5V	×	1
Cables jumper (genéricos)	×	1
Módulo relé (genérico)	×	1
UTSOURCE Componentes Electrónicos	1

Herramientas y máquinas necesarias

Destornillador (para módulo relé)

Aplicaciones y servicios online

Microsoft Visual Studio 2015	enlace
Arduino IDE	enlace

Sobre este proyecto

Luces de casa inteligentes

Aprenderemos a usar relé con sensor ultrasónico y Arduino para hacer nuestras luces (o cualquier dispositivo) más inteligentes.

Objetivo: bombilla bajo consumo se apaga al salir de la habitación y enciende al entrar. Muy fácil de implementar y poco tiempo.

Asume conocimientos básicos de Arduino. Si lo has usado antes, adelante.

⚠ PRECAUCIÓN: Este proyecto usa alta tensión AC. Si tienes <16 años o poca experiencia, necesitas supervisión experta para la parte AC.

Pero puedes completar el proyecto con dispositivos DC de baja tensión que demuestran el mismo concepto. Avisaré claramente cuando empiece lo peligroso.

Componentes

1. Arduino Uno

   

2. Multímetro

   

3. Cables Jumper

   

4. Protoboard

   

5. Módulo Relé

   

6. Sensor ultrasónico HC-SR04 + librería NewPing para Arduino (aquí). Si es tu primera librería externa: guía.

   

7. Fuente DC (opcional)

   

8. Destornillador (+) para módulo relé

   

9. Bombilla bajo consumo con portalámparas y enchufe (usé cable de radio vieja para el enchufe).

   

10. Pistola pegamento caliente para aislar extremos (mejor cinta aislante).

    

11. Visual Studio para código Arduino (gratis, cómo configurar) o Arduino IDE.

    

¡Empecemos!

Preparando el sensor ultrasónico

Conexión HC-SR04 a Arduino (ver imagen). Luego test del sensor.

Módulo Relé

Conecta un canal (el mío tiene 2): VCC → 5V, IN1 → Pin 8 Arduino (o el que elijas).

Importante: Mi módulo es active-low. Diferencia aquí. Para saber el tuyo: conecta VCC/GND, luego IN a 5V → si no pasa nada, es active-low; confirma conectando IN a GND.

La lámpara

Prepara la lámpara para enchufe y relé: un terminal directo al enchufe; el otro cortado a mitad, un extremo a NO1 (Normalmente Abierto) del relé, el otro a COM1 del relé y de ahí al enchufe.

Circuito final (lámpara simplificada):

Hardware listo. El código:

• Mide distancia ultrasónico
• Detecta si alguien pasa por la puerta
• Conmuta estado de la luz

Leyendo valores del ultrasónico

Ejemplo librería: imprime distancia.

sonar.ping_cm();   // cm
sonar.ping_inch(); // pulgadas

Configura pines y rango máx.

Problema: lecturas espurias ocasionales causan encendido/apagado involuntario.

Solución: media de varias lecturas o filtro mediana (ordena lecturas y toma la central; elimina ruido puntual). NewPing lo trae:

sonar.ping_median(unsigned byte numReadings);

Devuelve tiempo eco → convierte con:

sonar.convert_cm(unsigned int echoTime);
sonar.convert_in(unsigned int echoTime);

Ojo: Lee 0 si nada delante → solucionado poniendo distancia = MAX_DISTANCE si lee 0. Código final lectura (distance variable global):

Detectando paso por la puerta

Ultrasónico debe leer distancia crítica (mitad ancho puerta) para asegurar detección de paso.

La luz solo conmuta al detectar paso; si alguien se queda quieto delante, no hace nada. Código:

¡Felicidades! Adjunto proyecto Visual Studio completo (pequeña edición en librería: memoria dinámica en vez de arrays tamaño variable –VS no permite– y documentación).

Componentes en utsource.net.

Si te sirve, respeta el proyecto. Otros proyectos: Mezclador colores Arduino, Coche RC con 1Sheeld, Artículos: Desarrollando Arduino con Visual Studio.

Código

Smart House Light (Arduino)

Controla relé según lectura ultrasónico:

#define TRIGGER_PIN 12  // Pin trigger ultrasónico
#define ECHO_PIN 11     // Pin echo ultrasónico
#define MAX_DISTANCE 200 // Distancia máx ping (cm). Sensor 400-500cm.
#define RELAY_LINE1_PIN 8

#include "NewPing.h"
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

unsigned int critical_distance_cms = 50; // Distancia umbral conmutación
bool state = 0;

void setup() {
  Serial.begin(9600);
  pinMode(RELAY_LINE1_PIN, OUTPUT);
  digitalWrite(RELAY_LINE1_PIN, HIGH); // Luz OFF (active-low)
}

void loop() {
  delay(50); // 50ms entre pings (~20/s). Mín 29ms.
  unsigned int distance = readDistance();
  Serial.print("Ultrasonico: "); Serial.print(distance); Serial.println("cm");

  // Alguien cerca de la puerta
  if (distance < critical_distance_cms) {
    while (distance < critical_distance_cms) {
      distance = readDistance(); // Espera a que se aleje
      delay(5);
    }
    state = !state; // Cambia estado relé
    if (state) {
      Serial.println("Puerta Abierta!");
      digitalWrite(RELAY_LINE1_PIN, LOW); // Luz ON
    } else {
      Serial.println("Puerta Cerrada!");
      digitalWrite(RELAY_LINE1_PIN, HIGH); // Luz OFF
    }
  }
}

// Actualiza lectura ultrasónico con filtro mediana
unsigned int readDistance() {
  // Mediana de 7 lecturas (elimina ruido)
  unsigned int distance = sonar.convert_cm(sonar.ping_median(7));
  // 0 = nada delante → pon MAX_DISTANCE para no conmutar
  if (distance == 0) distance = MAX_DISTANCE;
  return distance;
}

Test Ultrasónico (Arduino)

Imprime lecturas ultrasónico:

// ---------------------------------------------------------------------------
// Ejemplo NewPing: ping ~20 veces/seg.
// ---------------------------------------------------------------------------
#include <NewPing.h>
#define TRIGGER_PIN 12
#define ECHO_PIN 11
#define MAX_DISTANCE 200
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

void setup() {
  Serial.begin(115200);
}

void loop() {
  delay(50);
  Serial.print("Ping: ");
  Serial.print(sonar.ping_cm());
  Serial.println("cm");
}

Smart House Lights

Proyecto completo Visual Studio con librería editada: GitHub

Esquemáticos