Part 24 — AI Butler Method B: A Safe AI Broker on an Old PC, Controlled via Telegram

#include <WiFi.h>
#include <WebServer.h>
#include <TFT_eSPI.h>
#include <XPT2046_Touchscreen.h>
#include <HTTPClient.h>

// =============================================
// Wi-Fi settings (fill in yourself!)
// =============================================
const char* ssid     = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";
const char* ap_ssid     = "IoT_Hub_Net";
const char* ap_password = "iothub1234";

// =============================================
// PC broker URL (fill in yourself!)
// =============================================
const char* PC_URL = "http://192.168.0.100:5000"; // ← change this to your PC's IP

// =============================================
// Hardware pins
// =============================================
#define BUZZER_PIN 13
#define TFT_BL     4
TFT_eSPI tft = TFT_eSPI();
WebServer server(80);

#define TS_CS  5
#define TS_IRQ 21
XPT2046_Touchscreen ts(TS_CS, TS_IRQ);

// =============================================
// 20 memory slots
// =============================================
#define SLOT_COUNT 20
String slot[SLOT_COUNT] = {
  "--", "--", "--", "--", "--",
  "--", "--", "--", "--", "--",
  "--", "--", "--", "--", "--",
  "--", "--", "--", "--", "--"
};

const char* label[SLOT_COUNT] = {
  "Living Temp","Living Hum","Outside Temp","AC",
  "Boiler","Stove","Gas Leak","Fire",
  "Front Door","Door Lock","Living Light","Fridge Temp",
  "CO2","Dust PM2.5","Power","Water",
  "Hot Water","Rain","Bath Hum","Pet Bowl"
};

// =============================================
// Colors
// =============================================
#define C_BG       TFT_BLACK
#define C_TITLE_BG TFT_WHITE
#define C_CARD     TFT_DARKGREEN
#define C_CARD_WARN TFT_RED
#define C_LABEL    TFT_SILVER
#define C_VALUE    TFT_YELLOW

// =============================================
// Timers
// =============================================
unsigned long lastScroll = 0;
unsigned long lastBuzzer = 0;
int scrollOffset = 0;
const int ITEMS_PER_PAGE = 4;
const int SCROLL_INTERVAL = 3000;
bool warningActive = false;

// PC communication timers
unsigned long lastCmdCheck = 0;
unsigned long lastDataSend = 0;
#define CMD_INTERVAL  5000
#define DATA_INTERVAL 30000

// =============================================
// Touch card zones
// =============================================
struct CardZone { int x, y, w, h, slotIdx; };
CardZone cards[4];

// =============================================
// setup
// =============================================
void setup() {
  Serial.begin(115200);

  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW);

  tft.init();
  tft.setRotation(1);
  tft.fillScreen(C_BG);
  tft.setTextWrap(false);

  ledcSetup(0, 5000, 8);
  ledcAttachPin(TFT_BL, 0);
  ledcWrite(0, 200);

  ts.begin();
  ts.setRotation(1);

  tft.setTextColor(TFT_WHITE, C_BG);
  tft.drawString("IoT Hub + AI", 40, 140, 4);
  tft.drawString("iothub.co.kr", 60, 180, 2);
  delay(1000);

  WiFi.mode(WIFI_AP_STA);
  WiFi.begin(ssid, password);

  tft.fillScreen(C_BG);
  tft.drawString("WiFi connecting...", 30, 100, 2);
  Serial.print("Connecting to WiFi");
  int dots = 0;
  while (WiFi.status() != WL_CONNECTED) {
    delay(500); Serial.print(".");
    tft.drawString(".", 180 + dots * 8, 100, 2); dots++;
  }
  Serial.println("\nSTA IP: " + WiFi.localIP().toString());

  WiFi.softAP(ap_ssid, ap_password);
  Serial.println("AP  IP: " + WiFi.softAPIP().toString());

  server.on("/set", handleSet);
  server.on("/", handleRoot);
  server.on("/status", handleStatus);
  server.onNotFound(handleNotFound);
  server.begin();

  tft.fillScreen(C_BG);
  tft.drawString("IoT Hub Ready", 20, 30, 4);
  tft.drawString("LAN: " + WiFi.localIP().toString(), 10, 80, 2);
  tft.drawString("PC : " + String(PC_URL), 10, 110, 2);
  delay(3000);
}

// =============================================
// loop
// =============================================
void loop() {
  server.handleClient();
  handleTouch();
  updateTFT();
  updateBuzzer();

  unsigned long now = millis();

  // Send sensor data to the PC every 30 seconds
  if (now - lastDataSend > DATA_INTERVAL) {
    lastDataSend = now;
    sendDataToPC();
  }

  // Check the PC for a new command every 5 seconds
  if (now - lastCmdCheck > CMD_INTERVAL) {
    lastCmdCheck = now;
    checkCommand();
  }
}

// =============================================
// Check warning state
// =============================================
bool checkWarning() {
  for (int i = 0; i < SLOT_COUNT; i++) {
    if ((i == 6 || i == 7 || i == 8)
        && slot[i] != "0" && slot[i] != "--") return true;
    if (i == 19 && slot[i] != "--" && slot[i].toInt() < 50) return true;
  }
  return false;
}

// =============================================
// Buzzer control
// =============================================
void updateBuzzer() {
  warningActive = checkWarning();
  if (warningActive) {
    unsigned long now = millis();
    if (now - lastBuzzer < 500) return;
    lastBuzzer = now;
    digitalWrite(BUZZER_PIN, !digitalRead(BUZZER_PIN));
  } else {
    digitalWrite(BUZZER_PIN, LOW);
  }
}

// =============================================
// GET /set?no1=value&no2=value ...
// =============================================
void handleSet() {
  int updated = 0;
  for (int i = 1; i <= SLOT_COUNT; i++) {
    String paramName = "no" + String(i);
    if (server.hasArg(paramName)) {
      slot[i - 1] = server.arg(paramName);
      updated++;
    }
  }
  server.send(200, "application/json", "{\"updated\":" + String(updated) + "}");
}

// =============================================
// GET / → HTML dashboard
// =============================================
void handleRoot() {
  String html = "<!DOCTYPE html><html lang=\"ko\"><head>"
  "<meta charset=\"UTF-8\">"
  "<meta name=\"viewport\" content=\"width=device-width,initial-scale=1.0\">"
  "<title>IoT Hub + AI</title>"
  "<style>"
  "*{margin:0;padding:0;box-sizing:border-box;}"
  "body{font-family:system-ui,sans-serif;background:#1a1a2e;color:#eee;padding:16px;}"
  "h1{text-align:center;font-size:1.3rem;margin-bottom:4px;color:#e94560;}"
  ".sub{text-align:center;font-size:0.7rem;color:#555;margin-bottom:16px;}"
  ".grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(185px,1fr));gap:10px;}"
  ".card{background:#16213e;border-radius:8px;padding:12px;border-left:4px solid #0f3460;}"
  ".card.warn{border-left-color:#e94560;background:#1c0e1a;}"
  ".card .no{font-size:0.6rem;color:#555;margin-bottom:2px;}"
  ".card .label{font-size:0.8rem;color:#a0a0b0;margin-bottom:4px;}"
  ".card .value{font-size:1.2rem;font-weight:700;}"
  ".footer{text-align:center;margin-top:16px;font-size:0.7rem;color:#444;}"
  "</style></head><body>"
  "<h1>IoT Hub + AI</h1><div class=\"sub\">Method B - PC Broker</div>"
  "<div class=\"grid\">";

  for (int i = 0; i < SLOT_COUNT; i++) {
    bool isWarn = false;
    String val = slot[i];
    if ((i == 6 || i == 7 || i == 8) && val != "0" && val != "--") isWarn = true;
    if (i == 19 && val != "--" && val.toInt() < 50) isWarn = true;
    html += "<div class=\"card" + String(isWarn ? " warn" : "") + "\">";
    html += "<div class=\"no\">#" + String(i + 1) + "</div>";
    html += "<div class=\"label\">" + String(label[i]) + "</div>";
    html += "<div class=\"value\">" + val + "</div></div>\n";
  }

  html += "</div><div class=\"footer\">IoT Hub + AI Broker | iothub.co.kr</div></body></html>";
  server.send(200, "text/html; charset=utf-8", html);
}

// =============================================
// GET /status → JSON
// =============================================
void handleStatus() {
  String json = "{";
  for (int i = 0; i < SLOT_COUNT; i++) {
    if (i > 0) json += ",";
    json += "\"no" + String(i + 1) + "\":\"" + slot[i] + "\"";
  }
  json += ",\"warning\":" + String(warningActive ? "true" : "false") + "}";
  server.send(200, "application/json", json);
}

// =============================================
// 404
// =============================================
void handleNotFound() {
  server.send(404, "text/plain", "404 - Use /set?no1=value  or  /  or  /status");
}

// =============================================
// TFT rendering (same as Part 22)
// =============================================
void updateTFT() {
  unsigned long now = millis();
  if (now - lastScroll < SCROLL_INTERVAL) return;
  lastScroll = now;
  tft.fillScreen(C_BG);

  tft.fillRect(0, 0, 320, 28, TFT_WHITE);
  tft.setTextColor(TFT_BLACK, TFT_WHITE);
  char buf[40];
  sprintf(buf, "IoT Hub [%d/%d]",
    scrollOffset / ITEMS_PER_PAGE + 1,
    (SLOT_COUNT + ITEMS_PER_PAGE - 1) / ITEMS_PER_PAGE);
  tft.drawString(buf, 4, 6, 2);

  for (int i = 0; i < ITEMS_PER_PAGE; i++) {
    int idx = scrollOffset + i;
    if (idx >= SLOT_COUNT) break;
    int y = 36 + i * 52;
    String val = slot[idx];

    bool isWarn = false;
    uint16_t cardBg = C_CARD;
    if ((idx == 6 || idx == 7 || idx == 8) && val != "0" && val != "--") {
      isWarn = true; cardBg = C_CARD_WARN;
    }
    if (idx == 19 && val != "--" && val.toInt() < 50) {
      isWarn = true; cardBg = C_CARD_WARN;
    }

    cards[i] = {4, y, 312, 48, idx};
    tft.fillRoundRect(4, y, 312, 48, 6, cardBg);
    tft.setTextColor(C_LABEL, cardBg);
    tft.drawString(label[idx], 14, y + 4, 2);
    tft.drawLine(14, y + 24, 306, y + 24, TFT_WHITE);
    tft.setTextColor(isWarn ? TFT_WHITE : C_VALUE, cardBg);
    tft.drawString(val, 18, y + 28, 4);
    tft.setTextColor(C_LABEL, cardBg);
    tft.drawString(getUnit(idx), 250, y + 28, 2);
    if (idx == 3 || idx == 6 || idx == 7 || idx == 8 || idx == 10 || idx == 19) {
      tft.drawString(":", 290, y + 4, 2);
    }
  }

  scrollOffset += ITEMS_PER_PAGE;
  if (scrollOffset >= SLOT_COUNT) scrollOffset = 0;
}

String getUnit(int idx) {
  switch (idx) {
    case 0: case 2: case 11: case 16: return "C";
    case 1: case 18: return "%";
    case 12: return "ppm"; case 13: return "ug";
    case 14: return "W"; case 15: return "L";
    case 19: return "g";
    default: return "";
  }
}

// =============================================
// Touch handling
// =============================================
void handleTouch() {
  if (!ts.tirqTouched() && !ts.touched()) return;
  TS_Point p = ts.getPoint();
  int tx = map(p.x, 200, 3800, 0, 320);
  int ty = map(p.y, 200, 3800, 0, 240);

  for (int i = 0; i < 4; i++) {
    CardZone cz = cards[i];
    if (tx >= cz.x && tx <= cz.x + cz.w &&
        ty >= cz.y && ty <= cz.y + cz.h) {
      int idx = cz.slotIdx;
      if (idx < 0 || idx >= SLOT_COUNT) break;
      if (idx == 3) { slot[idx] = (slot[idx] == "ON") ? "OFF" : "ON"; }
      else if (idx == 10) { slot[idx] = (slot[idx] == "ON") ? "OFF" : "ON"; }
      else if (idx == 6 || idx == 7 || idx == 8 || idx == 19) { slot[idx] = "0"; }
      lastScroll = 0;
      break;
    }
  }
}

// =============================================
// 🆕 Send the 20 sensor values to the PC (new in Part 24)
// =============================================
void sendDataToPC() {
  WiFiClient client;
  HTTPClient http;

  String url = String(PC_URL) + "/data";
  String body = "{";
  for (int i = 0; i < SLOT_COUNT; i++) {
    if (i > 0) body += ",";
    body += "\"no" + String(i + 1) + "\":\"" + slot[i] + "\"";
  }
  body += "}";

  http.begin(client, url);
  http.addHeader("Content-Type", "application/json");
  int code = http.POST(body);
  http.end();

  Serial.print("Data sent: HTTP ");
  Serial.print(code);
  Serial.print(" ("); Serial.print(body.length());
  Serial.println(" bytes)");
}

// =============================================
// 🆕 Fetch commands from the PC (new in Part 24)
// =============================================
void checkCommand() {
  WiFiClient client;
  HTTPClient http;

  String url = String(PC_URL) + "/command";
  http.begin(client, url);
  int code = http.GET();

  if (code == 200) {
    String resp = http.getString();
    if (resp != "{}" && resp != "") {
      Serial.print("Command received: ");
      Serial.println(resp);
      executeCommand(resp);
    }
  }
  http.end();
}

// =============================================
// 🆕 Execute command (new in Part 24)
// =============================================
void executeCommand(String json) {
  for (int i = 1; i <= SLOT_COUNT; i++) {
    String key = "no" + String(i);
    int pos = json.indexOf("\"" + key + "\":\"");
    if (pos < 0) continue;

    int start = pos + key.length() + 4;
    int end = json.indexOf("\"", start);
    String val = json.substring(start, end);

    slot[i - 1] = val;
    Serial.printf("  Slot %d (%s) <- %s\n", i, label[i - 1], val.c_str());
  }
  lastScroll = 0;
}

pip install flask requests

from flask import Flask, request, jsonify
import requests
import threading
import time
import json
import urllib.request
import urllib.parse

# =============================================
# 1. Settings (fill in yourself!)
# =============================================
OPENAI_API_KEY = "sk-your-api-key-here"
OPENAI_URL     = "https://api.openai.com/v1/chat/completions"
AI_MODEL       = "gpt-3.5-turbo"

TELEGRAM_BOT_TOKEN = "123456:ABC-DEF1234ghijk"
YOUR_CHAT_ID = 123456789

# =============================================
# 2. Flask app
# =============================================
app = Flask(__name__)

latest_data = {}
pending_commands = {}
last_ai_time = 0
AI_INTERVAL = 300

LABELS = [
    "Living Temp","Living Hum","Outside Temp","AC",
    "Boiler","Stove","Gas Leak","Fire",
    "Front Door","Door Lock","Living Light","Fridge Temp",
    "CO2","Dust PM2.5","Power","Water",
    "Hot Water","Rain","Bath Hum","Pet Bowl"
]

# =============================================
# 3. ESP32 → PC: receive sensor data
# =============================================
@app.route('/data', methods=['POST'])
def receive_data():
    global latest_data
    data = request.get_json()
    if data:
        latest_data = data
        print(f"[DATA] Received {len(data)} sensor values")
    return jsonify({"status": "ok"})

# =============================================
# 4. ESP32 ← PC: deliver commands
# =============================================
@app.route('/command', methods=['GET'])
def send_command():
    global pending_commands
    if pending_commands:
        cmd = json.dumps(pending_commands)
        pending_commands = {}
        print(f"[CMD] Sent: {cmd}")
        return cmd
    return "{}"

# =============================================
# 5. Handle Telegram commands
# =============================================
def handle_telegram_command(text):
    global pending_commands
    tl = text.lower().strip()

    if "에어컨" in text or "ac" in tl:
        if "켜" in text or "on" in tl:
            pending_commands["no4"] = "ON"
            return "에어컨 ON"
        elif "꺼" in text or "off" in tl:
            pending_commands["no4"] = "OFF"
            return "에어컨 OFF"

    if "조명" in text or "불" in text or "light" in tl:
        if "켜" in text or "on" in tl:
            pending_commands["no11"] = "ON"
            return "조명 ON"
        elif "꺼" in text or "off" in tl:
            pending_commands["no11"] = "OFF"
            return "조명 OFF"

    if "상태" in text or "집" in text or "status" in tl:
        return build_status_report()

    return None

def build_status_report():
    if not latest_data:
        return "아직 센서 데이터가 없습니다."
    report = "집 상태 보고\n\n"
    warnings = []
    for i in range(20):
        val = latest_data.get(f"no{i+1}", "--")
        report += f"  {LABELS[i]}: {val}\n"
        if i == 6 and val not in ("0", "--"): warnings.append("가스 누출!")
        if i == 7 and val not in ("0", "--"): warnings.append("화재 감지!")
        if i == 8 and val not in ("0", "--"): warnings.append("현관문 열림!")
        if i == 19 and val != "--":
            try:
                if int(val) < 50: warnings.append("반려견 밥 보충!")
            except: pass
    if warnings:
        report += "\n" + "\n".join(warnings)
    return report

# =============================================
# 6. AI analysis (background)
# =============================================
def ai_analysis_loop():
    global last_ai_time, pending_commands
    while True:
        time.sleep(30)
        if not latest_data: continue
        now = time.time()
        if now - last_ai_time < AI_INTERVAL: continue
        last_ai_time = now

        try:
            data_text = "\n".join(
                f"{LABELS[i]}: {latest_data.get(f'no{i+1}', '--')}"
                for i in range(20)
            )
            system_prompt = (
                "You are an AI home assistant. Analyze the sensor data "
                "and provide a brief English summary. "
                "1) Any warnings? 2) Any anomalies? 3) Recommended actions. "
                "Keep it under 4 sentences."
            )
            resp = requests.post(
                OPENAI_URL,
                headers={
                    "Authorization": f"Bearer {OPENAI_API_KEY}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": AI_MODEL,
                    "messages": [
                        {"role": "system", "content": system_prompt},
                        {"role": "user", "content": data_text}
                    ],
                    "max_tokens": 200
                },
                timeout=30
            )
            if resp.status_code == 200:
                content = resp.json()["choices"][0]["message"]["content"]
                print(f"[AI] {content}")
                # Send the AI analysis result via Telegram
                send_telegram(YOUR_CHAT_ID, "[AI 분석]
" + content)
            else:
                print(f"[AI] API error: {resp.status_code}")
        except Exception as e:
            print(f"[AI] Error: {e}")

# =============================================
# 7. Telegram bot (polling)
# =============================================
def telegram_loop():
    base_url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}"
    last_update_id = 0
    print("[TELEGRAM] Bot started. Send /start to begin.")

    while True:
        time.sleep(3)
        try:
            url = f"{base_url}/getUpdates?offset={last_update_id + 1}&timeout=10"
            resp = requests.get(url, timeout=15).json()
            for update in resp.get("result", []):
                last_update_id = update["update_id"]
                if "message" not in update: continue
                msg = update["message"]
                chat_id = msg["chat"]["id"]
                text = msg.get("text", "")
                print(f"[TELEGRAM] From {chat_id}: {text}")

                if text == "/start":
                    send_telegram(chat_id,
                        "AI 집사입니다.\n"
                        "'상태', '에어컨 켜줘/꺼줘', '조명 켜줘/꺼줘'")
                    continue

                reply = handle_telegram_command(text)
                if reply:
                    send_telegram(chat_id, reply)
                else:
                    send_telegram(chat_id,
                        "'상태', '에어컨 켜줘/꺼줘', '조명 켜줘/꺼줘' 중에 말해주세요.")
        except Exception as e:
            print(f"[TELEGRAM] Error: {e}")

def send_telegram(chat_id, text):
    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
    data = urllib.parse.urlencode({"chat_id": chat_id, "text": text}).encode()
    urllib.request.urlopen(url, data=data)

# =============================================
# 8. Run
# =============================================
if __name__ == "__main__":
    threading.Thread(target=ai_analysis_loop, daemon=True).start()
    threading.Thread(target=telegram_loop, daemon=True).start()
    print("=" * 50)
    print("  AI 집사 서버 시작")
    print("=" * 50)
    app.run(host="0.0.0.0", port=5000, debug=False)