پین‌های اصلی:
├── VCC: ولتاژ 3.3V یا 5V (با جامپر انتخاب می‌شود)
├── GND: زمین
├── TX: انتقال داده به RX دستگاه هدف
├── RX: دریافت داده از TX دستگاه هدف
├── DTR: کنترل جریان/ریست خودکار
└── RTS: کنترل جریان/مد برنامه‌ریزی

پین‌های اضافی (در برخی مدل‌ها):
├── GPIO0: برای قرار دادن ESP در حالت برنامه‌ریزی
├── GPIO2: پین عمومی ESP
├── EN/CH_PD: Enable پین ESP
└── IO0, IO15: برای حالت‌های خاص برنامه‌ریزی

ماژول USB-Serial ← ESP-01
------------------------
VCC (3.3V)  → VCC
GND         → GND
TX          → RX (ESP)
RX          → TX (ESP)
DTR         → GPIO0 (برای آپلود خودکار)
RTS         → EN (برای ریست خودکار)

نکته: برای ESP-01 نیاز به مقاومت pull-up روی GPIO0 دارید.

ماژول USB-Serial ← NodeMCU
---------------------------
GND         → GND
TX          → D6 (GPIO12) برای ارتباط
RX          → D7 (GPIO13) برای ارتباط
VCC (3.3V)  → 3.3V (اگر نیاز باشد)

نکته: NodeMCU خودش مبدل USB دارد، این اتصال برای ارتباط اضافی است.

/*
 * تست ساده ارتباط سریال بین کامپیوتر و ESP8266
 * این کد روی ESP8266 آپلود می‌شود
 */

void setup() {
  // شروع ارتباط سریال با نرخ 115200 baud
  Serial.begin(115200);
  delay(1000); // تأخیر برای پایداری
  
  Serial.println("\n\n========================================");
  Serial.println("   ESP8266 Serial Communication Test");
  Serial.println("   via USB to Serial Adapter");
  Serial.println("========================================");
  Serial.println();
  Serial.println("System Information:");
  Serial.print("Chip ID: ");
  Serial.println(ESP.getChipId(), HEX);
  Serial.print("Flash Size: ");
  Serial.print(ESP.getFlashChipSize() / 1024);
  Serial.println(" KB");
  Serial.print("Free Heap: ");
  Serial.print(ESP.getFreeHeap() / 1024);
  Serial.println(" KB");
  Serial.println();
  Serial.println("Type '?' for help");
  Serial.println("----------------------------------------");
}

void loop() {
  // اگر داده‌ای از سریال دریافت شد
  if (Serial.available() > 0) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    
    handleCommand(command);
  }
  
  // ارسال داده دوره‌ای برای تست
  static unsigned long lastSend = 0;
  if (millis() - lastSend > 5000) {
    Serial.print("[");
    Serial.print(millis() / 1000);
    Serial.println("] System is alive...");
    lastSend = millis();
  }
  
  delay(10);
}

void handleCommand(String cmd) {
  Serial.print("Command received: ");
  Serial.println(cmd);
  
  if (cmd == "?") {
    showHelp();
  }
  else if (cmd == "info") {
    showSystemInfo();
  }
  else if (cmd == "reset") {
    Serial.println("Restarting system...");
    delay(100);
    ESP.restart();
  }
  else if (cmd == "ledon") {
    pinMode(LED_BUILTIN, OUTPUT);
    digitalWrite(LED_BUILTIN, LOW); // LED روشن (در ESP-01 معکوس است)
    Serial.println("LED turned ON");
  }
  else if (cmd == "ledoff") {
    digitalWrite(LED_BUILTIN, HIGH); // LED خاموش
    Serial.println("LED turned OFF");
  }
  else if (cmd == "test") {
    runCommunicationTest();
  }
  else {
    Serial.println("Unknown command. Type '?' for help.");
  }
}

void showHelp() {
  Serial.println("\n=== Available Commands ===");
  Serial.println("?      - Show this help");
  Serial.println("info   - Show system information");
  Serial.println("reset  - Restart ESP8266");
  Serial.println("ledon  - Turn built-in LED ON");
  Serial.println("ledoff - Turn built-in LED OFF");
  Serial.println("test   - Run communication test");
  Serial.println("===========================\n");
}

void showSystemInfo() {
  Serial.println("\n=== System Information ===");
  Serial.print("Chip ID: 0x");
  Serial.println(ESP.getChipId(), HEX);
  
  Serial.print("Core Version: ");
  Serial.println(ESP.getCoreVersion());
  
  Serial.print("SDK Version: ");
  Serial.println(ESP.getSdkVersion());
  
  Serial.print("CPU Frequency: ");
  Serial.print(ESP.getCpuFreqMHz());
  Serial.println(" MHz");
  
  Serial.print("Flash Chip ID: 0x");
  Serial.println(ESP.getFlashChipId(), HEX);
  
  Serial.print("Flash Size: ");
  Serial.print(ESP.getFlashChipSize() / 1024);
  Serial.println(" KB");
  
  Serial.print("Flash Speed: ");
  Serial.print(ESP.getFlashChipSpeed() / 1000000);
  Serial.println(" MHz");
  
  Serial.print("Free Heap: ");
  Serial.print(ESP.getFreeHeap());
  Serial.println(" bytes");
  
  Serial.print("Sketch Size: ");
  Serial.print(ESP.getSketchSize());
  Serial.println(" bytes");
  
  Serial.print("Free Sketch Space: ");
  Serial.print(ESP.getFreeSketchSpace());
  Serial.println(" bytes");
  
  Serial.println("==========================\n");
}

void runCommunicationTest() {
  Serial.println("\n=== Communication Test ===");
  Serial.println("Sending test pattern...");
  
  // تست ارسال انواع داده
  Serial.println("String: Hello from ESP8266!");
  Serial.print("Integer: ");
  Serial.println(123456);
  Serial.print("Float: ");
  Serial.println(3.14159, 5);
  Serial.print("Hexadecimal: 0x");
  Serial.println(0xDEADBEEF, HEX);
  
  // تست سرعت
  unsigned long startTime = micros();
  for (int i = 0; i < 100; i++) {
    Serial.print(".");
  }
  unsigned long endTime = micros();
  
  Serial.println();
  Serial.print("100 characters sent in ");
  Serial.print(endTime - startTime);
  Serial.println(" microseconds");
  
  Serial.println("Test completed successfully!");
  Serial.println("============================\n");
}

/*
 * اسکچ Arduino برای برنامه‌ریزی ESP-01 با مبدل USB به سریال
 * این کد روی آردوینو آپلود می‌شود تا ESP-01 را برنامه‌ریزی کند
 */

#include <SoftwareSerial.h>

// پین‌های ارتباط با ESP-01
#define ESP_RX 2    // به TX ESP
#define ESP_TX 3    // به RX ESP
#define ESP_GPIO0 4 // برای حالت برنامه‌ریزی
#define ESP_EN 5    // برای ریست
#define ESP_GPIO2 6 // پین اضافی

SoftwareSerial espSerial(ESP_RX, ESP_TX); // RX, TX

void setup() {
  Serial.begin(115200);
  espSerial.begin(115200);
  
  // تنظیم پین‌های کنترل
  pinMode(ESP_GPIO0, OUTPUT);
  pinMode(ESP_EN, OUTPUT);
  pinMode(ESP_GPIO2, OUTPUT);
  
  // حالت عادی
  digitalWrite(ESP_GPIO2, HIGH);
  digitalWrite(ESP_EN, HIGH);
  
  Serial.println("========================================");
  Serial.println("   ESP-01 Programmer via USB-Serial");
  Serial.println("========================================");
  Serial.println("Commands:");
  Serial.println("  program - Enter programming mode");
  Serial.println("  run     - Enter normal run mode");
  Serial.println("  reset   - Reset ESP-01");
  Serial.println("  bridge  - Bridge between PC and ESP");
  Serial.println("  test    - Test communication");
  Serial.println("----------------------------------------");
  
  // شروع در حالت عادی
  setRunMode();
}

void loop() {
  // خواندن دستورات از سریال کامپیوتر
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    handleCommand(command);
  }
  
  // Bridge mode: انتقال داده بین کامپیوتر و ESP
  if (bridgeMode) {
    // از کامپیوتر به ESP
    if (Serial.available()) {
      char c = Serial.read();
      espSerial.write(c);
    }
    
    // از ESP به کامپیوتر
    if (espSerial.available()) {
      char c = espSerial.read();
      Serial.write(c);
    }
  }
  
  delay(1);
}

bool bridgeMode = false;

void handleCommand(String cmd) {
  Serial.print("> ");
  Serial.println(cmd);
  
  if (cmd == "program") {
    setProgrammingMode();
  }
  else if (cmd == "run") {
    setRunMode();
  }
  else if (cmd == "reset") {
    resetESP();
  }
  else if (cmd == "bridge") {
    bridgeMode = !bridgeMode;
    Serial.print("Bridge mode ");
    Serial.println(bridgeMode ? "ENABLED" : "DISABLED");
  }
  else if (cmd == "test") {
    testCommunication();
  }
  else if (cmd == "help") {
    showHelp();
  }
  else {
    // ارسال مستقیم به ESP
    espSerial.println(cmd);
  }
}

void setProgrammingMode() {
  Serial.println("Setting programming mode...");
  
  // GPIO0 = LOW برای حالت برنامه‌ریزی
  digitalWrite(ESP_GPIO0, LOW);
  delay(100);
  
  // ریست کردن ESP
  digitalWrite(ESP_EN, LOW);
  delay(100);
  digitalWrite(ESP_EN, HIGH);
  delay(100);
  
  Serial.println("ESP-01 is in PROGRAMMING mode");
  Serial.println("You can now upload code from Arduino IDE");
  Serial.println("Select: Generic ESP8266 Module");
  Serial.println("Port: Your USB-Serial port");
  Serial.println("----------------------------------------");
}

void setRunMode() {
  Serial.println("Setting run mode...");
  bridgeMode = false;
  
  // GPIO0 = HIGH برای حالت اجرا
  digitalWrite(ESP_GPIO0, HIGH);
  delay(100);
  
  // ریست کردن ESP
  digitalWrite(ESP_EN, LOW);
  delay(100);
  digitalWrite(ESP_EN, HIGH);
  delay(500); // زمان برای بوت شدن ESP
  
  Serial.println("ESP-01 is in RUN mode");
  Serial.println("Ready to execute programmed code");
}

void resetESP() {
  Serial.println("Resetting ESP-01...");
  
  digitalWrite(ESP_EN, LOW);
  delay(500);
  digitalWrite(ESP_EN, HIGH);
  delay(1000);
  
  Serial.println("ESP-01 reset complete");
}

void testCommunication() {
  Serial.println("Testing communication with ESP-01...");
  
  // ارسال دستور AT
  espSerial.println("AT");
  delay(100);
  
  // خواندن پاسخ
  Serial.print("Response: ");
  while (espSerial.available()) {
    Serial.write(espSerial.read());
  }
  Serial.println();
  
  // تست ارزیابی سیگنال
  espSerial.println("AT+CWLAP");
  delay(2000);
  
  Serial.println("Available WiFi networks:");
  while (espSerial.available()) {
    Serial.write(espSerial.read());
  }
  Serial.println();
  
  Serial.println("Communication test completed");
}

void showHelp() {
  Serial.println("\n=== ESP-01 Programmer Help ===");
  Serial.println("This programmer allows you to:");
  Serial.println("1. Upload code to ESP-01 from Arduino IDE");
  Serial.println("2. Switch between programming and run modes");
  Serial.println("3. Test ESP-01 functionality");
  Serial.println("4. Bridge PC serial to ESP-01 serial");
  Serial.println();
  Serial.println("Wiring:");
  Serial.println("USB-Serial TX -> ESP RX");
  Serial.println("USB-Serial RX -> ESP TX");
  Serial.println("USB-Serial DTR -> ESP GPIO0");
  Serial.println("USB-Serial RTS -> ESP EN");
  Serial.println("USB-Serial 3.3V -> ESP VCC");
  Serial.println("USB-Serial GND -> ESP GND");
  Serial.println("==============================\n");
}

/*
 * مانیتور سریال پیشرفته برای دیباگ ESP8266
 * با قابلیت فیلتر، ذخیره لاگ و تجزیه داده‌ها
 */

#include <SoftwareSerial.h>

#define BUFFER_SIZE 256
#define LOG_FILE_NAME "serial_log.txt"

SoftwareSerial deviceSerial(2, 3); // RX, TX برای اتصال به دستگاه

char inputBuffer[BUFFER_SIZE];
byte bufferIndex = 0;
bool loggingEnabled = false;
bool echoEnabled = true;
bool timestampEnabled = true;
bool hexMode = false;
unsigned long lineCount = 0;

// فیلترهای کلمات کلیدی
String filters[10];
byte filterCount = 0;

void setup() {
  Serial.begin(115200);
  deviceSerial.begin(115200);
  
  // راه‌اندازی سیستم
  initializeSystem();
  
  Serial.println("\n\n========================================");
  Serial.println("   Advanced Serial Monitor v2.0");
  Serial.println("   for ESP8266/ESP32 Debugging");
  Serial.println("========================================");
  
  showHelp();
  Serial.println("\nReady. Device output will appear below:");
  Serial.println("----------------------------------------");
}

void loop() {
  // خواندن از دستگاه و ارسال به کامپیوتر
  readFromDevice();
  
  // خواندن از کامپیوتر و ارسال به دستگاه
  readFromComputer();
  
  // مدیریت بافر
  manageBuffer();
}

void initializeSystem() {
  // پاک کردن بافر
  memset(inputBuffer, 0, BUFFER_SIZE);
  bufferIndex = 0;
  
  // تنظیمات اولیه
  loggingEnabled = false;
  echoEnabled = true;
  timestampEnabled = true;
  hexMode = false;
  lineCount = 0;
  filterCount = 0;
}

void readFromDevice() {
  while (deviceSerial.available()) {
    char c = deviceSerial.read();
    
    // ذخیره در بافر
    if (bufferIndex < BUFFER_SIZE - 1) {
      inputBuffer[bufferIndex++] = c;
    }
    
    // اگر خط کامل شد
    if (c == '\n' || bufferIndex >= BUFFER_SIZE - 1) {
      processBuffer();
    }
  }
}

void readFromComputer() {
  while (Serial.available()) {
    char c = Serial.read();
    
    // بررسی دستورات ویژه
    if (c == '!') {
      handleSpecialCommand();
    } 
    else {
      // ارسال به دستگاه
      deviceSerial.write(c);
      
      // اکو اگر فعال باشد
      if (echoEnabled && c != '\n' && c != '\r') {
        Serial.write(c);
      }
    }
  }
}

void processBuffer() {
  if (bufferIndex == 0) return;
  
  // پایان رشته
  inputBuffer[bufferIndex] = '\0';
  
  // اعمال فیلترها
  if (!passesFilters()) {
    bufferIndex = 0;
    return;
  }
  
  // اضافه کردن timestamp اگر فعال باشد
  String outputLine = "";
  if (timestampEnabled) {
    outputLine += "[";
    outputLine += millis();
    outputLine += "] ";
  }
  
  // تبدیل به hex اگر در حالت hex باشیم
  if (hexMode) {
    outputLine += "HEX: ";
    for (byte i = 0; i < bufferIndex; i++) {
      if (inputBuffer[i] >= 32 && inputBuffer[i] < 127) {
        // کاراکتر قابل چاپ
        outputLine += inputBuffer[i];
        outputLine += "(";
      }
      
      // نمایش hex
      char hex[3];
      sprintf(hex, "%02X", inputBuffer[i]);
      outputLine += hex;
      
      if (inputBuffer[i] >= 32 && inputBuffer[i] < 127) {
        outputLine += ")";
      }
      outputLine += " ";
    }
  } else {
    outputLine += inputBuffer;
  }
  
  // ارسال به کامپیوتر
  Serial.print(outputLine);
  
  // ذخیره در لاگ اگر فعال باشد
  if (loggingEnabled) {
    saveToLog(outputLine);
  }
  
  // افزایش شمارنده خط
  lineCount++;
  
  // نمایش شمارنده خط هر 50 خط
  if (lineCount % 50 == 0) {
    Serial.print("[Lines: ");
    Serial.print(lineCount);
    Serial.println("]");
  }
  
  // پاک کردن بافر
  bufferIndex = 0;
}

bool passesFilters() {
  if (filterCount == 0) return true;
  
  String bufferStr = String(inputBuffer);
  bufferStr.toUpperCase();
  
  for (byte i = 0; i < filterCount; i++) {
    if (bufferStr.indexOf(filters[i]) >= 0) {
      return true;
    }
  }
  
  return false;
}

void saveToLog(String data) {
  // در اینجا می‌توانید به SD Card یا EEPROM ذخیره کنید
  // برای سادگی، فعلاً فقط نمایش می‌دهیم
  static unsigned long lastLogNotice = 0;
  
  if (millis() - lastLogNotice > 5000) {
    Serial.println("[LOG: Data saved to buffer]");
    lastLogNotice = millis();
  }
}

void handleSpecialCommand() {
  String command = Serial.readStringUntil('\n');
  command.trim();
  
  Serial.print(">! ");
  Serial.println(command);
  
  if (command == "help") {
    showHelp();
  }
  else if (command == "log on") {
    loggingEnabled = true;
    Serial.println("Logging ENABLED");
  }
  else if (command == "log off") {
    loggingEnabled = false;
    Serial.println("Logging DISABLED");
  }
  else if (command == "echo on") {
    echoEnabled = true;
    Serial.println("Echo ENABLED");
  }
  else if (command == "echo off") {
    echoEnabled = false;
    Serial.println("Echo DISABLED");
  }
  else if (command == "time on") {
    timestampEnabled = true;
    Serial.println("Timestamp ENABLED");
  }
  else if (command == "time off") {
    timestampEnabled = false;
    Serial.println("Timestamp DISABLED");
  }
  else if (command == "hex on") {
    hexMode = true;
    Serial.println("Hex mode ENABLED");
  }
  else if (command == "hex off") {
    hexMode = false;
    Serial.println("Hex mode DISABLED");
  }
  else if (command.startsWith("filter add ")) {
    String filter = command.substring(11);
    filter.toUpperCase();
    
    if (filterCount < 10) {
      filters[filterCount++] = filter;
      Serial.print("Filter added: ");
      Serial.println(filter);
    } else {
      Serial.println("Filter limit reached (max 10)");
    }
  }
  else if (command == "filter clear") {
    filterCount = 0;
    Serial.println("All filters cleared");
  }
  else if (command == "filter list") {
    Serial.println("Active filters:");
    for (byte i = 0; i < filterCount; i++) {
      Serial.print("  ");
      Serial.print(i + 1);
      Serial.print(": ");
      Serial.println(filters[i]);
    }
  }
  else if (command == "stats") {
    showStatistics();
  }
  else if (command == "clear") {
    clearScreen();
  }
  else if (command == "reset") {
    initializeSystem();
    Serial.println("Monitor reset");
  }
  else {
    Serial.println("Unknown command. Type '!help' for commands.");
  }
}

void showHelp() {
  Serial.println("\n=== Serial Monitor Commands ===");
  Serial.println("All commands start with '!'");
  Serial.println("!help         - Show this help");
  Serial.println("!log on/off   - Enable/disable logging");
  Serial.println("!echo on/off  - Enable/disable echo");
  Serial.println("!time on/off  - Enable/disable timestamp");
  Serial.println("!hex on/off   - Enable/disable hex mode");
  Serial.println("!filter add X - Add filter for text X");
  Serial.println("!filter clear - Clear all filters");
  Serial.println("!filter list  - List active filters");
  Serial.println("!stats        - Show statistics");
  Serial.println("!clear        - Clear screen");
  Serial.println("!reset        - Reset monitor");
  Serial.println("===============================\n");
}

void showStatistics() {
  Serial.println("\n=== Statistics ===");
  Serial.print("Lines processed: ");
  Serial.println(lineCount);
  Serial.print("Active filters: ");
  Serial.println(filterCount);
  Serial.print("Logging: ");
  Serial.println(loggingEnabled ? "ENABLED" : "DISABLED");
  Serial.print("Echo: ");
  Serial.println(echoEnabled ? "ENABLED" : "DISABLED");
  Serial.print("Timestamp: ");
  Serial.println(timestampEnabled ? "ENABLED" : "DISABLED");
  Serial.print("Hex mode: ");
  Serial.println(hexMode ? "ENABLED" : "DISABLED");
  Serial.print("Uptime: ");
  Serial.print(millis() / 1000);
  Serial.println(" seconds");
  Serial.println("==================\n");
}

void clearScreen() {
  // ارسال کدهای clear screen برای ترمینال
  Serial.write(27);    // ESC
  Serial.print("[2J"); // Clear screen
  Serial.write(27);    // ESC
  Serial.print("[H");  // Cursor home
  
  Serial.println("Screen cleared");
  Serial.println("----------------------------------------");
}

void manageBuffer() {
  // پاک کردن خودکار بافر اگر بیش از حد بزرگ شود
  static unsigned long lastBufferCheck = 0;
  
  if (millis() - lastBufferCheck > 10000) { // هر 10 ثانیه
    if (bufferIndex > BUFFER_SIZE * 0.8) {
      Serial.println("[WARNING: Buffer almost full, clearing...]");
      bufferIndex = 0;
    }
    lastBufferCheck = millis();
  }
}

/*
 * ارتباط دوطرفه بین ESP8266 و کامپیوتر
 * ESP8266 داده از سنسورها می‌خواند و به کامپیوتر می‌فرستد
 * کامپیوتر دستورات کنترل را به ESP8266 می‌فرستد
 */

#include <ESP8266WiFi.h>

// تنظیمات WiFi (اگر نیاز باشد)
const char* ssid = "YourWiFi";
const char* password = "YourPassword";

// پین‌های سنسورها
#define TEMP_SENSOR_PIN A0
#define LIGHT_SENSOR_PIN D1
#define MOTION_SENSOR_PIN D2
#define RELAY_PIN D3
#define LED_PIN D4

// متغیرهای سیستم
bool systemActive = true;
float temperature = 0.0;
int lightLevel = 0;
bool motionDetected = false;
unsigned long lastDataSend = 0;
const unsigned long DATA_INTERVAL = 2000; // ارسال داده هر 2 ثانیه

// ساختار برای دستورات
struct Command {
  char type;      // نوع دستور: R=رله, L=LED, S=سیستم
  char action;    // عمل: 0=خاموش, 1=روشن, 2=تغییر حالت
  int value;      // مقدار (برای تنظیمات)
};

void setup() {
  // شروع سریال
  Serial.begin(115200);
  delay(1000);
  
  // تنظیم پین‌ها
  pinMode(TEMP_SENSOR_PIN, INPUT);
  pinMode(LIGHT_SENSOR_PIN, INPUT);
  pinMode(MOTION_SENSOR_PIN, INPUT_PULLUP);
  pinMode(RELAY_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
  
  digitalWrite(RELAY_PIN, LOW);
  digitalWrite(LED_PIN, LOW);
  
  // اتصال به WiFi (اختیاری)
  // connectToWiFi();
  
  Serial.println("\n\n========================================");
  Serial.println("   ESP8266 - PC Bidirectional Comm");
  Serial.println("========================================");
  Serial.println("System ready");
  Serial.println("Commands from PC:");
  Serial.println("  R0/R1 - Relay OFF/ON");
  Serial.println("  L0/L1 - LED OFF/ON");
  Serial.println("  S0/S1 - System OFF/ON");
  Serial.println("  ?     - Show help");
  Serial.println("  D     - Debug info");
  Serial.println("----------------------------------------");
}

void loop() {
  // خواندن سنسورها
  readSensors();
  
  // ارسال داده به کامپیوتر
  sendDataToPC();
  
  // بررسی دستورات از کامپیوتر
  checkPCCommands();
  
  // کنترل سیستم بر اساس سنسورها
  autonomousControl();
  
  delay(100);
}

void readSensors() {
  // خواندن دمای شبیه‌سازی شده (NTC)
  int tempRaw = analogRead(TEMP_SENSOR_PIN);
  temperature = (tempRaw / 1023.0) * 100.0; // تبدیل به درجه سانتی‌گراد
  
  // خواندن سطح نور (LDR)
  lightLevel = analogRead(LIGHT_SENSOR_PIN);
  
  // تشخیص حرکت
  motionDetected = (digitalRead(MOTION_SENSOR_PIN) == LOW);
}

void sendDataToPC() {
  if (millis() - lastDataSend >= DATA_INTERVAL) {
    // ایجاد JSON-like format
    Serial.print("{");
    Serial.print("\"temp\":");
    Serial.print(temperature, 1);
    Serial.print(",\"light\":");
    Serial.print(lightLevel);
    Serial.print(",\"motion\":");
    Serial.print(motionDetected ? "true" : "false");
    Serial.print(",\"relay\":");
    Serial.print(digitalRead(RELAY_PIN));
    Serial.print(",\"led\":");
    Serial.print(digitalRead(LED_PIN));
    Serial.print(",\"active\":");
    Serial.print(systemActive ? "true" : "false");
    Serial.print(",\"time\":");
    Serial.print(millis());
    Serial.println("}");
    
    lastDataSend = millis();
  }
}

void checkPCCommands() {
  if (Serial.available()) {
    String command = Serial.readStringUntil('\n');
    command.trim();
    
    processCommand(command);
  }
}

void processCommand(String cmd) {
  Serial.print("[CMD] ");
  Serial.println(cmd);
  
  if (cmd == "?") {
    showHelp();
  }
  else if (cmd == "D" || cmd == "d") {
    showDebugInfo();
  }
  else if (cmd.length() >= 2) {
    char type = cmd.charAt(0);
    char action = cmd.charAt(1);
    
    switch (type) {
      case 'R': // Relay کنترل
      case 'r':
        if (action == '0') {
          digitalWrite(RELAY_PIN, LOW);
          Serial.println("Relay OFF");
        } else if (action == '1') {
          digitalWrite(RELAY_PIN, HIGH);
          Serial.println("Relay ON");
        }
        break;
        
      case 'L': // LED کنترل
      case 'l':
        if (action == '0') {
          digitalWrite(LED_PIN, LOW);
          Serial.println("LED OFF");
        } else if (action == '1') {
          digitalWrite(LED_PIN, HIGH);
          Serial.println("LED ON");
        }
        break;
        
      case 'S': // System کنترل
      case 's':
        if (action == '0') {
          systemActive = false;
          Serial.println("System INACTIVE");
        } else if (action == '1') {
          systemActive = true;
          Serial.println("System ACTIVE");
        }
        break;
        
      default:
        Serial.println("Unknown command type");
    }
  }
}

void autonomousControl() {
  if (!systemActive) return;
  
  // کنترل خودکار LED بر اساس نور
  if (lightLevel < 300) { // اگر تاریک است
    digitalWrite(LED_PIN, HIGH);
  } else {
    digitalWrite(LED_PIN, LOW);
  }
  
  // کنترل خودکار رله بر اساس دما
  if (temperature > 30.0) {
    digitalWrite(RELAY_PIN, HIGH); // روشن کردن فن
  } else if (temperature < 25.0) {
    digitalWrite(RELAY_PIN, LOW); // خاموش کردن فن
  }
}

void showHelp() {
  Serial.println("\n=== ESP8266 Control System ===");
  Serial.println("Real-time sensor monitoring and control");
  Serial.println("\nCommands:");
  Serial.println("  R0    - Turn relay OFF");
  Serial.println("  R1    - Turn relay ON");
  Serial.println("  L0    - Turn LED OFF");
  Serial.println("  L1    - Turn LED ON");
  Serial.println("  S0    - Deactivate system");
  Serial.println("  S1    - Activate system");
  Serial.println("  D     - Show debug information");
  Serial.println("  ?     - Show this help");
  Serial.println("\nData format (auto-sent every 2s):");
  Serial.println("  {\"temp\":25.5,\"light\":450,\"motion\":false,...}");
  Serial.println("===============================\n");
}

void showDebugInfo() {
  Serial.println("\n=== Debug Information ===");
  Serial.print("Free Heap: ");
  Serial.print(ESP.getFreeHeap());
  Serial.println(" bytes");
  
  Serial.print("WiFi Status: ");
  Serial.println(WiFi.status());
  
  if (WiFi.status() == WL_CONNECTED) {
    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP());
  }
  
  Serial.print("System Active: ");
  Serial.println(systemActive ? "YES" : "NO");
  
  Serial.print("Sensors - Temp: ");
  Serial.print(temperature, 1);
  Serial.print("C, Light: ");
  Serial.print(lightLevel);
  Serial.print(", Motion: ");
  Serial.println(motionDetected ? "YES" : "NO");
  
  Serial.print("Outputs - Relay: ");
  Serial.print(digitalRead(RELAY_PIN));
  Serial.print(", LED: ");
  Serial.println(digitalRead(LED_PIN));
  
  Serial.print("Uptime: ");
  Serial.print(millis() / 1000);
  Serial.println(" seconds");
  Serial.println("=======================\n");
}

void connectToWiFi() {
  Serial.print("Connecting to ");
  Serial.println(ssid);
  
  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("\nWiFi connected!");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("\nWiFi connection failed");
    Serial.println("Continuing in offline mode...");
  }
}

# نصب با Homebrew
brew install --cask wch-ch34x-usb-serial-driver

# معمولاً به صورت پیش‌فرض پشتیبانی می‌شود
ls /dev/ttyUSB*

// ارسال داده‌های DHT22، BMP180، MQ-135 به کامپیوتر

// ارسال دستورات حرکت از سریال به موتورهای ربات

// استفاده به عنوان پروگرامر برای میکروکنترلرهای دیگر

// ارتباط با روترها، سوئیچ‌های شبکه

// ذخیره داده‌های سریال در فایل برای تحلیل