Domótica con Arduino y sensores: tu guía paso a paso

Si querés saber cómo hacer domótica con Arduino y sensores, llegaste al lugar correcto. Imaginá que tu Arduino detecta que saliste del cuarto y apaga las luces automáticamente. O que te avisa por el celular si la temperatura sube demasiado mientras dormís. Eso no es ciencia ficción ni requiere un presupuesto enorme: es domótica DIY, y podés armarla en un fin de semana con componentes accesibles. Un DHT22 sale alrededor de 3, 5 USD, un LDR menos de 1 USD y un módulo de relé no supera los 2, 3 USD en la mayoría de las tiendas.

Cuando armé mi primer proyecto de automatización del hogar con Arduino, perdí horas comparando datasheets confusos en tiendas de importación genéricas. Encontrar los sensores correctos con especificaciones técnicas reales en especificar.cl me ahorró esa frustración, porque sabía exactamente qué estaba comprando antes de hacer el pedido. En este artículo vas a ver qué componentes necesitás, cómo cablearlos, qué código usar y cómo conectar todo a Home Assistant. El nivel de entrada es simple: si sabés cargar un sketch en el IDE de Arduino y alguna vez hiciste parpadear un LED, estás listo para arrancar.

Qué componentes necesitás para hacer domótica con Arduino y sensores

La buena noticia es que no necesitás una lista interminable de piezas. Un proyecto domótico básico pero funcional se arma con una placa, cuatro sensores y un módulo de relé. Lo importante es entender qué hace cada uno antes de comprar.

La placa central: Arduino Uno o ESP32/ESP8266

El Arduino Uno es el punto de partida más simple: lo conocés, tiene documentación en todos los idiomas posibles y los errores comunes están todos resueltos en foros. Para un prototipo domótico local donde querés encender una luz cuando detectás movimiento, el Uno alcanza perfectamente. El problema aparece cuando querés ver los datos desde tu celular o integrarte con Home Assistant: el Uno no tiene WiFi nativo.

Ahí entra el ESP32. Tiene WiFi y Bluetooth integrados, procesa datos varias veces más rápido que el Uno y tiene suficientes pines GPIO para conectar todos tus sensores sin necesitar multiplexores. Para hacer domótica con Arduino usando MQTT y Home Assistant, el ESP32 es la elección natural desde el principio. El ESP8266 es una alternativa más económica y compacta, aunque con menos pines y memoria.

Los sensores que le dan “ojos” a tu casa

Cuatro sensores cubren la mayoría de los casos de uso domésticos. El DHT22 mide temperatura y humedad con una precisión de ±0.5°C, muy superior al DHT11 (±2°C): esa diferencia importa cuando querés automatizar un ventilador según temperatura real. El HC-SR501 PIR detecta movimiento por infrarrojos pasivos hasta 7 metros de distancia. Es básicamente un sensor que sabe si alguien pasó frente a él y, si lo configurás bien, es increíblemente confiable.

El LDR mide luminosidad de forma analógica: simple, económico y perfecto para decidir si encender una luz según la claridad del ambiente. El HC-SR04 mide distancia por ultrasonidos y sirve para detectar presencia en zonas específicas, como un cajón abierto o una puerta. Con estos cuatro sensores cubrís temperatura, movimiento, luz y distancia: las variables más útiles en cualquier automatización doméstica. Si en algún momento querés sumar detección de gases (humo, GLP), el sensor MQ-2 se integra de forma similar al LDR con una lectura analógica, y es un buen paso siguiente una vez que tengas este proyecto funcionando.

Actuadores: el módulo de relé y por qué importa el aislamiento óptico

El relé es el componente que permite a tu Arduino controlar cargas de 220V AC, como luces o electrodomésticos, sin conectarse directamente a esa tensión. Los módulos de relé modernos incluyen un optoacoplador que separa galvánicamente el circuito de control del circuito de potencia. Eso significa que si algo falla en el lado de 220V, esa falla no puede llegar eléctricamente hasta el Arduino. El LED interno del optoacoplador activa el fototransistor del lado de potencia sin ninguna conexión eléctrica directa: esa barrera es lo que protege tu placa.

Cómo conectar los sensores sin armar un lío de cables

Antes de soldar nada, usá una protoboard con cables Dupont. El objetivo es validar que todo funciona primero, ajustar lo que haga falta y recién entonces pensar en una solución más permanente.

Diagrama de pines: DHT22 y sensor PIR al Arduino

El DHT22 tiene 4 pines. Conectá el Pin 1 (VCC) a 5V, el Pin 2 (DATA) al Pin digital 2 del Arduino, el Pin 3 lo dejás sin conectar y el Pin 4 (GND) a GND. Entre el Pin 2 y el 5V va una resistencia pull-up de 10kΩ: sin ella, la señal de datos flota y obtenés lecturas NaN constantemente. No es opcional.

Para el PIR HC-SR501, la conexión es más directa: VCC a 5V, GND a GND y OUT al Pin 3 del Arduino. Un detalle a tener en cuenta: el HC-SR501 puede tardar varios segundos en estabilizarse al encender (consultá el datasheet de tu modelo específico para el tiempo exacto). Durante ese período inicial puede reportar movimiento aunque no haya nadie. Es normal, no es un defecto.

Conectar el LDR y el sensor ultrasónico HC-SR04

El LDR se conecta en un divisor de voltaje: un extremo va a 5V, el otro al pin A0 del Arduino, y desde ese mismo punto hay una resistencia de 10kΩ hacia GND. La idea es simple: el LDR y la resistencia “compiten” por el voltaje, y esa competencia te da un valor analógico (0 a 1023) proporcional a la cantidad de luz. Es decir: más luz → resistencia LDR más baja → valor más alto en A0.

Para el HC-SR04: VCC a 5V, GND a GND, Trig al Pin 4 y Echo al Pin 5. Advertencia importante si usás ESP32: el Echo del HC-SR04 trabaja a 5V, pero los pines del ESP32 toleran solo 3.3V. Conectarlo directo puede quemar el pin. Necesitás un divisor de voltaje en la línea Echo antes de conectarla al ESP32.

Cablear el módulo de relé de forma segura

La parte de control del relé es sencilla: IN al Pin 6 del Arduino, VCC a 5V y GND a GND. La parte AC (los terminales COM, NO y NC) es el circuito de potencia. Regla número uno: nunca tocar ese bloque con el sistema energizado. Desenchufá todo antes de conectar cualquier cable en esa sección. Muchos módulos de relé comerciales son activos en LOW, lo que confunde al principio: le mandás un LOW al pin y el relé se enciende. Si no estás seguro de cómo funciona tu módulo, revisá el marcado en el PCB o la ficha técnica del fabricante.

El código que hace funcionar todo esto

Antes de subir cualquier código, instalá la librería DHT sensor library de Adafruit desde el Library Manager del Arduino IDE (buscá “DHT sensor library” de Adafruit y seleccioná “Install All” cuando te pida las dependencias). Si te saltás ese paso, el código no compila: el error típico es fatal error: DHT.h: No such file or directory, que no deja muy claro qué está faltando. Es un paso que vale la pena no omitir.

Este es el sketch que lee los cuatro sensores y muestra todo por el Serial Monitor:

#include 

#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

#define PIR_PIN 3
#define LDR_PIN A0
#define TRIG_PIN 4
#define ECHO_PIN 5
#define RELAY_PIN 6

void setup() {
  Serial.begin(9600);
  dht.begin();
  pinMode(PIR_PIN, INPUT);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  pinMode(RELAY_PIN, OUTPUT);
  digitalWrite(RELAY_PIN, HIGH); // relé apagado al inicio
}

void loop() {
  float temp = dht.readTemperature();
  float hum = dht.readHumidity();
  if (isnan(temp) || isnan(hum)) {
    Serial.println("Error DHT22: verificar resistencia pull-up");
  } else {
    int pir = digitalRead(PIR_PIN);
    int luz = analogRead(LDR_PIN);

    digitalWrite(TRIG_PIN, LOW); delayMicroseconds(2);
    digitalWrite(TRIG_PIN, HIGH); delayMicroseconds(10);
    digitalWrite(TRIG_PIN, LOW);
    long duration = pulseIn(ECHO_PIN, HIGH);
    float distancia = duration * 0.034 / 2;

    Serial.print("Temp: "); Serial.print(temp); Serial.print("C | ");
    Serial.print("Hum: "); Serial.print(hum); Serial.print("% | ");
    Serial.print("PIR: "); Serial.print(pir ? "SI" : "NO"); Serial.print(" | ");
    Serial.print("Luz: "); Serial.print(luz); Serial.print(" | ");
    Serial.print("Dist: "); Serial.print(distancia); Serial.println(" cm");

    // Lógica domótica básica
    if (pir == HIGH && luz < 500) {
      digitalWrite(RELAY_PIN, LOW); // enciende luz
    } else {
      digitalWrite(RELAY_PIN, HIGH); // apaga luz
    }

    if (temp > 28) {
      Serial.println("Temperatura alta: activar ventilador");
    }
  }
  delay(2000);
}

La función isnan() detecta cuando el DHT22 retorna un valor inválido y evita que el programa tome decisiones con datos basura. En un proyecto domótico real, una lectura errónea no debería encender ni apagar nada. Para proyectos más complejos con múltiples sensores, reemplazá delay(2000) por lógica basada en millis(): así el programa sigue ejecutándose mientras espera el próximo ciclo de lectura, sin bloquear otras tareas.

Cómo integrar tu proyecto domótico con Arduino en Home Assistant usando MQTT

Una vez que el sistema funciona localmente, el siguiente paso es verlo desde cualquier lugar y crear automatizaciones más inteligentes. Para eso necesitás un ESP32 (o ESP8266), un broker MQTT activo y la integración MQTT habilitada en Home Assistant.

El flujo es simple: el ESP32 publica los datos de los sensores al broker MQTT de Home Assistant, y Home Assistant los muestra como entidades (temperatura, switch, sensor de movimiento) en tu dashboard. La librería ArduinoHA hace todo esto sin que tengas que escribir una sola línea de YAML. Instalala desde el Library Manager buscando “ArduinoHA”. Podés consultar la documentación oficial en el repositorio de ArduinoHA y la guía de MQTT para Home Assistant para entender cómo se generan los topics automáticamente.

Primero, habilitá el add-on Mosquitto broker en Home Assistant desde el panel de integraciones y asegurate de configurar usuario y contraseña. Luego, en tu sketch de ESP32, la conexión básica se ve así (este fragmento asume que ya tenés incluida la librería DHT y creada la instancia dht, tal como aparece en el sketch completo de la sección anterior):

#include 
#include 
#include 

#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

const char* ssid = "tu_wifi";
const char* wifiPass = "tu_password";
const char* mqttServer = "192.168.1.100"; // IP de Home Assistant

WiFiClient wifiClient;
HADevice device("esp32_sala");
HAMqtt mqtt(wifiClient, device);

HASensor tempSensor("temperatura");
HASwitch luzSwitch("luz_sala");

void setup() {
  dht.begin();
  WiFi.begin(ssid, wifiPass);
  while (WiFi.status() != WL_CONNECTED) delay(500);

  tempSensor.setName("Temperatura Sala");
  tempSensor.setUnitOfMeasurement("°C");
  luzSwitch.setName("Luz Sala");

  mqtt.begin(mqttServer, "ha_user", "ha_password");
}

void loop() {
  mqtt.loop();
  // publica temperatura cada ciclo
  tempSensor.setValue(dht.readTemperature());
}

La librería genera automáticamente los topics MQTT siguiendo el estándar de descubrimiento de Home Assistant. No tenés que configurar nada extra: el dispositivo aparece solo en “Configuración › Dispositivos y servicios › MQTT”. Desde tu celular podés ver la temperatura en tiempo real y encender o apagar el relé con un tap.

Seguridad eléctrica y errores frecuentes que hay que evitar

La parte más importante de este proyecto no es el código, es no hacerse daño con los 220V. La regla principal no tiene excepciones: nunca tocar la sección AC del módulo de relé con el circuito energizado. Desenchufá la fuente antes de conectar o desconectar cualquier cable en esa parte. El optoacoplador protege al Arduino de fallas eléctricas del lado de potencia, pero no te protege a vos de un contacto directo con la red.

Para los dimmers AC, usá solo cargas resistivas como bombillas incandescentes de filamento. Las bombillas LED con driver electrónico y las CFL no son compatibles con control de fase: pueden fallar, sobrecalentarse o simplemente no funcionar correctamente.

En el lado del software, usá siempre contraseñas en el broker MQTT. Una red sin autenticación puede ser controlada por cualquier dispositivo en la misma WiFi. Documentá en el código qué pin controla qué carga: en seis meses no vas a recordar por qué el Pin 6 enciende la luz del pasillo, y esa información vale más de lo que pensás.

Dónde conseguir todos los componentes en Chile

Uno de los problemas más comunes al comprar sensores en tiendas genéricas es que las fichas de producto no distinguen entre DHT11 y DHT22, o no documentan el rango de operación real. Comprás un “sensor DHT” y cuando llega resulta que es el modelo menos preciso, incompatible con el código que ya escribiste. En un proyecto domótico, eso no es solo una molestia: es empezar de cero.

especificar.cl tiene disponibles todos los componentes de este proyecto: placas Arduino Uno, ESP32, ESP8266, sensores DHT22, PIR HC-SR501, módulos de relé con optoacoplador y el HC-SR04, cada uno con especificaciones técnicas reales en la ficha de producto. Hacen envíos a todo Chile por Starken, Blue o Chilexpress, con opción de retiro presencial en Placilla, Valparaíso. Si tenés dudas sobre qué versión de un componente comprar, el equipo de asesoría técnica puede orientarte antes de que hagas el pedido.

Por dónde empezar ahora mismo

En resumen, así es cómo hacer domótica con Arduino y sensores: elegís tu placa, cableás los sensores de a uno, subís el sketch y, cuando todo funciona localmente, lo conectás a Home Assistant con MQTT. No necesitás saber todo esto de memoria desde el día uno. La domótica con Arduino se aprende conectando un sensor a la vez y viendo qué pasa.

La recomendación concreta es empezar con el DHT22 solo. Conectalo, instalá la librería de Adafruit, abrí el Serial Monitor y mirá cómo cambian los valores al soplar cerca del sensor. Eso ya es tu sistema domótico funcionando. Después agregás el PIR, después el relé, y en algún momento de ese proceso vas a tener luces que se encienden solas cuando entrás a un cuarto.

Conseguí los componentes en especificar.cl con la tranquilidad de que las especificaciones técnicas son reales y el soporte está disponible si algo no funciona como esperabas. Todo lo que necesitás para arrancar está a un pedido de distancia: el resto lo hacés vos, un sensor a la vez.