🎯 IoT와 C언어, 왜 이 조합이 최고일까?

안녕! 오늘은 정말 재미있는 주제로 이야기를 나눠볼 거야. 바로 **C언어를 활용한 IoT 프로그래밍**이야. 요즘 스마트홈, 웨어러블 기기, 자율주행차 등 IoT 기술이 우리 생활 곳곳에 스며들고 있잖아? 🏠✨

그런데 말이야, 많은 사람들이 IoT 프로그래밍이라고 하면 파이썬이나 자바스크립트 같은 언어를 먼저 떠올려. 물론 그것들도 좋지만, 진짜 하드웨어와 직접 대화하고 싶다면 C언어만한 게 없어. 왜냐고? C언어는 하드웨어에 가장 가까운 고급 언어거든! 💪

센서에서 데이터를 읽어오고, 그 데이터를 처리하고, 다시 액추에이터를 제어하는 모든 과정에서 C언어는 빠르고 효율적이야. 특히 메모리가 제한적인 임베디드 시스템에서는 C언어의 진가가 발휘되지. 아두이노, 라즈베리파이, ESP32 같은 보드들도 모두 C/C++ 기반으로 동작하고 있어!

🔧 개발 환경 구축하기

자, 그럼 본격적으로 시작해볼까? 먼저 개발 환경부터 세팅해야겠지? 걱정 마, 생각보다 어렵지 않아! 😊 IoT 프로젝트를 시작하려면 몇 가지 하드웨어가 필요해. 초보자라면 **아두이노 우노**나 **ESP32** 보드를 추천해. 가격도 저렴하고 커뮤니티도 활발해서 문제가 생겨도 해결하기 쉽거든! 🎮

보드 종류	특징	추천 용도
Arduino Uno	초보자 친화적, 풍부한 라이브러리	기본 센서 실습
ESP32	WiFi/Bluetooth 내장, 저렴한 가격	무선 IoT 프로젝트
Raspberry Pi	리눅스 OS, 강력한 성능	복잡한 데이터 처리
STM32	산업용 수준, 다양한 시리즈	전문적인 임베디드 개발

센서도 몇 개 준비해야겠지? 처음에는 **DHT11**(온습도 센서), **HC-SR04**(초음파 거리 센서), **LDR**(조도 센서) 정도면 충분해. 이것들로 정말 다양한 프로젝트를 만들 수 있거든! 🌡️📏💡 하드웨어 준비가 끝났다면 이제 코딩 환경을 만들어야지. 아두이노를 사용한다면 **Arduino IDE**가 가장 간단해. 하지만 좀 더 전문적인 개발을 원한다면 **PlatformIO**나 **VS Code**를 추천해! 🖥️

ESP32나 STM32 같은 보드를 사용한다면 각 제조사에서 제공하는 SDK를 설치해야 해. ESP32는 **ESP-IDF**, STM32는 **STM32CubeIDE**를 사용하면 돼. 처음엔 복잡해 보이지만, 한번 익숙해지면 정말 강력한 도구들이야! 💪

📡 센서 데이터 읽기의 기초

자, 이제 본격적으로 센서와 대화해볼 시간이야! 센서 데이터를 읽는 건 생각보다 간단해. 기본적으로 **디지털 입력**과 **아날로그 입력** 두 가지 방식이 있어. 🎛️ 디지털 센서는 0 또는 1, 즉 HIGH나 LOW 값만 반환해. 예를 들어 버튼이나 PIR 모션 센서 같은 거지. 코드로 보면 이렇게 생겨먹었어:

#define BUTTON_PIN 2

void setup() {
    pinMode(BUTTON_PIN, INPUT);
    Serial.begin(9600);
}

void loop() {
    int buttonState = digitalRead(BUTTON_PIN);
    
    if (buttonState == HIGH) {
        Serial.println("버튼이 눌렸어요! 🎉");
    }
    
    delay(100);
}

간단하지? pinMode()로 핀을 입력 모드로 설정하고, digitalRead()로 값을 읽어오면 끝이야! 😎 아날로그 센서는 좀 더 재미있어. 0부터 1023까지(10비트 ADC 기준) 연속적인 값을 반환하거든. 온도 센서, 조도 센서, 가변저항 등이 여기 속해. 🌡️

예를 들어 조도 센서로 빛의 밝기를 측정하는 코드를 볼까?

#define LDR_PIN A0

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

void loop() {
    int lightValue = analogRead(LDR_PIN);
    
    // 0-1023 값을 0-100 퍼센트로 변환
    int brightness = map(lightValue, 0, 1023, 0, 100);
    
    Serial.print("밝기: ");
    Serial.print(brightness);
    Serial.println("%");
    
    // 어두우면 경고 메시지
    if (brightness < 30) {
        Serial.println("⚠️ 너무 어두워요!");
    }
    
    delay(500);
}

여기서 map() 함수가 정말 유용해! 센서 값의 범위를 우리가 원하는 범위로 쉽게 변환해주거든. 이런 작은 팁들이 모여서 멋진 프로젝트가 되는 거야! ✨

🌡️ 실전! DHT11 온습도 센서 프로젝트

이론만 배우면 재미없잖아? 이제 실제로 DHT11 온습도 센서를 사용해서 데이터를 수집하고 처리하는 완전한 시스템을 만들어볼 거야! 이 프로젝트는 정말 실용적이라서 스마트홈 시스템의 기초가 될 수 있어. 🏡 DHT11 센서는 보통 3개의 핀을 가지고 있어. VCC(전원), GND(접지), DATA(데이터) 핀이지. 연결은 이렇게 하면 돼:

• DHT11 VCC → Arduino 5V
• DHT11 GND → Arduino GND
• DHT11 DATA → Arduino Digital Pin 2
• DATA 핀과 VCC 사이에 10kΩ 풀업 저항 연결 (중요!) 🔌 Arduino IDE에서 라이브러리 매니저를 열고 "DHT sensor library"를 검색해서 설치하자. Adafruit에서 만든 라이브러리가 가장 안정적이야! 📚

자, 이제 본격적인 코드를 작성해볼까?

#include "DHT.h"

#define DHTPIN 2        // DHT11 데이터 핀
#define DHTTYPE DHT11   // 센서 타입 지정

DHT dht(DHTPIN, DHTTYPE);

// 데이터 저장을 위한 구조체
typedef struct {
    float temperature;
    float humidity;
    unsigned long timestamp;
    bool isValid;
} SensorData;

SensorData currentData;

void setup() {
    Serial.begin(9600);
    Serial.println("🌡️ DHT11 센서 시스템 시작!");
    
    dht.begin();
    
    // 초기화
    currentData.isValid = false;
}

void loop() {
    // 센서 읽기 (2초마다)
    delay(2000);
    
    // 온습도 데이터 읽기
    float h = dht.readHumidity();
    float t = dht.readTemperature();
    
    // 읽기 실패 체크
    if (isnan(h) || isnan(t)) {
        Serial.println("❌ 센서 읽기 실패!");
        currentData.isValid = false;
        return;
    }
    
    // 데이터 저장
    currentData.temperature = t;
    currentData.humidity = h;
    currentData.timestamp = millis();
    currentData.isValid = true;
    
    // 데이터 출력
    printSensorData();
    
    // 경고 시스템
    checkAlerts();
}

void printSensorData() {
    Serial.println("━━━━━━━━━━━━━━━━━━━━");
    Serial.print("🌡️  온도: ");
    Serial.print(currentData.temperature);
    Serial.println("°C");
    
    Serial.print("💧 습도: ");
    Serial.print(currentData.humidity);
    Serial.println("%");
    
    // 체감온도 계산 (열지수)
    float heatIndex = calculateHeatIndex(
        currentData.temperature, 
        currentData.humidity
    );
    
    Serial.print("🔥 체감온도: ");
    Serial.print(heatIndex);
    Serial.println("°C");
    
    Serial.println("━━━━━━━━━━━━━━━━━━━━");
}

// 열지수(Heat Index) 계산 함수
float calculateHeatIndex(float temp, float humidity) {
    // 간단한 열지수 공식
    float hi = temp + 0.5555 * (6.11 * exp(5417.7530 * 
               ((1/273.16) - (1/(273.15+temp)))) * 
               (humidity/100.0) - 10.0);
    return hi;
}

void checkAlerts() {
    // 온도 경고
    if (currentData.temperature > 30.0) {
        Serial.println("🔴 경고: 온도가 너무 높습니다!");
    } else if (currentData.temperature < 15.0) {
        Serial.println("🔵 경고: 온도가 너무 낮습니다!");
    }
    
    // 습도 경고
    if (currentData.humidity > 70.0) {
        Serial.println("💦 경고: 습도가 너무 높습니다!");
    } else if (currentData.humidity < 30.0) {
        Serial.println("🏜️ 경고: 습도가 너무 낮습니다!");
    }
}

와! 코드가 좀 길어 보이지? 하지만 하나하나 뜯어보면 전혀 어렵지 않아. 구조체를 사용해서 데이터를 체계적으로 관리하고, 함수로 기능을 분리해서 코드를 깔끔하게 만들었어. 이게 바로 좋은 C 프로그래밍 습관이야! 👍

📊 센서 데이터 처리 및 필터링

센서에서 읽어온 데이터를 그대로 사용하면 안 돼! 왜냐고? 센서 데이터에는 항상 **노이즈**가 섞여 있거든. 전기적 간섭, 센서 자체의 오차, 환경적 요인 등으로 인해 값이 튀는 경우가 많아. 😰

그래서 우리는 데이터를 **필터링**하고 **평활화**해야 해. 여러 가지 방법이 있는데, 가장 많이 쓰이는 기법들을 알아보자! 가장 간단하면서도 효과적인 방법이야. 최근 N개의 데이터를 평균내서 사용하는 거지. 코드로 구현하면 이렇게 돼:

#define WINDOW_SIZE 10

typedef struct {
    float buffer[WINDOW_SIZE];
    int index;
    int count;
    float sum;
} MovingAverage;

MovingAverage tempFilter;
MovingAverage humidFilter;

void initMovingAverage(MovingAverage *ma) {
    ma->index = 0;
    ma->count = 0;
    ma->sum = 0.0;
    
    for (int i = 0; i < WINDOW_SIZE; i++) {
        ma->buffer[i] = 0.0;
    }
}

float addValue(MovingAverage *ma, float value) {
    // 이전 값을 합계에서 빼기
    ma->sum -= ma->buffer[ma->index];
    
    // 새 값을 버퍼에 저장
    ma->buffer[ma->index] = value;
    ma->sum += value;
    
    // 인덱스 업데이트 (순환 버퍼)
    ma->index = (ma->index + 1) % WINDOW_SIZE;
    
    // 카운트 업데이트
    if (ma->count < WINDOW_SIZE) {
        ma->count++;
    }
    
    // 평균 반환
    return ma->sum / ma->count;
}

void setup() {
    Serial.begin(9600);
    dht.begin();
    
    // 필터 초기화
    initMovingAverage(&tempFilter);
    initMovingAverage(&humidFilter);
}

void loop() {
    delay(2000);
    
    float rawTemp = dht.readTemperature();
    float rawHumid = dht.readHumidity();
    
    if (!isnan(rawTemp) && !isnan(rawHumid)) {
        // 필터링된 값 얻기
        float filteredTemp = addValue(&tempFilter, rawTemp);
        float filteredHumid = addValue(&humidFilter, rawHumid);
        
        Serial.print("원본 온도: ");
        Serial.print(rawTemp);
        Serial.print("°C → 필터링: ");
        Serial.print(filteredTemp);
        Serial.println("°C");
        
        Serial.print("원본 습도: ");
        Serial.print(rawHumid);
        Serial.print("% → 필터링: ");
        Serial.print(filteredHumid);
        Serial.println("%");
    }
}

이 코드의 핵심은 **순환 버퍼(Circular Buffer)**를 사용한다는 거야. 메모리를 효율적으로 사용하면서도 최근 데이터만 유지할 수 있지! 🔄 좀 더 고급 기법을 원한다면 칼만 필터를 사용해볼 수 있어. 이건 NASA에서 아폴로 우주선 항법에 사용했던 알고리즘이야! 🚀 복잡해 보이지만, 1차원 칼만 필터는 생각보다 간단해:

typedef struct {
    float q;  // 프로세스 노이즈
    float r;  // 측정 노이즈
    float x;  // 추정값
    float p;  // 추정 오차
    float k;  // 칼만 게인
} KalmanFilter;

void initKalman(KalmanFilter *kf, float q, float r, float initial) {
    kf->q = q;
    kf->r = r;
    kf->x = initial;
    kf->p = 1.0;
}

float updateKalman(KalmanFilter *kf, float measurement) {
    // 예측 단계
    kf->p = kf->p + kf->q;
    
    // 칼만 게인 계산
    kf->k = kf->p / (kf->p + kf->r);
    
    // 업데이트 단계
    kf->x = kf->x + kf->k * (measurement - kf->x);
    kf->p = (1 - kf->k) * kf->p;
    
    return kf->x;
}

KalmanFilter tempKalman;
KalmanFilter humidKalman;

void setup() {
    Serial.begin(9600);
    dht.begin();
    
    // 칼만 필터 초기화
    // (프로세스 노이즈, 측정 노이즈, 초기값)
    initKalman(&tempKalman, 0.01, 0.1, 25.0);
    initKalman(&humidKalman, 0.01, 0.1, 50.0);
}

void loop() {
    delay(2000);
    
    float rawTemp = dht.readTemperature();
    float rawHumid = dht.readHumidity();
    
    if (!isnan(rawTemp) && !isnan(rawHumid)) {
        float kalmanTemp = updateKalman(&tempKalman, rawTemp);
        float kalmanHumid = updateKalman(&humidKalman, rawHumid);
        
        Serial.print("칼만 온도: ");
        Serial.print(kalmanTemp);
        Serial.println("°C");
        
        Serial.print("칼만 습도: ");
        Serial.print(kalmanHumid);
        Serial.println("%");
    }
}

칼만 필터는 이동 평균보다 반응이 빠르면서도 노이즈를 효과적으로 제거해줘. 특히 빠르게 변하는 센서 값을 추적할 때 유용해! 🎯

🔗 다중 센서 통합 시스템

실제 IoT 프로젝트에서는 하나의 센서만 사용하는 경우가 거의 없어. 여러 센서를 동시에 읽고 처리해야 하지! 이제 DHT11, 조도 센서, 초음파 센서를 모두 통합한 시스템을 만들어보자. 🎨 여러 센서를 효율적으로 관리하려면 체계적인 구조가 필요해. 객체지향적 사고를 C언어로 구현해보자!

#include "DHT.h"

// 센서 타입 정의
typedef enum {
    SENSOR_DHT11,
    SENSOR_LDR,
    SENSOR_ULTRASONIC,
    SENSOR_COUNT
} SensorType;

// 센서 상태
typedef enum {
    SENSOR_OK,
    SENSOR_ERROR,
    SENSOR_NOT_READY
} SensorStatus;

// 센서 데이터 구조체
typedef struct {
    SensorType type;
    SensorStatus status;
    float value1;      // 온도 or 조도 or 거리
    float value2;      // 습도 (DHT11만 사용)
    unsigned long lastRead;
    unsigned int readInterval;  // ms 단위
} Sensor;

// 센서 배열
Sensor sensors[SENSOR_COUNT];

// DHT11 설정
#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

// 조도 센서 설정
#define LDR_PIN A0

// 초음파 센서 설정
#define TRIG_PIN 9
#define ECHO_PIN 10

// 센서 초기화 함수
void initSensors() {
    // DHT11 초기화
    sensors[SENSOR_DHT11].type = SENSOR_DHT11;
    sensors[SENSOR_DHT11].readInterval = 2000;  // 2초
    sensors[SENSOR_DHT11].lastRead = 0;
    sensors[SENSOR_DHT11].status = SENSOR_NOT_READY;
    dht.begin();
    
    // 조도 센서 초기화
    sensors[SENSOR_LDR].type = SENSOR_LDR;
    sensors[SENSOR_LDR].readInterval = 500;  // 0.5초
    sensors[SENSOR_LDR].lastRead = 0;
    sensors[SENSOR_LDR].status = SENSOR_OK;
    pinMode(LDR_PIN, INPUT);
    
    // 초음파 센서 초기화
    sensors[SENSOR_ULTRASONIC].type = SENSOR_ULTRASONIC;
    sensors[SENSOR_ULTRASONIC].readInterval = 100;  // 0.1초
    sensors[SENSOR_ULTRASONIC].lastRead = 0;
    sensors[SENSOR_ULTRASONIC].status = SENSOR_OK;
    pinMode(TRIG_PIN, OUTPUT);
    pinMode(ECHO_PIN, INPUT);
    
    Serial.println("✅ 모든 센서 초기화 완료!");
}

// DHT11 읽기
bool readDHT11(Sensor *sensor) {
    float h = dht.readHumidity();
    float t = dht.readTemperature();
    
    if (isnan(h) || isnan(t)) {
        sensor->status = SENSOR_ERROR;
        return false;
    }
    
    sensor->value1 = t;
    sensor->value2 = h;
    sensor->status = SENSOR_OK;
    return true;
}

// 조도 센서 읽기
bool readLDR(Sensor *sensor) {
    int rawValue = analogRead(LDR_PIN);
    // 0-1023을 0-100%로 변환
    sensor->value1 = map(rawValue, 0, 1023, 0, 100);
    sensor->status = SENSOR_OK;
    return true;
}

// 초음파 센서 읽기
bool readUltrasonic(Sensor *sensor) {
    // 트리거 펄스 생성
    digitalWrite(TRIG_PIN, LOW);
    delayMicroseconds(2);
    digitalWrite(TRIG_PIN, HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG_PIN, LOW);
    
    // 에코 펄스 측정
    long duration = pulseIn(ECHO_PIN, HIGH, 30000);  // 타임아웃 30ms
    
    if (duration == 0) {
        sensor->status = SENSOR_ERROR;
        return false;
    }
    
    // 거리 계산 (cm)
    float distance = duration * 0.034 / 2;
    sensor->value1 = distance;
    sensor->status = SENSOR_OK;
    return true;
}

// 센서 업데이트 (논블로킹 방식)
void updateSensors() {
    unsigned long currentTime = millis();
    
    for (int i = 0; i < SENSOR_COUNT; i++) {
        // 읽기 간격 체크
        if (currentTime - sensors[i].lastRead >= sensors[i].readInterval) {
            bool success = false;
            
            switch (sensors[i].type) {
                case SENSOR_DHT11:
                    success = readDHT11(&sensors[i]);
                    break;
                case SENSOR_LDR:
                    success = readLDR(&sensors[i]);
                    break;
                case SENSOR_ULTRASONIC:
                    success = readUltrasonic(&sensors[i]);
                    break;
            }
            
            sensors[i].lastRead = currentTime;
            
            if (success) {
                printSensorData(&sensors[i]);
            }
        }
    }
}

// 센서 데이터 출력
void printSensorData(Sensor *sensor) {
    Serial.print("[");
    Serial.print(millis());
    Serial.print("ms] ");
    
    switch (sensor->type) {
        case SENSOR_DHT11:
            Serial.print("🌡️ 온도: ");
            Serial.print(sensor->value1);
            Serial.print("°C, 💧 습도: ");
            Serial.print(sensor->value2);
            Serial.println("%");
            break;
            
        case SENSOR_LDR:
            Serial.print("💡 조도: ");
            Serial.print(sensor->value1);
            Serial.println("%");
            break;
            
        case SENSOR_ULTRASONIC:
            Serial.print("📏 거리: ");
            Serial.print(sensor->value1);
            Serial.println("cm");
            break;
    }
}

void setup() {
    Serial.begin(9600);
    Serial.println("🚀 다중 센서 시스템 시작!");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━");
    
    initSensors();
}

void loop() {
    updateSensors();
    
    // 다른 작업도 여기서 수행 가능
    // 논블로킹 방식이라 시스템이 멈추지 않음!
}

이 코드의 핵심은 논블로킹(Non-blocking) 방식이야! 각 센서가 자신의 읽기 간격을 가지고 있어서, 하나의 센서를 기다리느라 다른 센서가 멈추는 일이 없어. 이게 바로 실전 IoT 시스템의 핵심이지! ⚡

📡 데이터 통신 프로토콜

센서 데이터를 수집했으면 이제 어딘가로 보내야겠지? IoT의 핵심은 바로 **통신**이야! 여러 가지 통신 방법이 있는데, 하나씩 알아보자. 📶 가장 기본적인 통신 방법이야. 우리가 지금까지 사용한 Serial.print()가 바로 UART 통신이지! 간단하지만 강력해:

// JSON 형식으로 데이터 전송
void sendSensorDataJSON() {
    Serial.print("{");
    Serial.print("\"temperature\":");
    Serial.print(sensors[SENSOR_DHT11].value1);
    Serial.print(",\"humidity\":");
    Serial.print(sensors[SENSOR_DHT11].value2);
    Serial.print(",\"light\":");
    Serial.print(sensors[SENSOR_LDR].value1);
    Serial.print(",\"distance\":");
    Serial.print(sensors[SENSOR_ULTRASONIC].value1);
    Serial.print(",\"timestamp\":");
    Serial.print(millis());
    Serial.println("}");
}

// 바이너리 프로토콜 (더 효율적)
typedef struct {
    uint8_t header;      // 0xAA (시작 마커)
    float temperature;
    float humidity;
    float light;
    float distance;
    uint32_t timestamp;
    uint8_t checksum;
} __attribute__((packed)) DataPacket;

void sendBinaryData() {
    DataPacket packet;
    packet.header = 0xAA;
    packet.temperature = sensors[SENSOR_DHT11].value1;
    packet.humidity = sensors[SENSOR_DHT11].value2;
    packet.light = sensors[SENSOR_LDR].value1;
    packet.distance = sensors[SENSOR_ULTRASONIC].value1;
    packet.timestamp = millis();
    
    // 체크섬 계산 (간단한 XOR)
    uint8_t *data = (uint8_t*)&packet;
    packet.checksum = 0;
    for (int i = 0; i < sizeof(DataPacket) - 1; i++) {
        packet.checksum ^= data[i];
    }
    
    // 바이너리 데이터 전송
    Serial.write((uint8_t*)&packet, sizeof(DataPacket));
}

JSON은 사람이 읽기 쉽지만 데이터 크기가 커. 반면 바이너리 프로토콜은 효율적이지만 파싱이 복잡해. 상황에 맞게 선택하면 돼! 🎯 ESP32를 사용하면 WiFi로 데이터를 전송할 수 있어. 진짜 IoT의 시작이지! 🌐

#include <WiFi.h>
#include <HTTPClient.h>

const char* ssid = "your_wifi_ssid";
const char* password = "your_wifi_password";
const char* serverUrl = "http://your-server.com/api/sensor-data";

void setupWiFi() {
    Serial.print("WiFi 연결 중");
    WiFi.begin(ssid, password);
    
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    
    Serial.println("\n✅ WiFi 연결 완료!");
    Serial.print("IP 주소: ");
    Serial.println(WiFi.localIP());
}

void sendDataToServer() {
    if (WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        http.begin(serverUrl);
        http.addHeader("Content-Type", "application/json");
        
        // JSON 데이터 생성
        String jsonData = "{";
        jsonData += "\"temperature\":" + String(sensors[SENSOR_DHT11].value1) + ",";
        jsonData += "\"humidity\":" + String(sensors[SENSOR_DHT11].value2) + ",";
        jsonData += "\"light\":" + String(sensors[SENSOR_LDR].value1) + ",";
        jsonData += "\"distance\":" + String(sensors[SENSOR_ULTRASONIC].value1) + ",";
        jsonData += "\"timestamp\":" + String(millis());
        jsonData += "}";
        
        // POST 요청
        int httpResponseCode = http.POST(jsonData);
        
        if (httpResponseCode > 0) {
            String response = http.getString();
            Serial.print("✅ 서버 응답: ");
            Serial.println(response);
        } else {
            Serial.print("❌ 전송 실패: ");
            Serial.println(httpResponseCode);
        }
        
        http.end();
    } else {
        Serial.println("⚠️ WiFi 연결 끊김!");
    }
}

// MQTT 프로토콜 (더 효율적인 IoT 통신)
#include <PubSubClient.h>

WiFiClient espClient;
PubSubClient mqttClient(espClient);

const char* mqttServer = "broker.hivemq.com";
const int mqttPort = 1883;
const char* mqttTopic = "myiot/sensors";

void setupMQTT() {
    mqttClient.setServer(mqttServer, mqttPort);
    mqttClient.setCallback(mqttCallback);
}

void mqttCallback(char* topic, byte* payload, unsigned int length) {
    Serial.print("📨 메시지 수신: ");
    for (int i = 0; i < length; i++) {
        Serial.print((char)payload[i]);
    }
    Serial.println();
}

void reconnectMQTT() {
    while (!mqttClient.connected()) {
        Serial.print("MQTT 연결 시도...");
        
        if (mqttClient.connect("ESP32Client")) {
            Serial.println("✅ 연결 성공!");
            mqttClient.subscribe("myiot/commands");
        } else {
            Serial.print("❌ 실패, rc=");
            Serial.print(mqttClient.state());
            Serial.println(" 5초 후 재시도");
            delay(5000);
        }
    }
}

void publishSensorData() {
    if (!mqttClient.connected()) {
        reconnectMQTT();
    }
    mqttClient.loop();
    
    String payload = "{";
    payload += "\"temp\":" + String(sensors[SENSOR_DHT11].value1) + ",";
    payload += "\"humid\":" + String(sensors[SENSOR_DHT11].value2);
    payload += "}";
    
    mqttClient.publish(mqttTopic, payload.c_str());
    Serial.println("📤 데이터 발행 완료!");
}

MQTT는 IoT에 최적화된 프로토콜이야. HTTP보다 훨씬 가볍고 효율적이지! 실시간 양방향 통신도 가능해서 명령을 받아 액추에이터를 제어할 수도 있어. 🎮

💾 데이터 저장 및 로깅 시스템

센서 데이터를 수집하고 통신까지 했다면, 이제 데이터를 저장해야겠지? 나중에 분석하거나 문제가 생겼을 때 디버깅하려면 로그가 필수야! 📝 아두이노나 ESP32에 SD 카드 모듈을 연결하면 로컬에 데이터를 저장할 수 있어. 인터넷 연결이 끊겨도 데이터를 잃어버리지 않지!

#include <SD.h>
#include <SPI.h>

#define SD_CS_PIN 5  // SD 카드 칩 셀렉트 핀

File dataFile;
unsigned long lastLogTime = 0;
const unsigned long LOG_INTERVAL = 60000;  // 1분마다 로그

bool initSDCard() {
    Serial.print("SD 카드 초기화 중...");
    
    if (!SD.begin(SD_CS_PIN)) {
        Serial.println("❌ SD 카드 초기화 실패!");
        return false;
    }
    
    Serial.println("✅ SD 카드 준비 완료!");
    
    // 로그 파일 헤더 작성 (파일이 없을 때만)
    if (!SD.exists("/sensor_log.csv")) {
        dataFile = SD.open("/sensor_log.csv", FILE_WRITE);
        if (dataFile) {
            dataFile.println("Timestamp,Temperature,Humidity,Light,Distance");
            dataFile.close();
            Serial.println("📄 새 로그 파일 생성");
        }
    }
    
    return true;
}

void logSensorData() {
    unsigned long currentTime = millis();
    
    // 로그 간격 체크
    if (currentTime - lastLogTime < LOG_INTERVAL) {
        return;
    }
    
    lastLogTime = currentTime;
    
    // CSV 형식으로 데이터 저장
    dataFile = SD.open("/sensor_log.csv", FILE_APPEND);
    
    if (dataFile) {
        dataFile.print(currentTime);
        dataFile.print(",");
        dataFile.print(sensors[SENSOR_DHT11].value1);
        dataFile.print(",");
        dataFile.print(sensors[SENSOR_DHT11].value2);
        dataFile.print(",");
        dataFile.print(sensors[SENSOR_LDR].value1);
        dataFile.print(",");
        dataFile.println(sensors[SENSOR_ULTRASONIC].value1);
        
        dataFile.close();
        
        Serial.println("💾 데이터 저장 완료!");
    } else {
        Serial.println("❌ 파일 열기 실패!");
    }
}

// 로그 파일 읽기 및 출력
void printLogFile() {
    dataFile = SD.open("/sensor_log.csv", FILE_READ);
    
    if (dataFile) {
        Serial.println("📖 로그 파일 내용:");
        Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━");
        
        while (dataFile.available()) {
            Serial.write(dataFile.read());
        }
        
        dataFile.close();
        Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━");
    } else {
        Serial.println("❌ 로그 파일 없음!");
    }
}

// 로그 파일 크기 관리 (순환 로깅)
void manageLogSize() {
    File logFile = SD.open("/sensor_log.csv", FILE_READ);
    
    if (logFile) {
        unsigned long fileSize = logFile.size();
        logFile.close();
        
        // 파일이 1MB를 초과하면 백업하고 새로 시작
        if (fileSize > 1048576) {
            Serial.println("📦 로그 파일 백업 중...");
            
            // 기존 파일을 백업으로 이름 변경
            SD.remove("/sensor_log_old.csv");
            SD.rename("/sensor_log.csv", "/sensor_log_old.csv");
            
            // 새 로그 파일 생성
            dataFile = SD.open("/sensor_log.csv", FILE_WRITE);
            if (dataFile) {
                dataFile.println("Timestamp,Temperature,Humidity,Light,Distance");
                dataFile.close();
                Serial.println("✅ 새 로그 파일 시작!");
            }
        }
    }
}

이렇게 하면 장기간 데이터를 안전하게 저장할 수 있어! CSV 형식이라 엑셀이나 파이썬으로 분석하기도 쉽지. 📊 설정값이나 중요한 데이터는 EEPROM에 저장하면 전원이 꺼져도 유지돼. 하지만 쓰기 횟수 제한이 있으니 주의해야 해!

#include <EEPROM.h>

// EEPROM 주소 정의
#define EEPROM_SIZE 512
#define ADDR_TEMP_THRESHOLD 0
#define ADDR_HUMID_THRESHOLD 4
#define ADDR_LOG_INTERVAL 8
#define ADDR_WIFI_SSID 12
#define ADDR_WIFI_PASS 44

// 설정 구조체
typedef struct {
    float tempThreshold;
    float humidThreshold;
    unsigned long logInterval;
    char wifiSSID[32];
    char wifiPassword[32];
} SystemConfig;

SystemConfig config;

void initEEPROM() {
    EEPROM.begin(EEPROM_SIZE);
    Serial.println("💾 EEPROM 초기화 완료");
}

// 설정 저장
void saveConfig() {
    EEPROM.put(ADDR_TEMP_THRESHOLD, config.tempThreshold);
    EEPROM.put(ADDR_HUMID_THRESHOLD, config.humidThreshold);
    EEPROM.put(ADDR_LOG_INTERVAL, config.logInterval);
    
    // 문자열 저장
    for (int i = 0; i < 32; i++) {
        EEPROM.write(ADDR_WIFI_SSID + i, config.wifiSSID[i]);
        EEPROM.write(ADDR_WIFI_PASS + i, config.wifiPassword[i]);
    }
    
    EEPROM.commit();  // ESP32에서는 commit 필요
    Serial.println("✅ 설정 저장 완료!");
}

// 설정 불러오기
void loadConfig() {
    EEPROM.get(ADDR_TEMP_THRESHOLD, config.tempThreshold);
    EEPROM.get(ADDR_HUMID_THRESHOLD, config.humidThreshold);
    EEPROM.get(ADDR_LOG_INTERVAL, config.logInterval);
    
    // 문자열 불러오기
    for (int i = 0; i < 32; i++) {
        config.wifiSSID[i] = EEPROM.read(ADDR_WIFI_SSID + i);
        config.wifiPassword[i] = EEPROM.read(ADDR_WIFI_PASS + i);
    }
    
    Serial.println("✅ 설정 불러오기 완료!");
    printConfig();
}

void printConfig() {
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("⚙️ 현재 설정:");
    Serial.print("온도 임계값: ");
    Serial.print(config.tempThreshold);
    Serial.println("°C");
    Serial.print("습도 임계값: ");
    Serial.print(config.humidThreshold);
    Serial.println("%");
    Serial.print("로그 간격: ");
    Serial.print(config.logInterval / 1000);
    Serial.println("초");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━");
}

🎨 고급 데이터 처리 기법

이제 좀 더 고급 기술을 배워볼까? 실제 산업 현장에서 사용하는 데이터 처리 기법들이야! 🚀 센서가 가끔 이상한 값을 뱉을 때가 있어. 이런 이상치를 자동으로 감지하고 제거하는 알고리즘을 만들어보자!

#define HISTORY_SIZE 20

typedef struct {
    float values[HISTORY_SIZE];
    int count;
    int index;
} DataHistory;

DataHistory tempHistory;

void initHistory(DataHistory *hist) {
    hist->count = 0;
    hist->index = 0;
    for (int i = 0; i < HISTORY_SIZE; i++) {
        hist->values[i] = 0.0;
    }
}

void addToHistory(DataHistory *hist, float value) {
    hist->values[hist->index] = value;
    hist->index = (hist->index + 1) % HISTORY_SIZE;
    if (hist->count < HISTORY_SIZE) {
        hist->count++;
    }
}

// 평균 계산
float calculateMean(DataHistory *hist) {
    if (hist->count == 0) return 0.0;
    
    float sum = 0.0;
    for (int i = 0; i < hist->count; i++) {
        sum += hist->values[i];
    }
    return sum / hist->count;
}

// 표준편차 계산
float calculateStdDev(DataHistory *hist) {
    if (hist->count < 2) return 0.0;
    
    float mean = calculateMean(hist);
    float sumSquares = 0.0;
    
    for (int i = 0; i < hist->count; i++) {
        float diff = hist->values[i] - mean;
        sumSquares += diff * diff;
    }
    
    return sqrt(sumSquares / (hist->count - 1));
}

// 이상치 판단 (Z-score 방법)
bool isOutlier(DataHistory *hist, float newValue, float threshold) {
    if (hist->count < 3) return false;  // 데이터가 충분하지 않음
    
    float mean = calculateMean(hist);
    float stdDev = calculateStdDev(hist);
    
    if (stdDev < 0.01) return false;  // 표준편차가 너무 작음
    
    // Z-score 계산
    float zScore = abs(newValue - mean) / stdDev;
    
    // 임계값 초과 시 이상치로 판단
    if (zScore > threshold) {
        Serial.print("🚨 이상치 감지! 값: ");
        Serial.print(newValue);
        Serial.print(", Z-score: ");
        Serial.println(zScore);
        return true;
    }
    
    return false;
}

// 이상치 제거 후 값 반환
float getFilteredValue(DataHistory *hist, float newValue) {
    // 이상치 판단 (Z-score > 3이면 이상치)
    if (isOutlier(hist, newValue, 3.0)) {
        // 이상치면 이전 평균값 반환
        Serial.println("⚠️ 이상치 제거, 평균값 사용");
        return calculateMean(hist);
    }
    
    // 정상 값이면 히스토리에 추가하고 반환
    addToHistory(hist, newValue);
    return newValue;
}

void loop() {
    delay(2000);
    
    float rawTemp = dht.readTemperature();
    
    if (!isnan(rawTemp)) {
        // 이상치 필터링 적용
        float filteredTemp = getFilteredValue(&tempHistory, rawTemp);
        
        Serial.print("원본: ");
        Serial.print(rawTemp);
        Serial.print("°C → 필터링: ");
        Serial.print(filteredTemp);
        Serial.println("°C");
    }
}

이 알고리즘은 통계적 방법으로 이상치를 감지해. Z-score가 3을 넘으면 99.7% 확률로 이상치라고 판단할 수 있어! 📈 과거 데이터를 바탕으로 미래 값을 예측할 수도 있어! 간단한 선형 회귀를 구현해보자:

typedef struct {
    float slope;
    float intercept;
    float correlation;
} RegressionModel;

// 선형 회귀 계산
RegressionModel calculateRegression(DataHistory *hist) {
    RegressionModel model = {0.0, 0.0, 0.0};
    
    if (hist->count < 2) return model;
    
    float sumX = 0.0, sumY = 0.0, sumXY = 0.0, sumX2 = 0.0;
    
    for (int i = 0; i < hist->count; i++) {
        float x = (float)i;
        float y = hist->values[i];
        
        sumX += x;
        sumY += y;
        sumXY += x * y;
        sumX2 += x * x;
    }
    
    int n = hist->count;
    
    // 기울기 계산
    model.slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
    
    // 절편 계산
    model.intercept = (sumY - model.slope * sumX) / n;
    
    // 상관계수 계산
    float meanX = sumX / n;
    float meanY = sumY / n;
    float sumXDiff2 = 0.0, sumYDiff2 = 0.0, sumXYDiff = 0.0;
    
    for (int i = 0; i < n; i++) {
        float xDiff = i - meanX;
        float yDiff = hist->values[i] - meanY;
        sumXDiff2 += xDiff * xDiff;
        sumYDiff2 += yDiff * yDiff;
        sumXYDiff += xDiff * yDiff;
    }
    
    model.correlation = sumXYDiff / sqrt(sumXDiff2 * sumYDiff2);
    
    return model;
}

// 미래 값 예측
float predictValue(RegressionModel *model, int stepsAhead) {
    int futureX = HISTORY_SIZE + stepsAhead;
    return model->slope * futureX + model->intercept;
}

void analyzeTemperatureTrend() {
    RegressionModel model = calculateRegression(&tempHistory);
    
    Serial.println("📊 온도 트렌드 분석:");
    Serial.print("기울기: ");
    Serial.println(model.slope, 4);
    Serial.print("상관계수: ");
    Serial.println(model.correlation, 4);
    
    if (model.slope > 0.1) {
        Serial.println("📈 온도 상승 추세!");
    } else if (model.slope < -0.1) {
        Serial.println("📉 온도 하강 추세!");
    } else {
        Serial.println("➡️ 온도 안정적");
    }
    
    // 10분 후 예측
    float prediction = predictValue(&model, 5);  // 5개 데이터 포인트 후
    Serial.print("🔮 예상 온도 (10분 후): ");
    Serial.print(prediction);
    Serial.println("°C");
}

이런 예측 알고리즘을 사용하면 온도가 임계값을 넘기 전에 미리 경고를 줄 수 있어! 정말 스마트하지? 🧠

⚡ 전력 관리 및 최적화

IoT 기기는 대부분 배터리로 동작하잖아? 그래서 전력 관리가 정말 중요해! 효율적인 전력 관리 기법을 알아보자. 🔋 센서를 계속 읽을 필요가 없다면 마이크로컨트롤러를 슬립 모드로 보내자. 전력 소비를 90% 이상 줄일 수 있어!

#include <esp_sleep.h>  // ESP32용

#define SLEEP_DURATION 60  // 초 단위

// 딥 슬립 설정
void setupDeepSleep() {
    // 타이머로 깨어나기 설정
    esp_sleep_enable_timer_wakeup(SLEEP_DURATION * 1000000ULL);
    
    Serial.println("💤 딥 슬립 모드 진입...");
    Serial.flush();  // 시리얼 버퍼 비우기
    
    // 딥 슬립 진입
    esp_deep_sleep_start();
}

// 라이트 슬립 (더 빠른 깨어남)
void lightSleep(int seconds) {
    Serial.println("😴 라이트 슬립 모드...");
    
    esp_sleep_enable_timer_wakeup(seconds * 1000000ULL);
    esp_light_sleep_start();
    
    Serial.println("👀 깨어남!");
}

// 센서 읽기 → 전송 → 슬립 사이클
void efficientDataCollection() {
    // 1. 센서 데이터 읽기
    float temp = dht.readTemperature();
    float humid = dht.readHumidity();
    
    // 2. 데이터 전송
    if (!isnan(temp) && !isnan(humid)) {
        sendDataToServer();  // WiFi로 전송
    }
    
    // 3. WiFi 끄기 (전력 절약)
    WiFi.disconnect(true);
    WiFi.mode(WIFI_OFF);
    
    // 4. 딥 슬립 (1분간)
    setupDeepSleep();
}

// 깨어났을 때 실행되는 코드
void setup() {
    Serial.begin(115200);
    
    // 깨어난 이유 확인
    esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
    
    switch(wakeup_reason) {
        case ESP_SLEEP_WAKEUP_TIMER:
            Serial.println("⏰ 타이머로 깨어남");
            break;
        case ESP_SLEEP_WAKEUP_EXT0:
            Serial.println("🔔 외부 인터럽트로 깨어남");
            break;
        default:
            Serial.println("🔌 전원 켜짐");
            break;
    }
    
    // WiFi 연결
    setupWiFi();
    
    // 센서 초기화
    dht.begin();
}

void loop() {
    efficientDataCollection();
    // 이 코드는 실행되지 않음 (딥 슬립 후 재부팅)
}

딥 슬립을 사용하면 배터리 수명이 몇 주에서 몇 달로 늘어날 수 있어! 하지만 깨어날 때마다 재부팅되니 주의해야 해. 💡 상황에 따라 센서 읽기 주기를 조절하는 것도 좋은 방법이야:

typedef enum {
    POWER_MODE_NORMAL,
    POWER_MODE_ECO,
    POWER_MODE_ULTRA_ECO
} PowerMode;

PowerMode currentPowerMode = POWER_MODE_NORMAL;
float batteryVoltage = 4.2;  // 리튬 배터리 전압

// 배터리 전압 읽기 (ESP32 ADC 사용)
float readBatteryVoltage() {
    int adcValue = analogRead(35);  // 배터리 전압 분배 회로 연결
    // ADC 값을 전압으로 변환 (보정 필요)
    return (adcValue / 4095.0) * 3.3 * 2.0;  // 전압 분배 비율 2:1
}

// 전력 모드 결정
void updatePowerMode() {
    batteryVoltage = readBatteryVoltage();
    
    if (batteryVoltage > 3.8) {
        currentPowerMode = POWER_MODE_NORMAL;
        Serial.println("🔋 배터리 충분 - 일반 모드");
    } else if (batteryVoltage > 3.5) {
        currentPowerMode = POWER_MODE_ECO;
        Serial.println("🔋 배터리 보통 - 절약 모드");
    } else {
        currentPowerMode = POWER_MODE_ULTRA_ECO;
        Serial.println("🔋 배터리 부족 - 초절약 모드");
    }
}

// 모드에 따른 센서 읽기 간격
unsigned long getSensorInterval() {
    switch (currentPowerMode) {
        case POWER_MODE_NORMAL:
            return 10000;   // 10초
        case POWER_MODE_ECO:
            return 60000;   // 1분
        case POWER_MODE_ULTRA_ECO:
            return 300000;  // 5분
        default:
            return 10000;
    }
}

// 모드에 따른 WiFi 사용 결정
bool shouldUseWiFi() {
    switch (currentPowerMode) {
        case POWER_MODE_NORMAL:
            return true;    // 항상 전송
        case POWER_MODE_ECO:
            return (millis() % 300000 < 10000);  // 5분마다 전송
        case POWER_MODE_ULTRA_ECO:
            return false;   // SD 카드에만 저장
        default:
            return true;
    }
}

void smartDataCollection() {
    static unsigned long lastSensorRead = 0;
    unsigned long currentTime = millis();
    
    // 전력 모드 업데이트 (10분마다)
    if (currentTime % 600000 < 1000) {
        updatePowerMode();
    }
    
    // 센서 읽기 간격 체크
    if (currentTime - lastSensorRead >= getSensorInterval()) {
        lastSensorRead = currentTime;
        
        // 센서 데이터 읽기
        float temp = dht.readTemperature();
        float humid = dht.readHumidity();
        
        // SD 카드에 저장 (항상)
        logSensorData();
        
        // WiFi 전송 (모드에 따라)
        if (shouldUseWiFi()) {
            sendDataToServer();
        }
    }
}

이렇게 하면 배터리 상태에 따라 자동으로 전력 소비를 조절할 수 있어! 정말 스마트하지? 🤖

🛡️ 에러 처리 및 시스템 안정성

실전 IoT 시스템에서는 예상치 못한 문제가 항상 발생해. 견고한 에러 처리가 필수야! 🛠️ 시스템이 멈췄을 때 자동으로 재시작하는 워치독 타이머를 설정하자:

#include <esp_task_wdt.h>

#define WDT_TIMEOUT 30  // 30초

void setupWatchdog() {
    Serial.println("🐕 워치독 타이머 설정");
    
    // 워치독 초기화
    esp_task_wdt_init(WDT_TIMEOUT, true);
    esp_task_wdt_add(NULL);  // 현재 태스크 추가
}

void feedWatchdog() {
    // 워치독에게 "나 살아있어!" 신호 보내기
    esp_task_wdt_reset();
}

void loop() {
    // 센서 읽기
    updateSensors();
    
    // 데이터 처리
    processData();
    
    // 워치독 리셋 (정상 동작 중임을 알림)
    feedWatchdog();
    
    delay(1000);
}

WiFi 연결이나 센서 읽기가 실패했을 때 자동으로 재시도하는 로직:

typedef struct {
    int maxRetries;
    int currentRetry;
    unsigned long retryDelay;
    unsigned long lastAttempt;
} RetryHandler;

bool readSensorWithRetry(RetryHandler *retry) {
    unsigned long currentTime = millis();
    
    // 재시도 간격 체크
    if (currentTime - retry->lastAttempt < retry->retryDelay) {
        return false;
    }
    
    retry->lastAttempt = currentTime;
    
    // 센서 읽기 시도
    float temp = dht.readTemperature();
    
    if (isnan(temp)) {
        retry->currentRetry++;
        
        Serial.print("❌ 센서 읽기 실패 (");
        Serial.print(retry->currentRetry);
        Serial.print("/");
        Serial.print(retry->maxRetries);
        Serial.println(")");
        
        if (retry->currentRetry >= retry->maxRetries) {
            Serial.println("🚨 최대 재시도 횟수 초과!");
            // 센서 재초기화 시도
            dht.begin();
            retry->currentRetry = 0;
            retry->retryDelay *= 2;  // 지수 백오프
        }
        
        return false;
    }
    
    // 성공!
    retry->currentRetry = 0;
    retry->retryDelay = 1000;  // 초기값으로 리셋
    return true;
}

// WiFi 재연결 로직
bool reconnectWiFi(int maxAttempts) {
    int attempts = 0;
    
    while (WiFi.status() != WL_CONNECTED && attempts < maxAttempts) {
        attempts++;
        
        Serial.print("🔄 WiFi 재연결 시도 ");
        Serial.print(attempts);
        Serial.print("/");
        Serial.println(maxAttempts);
        
        WiFi.disconnect();
        delay(1000);
        WiFi.begin(ssid, password);
        
        int timeout = 0;
        while (WiFi.status() != WL_CONNECTED && timeout < 20) {
            delay(500);
            Serial.print(".");
            timeout++;
        }
        
        if (WiFi.status() == WL_CONNECTED) {
            Serial.println("\n✅ WiFi 재연결 성공!");
            return true;
        }
    }
    
    Serial.println("\n❌ WiFi 재연결 실패");
    return false;
}

시스템의 건강 상태를 지속적으로 체크하는 모니터링 시스템:

typedef struct {
    unsigned long uptime;
    int wifiReconnects;
    int sensorErrors;
    int dataTransmissions;
    int failedTransmissions;
    float avgLoopTime;
    unsigned long freeHeap;
} SystemStats;

SystemStats stats = {0};

void updateSystemStats() {
    static unsigned long lastUpdate = 0;
    static unsigned long loopStartTime = 0;
    static int loopCount = 0;
    
    unsigned long currentTime = millis();
    
    // 루프 시간 측정
    if (loopStartTime > 0) {
        unsigned long loopTime = currentTime - loopStartTime;
        stats.avgLoopTime = (stats.avgLoopTime * loopCount + loopTime) / (loopCount + 1);
        loopCount++;
    }
    loopStartTime = currentTime;
    
    // 1분마다 통계 업데이트
    if (currentTime - lastUpdate >= 60000) {
        lastUpdate = currentTime;
        
        stats.uptime = currentTime / 1000;  // 초 단위
        stats.freeHeap = ESP.getFreeHeap();
        
        printSystemStats();
    }
}

void printSystemStats() {
    Serial.println("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("📊 시스템 통계");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    
    // 가동 시간
    unsigned long hours = stats.uptime / 3600;
    unsigned long minutes = (stats.uptime % 3600) / 60;
    Serial.print("⏱️  가동 시간: ");
    Serial.print(hours);
    Serial.print("시간 ");
    Serial.print(minutes);
    Serial.println("분");
    
    // WiFi 통계
    Serial.print("📡 WiFi 재연결: ");
    Serial.print(stats.wifiReconnects);
    Serial.println("회");
    
    // 센서 통계
    Serial.print("🌡️  센서 에러: ");
    Serial.print(stats.sensorErrors);
    Serial.println("회");
    
    // 전송 통계
    Serial.print("📤 데이터 전송: ");
    Serial.print(stats.dataTransmissions);
    Serial.print("회 (실패: ");
    Serial.print(stats.failedTransmissions);
    Serial.println("회)");
    
    float successRate = 100.0 * (stats.dataTransmissions - stats.failedTransmissions) / 
                        max(stats.dataTransmissions, 1);
    Serial.print("✅ 성공률: ");
    Serial.print(successRate, 1);
    Serial.println("%");
    
    // 성능 통계
    Serial.print("⚡ 평균 루프 시간: ");
    Serial.print(stats.avgLoopTime);
    Serial.println("ms");
    
    // 메모리 통계
    Serial.print("💾 여유 메모리: ");
    Serial.print(stats.freeHeap);
    Serial.println(" bytes");
    
    // 배터리 상태
    Serial.print("🔋 배터리 전압: ");
    Serial.print(batteryVoltage, 2);
    Serial.println("V");
    
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
}

// 시스템 건강 체크
bool isSystemHealthy() {
    bool healthy = true;
    
    // 메모리 부족 체크
    if (stats.freeHeap < 10000) {
        Serial.println("⚠️ 경고: 메모리 부족!");
        healthy = false;
    }
    
    // 센서 에러율 체크
    if (stats.sensorErrors > 100) {
        Serial.println("⚠️ 경고: 센서 에러 과다!");
        healthy = false;
    }
    
    // 전송 실패율 체크
    float failRate = 100.0 * stats.failedTransmissions / max(stats.dataTransmissions, 1);
    if (failRate > 50.0) {
        Serial.println("⚠️ 경고: 데이터 전송 실패율 높음!");
        healthy = false;
    }
    
    // 배터리 체크
    if (batteryVoltage < 3.3) {
        Serial.println("🔴 경고: 배터리 위험 수준!");
        healthy = false;
    }
    
    return healthy;
}

이런 모니터링 시스템이 있으면 문제를 조기에 발견하고 대응할 수 있어! 🎯

🌐 실전 프로젝트: 스마트 환경 모니터링 시스템

자, 이제 지금까지 배운 모든 걸 종합해서 완전한 IoT 시스템을 만들어보자! 이건 실제로 사용할 수 있는 수준의 프로젝트야. 🏆 우리가 만들 시스템은 이런 구조야:

**하드웨어 레이어**
• ESP32 메인 보드
• DHT22 온습도 센서
• BH1750 조도 센서
• MQ-135 공기질 센서
• OLED 디스플레이
• SD 카드 모듈
• 배터리 + 충전 회로

**소프트웨어 레이어**
• 센서 데이터 수집 모듈
• 데이터 필터링 및 처리
• 로컬 저장 (SD 카드)
• WiFi 통신 (MQTT)
• 웹 서버 (설정 페이지)
• 전력 관리
• 에러 처리

// 완전한 스마트 환경 모니터링 시스템
#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <DHT.h>
#include <BH1750.h>
#include <SD.h>
#include <ArduinoJson.h>

// ========== 핀 정의 ==========
#define DHT_PIN 4
#define DHT_TYPE DHT22
#define MQ135_PIN 34
#define SD_CS_PIN 5
#define BATTERY_PIN 35

// ========== 디스플레이 설정 ==========
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// ========== 센서 객체 ==========
DHT dht(DHT_PIN, DHT_TYPE);
BH1750 lightMeter;

// ========== WiFi & MQTT 설정 ==========
const char* ssid = "YourWiFiSSID";
const char* password = "YourPassword";
const char* mqtt_server = "broker.hivemq.com";
const char* mqtt_topic = "smartenv/data";

WiFiClient espClient;
PubSubClient mqtt(espClient);

// ========== 데이터 구조체 ==========
typedef struct {
    float temperature;
    float humidity;
    float light;
    int airQuality;
    float batteryVoltage;
    unsigned long timestamp;
    bool valid;
} EnvironmentData;

EnvironmentData currentData;
EnvironmentData dataHistory[100];
int historyIndex = 0;

// ========== 시스템 상태 ==========
typedef enum {
    STATE_INIT,
    STATE_NORMAL,
    STATE_LOW_POWER,
    STATE_ERROR
} SystemState;

SystemState systemState = STATE_INIT;

// ========== 필터 ==========
MovingAverage tempFilter;
MovingAverage humidFilter;
MovingAverage lightFilter;

// ========== 초기화 함수들 ==========
void setupDisplay() {
    if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
        Serial.println("❌ OLED 초기화 실패!");
        return;
    }
    
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 0);
    display.println("Smart Environment");
    display.println("Monitor v1.0");
    display.display();
    delay(2000);
    
    Serial.println("✅ 디스플레이 초기화 완료");
}

void setupSensors() {
    // DHT22 초기화
    dht.begin();
    Serial.println("✅ DHT22 초기화");
    
    // BH1750 초기화
    if (lightMeter.begin(BH1750::CONTINUOUS_HIGH_RES_MODE)) {
        Serial.println("✅ BH1750 초기화");
    } else {
        Serial.println("❌ BH1750 초기화 실패");
    }
    
    // MQ-135 핀 설정
    pinMode(MQ135_PIN, INPUT);
    Serial.println("✅ MQ-135 초기화");
    
    // 필터 초기화
    initMovingAverage(&tempFilter);
    initMovingAverage(&humidFilter);
    initMovingAverage(&lightFilter);
}

void setupSDCard() {
    if (!SD.begin(SD_CS_PIN)) {
        Serial.println("❌ SD 카드 초기화 실패");
        return;
    }
    
    Serial.println("✅ SD 카드 초기화 완료");
    
    // 로그 파일 생성
    File logFile = SD.open("/env_log.csv", FILE_WRITE);
    if (logFile) {
        logFile.println("Timestamp,Temp,Humid,Light,AirQuality,Battery");
        logFile.close();
    }
}

void setupWiFiAndMQTT() {
    Serial.print("WiFi 연결 중");
    WiFi.begin(ssid, password);
    
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 20) {
        delay(500);
        Serial.print(".");
        attempts++;
    }
    
    if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\n✅ WiFi 연결 성공!");
        Serial.print("IP: ");
        Serial.println(WiFi.localIP());
        
        mqtt.setServer(mqtt_server, 1883);
        connectMQTT();
    } else {
        Serial.println("\n❌ WiFi 연결 실패");
    }
}

void connectMQTT() {
    while (!mqtt.connected()) {
        Serial.print("MQTT 연결 시도...");
        
        if (mqtt.connect("SmartEnvMonitor")) {
            Serial.println("✅ 연결 성공!");
        } else {
            Serial.print("❌ 실패, rc=");
            Serial.println(mqtt.state());
            delay(5000);
        }
    }
}

// ========== 센서 읽기 함수들 ==========
bool readAllSensors() {
    currentData.timestamp = millis();
    currentData.valid = true;
    
    // 온습도 읽기
    float temp = dht.readTemperature();
    float humid = dht.readHumidity();
    
    if (isnan(temp) || isnan(humid)) {
        Serial.println("❌ DHT22 읽기 실패");
        currentData.valid = false;
        return false;
    }
    
    // 필터링 적용
    currentData.temperature = addValue(&tempFilter, temp);
    currentData.humidity = addValue(&humidFilter, humid);
    
    // 조도 읽기
    float lux = lightMeter.readLightLevel();
    currentData.light = addValue(&lightFilter, lux);
    
    // 공기질 읽기 (0-4095)
    currentData.airQuality = analogRead(MQ135_PIN);
    
    // 배터리 전압 읽기
    int batteryADC = analogRead(BATTERY_PIN);
    currentData.batteryVoltage = (batteryADC / 4095.0) * 3.3 * 2.0;
    
    // 히스토리에 저장
    dataHistory[historyIndex] = currentData;
    historyIndex = (historyIndex + 1) % 100;
    
    return true;
}

// ========== 디스플레이 업데이트 ==========
void updateDisplay() {
    display.clearDisplay();
    display.setTextSize(1);
    display.setCursor(0, 0);
    
    // 온도
    display.print("Temp: ");
    display.print(currentData.temperature, 1);
    display.println(" C");
    
    // 습도
    display.print("Humid: ");
    display.print(currentData.humidity, 1);
    display.println(" %");
    
    // 조도
    display.print("Light: ");
    display.print(currentData.light, 0);
    display.println(" lux");
    
    // 공기질
    display.print("Air: ");
    if (currentData.airQuality < 1000) {
        display.println("Good");
    } else if (currentData.airQuality < 2000) {
        display.println("Moderate");
    } else {
        display.println("Poor");
    }
    
    // 배터리
    display.print("Batt: ");
    display.print(currentData.batteryVoltage, 2);
    display.println("V");
    
    // WiFi 상태
    if (WiFi.status() == WL_CONNECTED) {
        display.println("WiFi: OK");
    } else {
        display.println("WiFi: --");
    }
    
    display.display();
}

// ========== 데이터 저장 ==========
void saveToSD() {
    File logFile = SD.open("/env_log.csv", FILE_APPEND);
    
    if (logFile) {
        logFile.print(currentData.timestamp);
        logFile.print(",");
        logFile.print(currentData.temperature);
        logFile.print(",");
        logFile.print(currentData.humidity);
        logFile.print(",");
        logFile.print(currentData.light);
        logFile.print(",");
        logFile.print(currentData.airQuality);
        logFile.print(",");
        logFile.println(currentData.batteryVoltage);
        
        logFile.close();
        Serial.println("💾 SD 저장 완료");
    }
}

// ========== MQTT 전송 ==========
void publishToMQTT() {
    if (!mqtt.connected()) {
        connectMQTT();
    }
    
    // JSON 생성
    StaticJsonDocument<256> doc;
    doc["temperature"] = currentData.temperature;
    doc["humidity"] = currentData.humidity;
    doc["light"] = currentData.light;
    doc["airQuality"] = currentData.airQuality;
    doc["battery"] = currentData.batteryVoltage;
    doc["timestamp"] = currentData.timestamp;
    
    char jsonBuffer[256];
    serializeJson(doc, jsonBuffer);
    
    if (mqtt.publish(mqtt_topic, jsonBuffer)) {
        Serial.println("📤 MQTT 전송 완료");
    } else {
        Serial.println("❌ MQTT 전송 실패");
    }
}

// ========== 경고 시스템 ==========
void checkAlerts() {
    bool alert = false;
    
    if (currentData.temperature > 35.0) {
        Serial.println("🔴 경고: 고온!");
        alert = true;
    }
    
    if (currentData.humidity > 80.0) {
        Serial.println("💦 경고: 고습도!");
        alert = true;
    }
    
    if (currentData.airQuality > 2000) {
        Serial.println("😷 경고: 공기질 나쁨!");
        alert = true;
    }
    
    if (currentData.batteryVoltage < 3.5) {
        Serial.println("🔋 경고: 배터리 부족!");
        alert = true;
    }
    
    if (alert) {
        // 긴급 알림 전송
        mqtt.publish("smartenv/alerts", "ALERT");
    }
}

// ========== 메인 함수들 ==========
void setup() {
    Serial.begin(115200);
    Serial.println("\n🚀 스마트 환경 모니터링 시스템 시작!");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    
    // 초기화
    setupDisplay();
    setupSensors();
    setupSDCard();
    setupWiFiAndMQTT();
    
    systemState = STATE_NORMAL;
    Serial.println("✅ 모든 초기화 완료!");
}

void loop() {
    static unsigned long lastSensorRead = 0;
    static unsigned long lastMQTTPublish = 0;
    static unsigned long lastSDSave = 0;
    static unsigned long lastDisplayUpdate = 0;
    
    unsigned long currentTime = millis();
    
    // 센서 읽기 (10초마다)
    if (currentTime - lastSensorRead >= 10000) {
        lastSensorRead = currentTime;
        
        if (readAllSensors()) {
            checkAlerts();
        }
    }
    
    // 디스플레이 업데이트 (2초마다)
    if (currentTime - lastDisplayUpdate >= 2000) {
        lastDisplayUpdate = currentTime;
        updateDisplay();
    }
    
    // SD 카드 저장 (1분마다)
    if (currentTime - lastSDSave >= 60000) {
        lastSDSave = currentTime;
        saveToSD();
    }
    
    // MQTT 전송 (30초마다)
    if (currentTime - lastMQTTPublish >= 30000) {
        lastMQTTPublish = currentTime;
        
        if (WiFi.status() == WL_CONNECTED) {
            publishToMQTT();
        }
    }
    
    // MQTT 루프
    mqtt.loop();
    
    delay(100);
}

와! 정말 완전한 시스템이지? 이 코드는 실제로 동작하는 프로덕션 수준의 IoT 시스템이야! 🎉

📈 데이터 분석 및 시각화

센서 데이터를 수집했으면 이제 분석해야겠지? 간단한 통계 분석부터 시작해보자! 📊

typedef struct {
    float min;
    float max;
    float mean;
    float stdDev;
    float median;
} Statistics;

Statistics calculateStatistics(float* data, int count) {
    Statistics stats = {0};
    
    if (count == 0) return stats;
    
    // 최소/최대/합계
    stats.min = data[0];
    stats.max = data[0];
    float sum = 0.0;
    
    for (int i = 0; i < count; i++) {
        if (data[i] < stats.min) stats.min = data[i];
        if (data[i] > stats.max) stats.max = data[i];
        sum += data[i];
    }
    
    // 평균
    stats.mean = sum / count;
    
    // 표준편차
    float sumSquares = 0.0;
    for (int i = 0; i < count; i++) {
        float diff = data[i] - stats.mean;
        sumSquares += diff * diff;
    }
    stats.stdDev = sqrt(sumSquares / count);
    
    // 중간값 (정렬 필요)
    float sorted[count];
    memcpy(sorted, data, count * sizeof(float));
    
    // 간단한 버블 정렬
    for (int i = 0; i < count - 1; i++) {
        for (int j = 0; j < count - i - 1; j++) {
            if (sorted[j] > sorted[j + 1]) {
                float temp = sorted[j];
                sorted[j] = sorted[j + 1];
                sorted[j + 1] = temp;
            }
        }
    }
    
    if (count % 2 == 0) {
        stats.median = (sorted[count/2 - 1] + sorted[count/2]) / 2.0;
    } else {
        stats.median = sorted[count/2];
    }
    
    return stats;
}

void analyzeTemperatureData() {
    float tempData[100];
    
    // 히스토리에서 온도 데이터 추출
    for (int i = 0; i < 100; i++) {
        tempData[i] = dataHistory[i].temperature;
    }
    
    Statistics stats = calculateStatistics(tempData, 100);
    
    Serial.println("\n📊 온도 통계 분석 (최근 100개 데이터)");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.print("최소값: ");
    Serial.print(stats.min, 2);
    Serial.println("°C");
    Serial.print("최대값: ");
    Serial.print(stats.max, 2);
    Serial.println("°C");
    Serial.print("평균: ");
    Serial.print(stats.mean, 2);
    Serial.println("°C");
    Serial.print("표준편차: ");
    Serial.print(stats.stdDev, 2);
    Serial.println("°C");
    Serial.print("중간값: ");
    Serial.print(stats.median, 2);
    Serial.println("°C");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
}

온도와 습도의 상관관계를 분석해보자:

float calculateCorrelation(float* x, float* y, int count) {
    if (count < 2) return 0.0;
    
    // 평균 계산
    float meanX = 0.0, meanY = 0.0;
    for (int i = 0; i < count; i++) {
        meanX += x[i];
        meanY += y[i];
    }
    meanX /= count;
    meanY /= count;
    
    // 공분산과 표준편차 계산
    float covariance = 0.0;
    float stdX = 0.0, stdY = 0.0;
    
    for (int i = 0; i < count; i++) {
        float diffX = x[i] - meanX;
        float diffY = y[i] - meanY;
        covariance += diffX * diffY;
        stdX += diffX * diffX;
        stdY += diffY * diffY;
    }
    
    stdX = sqrt(stdX / count);
    stdY = sqrt(stdY / count);
    
    if (stdX == 0.0 || stdY == 0.0) return 0.0;
    
    return covariance / (count * stdX * stdY);
}

void analyzeCorrelations() {
    float tempData[100], humidData[100], lightData[100];
    
    for (int i = 0; i < 100; i++) {
        tempData[i] = dataHistory[i].temperature;
        humidData[i] = dataHistory[i].humidity;
        lightData[i] = dataHistory[i].light;
    }
    
    float tempHumidCorr = calculateCorrelation(tempData, humidData, 100);
    float tempLightCorr = calculateCorrelation(tempData, lightData, 100);
    float humidLightCorr = calculateCorrelation(humidData, lightData, 100);
    
    Serial.println("\n🔗 상관관계 분석");
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.print("온도 ↔ 습도: ");
    Serial.println(tempHumidCorr, 3);
    Serial.print("온도 ↔ 조도: ");
    Serial.println(tempLightCorr, 3);
    Serial.print("습도 ↔ 조도: ");
    Serial.println(humidLightCorr, 3);
    Serial.println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
    Serial.println("(1에 가까울수록 강한 양의 상관관계)");
    Serial.println("(-1에 가까울수록 강한 음의 상관관계)\n");
}

이런 분석을 통해 센서 데이터 간의 관계를 이해할 수 있어! 예를 들어 온도가 올라가면 습도가 내려가는 경향이 있다든지 하는 패턴을 발견할 수 있지. 🔍

🎯 마무리하며

와! 정말 긴 여정이었지? 우리는 C언어를 사용해서 완전한 IoT 센서 데이터 수집 및 처리 시스템을 만들어봤어. 기본적인 센서 읽기부터 시작해서 데이터 필터링, 통신, 저장, 전력 관리, 에러 처리, 그리고 데이터 분석까지 모든 걸 다뤘어! 🎉

이제 너도 실전 IoT 프로젝트를 만들 수 있는 실력을 갖췄어. 물론 처음부터 완벽할 순 없어. 하지만 이 글에서 배운 개념들을 하나씩 적용해가면서 점점 더 나은 시스템을 만들 수 있을 거야! 💪

혼자서 막히는 부분이 있다면 재능넷에서 IoT 전문가들의 도움을 받아보는 것도 좋은 방법이야. 실전 경험이 풍부한 개발자들의 조언은 정말 값진 자산이 될 거야! 🌟

IoT는 정말 재미있고 무한한 가능성을 가진 분야야. 스마트홈, 농업, 의료, 산업 자동화 등 모든 곳에서 IoT 기술이 필요해. 너의 창의력과 C언어 실력을 결합하면 정말 멋진 프로젝트를 만들 수 있을 거야! 🎨

자, 이제 직접 센서를 연결하고 코드를 작성해보자! 실패를 두려워하지 말고, 하나씩 시도해보면서 배워가는 거야. 그게 바로 진짜 개발자가 되는 길이니까! 😊

행운을 빌어! 그리고 멋진 IoT 프로젝트를 만들면 꼭 자랑해줘! 🚀✨