#include <SPI.h>
#include <LoRa.h>

// LoRa 핀 설정
#define NSS 10
#define RESET 9
#define DIO0 2

// 전송 카운터
int counter = 0;

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  Serial.println("LoRa 송신부 시작!");
  
  // LoRa 핀 설정
  LoRa.setPins(NSS, RESET, DIO0);
  
  // LoRa 초기화 (한국 주파수: 920MHz)
  if (!LoRa.begin(920E6)) {
    Serial.println("LoRa 초기화 실패!");
    while (1);
  }
  
  // LoRa 파라미터 설정
  LoRa.setSpreadingFactor(12);      // SF12 (최대 거리)
  LoRa.setSignalBandwidth(125E3);   // 125kHz
  LoRa.setCodingRate4(5);           // CR 4/5
  LoRa.setTxPower(20);              // 최대 출력
  
  Serial.println("LoRa 초기화 완료!");
}

void loop() {
  Serial.print("패킷 전송 중: ");
  Serial.println(counter);
  
  // 패킷 전송 시작
  LoRa.beginPacket();
  LoRa.print("안녕하세요! 패킷 번호: ");
  LoRa.print(counter);
  LoRa.endPacket();
  
  counter++;
  
  // 5초 대기
  delay(5000);
}

#include <SPI.h>
#include <LoRa.h>
#include <DHT.h>

#define DHTPIN 4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

#define NSS 10
#define RESET 9
#define DIO0 2

void setup() {
  Serial.begin(9600);
  dht.begin();
  
  LoRa.setPins(NSS, RESET, DIO0);
  
  if (!LoRa.begin(920E6)) {
    Serial.println("LoRa 초기화 실패!");
    while (1);
  }
  
  LoRa.setSpreadingFactor(10);
  LoRa.setSignalBandwidth(125E3);
  LoRa.setTxPower(17);
  
  Serial.println("센서 모니터링 시작!");
}

void loop() {
  // 센서 데이터 읽기
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();
  
  // 데이터 유효성 체크
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("센서 읽기 실패!");
    delay(2000);
    return;
  }
  
  // JSON 형식으로 데이터 구성
  String jsonData = "{";
  jsonData += "\"temp\":";
  jsonData += String(temperature, 1);
  jsonData += ",\"humi\":";
  jsonData += String(humidity, 1);
  jsonData += "}";
  
  // LoRa로 전송
  Serial.print("전송: ");
  Serial.println(jsonData);
  
  LoRa.beginPacket();
  LoRa.print(jsonData);
  LoRa.endPacket();
  
  // 10초 대기 (배터리 절약)
  delay(10000);
}

#include <SPI.h>
#include <LoRa.h>

#define NSS 10
#define RESET 9
#define DIO0 2

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  Serial.println("LoRa 수신부 시작!");
  
  LoRa.setPins(NSS, RESET, DIO0);
  
  if (!LoRa.begin(920E6)) {
    Serial.println("LoRa 초기화 실패!");
    while (1);
  }
  
  // 송신부와 동일한 파라미터 설정
  LoRa.setSpreadingFactor(12);
  LoRa.setSignalBandwidth(125E3);
  LoRa.setCodingRate4(5);
  
  Serial.println("수신 대기 중...");
}

void loop() {
  // 패킷 수신 확인
  int packetSize = LoRa.parsePacket();
  
  if (packetSize) {
    // 패킷 수신됨!
    Serial.print("패킷 수신! 크기: ");
    Serial.println(packetSize);
    
    // 데이터 읽기
    String received = "";
    while (LoRa.available()) {
      received += (char)LoRa.read();
    }
    
    Serial.print("내용: ");
    Serial.println(received);
    
    // RSSI (신호 강도) 출력
    Serial.print("RSSI: ");
    Serial.print(LoRa.packetRssi());
    Serial.println(" dBm");
    
    // SNR (신호 대 잡음비) 출력
    Serial.print("SNR: ");
    Serial.print(LoRa.packetSnr());
    Serial.println(" dB");
    
    Serial.println("-------------------");
  }
}

#include <SPI.h>
#include <LoRa.h>
#include <ArduinoJson.h>

#define NSS 10
#define RESET 9
#define DIO0 2

void setup() {
  Serial.begin(9600);
  while (!Serial);
  
  LoRa.setPins(NSS, RESET, DIO0);
  
  if (!LoRa.begin(920E6)) {
    Serial.println("LoRa 초기화 실패!");
    while (1);
  }
  
  LoRa.setSpreadingFactor(10);
  LoRa.setSignalBandwidth(125E3);
  
  Serial.println("센서 데이터 수신 대기...");
}

void loop() {
  int packetSize = LoRa.parsePacket();
  
  if (packetSize) {
    String received = "";
    while (LoRa.available()) {
      received += (char)LoRa.read();
    }
    
    // JSON 파싱
    StaticJsonDocument<200> doc;
    DeserializationError error = deserializeJson(doc, received);
    
    if (error) {
      Serial.print("JSON 파싱 실패: ");
      Serial.println(error.c_str());
      return;
    }
    
    // 데이터 추출
    float temperature = doc["temp"];
    float humidity = doc["humi"];
    
    // 출력
    Serial.println("=== 센서 데이터 수신 ===");
    Serial.print("온도: ");
    Serial.print(temperature);
    Serial.println(" °C");
    Serial.print("습도: ");
    Serial.print(humidity);
    Serial.println(" %");
    Serial.print("신호 강도: ");
    Serial.print(LoRa.packetRssi());
    Serial.println(" dBm");
    Serial.println("========================");
  }
}

#include <AES.h>

// AES 암호화 키 (16바이트)
byte aes_key[] = {0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
                  0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C};

AES aes;

// 데이터 암호화 함수
String encryptData(String plaintext) {
  byte encrypted[128];
  int paddedLength = plaintext.length();
  
  // 16바이트 배수로 패딩
  while (paddedLength % 16 != 0) {
    plaintext += ' ';
    paddedLength++;
  }
  
  byte plain[paddedLength];
  plaintext.getBytes(plain, paddedLength + 1);
  
  aes.set_key(aes_key, 128);
  aes.encrypt(plain, encrypted);
  
  // Base64 인코딩 (전송용)
  String result = base64::encode(encrypted, paddedLength);
  return result;
}

// 데이터 복호화 함수
String decryptData(String ciphertext) {
  byte decoded[128];
  int decodedLength = base64::decode(ciphertext, decoded);
  
  byte decrypted[128];
  aes.set_key(aes_key, 128);
  aes.decrypt(decoded, decrypted);
  
  String result = String((char*)decrypted);
  result.trim();
  return result;
}

// 송신부 코드 (ACK 대기 포함)
void sendWithAck(String data, int maxRetries = 3) {
  for (int retry = 0; retry < maxRetries; retry++) {
    Serial.print("전송 시도 ");
    Serial.print(retry + 1);
    Serial.print("/");
    Serial.println(maxRetries);
    
    // 데이터 전송
    LoRa.beginPacket();
    LoRa.print(data);
    LoRa.endPacket();
    
    // ACK 대기 (5초)
    unsigned long startTime = millis();
    bool ackReceived = false;
    
    while (millis() - startTime < 5000) {
      int packetSize = LoRa.parsePacket();
      if (packetSize) {
        String response = "";
        while (LoRa.available()) {
          response += (char)LoRa.read();
        }
        
        if (response == "ACK") {
          Serial.println("✓ ACK 수신! 전송 성공");
          ackReceived = true;
          break;
        }
      }
    }
    
    if (ackReceived) {
      return;  // 성공!
    }
    
    Serial.println("✗ ACK 미수신, 재시도...");
    delay(1000);
  }
  
  Serial.println("전송 실패!");
}

// 수신부 코드 (ACK 전송 포함)
void loop() {
  int packetSize = LoRa.parsePacket();
  
  if (packetSize) {
    String received = "";
    while (LoRa.available()) {
      received += (char)LoRa.read();
    }
    
    Serial.print("데이터 수신: ");
    Serial.println(received);
    
    // ACK 전송
    delay(100);  // 짧은 대기
    LoRa.beginPacket();
    LoRa.print("ACK");
    LoRa.endPacket();
    
    Serial.println("ACK 전송 완료");
  }
}

// 노드 ID 정의
#define NODE_ID 1  // 각 노드마다 다른 번호

// 패킷 구조체
struct Packet {
  uint8_t nodeId;
  uint8_t messageType;  // 1: 센서데이터, 2: 상태, 3: 알람
  float data1;
  float data2;
  uint32_t timestamp;
};

// 송신부 - 구조화된 데이터 전송
void sendStructuredData(float temp, float humi) {
  Packet packet;
  packet.nodeId = NODE_ID;
  packet.messageType = 1;
  packet.data1 = temp;
  packet.data2 = humi;
  packet.timestamp = millis();
  
  LoRa.beginPacket();
  LoRa.write((uint8_t*)&packet, sizeof(packet));
  LoRa.endPacket();
  
  Serial.print("노드 ");
  Serial.print(NODE_ID);
  Serial.println(" 데이터 전송");
}

// 수신부 - 구조화된 데이터 수신
void loop() {
  int packetSize = LoRa.parsePacket();
  
  if (packetSize == sizeof(Packet)) {
    Packet packet;
    LoRa.readBytes((uint8_t*)&packet, sizeof(packet));
    
    Serial.println("=== 패킷 수신 ===");
    Serial.print("노드 ID: ");
    Serial.println(packet.nodeId);
    Serial.print("메시지 타입: ");
    Serial.println(packet.messageType);
    Serial.print("데이터1: ");
    Serial.println(packet.data1);
    Serial.print("데이터2: ");
    Serial.println(packet.data2);
    Serial.print("타임스탬프: ");
    Serial.println(packet.timestamp);
    Serial.println("=================");
  }
}

// ESP32 Deep Sleep 예제
#include <esp_sleep.h>

#define SLEEP_TIME 600  // 10분 (초 단위)

void setup() {
  // LoRa 초기화 및 데이터 전송
  initLoRa();
  sendSensorData();
  
  // Deep Sleep 진입
  Serial.println("Sleep 모드 진입...");
  esp_sleep_enable_timer_wakeup(SLEEP_TIME * 1000000ULL);
  esp_deep_sleep_start();
}

void loop() {
  // Deep Sleep에서는 loop 실행 안 됨
}

// 센서 전원 제어
void powerSensor(bool on) {
  if (on) {
    digitalWrite(SENSOR_POWER_PIN, HIGH);
    delay(100);  // 센서 안정화 대기
  } else {
    digitalWrite(SENSOR_POWER_PIN, LOW);
  }
}

// 정수형으로 변환해서 전송 (float 대신)
// 예: 온도 23.5°C → 235 (10배)

void sendCompressedData(float temp, float humi) {
  int16_t tempInt = (int16_t)(temp * 10);
  int16_t humiInt = (int16_t)(humi * 10);
  
  byte data[4];
  data[0] = tempInt >> 8;
  data[1] = tempInt & 0xFF;
  data[2] = humiInt >> 8;
  data[3] = humiInt & 0xFF;
  
  LoRa.beginPacket();
  LoRa.write(data, 4);  // 4바이트만 전송!
  LoRa.endPacket();
}

// 수신부에서 복원
void receiveCompressedData() {
  if (LoRa.parsePacket() == 4) {
    byte data[4];
    LoRa.readBytes(data, 4);
    
    int16_t tempInt = (data[0] << 8) | data[1];
    int16_t humiInt = (data[2] << 8) | data[3];
    
    float temp = tempInt / 10.0;
    float humi = humiInt / 10.0;
    
    Serial.print("온도: ");
    Serial.println(temp);
    Serial.print("습도: ");
    Serial.println(humi);
  }
}