코드 짜기 전에 하드웨어부터 알아야 해. 어떤 보드를 쓰느냐에 따라 코드 스타일도 달라지거든. 🛠️

▶ESP8266 / ESP32

DIY 스마트홈의 국민 보드야. 가격이 저렴하고(ESP32 기준 3,000~6,000원), Wi-Fi가 내장되어 있어서 별도 모듈 없이 바로 인터넷에 연결할 수 있어.
ESP32는 ESP8266의 업그레이드 버전으로 블루투스까지 지원하고, 듀얼 코어 CPU에 더 많은 GPIO 핀을 가지고 있어.

▶라즈베리파이 (Raspberry Pi)

스마트홈의 두뇌 역할을 하는 싱글보드 컴퓨터야. 리눅스가 돌아가기 때문에 Home Assistant, MQTT 브로커, Node-RED 같은 서버 소프트웨어를 직접 돌릴 수 있어.
라즈베리파이 4 기준으로 4GB RAM 모델이 스마트홈 허브로 가장 많이 쓰여.

▶아두이노 (Arduino)

입문자에게 친숙한 보드야. 하지만 기본 아두이노 우노는 Wi-Fi가 없어서 스마트홈에 쓰려면 ESP8266 쉴드나 아두이노 MKR WiFi 1010 같은 Wi-Fi 지원 모델을 써야 해.
요즘은 ESP32가 아두이노 IDE에서도 개발 가능하기 때문에, 아두이노 문법 그대로 ESP32를 쓰는 경우가 많아.

▶주요 부품 목록

자, 이제 진짜 코드 얘기야! 🎉
조명 제어는 스마트홈의 가장 기본이자 가장 많이 쓰이는 기능이야. 크게 세 가지로 나눌 수 있어:

▶기본 LED ON/OFF 제어 (ESP32 + MQTT)

가장 기본적인 예제야. ESP32가 MQTT 브로커에서 메시지를 받아서 LED를 켜고 끄는 코드야.

// ESP32 LED ON/OFF 제어 - MQTT 연동
// 필요 라이브러리: PubSubClient, WiFi

#include <WiFi.h>
#include <PubSubClient.h>

// ===== 설정값 =====
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";  // 라즈베리파이 IP
const int mqtt_port = 1883;
const char* mqtt_client_id = "esp32_light_01";

// MQTT 토픽 정의
const char* topic_light_cmd = "home/livingroom/light/set";    // 명령 수신
const char* topic_light_state = "home/livingroom/light/state"; // 상태 발행

// GPIO 핀 설정
const int LED_PIN = 2;  // ESP32 내장 LED 또는 외부 LED

WiFiClient espClient;
PubSubClient client(espClient);

// ===== Wi-Fi 연결 함수 =====
void setupWiFi() {
  Serial.print("Wi-Fi 연결 중: ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("\nWi-Fi 연결 완료!");
  Serial.print("IP 주소: ");
  Serial.println(WiFi.localIP());
}

// ===== MQTT 메시지 수신 콜백 =====
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  // 수신된 메시지를 문자열로 변환
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  
  Serial.print("메시지 수신 [");
  Serial.print(topic);
  Serial.print("]: ");
  Serial.println(message);
  
  // 조명 제어 토픽 처리
  if (String(topic) == topic_light_cmd) {
    if (message == "ON" || message == "1" || message == "true") {
      digitalWrite(LED_PIN, HIGH);
      client.publish(topic_light_state, "ON");  // 상태 발행
      Serial.println("💡 조명 ON");
    } 
    else if (message == "OFF" || message == "0" || message == "false") {
      digitalWrite(LED_PIN, LOW);
      client.publish(topic_light_state, "OFF");  // 상태 발행
      Serial.println("🌑 조명 OFF");
    }
  }
}

// ===== MQTT 재연결 함수 =====
void reconnectMQTT() {
  while (!client.connected()) {
    Serial.print("MQTT 연결 시도...");
    
    if (client.connect(mqtt_client_id)) {
      Serial.println("연결 성공!");
      // 토픽 구독
      client.subscribe(topic_light_cmd);
      Serial.print("구독 토픽: ");
      Serial.println(topic_light_cmd);
      
      // 연결 시 현재 상태 발행
      int currentState = digitalRead(LED_PIN);
      client.publish(topic_light_state, currentState ? "ON" : "OFF");
    } else {
      Serial.print("연결 실패, rc=");
      Serial.print(client.state());
      Serial.println(" 5초 후 재시도...");
      delay(5000);
    }
  }
}

// ===== setup() =====
void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);  // 초기 상태: OFF
  
  setupWiFi();
  
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(mqttCallback);
}

// ===== loop() =====
void loop() {
  if (!client.connected()) {
    reconnectMQTT();
  }
  client.loop();  // MQTT 메시지 처리
}

▶PWM 밝기 조절 제어

단순 ON/OFF를 넘어서 밝기를 0~255 단계로 조절하는 코드야.
MQTT 메시지로 밝기 값(0~255)을 받아서 PWM으로 LED 밝기를 제어해.

// ESP32 PWM 밝기 조절 - MQTT 연동
// JSON 형식 메시지 처리 포함
// 필요 라이브러리: PubSubClient, WiFi, ArduinoJson

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";

// MQTT 토픽
const char* topic_light_cmd = "home/bedroom/light/set";
const char* topic_light_state = "home/bedroom/light/state";

// PWM 설정 (ESP32 LEDC)
const int LED_PIN = 18;
const int PWM_CHANNEL = 0;
const int PWM_FREQ = 5000;    // 5kHz
const int PWM_RESOLUTION = 8; // 8비트 = 0~255

int currentBrightness = 0;
bool lightState = false;

WiFiClient espClient;
PubSubClient client(espClient);

// 상태 JSON 발행 함수
void publishState() {
  StaticJsonDocument<128> doc;
  doc["state"] = lightState ? "ON" : "OFF";
  doc["brightness"] = currentBrightness;
  
  char buffer[128];
  serializeJson(doc, buffer);
  client.publish(topic_light_state, buffer, true); // retain=true
  
  Serial.print("상태 발행: ");
  Serial.println(buffer);
}

// MQTT 콜백
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  
  Serial.print("수신: ");
  Serial.println(message);
  
  // JSON 파싱
  StaticJsonDocument<128> doc;
  DeserializationError error = deserializeJson(doc, message);
  
  if (!error) {
    // JSON 형식: {"state": "ON", "brightness": 128}
    if (doc.containsKey("state")) {
      String state = doc["state"].as<String>();
      lightState = (state == "ON");
    }
    
    if (doc.containsKey("brightness")) {
      currentBrightness = doc["brightness"].as<int>();
      currentBrightness = constrain(currentBrightness, 0, 255);
    }
  } else {
    // 단순 문자열 처리
    if (message == "ON") {
      lightState = true;
      if (currentBrightness == 0) currentBrightness = 255;
    } else if (message == "OFF") {
      lightState = false;
    }
  }
  
  // PWM 출력 적용
  int pwmValue = lightState ? currentBrightness : 0;
  ledcWrite(PWM_CHANNEL, pwmValue);
  
  Serial.print("PWM 출력: ");
  Serial.println(pwmValue);
  
  publishState();
}

void reconnectMQTT() {
  while (!client.connected()) {
    if (client.connect("esp32_bedroom_light")) {
      client.subscribe(topic_light_cmd);
      publishState();
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  
  // ESP32 LEDC PWM 설정
  ledcSetup(PWM_CHANNEL, PWM_FREQ, PWM_RESOLUTION);
  ledcAttachPin(LED_PIN, PWM_CHANNEL);
  ledcWrite(PWM_CHANNEL, 0);  // 초기값 0 (OFF)
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer(mqtt_server, 1883);
  client.setCallback(mqttCallback);
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
}

▶WS2812B RGB LED 스트립 제어

이제 진짜 화려한 거야! 🌈 WS2812B는 각 LED를 개별적으로 제어할 수 있는 어드레서블 LED야.
FastLED 라이브러리를 사용하면 엄청 쉽게 제어할 수 있어.

// ESP32 WS2812B RGB LED 스트립 제어 - MQTT 연동
// 필요 라이브러리: PubSubClient, WiFi, FastLED, ArduinoJson

#include <WiFi.h>
#include <PubSubClient.h>
#include <FastLED.h>
#include <ArduinoJson.h>

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";

// LED 스트립 설정
#define LED_PIN     5
#define NUM_LEDS    60    // LED 개수 (1m 기준 60개)
#define LED_TYPE    WS2812B
#define COLOR_ORDER GRB   // WS2812B는 GRB 순서!

CRGB leds[NUM_LEDS];

// MQTT 토픽
const char* topic_rgb_cmd = "home/livingroom/rgb/set";
const char* topic_rgb_state = "home/livingroom/rgb/state";

// 현재 상태
bool rgbState = false;
int brightness = 128;
int r = 255, g = 255, b = 255;  // 기본 흰색
String effect = "solid";  // 효과: solid, rainbow, pulse

WiFiClient espClient;
PubSubClient client(espClient);

// 효과 변수
unsigned long lastEffectUpdate = 0;
int hue = 0;

// 무지개 효과
void rainbowEffect() {
  if (millis() - lastEffectUpdate > 20) {
    for (int i = 0; i < NUM_LEDS; i++) {
      leds[i] = CHSV(hue + (i * 256 / NUM_LEDS), 255, brightness);
    }
    FastLED.show();
    hue++;
    lastEffectUpdate = millis();
  }
}

// 펄스 효과
void pulseEffect() {
  static int pulseVal = 0;
  static int pulseDir = 1;
  
  if (millis() - lastEffectUpdate > 15) {
    pulseVal += pulseDir * 3;
    if (pulseVal >= 255) { pulseVal = 255; pulseDir = -1; }
    if (pulseVal <= 0)   { pulseVal = 0;   pulseDir = 1;  }
    
    fill_solid(leds, NUM_LEDS, CRGB(
      map(pulseVal, 0, 255, 0, r),
      map(pulseVal, 0, 255, 0, g),
      map(pulseVal, 0, 255, 0, b)
    ));
    FastLED.show();
    lastEffectUpdate = millis();
  }
}

// 상태 발행
void publishRGBState() {
  StaticJsonDocument<256> doc;
  doc["state"] = rgbState ? "ON" : "OFF";
  doc["brightness"] = brightness;
  
  JsonObject color = doc.createNestedObject("color");
  color["r"] = r;
  color["g"] = g;
  color["b"] = b;
  
  doc["effect"] = effect;
  
  char buffer[256];
  serializeJson(doc, buffer);
  client.publish(topic_rgb_state, buffer, true);
}

// MQTT 콜백
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  
  StaticJsonDocument<256> doc;
  if (deserializeJson(doc, message)) return;
  
  // 상태 처리
  if (doc.containsKey("state")) {
    rgbState = (String(doc["state"].as<const char*>()) == "ON");
  }
  
  // 밝기 처리
  if (doc.containsKey("brightness")) {
    brightness = constrain(doc["brightness"].as<int>(), 0, 255);
    FastLED.setBrightness(brightness);
  }
  
  // 색상 처리
  if (doc.containsKey("color")) {
    r = doc["color"]["r"] | 255;
    g = doc["color"]["g"] | 255;
    b = doc["color"]["b"] | 255;
  }
  
  // 효과 처리
  if (doc.containsKey("effect")) {
    effect = doc["effect"].as<String>();
  }
  
  // 즉시 적용 (solid 효과)
  if (!rgbState) {
    fill_solid(leds, NUM_LEDS, CRGB::Black);
    FastLED.show();
  } else if (effect == "solid") {
    fill_solid(leds, NUM_LEDS, CRGB(r, g, b));
    FastLED.show();
  }
  
  publishRGBState();
}

void reconnectMQTT() {
  while (!client.connected()) {
    if (client.connect("esp32_rgb_strip")) {
      client.subscribe(topic_rgb_cmd);
      publishRGBState();
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  
  // FastLED 초기화
  FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);
  FastLED.setBrightness(brightness);
  fill_solid(leds, NUM_LEDS, CRGB::Black);
  FastLED.show();
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer(mqtt_server, 1883);
  client.setCallback(mqttCallback);
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
  
  // 효과 처리 (loop에서 지속 실행)
  if (rgbState) {
    if (effect == "rainbow") rainbowEffect();
    else if (effect == "pulse") pulseEffect();
  }
}

조명 다음은 전원 제어야. 릴레이 모듈을 사용하면 220V AC 전원도 ESP32로 제어할 수 있어.
물론 고전압 작업이니까 안전에 각별히 주의해야 해! ⚠️

▶릴레이 모듈 기본 제어

릴레이는 전자석을 이용해서 기계적 스위치를 ON/OFF하는 부품이야.
5V 릴레이 모듈은 ESP32의 3.3V GPIO로도 제어 가능한 모델을 사용해야 해 (로직 레벨 변환 내장 모델).

// ESP32 릴레이 제어 - 다중 채널 + MQTT
// 4채널 릴레이 모듈 예제

#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";

// 릴레이 핀 설정 (4채널)
const int RELAY_PINS[] = {26, 27, 14, 12};
const int RELAY_COUNT = 4;

// 릴레이 이름 (MQTT 토픽용)
const char* RELAY_NAMES[] = {
  "outlet1",   // 콘센트 1
  "outlet2",   // 콘센트 2  
  "fan",       // 선풍기
  "heater"     // 히터
};

// 릴레이 상태 저장
bool relayStates[4] = {false, false, false, false};

// 릴레이 타입: true = 활성화 HIGH, false = 활성화 LOW (모듈에 따라 다름)
// 대부분의 중국산 릴레이 모듈은 LOW 활성화!
const bool RELAY_ACTIVE_HIGH = false;

WiFiClient espClient;
PubSubClient client(espClient);

// 릴레이 제어 함수
void setRelay(int index, bool state) {
  if (index < 0 || index >= RELAY_COUNT) return;
  
  relayStates[index] = state;
  
  // 활성화 레벨에 따른 출력
  if (RELAY_ACTIVE_HIGH) {
    digitalWrite(RELAY_PINS[index], state ? HIGH : LOW);
  } else {
    // LOW 활성화 (대부분의 릴레이 모듈)
    digitalWrite(RELAY_PINS[index], state ? LOW : HIGH);
  }
  
  // 상태 발행
  char topic[64];
  snprintf(topic, sizeof(topic), "home/power/%s/state", RELAY_NAMES[index]);
  client.publish(topic, state ? "ON" : "OFF", true);
  
  Serial.printf("릴레이 %d (%s): %s\n", 
    index + 1, RELAY_NAMES[index], state ? "ON" : "OFF");
}

// MQTT 콜백
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String topicStr = String(topic);
  String message = "";
  for (int i = 0; i < length; i++) {
    message += (char)payload[i];
  }
  
  // 토픽 파싱: home/power/{name}/set
  for (int i = 0; i < RELAY_COUNT; i++) {
    char expectedTopic[64];
    snprintf(expectedTopic, sizeof(expectedTopic), 
             "home/power/%s/set", RELAY_NAMES[i]);
    
    if (topicStr == expectedTopic) {
      if (message == "ON" || message == "1") {
        setRelay(i, true);
      } else if (message == "OFF" || message == "0") {
        setRelay(i, false);
      } else if (message == "TOGGLE") {
        setRelay(i, !relayStates[i]);
      }
      break;
    }
  }
  
  // 전체 제어: home/power/all/set
  if (topicStr == "home/power/all/set") {
    bool state = (message == "ON");
    for (int i = 0; i < RELAY_COUNT; i++) {
      setRelay(i, state);
    }
  }
}

// 타이머 기반 자동 OFF 기능
struct RelayTimer {
  bool active;
  unsigned long offTime;
};
RelayTimer timers[4] = {{false,0},{false,0},{false,0},{false,0}};

void setRelayTimer(int index, int seconds) {
  timers[index].active = true;
  timers[index].offTime = millis() + (seconds * 1000UL);
  setRelay(index, true);
  Serial.printf("릴레이 %d: %d초 후 자동 OFF\n", index+1, seconds);
}

void checkTimers() {
  for (int i = 0; i < RELAY_COUNT; i++) {
    if (timers[i].active && millis() >= timers[i].offTime) {
      timers[i].active = false;
      setRelay(i, false);
      Serial.printf("릴레이 %d: 타이머 OFF\n", i+1);
    }
  }
}

void reconnectMQTT() {
  while (!client.connected()) {
    if (client.connect("esp32_relay_controller")) {
      // 모든 릴레이 토픽 구독
      for (int i = 0; i < RELAY_COUNT; i++) {
        char topic[64];
        snprintf(topic, sizeof(topic), "home/power/%s/set", RELAY_NAMES[i]);
        client.subscribe(topic);
      }
      client.subscribe("home/power/all/set");
      
      // 현재 상태 발행
      for (int i = 0; i < RELAY_COUNT; i++) {
        char topic[64];
        snprintf(topic, sizeof(topic), "home/power/%s/state", RELAY_NAMES[i]);
        client.publish(topic, relayStates[i] ? "ON" : "OFF", true);
      }
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  
  // 릴레이 핀 초기화
  for (int i = 0; i < RELAY_COUNT; i++) {
    pinMode(RELAY_PINS[i], OUTPUT);
    // LOW 활성화 릴레이는 초기값 HIGH (OFF 상태)
    digitalWrite(RELAY_PINS[i], RELAY_ACTIVE_HIGH ? LOW : HIGH);
    relayStates[i] = false;
  }
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  Serial.println("Wi-Fi 연결 완료");
  
  client.setServer(mqtt_server, 1883);
  client.setCallback(mqttCallback);
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
  checkTimers();  // 타이머 체크
}

▶Tasmota 펌웨어 활용 (스마트 플러그)

직접 코드를 짜는 것 외에도, Tasmota라는 오픈소스 펌웨어를 ESP8266/ESP32 기반 스마트 플러그에 플래싱해서 사용하는 방법도 있어.
Tasmota는 MQTT를 기본 지원하고, Home Assistant와 자동 연동되는 강력한 펌웨어야.

Tasmota가 발행하는 상태 메시지 예시:

// Tasmota 상태 메시지 예시 (JSON)
// 토픽: stat/tasmota_XXXXXX/POWER

{
  "Time": "2024-01-15T14:30:00",
  "POWER": "ON"
}

// 에너지 모니터링 메시지 (전력 측정 모델)
// 토픽: tele/tasmota_XXXXXX/SENSOR

{
  "Time": "2024-01-15T14:30:10",
  "ENERGY": {
    "TotalStartTime": "2024-01-01T00:00:00",
    "Total": 12.345,        // 총 소비 전력량 (kWh)
    "Yesterday": 0.234,     // 어제 소비량 (kWh)
    "Today": 0.089,         // 오늘 소비량 (kWh)
    "Period": 0,
    "Power": 45,            // 현재 소비 전력 (W)
    "ApparentPower": 48,
    "ReactivePower": 16,
    "Factor": 0.94,         // 역률
    "Voltage": 220,         // 전압 (V)
    "Current": 0.218        // 전류 (A)
  }
}

센서는 스마트홈의 눈과 귀야. 센서 데이터를 기반으로 자동화 규칙을 만들 수 있거든.
"온도가 28도 이상이면 에어컨 켜기", "움직임 감지되면 조명 켜기" 같은 것들이 다 센서 덕분에 가능해! 🎯

▶DHT22 온도/습도 센서

DHT22는 가장 많이 쓰이는 온습도 센서야. DHT11보다 정확도가 높고 측정 범위도 넓어.
(DHT11: 온도 0~50°C, 습도 20~80% / DHT22: 온도 -40~80°C, 습도 0~100%)

// ESP32 DHT22 온습도 센서 - MQTT 발행
// 필요 라이브러리: PubSubClient, WiFi, DHT sensor library, ArduinoJson

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>
#include <ArduinoJson.h>

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";

// DHT 설정
#define DHT_PIN  4
#define DHT_TYPE DHT22
DHT dht(DHT_PIN, DHT_TYPE);

// MQTT 토픽
const char* topic_sensor = "home/sensor/livingroom/climate";
const char* topic_temp   = "home/sensor/livingroom/temperature";
const char* topic_humi   = "home/sensor/livingroom/humidity";

// 발행 주기 (30초)
const unsigned long PUBLISH_INTERVAL = 30000;
unsigned long lastPublish = 0;

WiFiClient espClient;
PubSubClient client(espClient);

// 센서 데이터 읽기 및 발행
void readAndPublishSensor() {
  // DHT22는 읽기 실패 시 NaN 반환
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();
  
  // 유효성 검사
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("DHT22 읽기 실패!");
    return;
  }
  
  // 열지수(Heat Index) 계산
  float heatIndex = dht.computeHeatIndex(temperature, humidity, false);
  
  Serial.printf("온도: %.1f°C, 습도: %.1f%%, 열지수: %.1f°C\n", 
    temperature, humidity, heatIndex);
  
  // JSON 형식으로 발행 (통합 토픽)
  StaticJsonDocument<256> doc;
  doc["temperature"] = round(temperature * 10) / 10.0;  // 소수점 1자리
  doc["humidity"] = round(humidity * 10) / 10.0;
  doc["heat_index"] = round(heatIndex * 10) / 10.0;
  doc["unit"] = "celsius";
  
  char buffer[256];
  serializeJson(doc, buffer);
  client.publish(topic_sensor, buffer, true);
  
  // 개별 토픽으로도 발행 (Home Assistant 자동 발견용)
  char tempStr[8], humiStr[8];
  dtostrf(temperature, 4, 1, tempStr);
  dtostrf(humidity, 4, 1, humiStr);
  client.publish(topic_temp, tempStr, true);
  client.publish(topic_humi, humiStr, true);
}

void reconnectMQTT() {
  while (!client.connected()) {
    if (client.connect("esp32_climate_sensor")) {
      Serial.println("MQTT 연결 완료");
      readAndPublishSensor();  // 연결 즉시 발행
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer(mqtt_server, 1883);
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
  
  // 주기적 발행
  if (millis() - lastPublish >= PUBLISH_INTERVAL) {
    lastPublish = millis();
    readAndPublishSensor();
  }
}

▶PIR 움직임 감지 센서 (HC-SR501)

PIR(Passive Infrared) 센서는 사람의 체온(적외선)을 감지해서 움직임을 탐지해.
현관이나 복도에 설치해서 "사람이 오면 조명 켜기" 같은 자동화에 딱이야!

// ESP32 PIR 움직임 감지 - MQTT 연동
// HC-SR501 센서 사용

#include <WiFi.h>
#include <PubSubClient.h>

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";

// PIR 핀 설정
const int PIR_PIN = 13;

// MQTT 토픽
const char* topic_motion = "home/sensor/hallway/motion";
const char* topic_motion_count = "home/sensor/hallway/motion_count";

// 상태 변수
bool lastMotionState = false;
int motionCount = 0;
unsigned long lastMotionTime = 0;
const unsigned long MOTION_COOLDOWN = 5000;  // 5초 쿨다운

// 인터럽트 플래그
volatile bool motionDetected = false;

WiFiClient espClient;
PubSubClient client(espClient);

// PIR 인터럽트 핸들러
void IRAM_ATTR onMotionDetected() {
  motionDetected = true;
}

void publishMotionState(bool state) {
  client.publish(topic_motion, state ? "ON" : "OFF", true);
  
  if (state) {
    motionCount++;
    char countStr[8];
    itoa(motionCount, countStr, 10);
    client.publish(topic_motion_count, countStr, true);
    
    Serial.printf("🚶 움직임 감지! (총 %d회)\n", motionCount);
  } else {
    Serial.println("😴 움직임 없음");
  }
}

void reconnectMQTT() {
  while (!client.connected()) {
    if (client.connect("esp32_pir_sensor")) {
      client.publish(topic_motion, "OFF", true);
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  
  // PIR 핀 설정 (인터럽트 사용)
  pinMode(PIR_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(PIR_PIN), onMotionDetected, CHANGE);
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer(mqtt_server, 1883);
  
  // HC-SR501 워밍업 대기 (약 60초)
  Serial.println("PIR 센서 워밍업 중... (60초)");
  delay(60000);
  Serial.println("준비 완료!");
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
  
  // 인터럽트 플래그 처리
  if (motionDetected) {
    motionDetected = false;
    
    bool currentState = digitalRead(PIR_PIN);
    
    // 상태 변화 감지
    if (currentState != lastMotionState) {
      // 쿨다운 체크 (연속 감지 방지)
      if (currentState || (millis() - lastMotionTime > MOTION_COOLDOWN)) {
        lastMotionState = currentState;
        if (currentState) lastMotionTime = millis();
        publishMotionState(currentState);
      }
    }
  }
}

▶BH1750 조도 센서

조도 센서는 주변 밝기를 측정해서 "어두워지면 조명 켜기" 같은 자동화에 사용해.
BH1750은 I2C 통신을 사용하는 디지털 조도 센서야. 측정 범위는 1~65535 lux.

// ESP32 BH1750 조도 센서 - MQTT 연동
// I2C 통신 사용
// 필요 라이브러리: BH1750, PubSubClient, WiFi

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <BH1750.h>

const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100";

// I2C 핀 (ESP32 기본: SDA=21, SCL=22)
const int SDA_PIN = 21;
const int SCL_PIN = 22;

BH1750 lightMeter;

// MQTT 토픽
const char* topic_lux = "home/sensor/livingroom/illuminance";
const char* topic_lux_state = "home/sensor/livingroom/light_state";

// 조도 임계값 (자동화 기준)
const float LUX_DARK = 50.0;    // 50 lux 이하: 어두움
const float LUX_DIM = 200.0;    // 200 lux 이하: 흐림
const float LUX_BRIGHT = 500.0; // 500 lux 이상: 밝음

const unsigned long PUBLISH_INTERVAL = 10000;  // 10초
unsigned long lastPublish = 0;

WiFiClient espClient;
PubSubClient client(espClient);

String getLightState(float lux) {
  if (lux < LUX_DARK) return "dark";
  else if (lux < LUX_DIM) return "dim";
  else if (lux < LUX_BRIGHT) return "normal";
  else return "bright";
}

void readAndPublishLux() {
  float lux = lightMeter.readLightLevel();
  
  if (lux < 0) {
    Serial.println("BH1750 읽기 실패!");
    return;
  }
  
  String lightState = getLightState(lux);
  
  Serial.printf("조도: %.1f lux (%s)\n", lux, lightState.c_str());
  
  // 조도값 발행
  char luxStr[10];
  dtostrf(lux, 5, 1, luxStr);
  client.publish(topic_lux, luxStr, true);
  
  // 조도 상태 발행
  client.publish(topic_lux_state, lightState.c_str(), true);
}

void reconnectMQTT() {
  while (!client.connected()) {
    if (client.connect("esp32_light_sensor")) {
      readAndPublishLux();
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  
  Wire.begin(SDA_PIN, SCL_PIN);
  
  if (!lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE)) {
    Serial.println("BH1750 초기화 실패!");
    while (1);
  }
  Serial.println("BH1750 초기화 완료");
  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer(mqtt_server, 1883);
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
  
  if (millis() - lastPublish >= PUBLISH_INTERVAL) {
    lastPublish = millis();
    readAndPublishLux();
  }
}

MQTT(Message Queuing Telemetry Transport)는 IoT에서 가장 많이 쓰이는 경량 메시지 프로토콜이야.
HTTP보다 훨씬 가볍고, 저전력 기기에서도 잘 동작해. 발행(Publish)/구독(Subscribe) 패턴을 사용해. 📨

▶Mosquitto MQTT 브로커 설치 (라즈베리파이)

# 라즈베리파이에 Mosquitto 설치
sudo apt update
sudo apt install -y mosquitto mosquitto-clients

# 서비스 시작 및 자동 시작 설정
sudo systemctl start mosquitto
sudo systemctl enable mosquitto

# 상태 확인
sudo systemctl status mosquitto

# /etc/mosquitto/mosquitto.conf 설정 파일 편집
sudo nano /etc/mosquitto/conf.d/default.conf

# 아래 내용 추가:
listener 1883
allow_anonymous true  # 개발용 (운영 시 반드시 인증 설정!)

# 로그 설정
log_dest file /var/log/mosquitto/mosquitto.log
log_type all

# 저장 후 재시작
sudo systemctl restart mosquitto

# 테스트: 터미널 1 - 구독
mosquitto_sub -h localhost -t "home/#" -v

# 테스트: 터미널 2 - 발행
mosquitto_pub -h localhost -t "home/test" -m "Hello IoT!"

# 조명 제어 테스트
mosquitto_pub -h 192.168.1.100 -t "home/livingroom/light/set" -m "ON"
mosquitto_pub -h 192.168.1.100 -t "home/livingroom/rgb/set" \
  -m '{"state":"ON","brightness":200,"color":{"r":255,"g":100,"b":50}}'

▶MQTT 토픽 설계 규칙

토픽 구조를 잘 설계해야 나중에 관리하기 편해. 일반적으로 이런 구조를 따라:

▶Last Will and Testament (LWT) — 기기 오프라인 감지

LWT는 기기가 예기치 않게 연결이 끊겼을 때 브로커가 자동으로 메시지를 발행하는 기능이야.
기기가 오프라인인지 온라인인지 실시간으로 알 수 있어.

// LWT (Last Will and Testament) 설정 예제
// ESP32가 갑자기 연결이 끊기면 브로커가 자동으로 "offline" 메시지 발행

#include <WiFi.h>
#include <PubSubClient.h>

const char* mqtt_server = "192.168.1.100";
const char* device_id = "esp32_livingroom_01";

// LWT 토픽 및 메시지
char lwt_topic[64];
const char* lwt_message = "offline";
const char* online_message = "online";

WiFiClient espClient;
PubSubClient client(espClient);

void reconnectMQTT() {
  // LWT 토픽 생성
  snprintf(lwt_topic, sizeof(lwt_topic), "home/status/%s", device_id);
  
  while (!client.connected()) {
    // connect() 함수에 LWT 파라미터 추가
    // connect(clientId, username, password, willTopic, willQos, willRetain, willMessage)
    if (client.connect(
          device_id,          // 클라이언트 ID
          NULL,               // 사용자명 (없으면 NULL)
          NULL,               // 비밀번호 (없으면 NULL)
          lwt_topic,          // LWT 토픽
          1,                  // QoS 1
          true,               // retain
          lwt_message         // LWT 메시지
        )) {
      
      // 연결 성공 시 온라인 상태 발행
      client.publish(lwt_topic, online_message, true);
      Serial.println("MQTT 연결 완료 - 온라인 상태 발행");
      
      // 토픽 구독
      client.subscribe("home/livingroom/light/set");
      
    } else {
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  WiFi.begin("YOUR_SSID", "YOUR_PASSWORD");
  while (WiFi.status() != WL_CONNECTED) delay(500);
  
  client.setServer(mqtt_server, 1883);
  // 콜백 설정...
}

void loop() {
  if (!client.connected()) reconnectMQTT();
  client.loop();
}

Home Assistant(HA)는 오픈소스 스마트홈 플랫폼의 끝판왕이야. 🏆
라즈베리파이에 설치하면 수천 가지 기기와 서비스를 통합 관리할 수 있어.
MQTT Discovery 기능을 사용하면 ESP32 기기가 자동으로 HA에 등록돼!

▶Home Assistant 설치 (라즈베리파이)

# Home Assistant OS 설치 방법 (권장)
# 1. https://www.home-assistant.io/installation/ 에서 라즈베리파이용 이미지 다운로드
# 2. Raspberry Pi Imager로 SD카드에 플래싱
# 3. 라즈베리파이 부팅 후 http://homeassistant.local:8123 접속

# 또는 Docker로 설치 (기존 라즈베리파이 OS에서)
docker run -d \
  --name homeassistant \
  --privileged \
  --restart=unless-stopped \
  -e TZ=Asia/Seoul \
  -v /home/pi/homeassistant:/config \
  --network=host \
  ghcr.io/home-assistant/home-assistant:stable

▶MQTT 통합 설정 (configuration.yaml)

HA에서 MQTT 기기를 수동으로 등록하는 방법이야.
configuration.yaml 파일에 기기 정보를 추가해줘.

# /config/configuration.yaml

# MQTT 브로커 설정 (HA UI에서도 설정 가능)
mqtt:
  broker: 192.168.1.100
  port: 1883
  username: ""
  password: ""

# 조명 엔티티 등록
light:
  # 단순 ON/OFF 조명
  - platform: mqtt
    name: "거실 조명"
    unique_id: "livingroom_light_01"
    state_topic: "home/livingroom/light/state"
    command_topic: "home/livingroom/light/set"
    payload_on: "ON"
    payload_off: "OFF"
    retain: true
    
  # 밝기 조절 가능한 조명
  - platform: mqtt
    name: "침실 조명"
    unique_id: "bedroom_light_01"
    state_topic: "home/bedroom/light/state"
    command_topic: "home/bedroom/light/set"
    brightness_state_topic: "home/bedroom/light/state"
    brightness_command_topic: "home/bedroom/light/set"
    brightness_value_template: "{{ value_json.brightness }}"
    state_value_template: "{{ value_json.state }}"
    on_command_type: "brightness"
    retain: true
    
  # RGB LED 스트립
  - platform: mqtt
    name: "거실 RGB 스트립"
    unique_id: "livingroom_rgb_01"
    state_topic: "home/livingroom/rgb/state"
    command_topic: "home/livingroom/rgb/set"
    state_value_template: "{{ value_json.state }}"
    brightness_state_topic: "home/livingroom/rgb/state"
    brightness_value_template: "{{ value_json.brightness }}"
    rgb_state_topic: "home/livingroom/rgb/state"
    rgb_value_template: >
      {{ value_json.color.r }},
      {{ value_json.color.g }},
      {{ value_json.color.b }}
    effect_state_topic: "home/livingroom/rgb/state"
    effect_value_template: "{{ value_json.effect }}"
    effect_list:
      - solid
      - rainbow
      - pulse
    retain: true

# 스위치 (전원 제어)
switch:
  - platform: mqtt
    name: "콘센트 1"
    unique_id: "outlet_01"
    state_topic: "home/power/outlet1/state"
    command_topic: "home/power/outlet1/set"
    payload_on: "ON"
    payload_off: "OFF"
    retain: true
    
  - platform: mqtt
    name: "선풍기"
    unique_id: "fan_01"
    state_topic: "home/power/fan/state"
    command_topic: "home/power/fan/set"
    payload_on: "ON"
    payload_off: "OFF"
    retain: true

# 센서 등록
sensor:
  - platform: mqtt
    name: "거실 온도"
    unique_id: "livingroom_temperature"
    state_topic: "home/sensor/livingroom/temperature"
    unit_of_measurement: "°C"
    device_class: temperature
    value_template: "{{ value | float | round(1) }}"
    
  - platform: mqtt
    name: "거실 습도"
    unique_id: "livingroom_humidity"
    state_topic: "home/sensor/livingroom/humidity"
    unit_of_measurement: "%"
    device_class: humidity
    value_template: "{{ value | float | round(1) }}"
    
  - platform: mqtt
    name: "거실 조도"
    unique_id: "livingroom_illuminance"
    state_topic: "home/sensor/livingroom/illuminance"
    unit_of_measurement: "lx"
    device_class: illuminance

# 이진 센서 (PIR 움직임 감지)
binary_sensor:
  - platform: mqtt
    name: "복도 움직임"
    unique_id: "hallway_motion"
    state_topic: "home/sensor/hallway/motion"
    payload_on: "ON"
    payload_off: "OFF"
    device_class: motion

▶MQTT Discovery — 자동 기기 등록

수동으로 configuration.yaml을 편집하는 대신, ESP32에서 특정 형식의 메시지를 발행하면 HA가 자동으로 기기를 인식하는 MQTT Discovery 기능을 사용할 수 있어!

// ESP32 MQTT Discovery 자동 등록 예제
// Home Assistant가 자동으로 기기를 인식함

void publishDiscovery() {
  // 조명 Discovery 메시지
  // 토픽: homeassistant/light/{unique_id}/config
  
  StaticJsonDocument<512> lightDoc;
  lightDoc["name"] = "거실 조명";
  lightDoc["unique_id"] = "esp32_livingroom_light";
  lightDoc["state_topic"] = "home/livingroom/light/state";
  lightDoc["command_topic"] = "home/livingroom/light/set";
  lightDoc["brightness_state_topic"] = "home/livingroom/light/state";
  lightDoc["brightness_command_topic"] = "home/livingroom/light/set";
  lightDoc["brightness_value_template"] = "{{ value_json.brightness }}";
  lightDoc["state_value_template"] = "{{ value_json.state }}";
  lightDoc["payload_on"] = "ON";
  lightDoc["payload_off"] = "OFF";
  
  // 기기 정보 (같은 기기의 여러 엔티티를 묶어줌)
  JsonObject device = lightDoc.createNestedObject("device");
  device["identifiers"][0] = "esp32_livingroom_01";
  device["name"] = "거실 ESP32";
  device["model"] = "ESP32 DevKit";
  device["manufacturer"] = "DIY";
  device["sw_version"] = "1.0.0";
  
  char buffer[512];
  serializeJson(lightDoc, buffer);
  
  // retain=true 로 발행 (HA 재시작 후에도 유지)
  client.publish(
    "homeassistant/light/esp32_livingroom_light/config",
    buffer,
    true  // retain
  );
  
  Serial.println("Discovery 메시지 발행 완료!");
  
  // 센서 Discovery 메시지
  StaticJsonDocument<512> sensorDoc;
  sensorDoc["name"] = "거실 온도";
  sensorDoc["unique_id"] = "esp32_livingroom_temp";
  sensorDoc["state_topic"] = "home/sensor/livingroom/temperature";
  sensorDoc["unit_of_measurement"] = "°C";
  sensorDoc["device_class"] = "temperature";
  sensorDoc["value_template"] = "{{ value | float | round(1) }}";
  
  JsonObject sensorDevice = sensorDoc.createNestedObject("device");
  sensorDevice["identifiers"][0] = "esp32_livingroom_01";
  sensorDevice["name"] = "거실 ESP32";
  
  char sensorBuffer[512];
  serializeJson(sensorDoc, sensorBuffer);
  
  client.publish(
    "homeassistant/sensor/esp32_livingroom_temp/config",
    sensorBuffer,
    true
  );
}

▶Home Assistant 자동화 예제

HA의 자동화 기능으로 센서 데이터에 따라 기기를 자동 제어할 수 있어.

# /config/automations.yaml

# 자동화 1: 움직임 감지 시 복도 조명 켜기
- id: "motion_light_hallway"
  alias: "복도 움직임 감지 조명 자동화"
  description: "PIR 센서 감지 시 복도 조명 켜고, 5분 후 자동 끄기"
  trigger:
    - platform: state
      entity_id: binary_sensor.복도_움직임
      to: "on"
  action:
    - service: light.turn_on
      target:
        entity_id: light.복도_조명
      data:
        brightness: 200
    - delay: "00:05:00"  # 5분 대기
    - service: light.turn_off
      target:
        entity_id: light.복도_조명

# 자동화 2: 온도 기반 에어컨 제어
- id: "temp_aircon_control"
  alias: "온도 기반 에어컨 자동 제어"
  trigger:
    - platform: numeric_state
      entity_id: sensor.거실_온도
      above: 28
  condition:
    - condition: time
      after: "09:00:00"
      before: "23:00:00"
  action:
    - service: switch.turn_on
      target:
        entity_id: switch.에어컨

# 자동화 3: 일몰 시 거실 조명 켜기
- id: "sunset_light"
  alias: "일몰 시 거실 조명 자동 켜기"
  trigger:
    - platform: sun
      event: sunset
      offset: "-00:30:00"  # 일몰 30분 전
  condition:
    - condition: state
      entity_id: binary_sensor.거실_움직임
      state: "on"
  action:
    - service: light.turn_on
      target:
        entity_id: light.거실_rgb_스트립
      data:
        brightness: 150
        rgb_color: [255, 200, 100]  # 따뜻한 노란빛
        effect: "solid"

# 자동화 4: 조도 기반 조명 자동 제어
- id: "lux_auto_light"
  alias: "조도 낮을 때 조명 자동 켜기"
  trigger:
    - platform: state
      entity_id: sensor.거실_조도_상태
      to: "dark"
  condition:
    - condition: time
      after: "07:00:00"
      before: "22:00:00"
  action:
    - service: light.turn_on
      target:
        entity_id: light.거실_조명

실제로 만들다 보면 이런저런 문제가 생기기 마련이야. 자주 발생하는 문제들을 정리해봤어. 🔧

▶유용한 개발 도구들