야 솔직히 말해서, 코드 짜다가 화면 속에서만 뭔가 움직이는 거 보면 좀 심심하지 않음? 🤔
근데 라즈베리파이에 Python 코드 한 줄 넣었더니 실제 LED가 반짝이고, 온도 센서가 값을 뱉고, 모터가 돌아가는 거 보면... 진짜 소름 돋음 ㄹㅇ 🔥
오늘은 IoT(사물인터넷)와 라즈베리파이를 활용해서 Python으로 하드웨어를 제어하는 방법을 처음부터 끝까지 싹 다 파헤쳐볼 거야.
초보자도 이해할 수 있게, 근데 내용은 진짜 알차게 — 시작해보자고!

🌐 1. IoT가 뭔데? 라즈베리파이는 또 뭐고?

IoT(Internet of Things, 사물인터넷)는 말 그대로 "사물들이 인터넷에 연결된다"는 개념이야.
냉장고가 인터넷에 연결되고, 전구가 스마트폰으로 제어되고, 공장 기계가 실시간으로 데이터를 보내는 것 — 이게 다 IoT임.
2024년 기준으로 전 세계 IoT 기기 수는 약 170억 개를 넘어섰고, 2030년에는 300억 개를 돌파할 거라는 전망이 있어. 진짜 어마어마하지? 😲

🍓 라즈베리파이(Raspberry Pi)란?

라즈베리파이는 영국의 Raspberry Pi Foundation에서 만든 초소형 싱글보드 컴퓨터(SBC)야.
신용카드 크기만 한 이 작은 보드에 CPU, RAM, GPU, USB, HDMI, GPIO 핀이 다 들어있어.
가격은 모델에 따라 다르지만 Raspberry Pi 4 Model B 기준으로 약 35~75달러 수준이고,
2024년에 출시된 Raspberry Pi 5는 성능이 대폭 향상되어 더 복잡한 IoT 프로젝트도 거뜬히 처리해.

🔧 2. 개발 환경 세팅 — 이것부터 해야 진짜 시작

📦 필요한 준비물

하드웨어 제어 시작 전에 뭐가 필요한지 체크해보자:

💿 OS 설치 및 초기 설정

python3 --version
# Python 3.11.x 이상이면 OK!

sudo apt update && sudo apt upgrade -y
sudo apt install python3-pip python3-venv -y
pip3 install RPi.GPIO gpiozero adafruit-blinka

🔌 GPIO 핀 이해하기

GPIO(General Purpose Input/Output)는 라즈베리파이의 핵심 인터페이스야.
라즈베리파이 3B+ 이상 모델은 40핀 GPIO 헤더를 가지고 있어.

🔘 4. 버튼 입력 처리 — 사용자와 소통하기

LED 켜는 건 출력(Output)이었고, 이번엔 입력(Input)을 다뤄볼 차례야.
버튼을 누르면 뭔가 일어나게 만드는 거 — 이게 인터랙티브 IoT의 시작이야!

🔌 버튼 회로 연결

🐍 버튼 폴링(Polling) 방식

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

# 버튼 핀 설정 (내부 풀업 저항 활성화)
GPIO.setup(2, GPIO.IN, pull_up_down=GPIO.PUD_UP)
# LED 핀 설정
GPIO.setup(17, GPIO.OUT)

print("버튼을 눌러보세요! (Ctrl+C로 종료)")

try:
    while True:
        # 버튼 상태 읽기
        # 풀업이라 평소엔 HIGH, 누르면 LOW
        button_state = GPIO.input(2)
        
        if button_state == GPIO.LOW:
            print("버튼 눌림! 💥")
            GPIO.output(17, GPIO.HIGH)  # LED 켜기
        else:
            GPIO.output(17, GPIO.LOW)   # LED 끄기
        
        time.sleep(0.05)  # CPU 과부하 방지

except KeyboardInterrupt:
    print("종료!")
finally:
    GPIO.cleanup()

⚡ 인터럽트(Interrupt) 방식 — 더 효율적!

폴링 방식은 계속 핀 상태를 체크하느라 CPU를 낭비해.
인터럽트 방식은 버튼이 눌릴 때만 함수가 호출되어서 훨씬 효율적이야:

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)
GPIO.setup(2, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(17, GPIO.OUT)

led_state = False

def button_callback(channel):
    """버튼이 눌릴 때 자동으로 호출되는 함수"""
    global led_state
    led_state = not led_state
    GPIO.output(17, led_state)
    print(f"LED {'ON 🔆' if led_state else 'OFF 🌑'}")

# 하강 엣지(HIGH→LOW) 감지 시 콜백 함수 호출
# bouncetime: 디바운싱 시간(ms) - 버튼 채터링 방지
GPIO.add_event_detect(
    2, 
    GPIO.FALLING, 
    callback=button_callback, 
    bouncetime=300
)

print("버튼으로 LED를 토글하세요! (Ctrl+C로 종료)")

try:
    while True:
        time.sleep(1)  # 메인 루프는 그냥 대기
except KeyboardInterrupt:
    print("종료!")
finally:
    GPIO.cleanup()

from gpiozero import Button, LED
from signal import pause

button = Button(2, pull_up=True, bounce_time=0.3)
led = LED(17)

# 버튼 눌릴 때 LED 켜기
button.when_pressed = led.on
# 버튼 뗄 때 LED 끄기
button.when_released = led.off

# 또는 토글
# button.when_pressed = led.toggle

print("버튼을 눌러보세요!")
pause()  # 프로그램 계속 실행 유지

🌐 8. MQTT로 IoT 네트워크 구축하기

이제 진짜 IoT다운 걸 해볼 거야 — 인터넷을 통한 원격 제어!
MQTT(Message Queuing Telemetry Transport)는 IoT에서 가장 많이 쓰이는 경량 메시지 프로토콜이야.
발행(Publish)/구독(Subscribe) 패턴으로 동작하고, 저전력·저대역폭 환경에 최적화되어 있어.

🦟 Mosquitto 브로커 설치

# Mosquitto MQTT 브로커 설치
sudo apt install mosquitto mosquitto-clients -y

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

# 상태 확인
sudo systemctl status mosquitto

# 테스트 (터미널 2개 열어서)
# 터미널 1: 구독
mosquitto_sub -h localhost -t "test/topic"

# 터미널 2: 발행
mosquitto_pub -h localhost -t "test/topic" -m "Hello MQTT!"

🐍 Python MQTT 클라이언트

pip3 install paho-mqtt

import paho.mqtt.client as mqtt
import json
import time
import random  # 실제로는 센서 라이브러리 사용

# MQTT 설정
BROKER = "localhost"  # 또는 원격 브로커 주소
PORT = 1883
TOPIC_TEMP = "home/sensor/temperature"
TOPIC_HUMID = "home/sensor/humidity"

# 클라이언트 생성
client = mqtt.Client(client_id="sensor_node_01")

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("✅ MQTT 브로커 연결 성공!")
    else:
        print(f"❌ 연결 실패: {rc}")

def on_publish(client, userdata, mid):
    print(f"📤 메시지 발행 완료 (ID: {mid})")

client.on_connect = on_connect
client.on_publish = on_publish

# 브로커 연결
client.connect(BROKER, PORT, keepalive=60)
client.loop_start()

print("센서 데이터 발행 시작! 📡")

try:
    while True:
        # 실제 환경에서는 DHT 센서에서 읽어옴
        temperature = round(20 + random.uniform(-5, 15), 1)
        humidity = round(50 + random.uniform(-20, 30), 1)
        
        # JSON 형태로 데이터 구성
        payload = json.dumps({
            "temperature": temperature,
            "humidity": humidity,
            "timestamp": time.time(),
            "device_id": "sensor_node_01"
        })
        
        # 발행 (QoS 1: 최소 1번 전달 보장)
        client.publish(TOPIC_TEMP, payload, qos=1)
        print(f"발행: 온도={temperature}°C, 습도={humidity}%")
        
        time.sleep(5)

except KeyboardInterrupt:
    print("종료!")
finally:
    client.loop_stop()
    client.disconnect()

import paho.mqtt.client as mqtt
import json
from gpiozero import LED

led = LED(17)

BROKER = "localhost"
PORT = 1883
TOPIC_CONTROL = "home/control/led"
TOPIC_STATUS = "home/status/led"

client = mqtt.Client(client_id="led_controller_01")

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("✅ 연결 성공!")
        # 연결 후 토픽 구독
        client.subscribe(TOPIC_CONTROL, qos=1)
        print(f"📥 구독 중: {TOPIC_CONTROL}")

def on_message(client, userdata, msg):
    """메시지 수신 시 호출"""
    try:
        payload = json.loads(msg.payload.decode())
        command = payload.get("command", "")
        
        if command == "on":
            led.on()
            print("💡 LED ON!")
            status = "on"
        elif command == "off":
            led.off()
            print("🌑 LED OFF!")
            status = "off"
        elif command == "toggle":
            led.toggle()
            status = "on" if led.is_lit else "off"
            print(f"🔄 LED 토글 → {status}")
        else:
            print(f"⚠️ 알 수 없는 명령: {command}")
            return
        
        # 상태 발행 (피드백)
        response = json.dumps({"status": status, "device": "led_01"})
        client.publish(TOPIC_STATUS, response, qos=1)
        
    except json.JSONDecodeError:
        print("❌ JSON 파싱 오류")

client.on_connect = on_connect
client.on_message = on_message

client.connect(BROKER, PORT, keepalive=60)

print("LED 원격 제어 대기 중... 🎮")
print("명령 예시: mosquitto_pub -t home/control/led -m '{\"command\":\"on\"}'")

client.loop_forever()  # 블로킹 루프 (Ctrl+C로 종료)

🏠 9. 실전 프로젝트 — 스마트 홈 시스템 만들기

지금까지 배운 걸 다 합쳐서 실제로 쓸 수 있는 스마트 홈 시스템을 만들어보자!
온습도 모니터링 + LED 자동 제어 + MQTT 원격 제어 + 웹 대시보드까지 — 진짜 IoT 프로젝트야 🏠

📋 프로젝트 구성

#!/usr/bin/env python3
"""
스마트 홈 IoT 시스템
라즈베리파이 + Python + MQTT + Flask
"""

import threading
import time
import json
import sqlite3
import logging
from datetime import datetime
from gpiozero import LED, Button
import adafruit_dht
import board
import paho.mqtt.client as mqtt

# 로깅 설정
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s'
)
logger = logging.getLogger(__name__)

# ===== 하드웨어 초기화 =====
status_led = LED(17)
warning_led = LED(27)
manual_button = Button(2, pull_up=True, bounce_time=0.3)
dht_sensor = adafruit_dht.DHT22(board.D4)

# ===== 데이터베이스 초기화 =====
def init_database():
    conn = sqlite3.connect('smart_home.db')
    cursor = conn.cursor()
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS sensor_data (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            temperature REAL,
            humidity REAL,
            led_status TEXT
        )
    ''')
    conn.commit()
    conn.close()
    logger.info("데이터베이스 초기화 완료")

def save_sensor_data(temp, humid, led_status):
    conn = sqlite3.connect('smart_home.db')
    cursor = conn.cursor()
    cursor.execute(
        'INSERT INTO sensor_data (timestamp, temperature, humidity, led_status) VALUES (?, ?, ?, ?)',
        (datetime.now().isoformat(), temp, humid, led_status)
    )
    conn.commit()
    conn.close()

# ===== 시스템 상태 =====
system_state = {
    "temperature": 0.0,
    "humidity": 0.0,
    "led_on": False,
    "auto_mode": True,
    "last_update": None
}

# ===== MQTT 설정 =====
mqtt_client = mqtt.Client(client_id="smart_home_main")

def on_mqtt_connect(client, userdata, flags, rc):
    if rc == 0:
        logger.info("MQTT 브로커 연결 성공!")
        client.subscribe("home/control/#", qos=1)
    else:
        logger.error(f"MQTT 연결 실패: {rc}")

def on_mqtt_message(client, userdata, msg):
    topic = msg.topic
    try:
        payload = json.loads(msg.payload.decode())
        
        if topic == "home/control/led":
            cmd = payload.get("command")
            if cmd == "on":
                status_led.on()
                system_state["led_on"] = True
                system_state["auto_mode"] = False
            elif cmd == "off":
                status_led.off()
                system_state["led_on"] = False
                system_state["auto_mode"] = False
            elif cmd == "auto":
                system_state["auto_mode"] = True
                logger.info("자동 모드 활성화")
                
        logger.info(f"명령 수신: {topic} → {payload}")
    except Exception as e:
        logger.error(f"메시지 처리 오류: {e}")

mqtt_client.on_connect = on_mqtt_connect
mqtt_client.on_message = on_mqtt_message

# ===== 센서 읽기 스레드 =====
def sensor_thread():
    """5초마다 센서 데이터 읽기"""
    while True:
        try:
            temp = dht_sensor.temperature
            humid = dht_sensor.humidity
            
            if temp is not None and humid is not None:
                system_state["temperature"] = temp
                system_state["humidity"] = humid
                system_state["last_update"] = datetime.now().isoformat()
                
                # 자동 모드: 온도 기반 LED 제어
                if system_state["auto_mode"]:
                    if temp > 28:
                        status_led.on()
                        warning_led.blink(on_time=0.5, off_time=0.5)
                        system_state["led_on"] = True
                        logger.warning(f"고온 경고! {temp}°C")
                    else:
                        status_led.off()
                        warning_led.off()
                        system_state["led_on"] = False
                
                # MQTT로 데이터 발행
                sensor_data = json.dumps({
                    "temperature": round(temp, 1),
                    "humidity": round(humid, 1),
                    "led_status": "on" if system_state["led_on"] else "off",
                    "auto_mode": system_state["auto_mode"],
                    "timestamp": system_state["last_update"]
                })
                mqtt_client.publish("home/sensor/data", sensor_data, qos=1)
                
                # DB 저장
                save_sensor_data(
                    temp, humid,
                    "on" if system_state["led_on"] else "off"
                )
                
                logger.info(f"온도: {temp:.1f}°C | 습도: {humid:.1f}%")
                
        except RuntimeError as e:
            logger.warning(f"센서 읽기 실패: {e}")
        
        time.sleep(5)

# ===== 버튼 핸들러 =====
def button_handler():
    """수동 버튼으로 LED 토글"""
    system_state["auto_mode"] = False
    status_led.toggle()
    system_state["led_on"] = status_led.is_lit
    logger.info(f"버튼 눌림 → LED {'ON' if system_state['led_on'] else 'OFF'}")

manual_button.when_pressed = button_handler

# ===== 메인 실행 =====
if __name__ == "__main__":
    logger.info("🏠 스마트 홈 시스템 시작!")
    
    init_database()
    
    # MQTT 연결
    mqtt_client.connect("localhost", 1883, keepalive=60)
    mqtt_client.loop_start()
    
    # 센서 스레드 시작
    sensor_t = threading.Thread(target=sensor_thread, daemon=True)
    sensor_t.start()
    
    logger.info("시스템 가동 중... (Ctrl+C로 종료)")
    
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        logger.info("시스템 종료!")
    finally:
        mqtt_client.loop_stop()
        mqtt_client.disconnect()

🌐 Flask 웹 대시보드

from flask import Flask, jsonify, render_template_string
import sqlite3
from datetime import datetime

app = Flask(__name__)

DASHBOARD_HTML = """
<!DOCTYPE html>
<html>
<head>
    <title>스마트 홈 대시보드</title>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <style>
        body { font-family: Arial; background: #f0f4ff; margin: 0; padding: 20px; }
        .card { background: white; border-radius: 12px; padding: 20px; margin: 10px; 
                box-shadow: 0 2px 8px rgba(0,0,0,0.1); display: inline-block; min-width: 150px; }
        .value { font-size: 2em; font-weight: bold; color: #5ba4cf; }
        h1 { color: #3a7ca5; }
    </style>
</head>
<body>
    <h1>🏠 스마트 홈 대시보드</h1>
    <div id="data">로딩 중...</div>
    <script>
        function updateData() {
            fetch('/api/status')
                .then(r => r.json())
                .then(data => {
                    document.getElementById('data').innerHTML = `
                        <div class="card">
                            <div>🌡️ 온도</div>
                            <div class="value">${data.temperature}°C</div>
                        </div>
                        <div class="card">
                            <div>💧 습도</div>
                            <div class="value">${data.humidity}%</div>
                        </div>
                        <div class="card">
                            <div>💡 LED</div>
                            <div class="value">${data.led_status}</div>
                        </div>
                    `;
                });
        }
        updateData();
        setInterval(updateData, 5000);
    </script>
</body>
</html>
"""

@app.route('/')
def dashboard():
    return render_template_string(DASHBOARD_HTML)

@app.route('/api/status')
def get_status():
    conn = sqlite3.connect('smart_home.db')
    cursor = conn.cursor()
    cursor.execute(
        'SELECT temperature, humidity, led_status, timestamp FROM sensor_data ORDER BY id DESC LIMIT 1'
    )
    row = cursor.fetchone()
    conn.close()
    
    if row:
        return jsonify({
            "temperature": row[0],
            "humidity": row[1],
            "led_status": row[2],
            "timestamp": row[3]
        })
    return jsonify({"error": "데이터 없음"})

@app.route('/api/history')
def get_history():
    conn = sqlite3.connect('smart_home.db')
    cursor = conn.cursor()
    cursor.execute(
        'SELECT temperature, humidity, timestamp FROM sensor_data ORDER BY id DESC LIMIT 50'
    )
    rows = cursor.fetchall()
    conn.close()
    
    return jsonify([
        {"temperature": r[0], "humidity": r[1], "timestamp": r[2]}
        for r in rows
    ])

if __name__ == '__main__':
    # 0.0.0.0으로 바인딩해야 외부에서 접속 가능
    app.run(host='0.0.0.0', port=5000, debug=False)

🔒 10. 보안 및 최적화 — 진짜 프로처럼

IoT 시스템을 만들었으면 보안도 신경 써야 해.
인터넷에 연결된 장치는 해킹 타겟이 될 수 있거든 — 진짜로 ㄷㄷ

🔐 MQTT 보안 설정

# 비밀번호 파일 생성
sudo mosquitto_passwd -c /etc/mosquitto/passwd myuser

# Mosquitto 설정 파일 수정
sudo nano /etc/mosquitto/conf.d/default.conf

# /etc/mosquitto/conf.d/default.conf
listener 1883 localhost
allow_anonymous false
password_file /etc/mosquitto/passwd

# TLS 설정 (외부 접속 시)
listener 8883
cafile /etc/mosquitto/certs/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile /etc/mosquitto/certs/server.key
require_certificate false

import paho.mqtt.client as mqtt

client = mqtt.Client()

# 사용자 인증 설정
client.username_pw_set("myuser", "mypassword")

# TLS 설정 (외부 브로커 사용 시)
# client.tls_set(ca_certs="/path/to/ca.crt")

client.connect("localhost", 1883, keepalive=60)

⚡ 성능 최적화 팁

import time
import logging

logger = logging.getLogger(__name__)

def read_sensor_with_retry(sensor, max_retries=3, delay=2):
    """재시도 로직이 포함된 안정적인 센서 읽기"""
    for attempt in range(max_retries):
        try:
            temp = sensor.temperature
            humid = sensor.humidity
            
            if temp is None or humid is None:
                raise ValueError("센서 값이 None")
            
            # 유효 범위 검증
            if not (-40 <= temp <= 80):
                raise ValueError(f"온도 범위 초과: {temp}")
            if not (0 <= humid <= 100):
                raise ValueError(f"습도 범위 초과: {humid}")
            
            return temp, humid
            
        except (RuntimeError, ValueError) as e:
            logger.warning(f"센서 읽기 실패 ({attempt+1}/{max_retries}): {e}")
            if attempt < max_retries - 1:
                time.sleep(delay)
    
    logger.error("최대 재시도 횟수 초과!")
    return None, None

🔄 systemd로 자동 시작 설정

라즈베리파이가 재부팅되어도 IoT 시스템이 자동으로 시작되게 하려면 systemd 서비스를 등록해야 해:

sudo nano /etc/systemd/system/smart-home.service

[Unit]
Description=Smart Home IoT System
After=network.target mosquitto.service
Wants=mosquitto.service

[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/smart-home
ExecStart=/usr/bin/python3 /home/pi/smart-home/main.py
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable smart-home.service
sudo systemctl start smart-home.service

# 상태 확인
sudo systemctl status smart-home.service

# 로그 확인
sudo journalctl -u smart-home.service -f

🚀 11. 더 나아가기 — 심화 주제들

기본기를 다 익혔으면 이제 더 깊이 들어가볼 수 있어.
IoT + Python의 세계는 진짜 무궁무진하거든 🌌

📊 InfluxDB + Grafana로 데이터 시각화

from influxdb_client import InfluxDBClient, Point
from influxdb_client.client.write_api import SYNCHRONOUS
import time

# InfluxDB 연결 설정
INFLUXDB_URL = "http://localhost:8086"
INFLUXDB_TOKEN = "your-token-here"
INFLUXDB_ORG = "my-org"
INFLUXDB_BUCKET = "smart-home"

client = InfluxDBClient(
    url=INFLUXDB_URL,
    token=INFLUXDB_TOKEN,
    org=INFLUXDB_ORG
)
write_api = client.write_api(write_options=SYNCHRONOUS)

def write_sensor_data(temperature, humidity, device_id="pi_01"):
    """InfluxDB에 센서 데이터 저장"""
    point = (
        Point("environment")
        .tag("device", device_id)
        .tag("location", "living_room")
        .field("temperature", temperature)
        .field("humidity", humidity)
    )
    write_api.write(bucket=INFLUXDB_BUCKET, record=point)
    print(f"InfluxDB 저장: {temperature}°C, {humidity}%")

# 사용 예시
write_sensor_data(25.3, 60.5)

🤖 머신러닝으로 이상 감지

import numpy as np
from sklearn.ensemble import IsolationForest
import pickle

# 정상 데이터로 모델 훈련
def train_anomaly_detector(normal_data):
    """
    normal_data: [[temp1, humid1], [temp2, humid2], ...] 형태
    """
    model = IsolationForest(
        contamination=0.1,  # 이상치 비율 예상값
        random_state=42
    )
    model.fit(normal_data)
    
    # 모델 저장
    with open('anomaly_model.pkl', 'wb') as f:
        pickle.dump(model, f)
    
    print("이상 감지 모델 훈련 완료!")
    return model

def detect_anomaly(model, temperature, humidity):
    """
    반환값: True = 이상, False = 정상
    """
    data = np.array([[temperature, humidity]])
    prediction = model.predict(data)
    return prediction[0] == -1  # -1이면 이상치

# 사용 예시
# 정상 데이터 수집 (실제로는 DB에서 읽어옴)
normal_data = np.array([
    [22.1, 55.2], [22.5, 56.1], [23.0, 54.8],
    [21.8, 57.3], [22.3, 55.9], [23.1, 56.5]
])

model = train_anomaly_detector(normal_data)

# 실시간 감지
test_temp, test_humid = 45.0, 95.0  # 비정상적인 값
if detect_anomaly(model, test_temp, test_humid):
    print(f"🚨 이상 감지! 온도:{test_temp}°C 습도:{test_humid}%")
else:
    print("✅ 정상 범위")

📱 Telegram 봇으로 알림 보내기

import requests
import json

class TelegramNotifier:
    def __init__(self, bot_token, chat_id):
        self.bot_token = bot_token
        self.chat_id = chat_id
        self.base_url = f"https://api.telegram.org/bot{bot_token}"
    
    def send_message(self, message):
        """텍스트 메시지 전송"""
        url = f"{self.base_url}/sendMessage"
        payload = {
            "chat_id": self.chat_id,
            "text": message,
            "parse_mode": "HTML"
        }
        response = requests.post(url, json=payload)
        return response.json()
    
    def send_alert(self, temperature, humidity):
        """온도/습도 경고 알림"""
        message = (
            f"🚨 <b>스마트 홈 경고!</b>\n\n"
            f"🌡️ 온도: <b>{temperature:.1f}°C</b>\n"
            f"💧 습도: <b>{humidity:.1f}%</b>\n\n"
            f"⏰ 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
        )
        return self.send_message(message)

# 사용 예시
# BotFather에서 봇 토큰 받고, 채팅 ID 확인 후 사용
notifier = TelegramNotifier(
    bot_token="YOUR_BOT_TOKEN",
    chat_id="YOUR_CHAT_ID"
)

# 고온 감지 시 알림
if temperature > 35:
    notifier.send_alert(temperature, humidity)
    print("📱 Telegram 알림 전송!")

📚 12. 트러블슈팅 — 막혔을 때 이렇게 해!

IoT 개발하다 보면 진짜 별의별 문제가 다 생겨 ㅋㅋㅋ
자주 만나는 문제들과 해결책을 정리해봤어:

# GPIO 상태 확인
gpio readall

# I2C 장치 스캔
sudo i2cdetect -y 1

# SPI 장치 확인
ls /dev/spi*

# 시스템 온도 확인 (라즈베리파이 CPU 온도)
vcgencmd measure_temp

# 메모리 사용량
free -h

# CPU 사용률
top

# 프로세스 확인
ps aux | grep python

# 포트 사용 확인
sudo netstat -tlnp | grep 1883

🎯 마무리 — 이제 진짜 IoT 개발자다!

와 진짜 긴 여정이었는데 여기까지 왔으면 박수 한 번 쳐도 됨 👏👏👏
오늘 우리가 다룬 내용을 정리해보면:

IoT는 진짜 무한한 가능성의 세계야.
스마트 홈, 농업 자동화, 공장 모니터링, 환경 감시, 로봇 제어...
Python이라는 강력한 언어와 라즈베리파이라는 저렴하고 강력한 하드웨어가 있으면
상상하는 거의 모든 걸 만들 수 있어.

그리고 이런 능력을 갈고 닦아서 재능넷같은 플랫폼에서 재능으로 공유하면
실제 수익도 창출할 수 있다는 거 잊지 마! 💪

자, 이제 브레드보드 꺼내고 코드 에디터 열어봐 — 세상을 움직일 시간이야! 🌍⚡