远程开机-esp8266

📋 目录

1. 项目介绍
2. 硬件需求
3. 软件环境配置
4. 使用说明
5. 完整代码
6. 版本对比与新特性
7. 注意事项
8. 故障排除
9. 总结

1. 项目介绍

🎯 ESP8266远程电源控制系统 2.0

本项目是基于ESP8266的智能远程电源控制系统的全新升级版本，通过Web界面实现电脑的远程开关机控制。2.0版本在保持原有功能的基础上，进行了全面的界面优化和功能增强。

更新提示：

• 新版本预览界面不再更新，代码版本要新一些
• 新增网络故障应急操作功能，搭配远程控制和WOL食用
• 修复相关bug，新增wifi检测，优化内容压力

✨ 2.0版本主要特性

• 🎨 全新响应式界面：完美适配电脑和手机端
• 🔄 新增重启功能：一键重启电脑，自动关机等待后开机
• ⏱️ 多时间单位支持：倒计时支持秒/分钟/小时三种单位
• 🚀 快速操作优化：5分钟后关机、重启电脑、明早8点开机
• 💡 智能交互体验：操作确认、实时验证、友好提示
• 📱 移动端优化：触摸友好、大按钮设计、垂直布局
• ⌨️ 电脑端增强：键盘快捷键、悬停效果、网格布局

🖼️ 界面预览

2.0版本界面

1.0版本界面

2. 硬件需求

2.1 必需硬件清单

• ESP8266 01s 开发板 - 主控芯片，负责WiFi连接和控制逻辑
• ESP8266 01s 配套继电器模块（Relay继电器插座） - 用于控制电脑电源按键信号
• ESP8266 01s 烧录下载器 - 用于将程序写入ESP8266芯片

2.2 硬件连接说明

• ESP8266 01s 直接插入配套的继电器插座模块
• 继电器模块的输出端连接到电脑主板的电源按键引脚
• 确保继电器模块供电正常（通常为5V或3.3V）

2.3 网络环境要求

⚠️ 重要提醒：WiFi条件必须是2.4GHz频段

• ESP8266芯片仅支持2.4GHz WiFi网络
• 不支持5GHz WiFi网络
• 确保路由器开启了2.4GHz频段并设置了正确的网络名称和密码

3. 软件环境配置

3.1 Arduino IDE 设置

• Arduino IDE - 推荐使用最新版本
• 开发板核心配置：
  • 在Arduino IDE中，进入 文件 → 首选项
  • 在"附加开发板管理器网址"中添加：http://arduino.esp8266.com/stable/package_esp8266com_index.json
  • 进入 工具 → 开发板 → 开发板管理器
  • 搜索并安装 “ESP8266” 开发板包
  • ⚠️ 关键设置：在 工具 → 开发板 中选择 “Generic ESP8266 Module” 或 “ESP8266-01”

3.2 必需库文件

• ESP8266WiFi库 - ESP8266核心库，用于WiFi连接
• ESP8266WebServer库 - 用于创建Web服务器
• ArduinoJson库 - 用于JSON数据处理
• ESP8266Ping库 - 用于检测电脑在线状态

3.3 库安装方法

1. 在Arduino IDE中进入 工具 → 管理库
2. 搜索并安装以上库文件
3. 确保所有库都是最新版本

4. 使用说明

4.1 代码配置

在使用前，需要修改代码中的以下参数：

• ssid - 修改为您的WiFi网络名称
• password - 修改为您的WiFi密码
• computerIP - 修改为您电脑的IP地址

⚠️ 重要提醒：除了上述WiFi和IP配置外，其他代码请勿修改，以免影响功能正常运行

4.2 烧录步骤

1. 将ESP8266 01s插入烧录下载器
2. 连接USB线到电脑
3. 在Arduino IDE中选择正确的开发板和端口
4. 点击上传按钮烧录程序
5. 烧录完成后，将ESP8266 01s插入继电器模块

4.3 功能特性

🎯 核心功能

• ⚡ 即时控制：一键开关机操作，按钮颜色动态变化
• ⏰ 定时任务：设置指定时间的开关机任务，支持未来时间验证
• ⏱️ 倒计时任务：支持秒/分钟/小时三种时间单位的倒计时
• 🔄 重启功能：智能重启，先关机检测到电脑状态发生改变后自动开机
• 📊 状态监控：实时显示电脑在线/离线状态和网络延迟
• 📋 任务管理：查看和取消待执行的任务，支持批量管理

🚀 快速操作

• ⏰ 5分钟后关机：快速设置短时关机任务
• 🔄 重启电脑：一键重启，无需手动操作
• 🌅 明早8点开机：自动设置次日早晨开机任务

🎨 界面特色

• 📱 响应式设计：电脑端网格布局，手机端垂直布局
• 💫 现代化UI：渐变背景、毛玻璃效果、动态反馈
• 🎯 智能交互：操作确认、输入验证、友好提示
• ⌨️ 快捷键支持：Ctrl+P触发电源，Ctrl+R刷新页面

5. 完整代码

⚠️ 注意：以下代码除WiFi配置和电脑IP地址外，请勿修改其他部分

5.1 ESP8266远程电源控制系统 2.0版本代码

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <ESP8266Ping.h>
#include <ArduinoJson.h>
#include <time.h>

const char* ssid = "zhou";
const char* password = "123456";
const char* computerIP = "1.1.1.45"; // 电脑的IP地址，需要替换为实际IP
String localGatewayIP = "192.168.31.1"; // ESP8266本地网关IP
String targetNetworkGatewayIP = "1.1.1.1"; // 目标电脑网络的网关IP

ESP8266WebServer server(80);
const int relayPin = 0;      // 继电器控制引脚
const int ledPin = 2;        // 状态指示LED引脚
bool computerStatus = false; // 电脑状态(true=在线, false=离线)
bool lastKnownComputerStatus = false; // 网络故障前最后已知的电脑状态
bool isRestarting = false;   // 重启状态标志
bool wifiConnected = false;  // WiFi连接状态
bool failSafeMode = false;   // 故障安全模式标志
bool statusValidBeforeFailure = false; // 故障前是否有有效的状态记录

unsigned long lastPingTime = 0;
const unsigned long pingInterval = 8000; // 每8秒ping一次（减少频率）
unsigned long lastWiFiCheck = 0;
const unsigned long wifiCheckInterval = 15000; // 每15秒检查WiFi连接（减少频率）
unsigned long networkFailureTime = 0; // 网络故障开始时间
const unsigned long failSafeTimeout = 10000; // 测试用：10秒后进入故障安全模式
const unsigned long routerStartupTimeout = 20000; // 测试用：路由器启动等待时间：20秒
unsigned long lastComputerOnlineTime = 0; // 最后一次检测到电脑在线的时间
unsigned long lastSuccessfulPingTime = 0; // 最后一次成功ping的时间
unsigned long continuousFailureStartTime = 0; // 连续故障开始时间
unsigned long systemStartTime = 0; // 系统启动时间
unsigned long totalOperations = 0; // 总操作次数
bool hasEverPingedSuccessfully = false; // 是否曾经ping成功过
bool isRouterStartupPhase = true; // 是否处于路由器启动阶段
unsigned long lastUserOperationTime = 0; // 最后一次用户操作时间
const unsigned long userOperationGracePeriod = 120000; // 用户操作后的宽限期：2分钟

// 故障安全策略配置
enum FailSafePolicy {
  FAILSAFE_ALWAYS_ON,      // 总是发送开机信号（最安全）
  FAILSAFE_PRESERVE_STATE, // 保持故障前状态（故障前在线才开机，故障前离线保持离线）
  FAILSAFE_SMART          // 智能策略（故障前在线不操作，故障前离线才开机）
};
FailSafePolicy failSafePolicy = FAILSAFE_SMART; // 默认使用智能策略
bool localNetworkConnectivity = false; // 本地网络连通性（ping本地网关）
bool targetNetworkConnectivity = false; // 目标网络连通性（ping目标网关）
unsigned long lastGatewayPingTime = 0; // 最后一次ping网关的时间

enum TaskType { TASK_ON, TASK_OFF, TASK_TOGGLE };

struct Task {
  TaskType type;
  unsigned long executeMillis; // 任务执行的绝对时间（millis）
  String desc; // 任务描述
};

const int MAX_TASKS = 5;
Task tasks[MAX_TASKS];
int taskCount = 0;

void handleRoot() {
  String html = F(R"=====(
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>远程电源控制</title>
<style>
*{box-sizing:border-box}
body{margin:0;padding:10px;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;background:linear-gradient(135deg,#667eea 0%,#764ba2 100%);min-height:100vh;color:#333}
.container{background:rgba(255,255,255,0.95);backdrop-filter:blur(10px);padding:20px;border-radius:12px;box-shadow:0 8px 32px rgba(0,0,0,0.1);max-width:800px;width:100%;margin:0 auto;border:1px solid rgba(255,255,255,0.2)}
h1{margin:0 0 20px 0;color:#2c3e50;font-size:24px;text-align:center}
h3{margin:15px 0 10px 0;color:#34495e;font-size:16px}
.status{margin:15px 0;padding:12px;border-radius:8px;font-weight:bold;text-align:center;font-size:16px;border:2px solid transparent}
.online{background:#d4edda;color:#155724;border-color:#c3e6cb}
.offline{background:#f8d7da;color:#721c24;border-color:#f5c6cb}
.info{font-size:13px;color:#6c757d;margin:5px 0;text-align:center}
.button{padding:12px 20px;font-size:16px;color:white;background:#007bff;border:none;border-radius:8px;cursor:pointer;margin:5px;transition:all 0.3s ease;font-weight:500;min-height:48px;display:flex;align-items:center;justify-content:center}
.button:hover{background:#0056b3;transform:translateY(-1px);box-shadow:0 4px 12px rgba(0,123,255,0.3)}
.button:active{transform:translateY(0)}
.button:disabled{background:#6c757d;cursor:not-allowed;transform:none;box-shadow:none}
.button.on{background:#28a745}
.button.on:hover{background:#218838;box-shadow:0 4px 12px rgba(40,167,69,0.3)}
.button.off{background:#dc3545}
.button.off:hover{background:#c82333;box-shadow:0 4px 12px rgba(220,53,69,0.3)}
.section{margin:20px 0;padding:15px;border:1px solid rgba(0,0,0,0.1);border-radius:10px;background:rgba(255,255,255,0.5)}
.input-group{margin:10px 0;display:flex;gap:8px;flex-wrap:wrap}
.input-group input,.input-group select{padding:10px;border:2px solid #e9ecef;border-radius:6px;font-size:14px;transition:border-color 0.3s ease;min-height:40px}
.input-group input:focus,.input-group select:focus{outline:none;border-color:#007bff;box-shadow:0 0 0 3px rgba(0,123,255,0.1)}
.task-item{padding:12px;margin:8px 0;background:rgba(248,249,250,0.8);border-radius:8px;display:flex;justify-content:space-between;align-items:center;font-size:14px;border:1px solid rgba(0,0,0,0.05)}
.task-item button{padding:6px 12px;font-size:12px;background:#dc3545;color:white;border:none;border-radius:5px;cursor:pointer;transition:background 0.3s ease}
.task-item button:hover{background:#c82333}
.quick-actions{display:flex;gap:8px;margin:15px 0;flex-wrap:wrap;justify-content:center}
.quick{padding:8px 12px;background:#17a2b8;color:white;border-radius:6px;cursor:pointer;font-size:13px;transition:all 0.3s ease;border:none;min-height:36px}
.quick:hover{background:#138496;transform:translateY(-1px)}
#message{margin:15px 0;padding:12px;background:#d1ecf1;color:#0c5460;border-radius:8px;display:none;border-left:4px solid #17a2b8}
.grid{display:grid;gap:15px}
@media(min-width:768px){
.container{padding:30px;max-width:900px}
h1{font-size:28px}
.grid{grid-template-columns:1fr 1fr}
.grid .section:first-child{grid-column:1/-1}
.input-group{flex-wrap:nowrap}
.input-group input,.input-group select{flex:1}
.quick-actions{justify-content:flex-start}
.button{width:auto;min-width:120px}
}
@media(max-width:767px){
.container{padding:15px;margin:5px}
h1{font-size:20px}
.input-group{flex-direction:column}
.input-group input,.input-group select{width:100%;margin:3px 0}
.button{width:100%;margin:8px 0}
.quick{flex:1;text-align:center;margin:3px}
.task-item{flex-direction:column;align-items:flex-start;gap:8px}
.task-item button{align-self:flex-end}
}
@media(max-width:480px){
body{padding:5px}
.container{padding:12px;border-radius:8px}
h1{font-size:18px;margin-bottom:15px}
h3{font-size:14px}
.status{font-size:14px;padding:10px}
.button{font-size:14px;padding:10px 15px;min-height:44px}
.info{font-size:12px}
}
</style>
</head>
<body>
<div class="container">
<h1>💻 电脑远程电源控制</h1>

<!-- 状态信息区域 -->
<div id="computerStatus" class="status offline">🔍 状态: 获取中...</div>
<div id="wifiStatus" class="info">📶 WiFi: 检测中...</div>
<div id="failSafeStatus" class="info" style="display:none;">⚠️ 故障安全模式</div>
<div class="info" id="pingInfo">正在检测网络连接...</div>
<div class="info" id="nowTime"></div>

<!-- 快速操作 -->
<div class="quick-actions">
<button class="quick" onclick="quickShutdown()">⏰ 5分钟后关机</button>
<button class="quick" onclick="quickRestart()">🔄 重启电脑</button>
<button class="quick" onclick="quickStartup()">🌅 明早8点开机</button>
<button class="quick" onclick="triggerFailSafe()" style="background:#ffc107;color:#000;">⚠️ 故障安全开机</button>
</div>

<div id="message"></div>

<!-- 网格布局开始 -->
<div class="grid">
<!-- 即时控制 -->
<div class="section">
<h3>⚡ 即时控制</h3>
<button class="button" id="powerButton" onclick="togglePower()">🔄 开/关机</button>
</div>

<!-- 定时指令 -->
<div class="section">
<h3>⏰ 定时指令</h3>
<div class="input-group">
<input type="datetime-local" id="scheduledTime" title="选择具体时间">
<select id="scheduleOp" title="选择操作类型">
<option value="on">🟢 开机</option>
<option value="off">🔴 关机</option>
</select>
</div>
<button class="button" onclick="setSchedule()">📅 设置定时任务</button>
</div>

<!-- 倒计时指令 -->
<div class="section">
<h3>⏱️ 倒计时指令</h3>
<div class="input-group">
<input type="number" id="countdownValue" placeholder="输入数值" min="1" max="3600" value="5" title="输入时间数值">
<select id="countdownUnit" title="选择时间单位">
<option value="s">秒</option>
<option value="m" selected>分钟</option>
<option value="h">小时</option>
</select>
<select id="countdownOp" title="选择操作类型">
<option value="on">🟢 开机</option>
<option value="off">🔴 关机</option>
</select>
</div>
<button class="button" onclick="setCountdown()">⏱️ 设置倒计时</button>
</div>
</div>
<!-- 网格布局结束 -->

<!-- 任务管理 -->
<div class="section">
<h3>📋 待执行任务</h3>
<div id="pendingTasks">
<div style="text-align:center;color:#6c757d;padding:20px;">
<div style="font-size:48px;margin-bottom:10px;">📝</div>
<div>暂无待执行任务</div>
</div>
</div>
</div>
        </div>

<script>
// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
  // 设置默认时间为当前时间+1小时
  const now = new Date();
  now.setHours(now.getHours() + 1);
  now.setMinutes(0);
  document.getElementById('scheduledTime').value = now.toISOString().slice(0, 16);

  // 监听倒计时单位变化，动态更新输入框限制
  document.getElementById('countdownUnit').addEventListener('change', function() {
    updateCountdownLimits();
  });

  // 初始化倒计时限制
  updateCountdownLimits();

  fetchStatus();
  setInterval(fetchStatus, 3000);
});

// 更新倒计时输入框的限制和提示
function updateCountdownLimits() {
  const unit = document.getElementById('countdownUnit').value;
  const input = document.getElementById('countdownValue');

  switch(unit) {
    case 's':
      input.max = 3600;
      input.placeholder = '输入秒数(1-3600)';
      input.title = '1-3600秒之间';
      break;
    case 'm':
      input.max = 1440;
      input.placeholder = '输入分钟数(1-1440)';
      input.title = '1-1440分钟之间';
      break;
    case 'h':
      input.max = 24;
      input.placeholder = '输入小时数(1-24)';
      input.title = '1-24小时之间';
      break;
  }

  // 如果当前值超过新的最大值，重置为默认值
  const currentValue = parseInt(input.value) || 0;
  if (currentValue > parseInt(input.max)) {
    input.value = unit === 'h' ? 1 : 5;
  }
}

function fetchStatus() {
  fetch('/status')
    .then(response => response.json())
    .then(data => {
      const statusDiv = document.getElementById('computerStatus');
      const powerButton = document.getElementById('powerButton');
      const wifiStatusDiv = document.getElementById('wifiStatus');
      const failSafeStatusDiv = document.getElementById('failSafeStatus');

      // 更新电脑状态
      if(data.online) {
        statusDiv.innerHTML = '🟢 状态: 电脑在线';
        statusDiv.className = 'status online';
        powerButton.innerHTML = '🔴 关机';
        powerButton.className = 'button off';
      } else {
        statusDiv.innerHTML = '🔴 状态: 电脑离线';
        statusDiv.className = 'status offline';
        powerButton.innerHTML = '🟢 开机';
        powerButton.className = 'button on';
      }

      // 更新WiFi状态
      if(data.wifiConnected) {
        const rssi = data.wifiRSSI;
        const signalStrength = rssi > -50 ? '强' : rssi > -70 ? '中' : '弱';
        wifiStatusDiv.innerHTML = `📶 WiFi: 已连接 (信号${signalStrength}: ${rssi}dBm)`;
        wifiStatusDiv.style.color = '#28a745';
      } else {
        wifiStatusDiv.innerHTML = '📶 WiFi: 断开连接';
        wifiStatusDiv.style.color = '#dc3545';
      }

      // 更新故障安全模式状态
      if(data.failSafeMode) {
        const lastKnownStatusText = data.statusValidBeforeFailure ?
          (data.lastKnownStatus ? '在线' : '离线') : '未知';
        failSafeStatusDiv.innerHTML = `⚠️ 故障安全模式: 已激活 (故障前状态: ${lastKnownStatusText})`;
        failSafeStatusDiv.style.display = 'block';
        failSafeStatusDiv.style.color = '#ffc107';
        failSafeStatusDiv.style.fontWeight = 'bold';
      } else if(data.networkFailureTime > 0) {
        const countdown = data.failSafeCountdown;
        const lastKnownStatusText = data.statusValidBeforeFailure ?
          (data.lastKnownStatus ? '在线' : '离线') : '未知';
        failSafeStatusDiv.innerHTML = `⏳ 网络故障: ${Math.floor(countdown/60)}分${countdown%60}秒后进入故障安全模式<br><small>故障前状态: ${lastKnownStatusText}</small>`;
        failSafeStatusDiv.style.display = 'block';
        failSafeStatusDiv.style.color = '#fd7e14';
      } else {
        failSafeStatusDiv.style.display = 'none';
      }

      const lastCheck = data.lastCheck.substr(11,8);
      const pingTime = data.pingTime > 0 ? data.pingTime + 'ms' : '无法检测';
      document.getElementById('pingInfo').innerHTML = `🌐 最后检测: ${lastCheck} | 延迟: ${pingTime}`;
      document.getElementById('nowTime').innerHTML = `🕐 当前时间: ${data.now.substr(11,8)}`;

      updateTasks(data.pendingTasks);
    })
    .catch(error => {
      showMessage('❌ 网络连接失败，请检查设备连接', 'error');
      document.getElementById('computerStatus').innerHTML = '❓ 状态: 连接失败';
      document.getElementById('computerStatus').className = 'status offline';
      document.getElementById('wifiStatus').innerHTML = '📶 WiFi: 无法连接到设备';
      document.getElementById('wifiStatus').style.color = '#dc3545';
    });
}

function updateTasks(tasks) {
  const div = document.getElementById('pendingTasks');
  if (tasks && tasks.length > 0) {
    div.innerHTML = tasks.map((task, i) =>
      `<div class="task-item">
        <span><strong>${task.type}</strong><br><small>${task.time}</small></span>
        <button onclick="cancelTask(${i})" title="取消任务">❌ 取消</button>
      </div>`
    ).join('');
  } else {
    div.innerHTML = `
      <div style="text-align:center;color:#6c757d;padding:20px;">
        <div style="font-size:48px;margin-bottom:10px;">📝</div>
        <div>暂无待执行任务</div>
        <small>设置定时或倒计时任务后会在这里显示</small>
      </div>`;
  }
}

function cancelTask(index) {
  if(confirm('确定要取消这个任务吗？')) {
    fetch(`/cancelTask?index=${index}`)
      .then(() => {
        showMessage('✅ 任务已取消', 'success');
        fetchStatus();
      })
      .catch(() => showMessage('❌ 取消失败', 'error'));
  }
}
function togglePower() {
  const button = document.getElementById('powerButton');
  button.disabled = true;
  button.innerHTML = '⏳ 执行中...';

  sendCommand('/trigger', '⚡ 正在发送电源信号...', () => {
    button.disabled = false;
    setTimeout(fetchStatus, 1000); // 1秒后刷新状态
  });
}

function setSchedule() {
  const time = document.getElementById('scheduledTime').value;
  const op = document.getElementById('scheduleOp').value;

  if (!time) {
    showMessage('⚠️ 请选择具体的时间', 'warning');
    return;
  }

  const selectedTime = new Date(time);
  const now = new Date();

  if (selectedTime <= now) {
    showMessage('⚠️ 请选择未来的时间', 'warning');
    return;
  }

  const opText = op === 'on' ? '开机' : '关机';
  const timeText = selectedTime.toLocaleString('zh-CN');

  if(confirm(`确定要在 ${timeText} 执行${opText}操作吗？`)) {
    sendCommand(`/schedule?time=${encodeURIComponent(time)}&op=${op}`, `📅 正在设置定时${opText}任务...`);
  }
}

function setCountdown() {
  const value = parseInt(document.getElementById('countdownValue').value) || 0;
  const unit = document.getElementById('countdownUnit').value;
  const op = document.getElementById('countdownOp').value;

  // 根据单位设置不同的最大值限制
  let maxValue, unitText;
  switch(unit) {
    case 's':
      maxValue = 3600; // 最大3600秒（1小时）
      unitText = '秒';
      break;
    case 'm':
      maxValue = 1440; // 最大1440分钟（24小时）
      unitText = '分钟';
      break;
    case 'h':
      maxValue = 24; // 最大24小时
      unitText = '小时';
      break;
    default:
      maxValue = 1440;
      unitText = '分钟';
  }

  if (value <= 0 || value > maxValue) {
    showMessage(`⚠️ 请输入1-${maxValue}${unitText}之间的数值`, 'warning');
    return;
  }

  const opText = op === 'on' ? '开机' : '关机';

  if(confirm(`确定要在${value}${unitText}后执行${opText}操作吗？`)) {
    sendCommand(`/countdown?unit=${unit}&value=${value}&op=${op}`, `⏱️ 正在设置${value}${unitText}后${opText}...`);
  }
}

function quickShutdown() {
  if(confirm('确定要在5分钟后关机吗？')) {
    // 同时更新界面上的倒计时设置
    document.getElementById('countdownValue').value = 5;
    document.getElementById('countdownUnit').value = 'm';
    document.getElementById('countdownOp').value = 'off';
    sendCommand('/countdown?unit=m&value=5&op=off', '⏰ 设置5分钟后关机...');
  }
}

function quickRestart() {
  if(confirm('确定要重启电脑吗？\n\n重启过程：\n1. 立即关机\n2. 检测电脑状态变化\n3. 检测到关机后自动开机')) {
    sendCommand('/restart', '🔄 正在重启电脑，检测状态变化中...');
  }
}

function quickStartup() {
  const tomorrow = new Date();
  tomorrow.setDate(tomorrow.getDate() + 1);
  tomorrow.setHours(8, 0, 0, 0);
  const timeStr = tomorrow.toISOString().slice(0, 16);

  if(confirm('确定要设置明天早上8点开机吗？')) {
    sendCommand(`/schedule?time=${encodeURIComponent(timeStr)}&op=on`, '🌅 设置明早8点开机...');
  }
}

function triggerFailSafe() {
  if(confirm('确定要手动触发故障安全模式吗？\n\n这将立即发送开机信号，确保电脑处于开机状态。\n通常在网络故障时使用此功能。')) {
    sendCommand('/failsafe', '⚠️ 正在激活故障安全模式...');
  }
}

function sendCommand(url, message, callback) {
  showMessage(message, 'info');

  fetch(url)
    .then(response => response.text())
    .then(data => {
      showMessage('✅ ' + data, 'success');
      setTimeout(() => {
        fetchStatus();
        if(callback) callback();
      }, 1000);
    })
    .catch(error => {
      showMessage('❌ 操作失败: ' + error, 'error');
      if(callback) callback();
    });
}

function showMessage(text, type = 'info') {
  const msg = document.getElementById('message');
  msg.style.display = 'block';
  msg.textContent = text;

  // 根据消息类型设置样式
  msg.style.backgroundColor = type === 'success' ? '#d4edda' :
                              type === 'error' ? '#f8d7da' :
                              type === 'warning' ? '#fff3cd' : '#d1ecf1';
  msg.style.color = type === 'success' ? '#155724' :
                    type === 'error' ? '#721c24' :
                    type === 'warning' ? '#856404' : '#0c5460';
  msg.style.borderLeftColor = type === 'success' ? '#28a745' :
                              type === 'error' ? '#dc3545' :
                              type === 'warning' ? '#ffc107' : '#17a2b8';

  // 自动隐藏消息
  setTimeout(() => {
    msg.style.display = 'none';
  }, type === 'error' ? 4000 : 3000);
}

// 添加键盘快捷键支持（仅电脑端）
document.addEventListener('keydown', function(e) {
  // 检查是否为移动设备
  if(window.innerWidth > 768) {
    if (e.ctrlKey && e.key === 'p') {
      e.preventDefault();
      togglePower();
    }
    if (e.ctrlKey && e.key === 'r') {
      e.preventDefault();
      location.reload();
    }
  }
});

// 添加触摸反馈（移动端）
if('ontouchstart' in window) {
  document.addEventListener('touchstart', function(e) {
    if(e.target.classList.contains('button') || e.target.classList.contains('quick')) {
      e.target.style.transform = 'scale(0.95)';
    }
  });

  document.addEventListener('touchend', function(e) {
    if(e.target.classList.contains('button') || e.target.classList.contains('quick')) {
      setTimeout(() => {
        e.target.style.transform = '';
      }, 150);
    }
  });
}
</script>
</body>
</html>
)=====");
  server.send(200, "text/html", html);
}

void handleTrigger() {
  if (isRestarting) {
    server.send(400, "text/plain", "重启过程进行中，请稍候");
    return;
  }

  // 记录用户操作时间
  lastUserOperationTime = millis();
  Serial.println("用户手动操作电源，记录操作时间");

  digitalWrite(ledPin, LOW);    // LED指示操作开始
  digitalWrite(relayPin, LOW);  // 触发继电器
  delay(500);                   // 模拟按键持续时间
  digitalWrite(relayPin, HIGH);
  digitalWrite(ledPin, HIGH);   // LED指示操作完成

  totalOperations++;
  String message = computerStatus ? "已发送关机信号" : "已发送开机信号";
  server.send(200, "text/plain", message);
}

void handleRestart() {
  if (computerStatus && !isRestarting) {
    // 记录用户操作时间
    lastUserOperationTime = millis();
    Serial.println("用户手动重启电脑，记录操作时间");

    isRestarting = true; // 设置重启状态标志
    Serial.println("开始重启过程");

    // 先关机
    digitalWrite(ledPin, LOW);
    digitalWrite(relayPin, LOW);
    delay(500);
    digitalWrite(relayPin, HIGH);
    Serial.println("已发送关机信号");

    // 等待电脑状态变为离线，最多等待30秒
    unsigned long startTime = millis();
    const unsigned long maxWaitTime = 300000; // 300秒超时
    bool shutdownDetected = false;

    while (millis() - startTime < maxWaitTime) {
      delay(1000); // 每秒检查一次

      // 手动检查ping状态，不调用checkComputerStatus避免状态变化触发其他逻辑
      bool pingResult = Ping.ping(computerIP, 3);

      if (pingResult != computerStatus) {
        computerStatus = pingResult;
        Serial.print("重启过程中状态改变: ");
        Serial.println(computerStatus ? "在线" : "离线");
      }

      if (!computerStatus) { // 检测到电脑已离线
        shutdownDetected = true;
        Serial.println("检测到电脑已关机");
        break;
      }

      // 处理Web服务器请求，避免阻塞
      server.handleClient();
    }

    if (shutdownDetected) {
      // 等待额外3秒确保完全关机
      Serial.println("等待3秒确保完全关机");
      delay(3000);

      // 发送开机信号
      Serial.println("发送开机信号");
      digitalWrite(relayPin, LOW);
      delay(500);
      digitalWrite(relayPin, HIGH);
      digitalWrite(ledPin, HIGH);

      // 等待5秒让开机过程开始，避免立即检测导致误判
      Serial.println("等待5秒让开机过程开始");
      delay(5000);

      totalOperations += 2;
      isRestarting = false; // 清除重启状态标志
      server.send(200, "text/plain", "重启完成：已检测到关机状态并发送开机信号");
      Serial.println("重启过程完成");
    } else {
      digitalWrite(ledPin, HIGH);
      totalOperations += 1;
      isRestarting = false; // 清除重启状态标志
      server.send(200, "text/plain", "重启超时：已发送关机信号但未检测到状态变化，请手动检查");
      Serial.println("重启过程超时");
    }
  } else if (isRestarting) {
    server.send(400, "text/plain", "重启过程进行中，请稍候");
  } else {
    server.send(400, "text/plain", "电脑当前离线，无法执行重启操作");
  }
}

String getTimeString() {
  unsigned long currentMillis = millis();
  unsigned long seconds = currentMillis / 1000;
  unsigned long minutes = seconds / 60;
  unsigned long hours = minutes / 60;
  
  char timeStr[20];
  sprintf(timeStr, "%02d:%02d:%02d", hours % 24, minutes % 60, seconds % 60);
  return String(timeStr);
}

String getDateTimeString() {
  time_t now = time(nullptr);
  struct tm *tm_info = localtime(&now);
  char buffer[32];
  strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", tm_info);
  return String(buffer);
}



void handleStatus() {
  DynamicJsonDocument doc(768); // 减少内存分配
  doc["online"] = computerStatus;
  doc["wifiConnected"] = wifiConnected;
  doc["localNetworkConnectivity"] = localNetworkConnectivity;
  doc["targetNetworkConnectivity"] = targetNetworkConnectivity;
  doc["failSafeMode"] = failSafeMode;
  doc["lastCheck"] = getDateTimeString();
  doc["pingTime"] = wifiConnected ? Ping.averageTime() : -1;
  doc["now"] = getDateTimeString();

  // 故障前状态信息（仅在需要时发送）
  if (networkFailureTime > 0 || failSafeMode) {
    doc["lastKnownStatus"] = lastKnownComputerStatus;
    doc["statusValidBeforeFailure"] = statusValidBeforeFailure;
  }

  // 网络故障时间信息（仅在故障时发送）
  if (networkFailureTime > 0) {
    unsigned long failureTime = millis() - networkFailureTime;
    unsigned long currentTimeout = hasEverPingedSuccessfully ? failSafeTimeout : routerStartupTimeout;
    doc["networkFailureTime"] = failureTime / 1000; // 转换为秒
    doc["failSafeCountdown"] = max(0L, (long)(currentTimeout - failureTime) / 1000);
    doc["isRouterStartupPhase"] = isRouterStartupPhase;
    doc["hasEverPingedSuccessfully"] = hasEverPingedSuccessfully;
  }

  // 用户操作宽限期信息
  if (lastUserOperationTime > 0) {
    unsigned long timeSinceOperation = millis() - lastUserOperationTime;
    if (timeSinceOperation < userOperationGracePeriod) {
      doc["userOperationGracePeriod"] = (userOperationGracePeriod - timeSinceOperation) / 1000;
    }
  }

  // WiFi信号强度（仅在连接时发送）
  if (wifiConnected) {
    doc["wifiRSSI"] = WiFi.RSSI();
  }

  // 任务信息（仅在有任务时发送）
  if (taskCount > 0) {
    JsonArray arr = doc.createNestedArray("pendingTasks");
    for (int i = 0; i < taskCount; i++) {
      JsonObject t = arr.createNestedObject();
      t["type"] = tasks[i].type == TASK_ON ? "开机" : (tasks[i].type == TASK_OFF ? "关机" : "反转");
      t["time"] = tasks[i].desc;
    }
  }

  String response;
  serializeJson(doc, response);
  server.send(200, "application/json", response);
}

void checkWiFiStatus() {
  bool currentWiFiStatus = (WiFi.status() == WL_CONNECTED);

  if (currentWiFiStatus != wifiConnected) {
    wifiConnected = currentWiFiStatus;
    Serial.print("WiFi状态改变: ");
    Serial.println(wifiConnected ? "已连接" : "断开连接");

    if (!wifiConnected) {
      // WiFi断开，保存故障前的电脑状态（仅在内存中）
      if (networkFailureTime == 0) {
        lastKnownComputerStatus = computerStatus;
        statusValidBeforeFailure = true;
        networkFailureTime = millis();
        continuousFailureStartTime = millis(); // 开始连续故障计时
        Serial.print("网络故障开始计时，保存故障前电脑状态: ");
        Serial.println(lastKnownComputerStatus ? "在线" : "离线");
      }
    } else {
      // WiFi恢复，等待网络稳定确认后再重置故障计时
      Serial.println("WiFi重新连接，等待网络稳定确认");
      // 注意：故障计时的重置将在checkComputerStatus中进行
    }
  }
}

void checkComputerStatus() {
  // 如果WiFi未连接到路由器，跳过ping检测
  if (!wifiConnected) {
    return;
  }

  // 分层网络连通性检测
  // 第1层：检测本地网络（ESP8266到子路由器）
  bool localGatewayPing = Ping.ping(localGatewayIP.c_str(), 1);
  bool previousLocalConnectivity = localNetworkConnectivity;
  localNetworkConnectivity = localGatewayPing;

  // 第2层：检测到目标网络的连通性（子路由器到主网络）
  bool targetGatewayPing = false;
  bool previousTargetConnectivity = targetNetworkConnectivity;
  if (localNetworkConnectivity) {
    targetGatewayPing = Ping.ping(targetNetworkGatewayIP.c_str(), 1);
  }
  targetNetworkConnectivity = targetGatewayPing;

  lastGatewayPingTime = millis();

  // 输出网络状态变化
  if (localGatewayPing != previousLocalConnectivity) {
    Serial.print("本地网络状态改变: ");
    Serial.println(localGatewayPing ? "正常" : "故障");
  }
  if (targetGatewayPing != previousTargetConnectivity) {
    Serial.print("目标网络连通性改变: ");
    Serial.println(targetGatewayPing ? "正常" : "故障");
  }

  // 综合网络连通性：只有两层都正常才算网络正常
  bool overallNetworkConnectivity = localNetworkConnectivity && targetNetworkConnectivity;

  // 第3层：如果网络连通性正常，再检测电脑状态
  bool computerPingResult = false;
  if (overallNetworkConnectivity) {
    computerPingResult = Ping.ping(computerIP, 2); // ping电脑
    lastSuccessfulPingTime = millis(); // 记录最后一次网络检测时间

    // 如果是首次网络连通，说明网络已经正常
    if (isRouterStartupPhase) {
      isRouterStartupPhase = false;
      hasEverPingedSuccessfully = true;
      Serial.println("网络连接已建立，退出路由器启动阶段");
    }

    // 如果网络恢复正常，重置故障计时
    if (networkFailureTime > 0) {
      Serial.println("网络已恢复正常，重置故障计时");
      networkFailureTime = 0;
      continuousFailureStartTime = 0;
      // 退出故障安全模式（如果已激活）
      if (failSafeMode) {
        failSafeMode = false;
        Serial.println("退出故障安全模式");
      }
    }
  } else {
    // 网络不通，检查是否需要开始故障计时
    if (networkFailureTime == 0) {
      unsigned long currentTime = millis();

      // 判断是否处于路由器启动阶段
      if (isRouterStartupPhase && !hasEverPingedSuccessfully && currentTime < routerStartupTimeout) {
        // 路由器启动阶段，暂不开始故障计时
        Serial.print("路由器启动阶段，网络不通但暂不计入故障 (已等待 ");
        Serial.print(currentTime / 1000);
        Serial.println(" 秒)");
        return;
      }

      // 开始网络故障计时
      lastKnownComputerStatus = computerStatus;
      statusValidBeforeFailure = true;
      networkFailureTime = millis();
      continuousFailureStartTime = millis();
      isRouterStartupPhase = false; // 确保退出启动阶段

      // 详细的故障信息
      Serial.print("网络故障检测 - 本地网络: ");
      Serial.print(localNetworkConnectivity ? "正常" : "故障");
      Serial.print(", 目标网络: ");
      Serial.print(targetNetworkConnectivity ? "正常" : "故障");
      Serial.print(", 开始故障计时，保存故障前电脑状态: ");
      Serial.println(lastKnownComputerStatus ? "在线" : "离线");
    }
  }

  // 更新电脑状态（只有在网络正常时才更新）
  if (overallNetworkConnectivity) {
    if (computerPingResult != computerStatus) {
      computerStatus = computerPingResult;
      Serial.print("电脑状态改变: ");
      Serial.println(computerStatus ? "在线" : "离线");

      if (computerStatus) {
        lastComputerOnlineTime = millis();
      }
    } else if (computerStatus) {
      // 电脑仍在线，更新最后在线时间
      lastComputerOnlineTime = millis();
    }
  }
}

void checkFailSafeMode() {
  // 检查是否需要进入故障安全模式
  if (networkFailureTime > 0 && !failSafeMode) {
    unsigned long failureTime = millis() - networkFailureTime;
    unsigned long currentTimeout = failSafeTimeout;

    // 如果从未ping成功过，说明可能是路由器启动问题，使用更长的超时时间
    if (!hasEverPingedSuccessfully) {
      currentTimeout = routerStartupTimeout; // 10分钟
    }

    if (failureTime >= currentTimeout) {
      failSafeMode = true;
      Serial.print("网络故障超时，进入故障安全模式 (故障时长: ");
      Serial.print(failureTime / 1000);
      Serial.print("秒, 超时阈值: ");
      Serial.print(currentTimeout / 1000);
      Serial.println("秒)");

      // 根据故障安全策略和故障前状态决定操作
      bool shouldPowerOn = false;
      String actionReason = "";

      if (statusValidBeforeFailure) {
        switch (failSafePolicy) {
          case FAILSAFE_ALWAYS_ON:
            shouldPowerOn = true;
            actionReason = "策略：总是开机 - 发送开机信号确保电脑可用";
            break;

          case FAILSAFE_PRESERVE_STATE:
            shouldPowerOn = lastKnownComputerStatus;
            actionReason = lastKnownComputerStatus ?
              "策略：保持状态 - 故障前在线，发送开机信号保持开机" :
              "策略：保持状态 - 故障前离线，保持关机状态";
            break;

          case FAILSAFE_SMART:
            shouldPowerOn = !lastKnownComputerStatus;
            actionReason = lastKnownComputerStatus ?
              "策略：智能模式 - 故障前在线，假设仍在线，不执行操作" :
              "策略：智能模式 - 故障前离线，发送开机信号确保可用";
            break;
        }
      } else {
        // 没有有效的故障前状态记录，默认发送开机信号
        shouldPowerOn = true;
        actionReason = "无故障前状态记录，默认发送开机信号（安全策略）";
      }

      Serial.println(actionReason);

      if (shouldPowerOn) {
        digitalWrite(ledPin, LOW);
        digitalWrite(relayPin, LOW);
        delay(500);
        digitalWrite(relayPin, HIGH);
        digitalWrite(ledPin, HIGH);
        totalOperations++;
        Serial.println("已执行开机操作");
      } else {
        Serial.println("根据策略，不执行任何操作");
      }
    }
  }
}

void addTask(TaskType type, unsigned long delayMillis, String desc) {
  if (taskCount < MAX_TASKS) {
    tasks[taskCount].type = type;
    tasks[taskCount].executeMillis = millis() + delayMillis;
    tasks[taskCount].desc = desc;
    taskCount++;
  }
}

void processTasks() {
  unsigned long now = millis();
  for (int i = 0; i < taskCount; ) {
    if (now >= tasks[i].executeMillis) {
      // 判断电脑状态，决定是否执行
      if (tasks[i].type == TASK_ON && computerStatus) {
        // 电脑已在线，不执行开机
      } else if (tasks[i].type == TASK_OFF && !computerStatus) {
        // 电脑已离线，不执行关机
      } else {
        // 执行操作
        lastUserOperationTime = millis(); // 记录定时任务执行时间
        Serial.println("定时任务执行，记录操作时间");
        digitalWrite(relayPin, LOW);
        delay(500);
        digitalWrite(relayPin, HIGH);
      }
      // 移除已执行任务
      for (int j = i; j < taskCount - 1; j++) tasks[j] = tasks[j + 1];
      taskCount--;
    } else {
      i++;
    }
  }
}

void handleCountdown() {
  String unit = server.hasArg("unit") ? server.arg("unit") : "s";
  int value = server.hasArg("value") ? server.arg("value").toInt() : 0;
  String op = server.hasArg("op") ? server.arg("op") : "toggle";
  if (value <= 0) {
    server.send(400, "text/plain", "倒计时时间无效");
    return;
  }
  unsigned long delayMillis = 0;
  if (unit == "s") delayMillis = value * 1000UL;
  else if (unit == "m") delayMillis = value * 60000UL;
  else if (unit == "h") delayMillis = value * 3600000UL;
  else {
    server.send(400, "text/plain", "单位无效");
    return;
  }
  TaskType type = TASK_TOGGLE;
  if (op == "on") type = TASK_ON;
  else if (op == "off") type = TASK_OFF;
  addTask(type, delayMillis, "倒计时" + String(value) + unit + "后" + op);
  server.send(200, "text/plain", "倒计时任务已添加");
}

void handleSchedule() {
  String timeStr = server.arg("time"); // 格式: yyyy-MM-ddTHH:mm
  String op = server.hasArg("op") ? server.arg("op") : "toggle";
  if (timeStr.length() < 16) {
    server.send(400, "text/plain", "时间格式无效");
    return;
  }
  // 解析时间
  int year = timeStr.substring(0,4).toInt();
  int month = timeStr.substring(5,7).toInt();
  int day = timeStr.substring(8,10).toInt();
  int hour = timeStr.substring(11,13).toInt();
  int minute = timeStr.substring(14,16).toInt();
  // 获取当前时间（近似，建议用RTC）
  time_t now = time(nullptr);
  struct tm targetTm = {0};
  targetTm.tm_year = year - 1900;
  targetTm.tm_mon = month - 1;
  targetTm.tm_mday = day;
  targetTm.tm_hour = hour;
  targetTm.tm_min = minute;
  targetTm.tm_sec = 0;
  time_t target = mktime(&targetTm);
  unsigned long delayMillis = 0;
  if (target > now) {
    delayMillis = (unsigned long)(target - now) * 1000UL;
  } else {
    server.send(400, "text/plain", "定时时间已过");
    return;
  }
  TaskType type = TASK_TOGGLE;
  if (op == "on") type = TASK_ON;
  else if (op == "off") type = TASK_OFF;
  addTask(type, delayMillis, "定时" + timeStr + op);
  server.send(200, "text/plain", "定时任务已添加");
}

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

  // 设置引脚
  pinMode(relayPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(relayPin, HIGH); // 初始化继电器为断开状态
  digitalWrite(ledPin, HIGH);   // 初始化LED为关闭状态

  systemStartTime = millis();

  // 初始化状态变量
  lastKnownComputerStatus = false;
  statusValidBeforeFailure = false;
  
  // 连接WiFi
  WiFi.mode(WIFI_STA);  // 设置为站点模式
  WiFi.begin(ssid, password);
  Serial.print("连接WiFi");

  // 尝试连接WiFi，最多等待30秒
  int wifiAttempts = 0;
  while (WiFi.status() != WL_CONNECTED && wifiAttempts < 60) {
    delay(500);
    Serial.print(".");
    wifiAttempts++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    wifiConnected = true;
    Serial.println("\nWiFi已连接");
    Serial.print("本机IP地址: ");
    Serial.println(WiFi.localIP());
    Serial.print("子网掩码: ");
    Serial.println(WiFi.subnetMask());
    Serial.print("网关地址: ");
    Serial.println(WiFi.gatewayIP());
    Serial.print("DNS服务器: ");
    Serial.println(WiFi.dnsIP());

    // 自动获取ESP8266的本地网关IP
    localGatewayIP = WiFi.gatewayIP().toString();
    Serial.print("本地网关IP (ESP8266直连): ");
    Serial.println(localGatewayIP);
    Serial.print("目标网关IP (电脑网络): ");
    Serial.println(targetNetworkGatewayIP);
    Serial.println("将使用分层网络检测：本地网关 + 目标网关");
  } else {
    wifiConnected = false;
    networkFailureTime = millis(); // 开始故障计时
    Serial.println("\nWiFi连接失败，启动AP模式");

    // 启动AP模式，允许直接连接控制
    WiFi.mode(WIFI_AP_STA);
    WiFi.softAP("ESP8266-PowerControl", "12345678");
    Serial.print("AP模式已启动，IP地址: ");
    Serial.println(WiFi.softAPIP());
    Serial.println("可以连接WiFi: ESP8266-PowerControl, 密码: 12345678");
  }

  // 配置NTP服务器，获取网络时间（仅在WiFi连接成功时）
  if (wifiConnected) {
    configTime(8 * 3600, 0, "ntp.aliyun.com", "ntp1.aliyun.com", "pool.ntp.org");
    Serial.print("等待NTP时间同步");
    time_t now = time(nullptr);
    int ntpAttempts = 0;
    while (now < 8 * 3600 * 2 && ntpAttempts < 20) { // 最多等待10秒
      delay(500);
      Serial.print(".");
      now = time(nullptr);
      ntpAttempts++;
    }
    if (now >= 8 * 3600 * 2) {
      Serial.println("");
      Serial.print("当前时间: ");
      Serial.println(ctime(&now));
    } else {
      Serial.println("\nNTP时间同步超时，使用系统时间");
    }
  } else {
    Serial.println("WiFi未连接，跳过NTP时间同步");
  }
  
  // 设置服务器路由
  server.on("/", handleRoot);
  server.on("/trigger", handleTrigger);
  server.on("/restart", handleRestart);
  server.on("/status", handleStatus);
  server.on("/countdown", handleCountdown);
  server.on("/schedule", handleSchedule);
  server.on("/failsafe", []() {
    if (!failSafeMode) {
      failSafeMode = true;
      Serial.println("手动激活故障安全模式");

      // 根据当前已知状态决定操作
      bool shouldPowerOn = true;
      String statusMessage = "";

      if (wifiConnected) {
        // WiFi连接正常，根据当前ping状态决定
        if (computerStatus) {
          statusMessage = "故障安全模式已激活，电脑当前在线，发送开机信号确保保持开机";
        } else {
          statusMessage = "故障安全模式已激活，电脑当前离线，发送开机信号";
        }
      } else {
        // WiFi断开，根据故障前状态决定
        if (statusValidBeforeFailure) {
          if (lastKnownComputerStatus) {
            statusMessage = "故障安全模式已激活，故障前电脑在线，发送开机信号确保保持开机";
          } else {
            shouldPowerOn = false;
            statusMessage = "故障安全模式已激活，故障前电脑离线，保持关机状态";
          }
        } else {
          statusMessage = "故障安全模式已激活，无故障前状态记录，默认发送开机信号";
        }
      }

      if (shouldPowerOn) {
        digitalWrite(ledPin, LOW);
        digitalWrite(relayPin, LOW);
        delay(500);
        digitalWrite(relayPin, HIGH);
        digitalWrite(ledPin, HIGH);
        totalOperations++;
      }

      server.send(200, "text/plain", statusMessage);
    } else {
      server.send(200, "text/plain", "故障安全模式已经激活");
    }
  });
  server.on("/cancelTask", []() {
    if (server.hasArg("index")) {
      int idx = server.arg("index").toInt();
      if (idx >= 0 && idx < taskCount) {
        for (int j = idx; j < taskCount - 1; j++) tasks[j] = tasks[j + 1];
        taskCount--;
        server.send(200, "text/plain", "任务已取消");
        return;
      }
    }
    server.send(400, "text/plain", "参数错误");
  });
  
  // 启动服务器
  server.begin();
  Serial.println("服务器已启动");

  // 初始ping检测（仅在WiFi连接时）
  if (wifiConnected) {
    Serial.println("开始初始网络检测...");
    checkComputerStatus();

    // 检查是否是"WiFi连接但网络不通"的情况
    if (networkFailureTime > 0) {
      Serial.println("检测到网络连接问题：WiFi已连接但无法ping通目标设备");
      Serial.println("可能原因：路由器未连接互联网、目标设备离线、或网络配置问题");
      Serial.println("将在5分钟后进入故障安全模式");
    }
  }

  Serial.println("=== 初始化完成 ===");
  Serial.print("运行模式: ");
  if (wifiConnected) {
    if (networkFailureTime > 0) {
      Serial.println("网络故障模式 (WiFi已连接但网络不通)");
    } else {
      Serial.println("正常模式 (WiFi已连接，网络正常)");
    }
  } else {
    Serial.println("故障安全模式 (WiFi未连接，AP模式已启动)");
  }
  Serial.println("开始主循环...");
}

void loop() {
  server.handleClient();

  // 如果正在重启，跳过常规检测和任务处理
  if (isRestarting) {
    return;
  }

  unsigned long currentMillis = millis();

  // 定时检查WiFi连接状态
  if (currentMillis - lastWiFiCheck >= wifiCheckInterval) {
    lastWiFiCheck = currentMillis;
    checkWiFiStatus();

    // 尝试重连WiFi（如果断开的话）
    if (!wifiConnected) {
      Serial.println("尝试重连WiFi...");
      WiFi.reconnect();
    }
  }

  // 定时ping检测电脑状态
  if (currentMillis - lastPingTime >= pingInterval) {
    lastPingTime = currentMillis;
    checkComputerStatus();

    // 调试信息：每分钟输出一次故障检测状态
    static unsigned long lastDebugOutput = 0;
    if (currentMillis - lastDebugOutput >= 60000) { // 每60秒输出一次
      lastDebugOutput = currentMillis;
      Serial.print("故障检测状态 - WiFi: ");
      Serial.print(wifiConnected ? "连接" : "断开");
      Serial.print(", 本地网络: ");
      Serial.print(localNetworkConnectivity ? "正常" : "故障");
      Serial.print(", 目标网络: ");
      Serial.print(targetNetworkConnectivity ? "正常" : "故障");
      Serial.print(", 电脑: ");
      Serial.print(computerStatus ? "在线" : "离线");
      Serial.print(", 网络阶段: ");
      if (isRouterStartupPhase) {
        Serial.print("路由器启动");
      } else if (hasEverPingedSuccessfully) {
        Serial.print("正常运行");
      } else {
        Serial.print("连接问题");
      }
      Serial.print(", 故障计时: ");
      if (networkFailureTime > 0) {
        unsigned long failureTime = (currentMillis - networkFailureTime) / 1000;
        unsigned long timeoutThreshold = (hasEverPingedSuccessfully ? failSafeTimeout : routerStartupTimeout) / 1000;
        Serial.print(failureTime);
        Serial.print("/");
        Serial.print(timeoutThreshold);
        Serial.print("秒");
      } else {
        Serial.print("无");
      }
      Serial.print(", 故障安全模式: ");
      Serial.print(failSafeMode ? "激活" : "未激活");

      // 显示用户操作宽限期状态
      if (lastUserOperationTime > 0) {
        unsigned long timeSinceOperation = (currentMillis - lastUserOperationTime) / 1000;
        if (timeSinceOperation < userOperationGracePeriod / 1000) {
          Serial.print(", 用户操作宽限期: ");
          Serial.print((userOperationGracePeriod / 1000) - timeSinceOperation);
          Serial.print("秒");
        }
      }
      Serial.println();
    }
  }

  // 检查故障安全模式
  checkFailSafeMode();

  // LED状态指示
  updateLEDStatus();

  processTasks();
}

void updateLEDStatus() {
  static unsigned long lastLEDUpdate = 0;
  static bool ledState = false;
  static int lastLEDMode = -1; // 记录上次LED模式，避免重复设置
  unsigned long currentMillis = millis();

  int currentLEDMode = 0; // 0=常亮, 1=慢闪, 2=中闪, 3=快闪

  if (failSafeMode) {
    currentLEDMode = 3; // 故障安全模式：快速闪烁
  } else if (!wifiConnected) {
    currentLEDMode = 2; // WiFi断开：中速闪烁
  } else if (computerStatus) {
    currentLEDMode = 0; // 电脑在线且WiFi正常：LED常亮
  } else {
    currentLEDMode = 1; // 电脑离线但WiFi正常：慢速闪烁
  }

  // 根据模式设置不同的更新间隔
  unsigned long interval = 1000; // 默认1秒
  if (currentLEDMode == 3) interval = 200;      // 快闪200ms
  else if (currentLEDMode == 2) interval = 500; // 中闪500ms
  else if (currentLEDMode == 1) interval = 1000; // 慢闪1秒

  if (currentMillis - lastLEDUpdate >= interval) {
    lastLEDUpdate = currentMillis;

    if (currentLEDMode == 0) {
      // 常亮模式，只在模式改变时设置一次
      if (lastLEDMode != 0) {
        digitalWrite(ledPin, HIGH);
      }
    } else {
      // 闪烁模式
      ledState = !ledState;
      digitalWrite(ledPin, ledState ? LOW : HIGH);
    }

    lastLEDMode = currentLEDMode;
  }
}

6. 版本对比与新特性

📈 2.0版本 vs 1.0版本对比

功能特性	1.0版本	2.0版本	改进说明
界面设计	基础样式	现代化响应式	渐变背景、毛玻璃效果、动态反馈
移动端适配	基本适配	完美优化	触摸友好、大按钮、垂直布局
电脑端体验	标准界面	增强体验	网格布局、悬停效果、快捷键
倒计时单位	秒/分钟/小时	秒/分钟/小时	智能验证、动态提示
快速操作	无	3个快捷按钮	5分钟关机、重启、明早开机
重启功能	❌ 不支持	✅ 智能重启	自动关机检测状态改变后开机
用户交互	基础功能	智能交互	操作确认、实时验证、友好提示
状态指示	基本显示	丰富反馈	LED指示、动态按钮、图标状态
代码优化	标准实现	性能优化	压缩CSS、优化内存、响应式

✨ 2.0版本核心新特性

🎨 全新界面设计

• 现代化视觉：采用渐变背景和毛玻璃效果
• 响应式布局：完美适配各种屏幕尺寸
• 动态反馈：按钮悬停、点击动画、状态变化
• 图标系统：丰富的emoji图标增强视觉识别

📱 移动端完美优化

• 触摸友好：按钮尺寸符合触摸标准（最小44px）
• 垂直布局：手机端采用单列布局，避免拥挤
• 触摸反馈：按下时的缩放效果提升操作体验
• 全屏优化：充分利用移动设备屏幕空间

💻 电脑端增强体验

• 网格布局：定时和倒计时功能并排显示
• 键盘快捷键：Ctrl+P触发电源，Ctrl+R刷新
• 悬停效果：丰富的鼠标交互反馈
• 精确控制：更适合鼠标操作的界面设计

🔄 新增重启功能

• 智能重启：检测电脑状态，仅在线时执行
• 自动流程：先关机→检测到电脑状态发生改变→自动开机
• 安全确认：详细的确认对话框说明重启过程
• 状态反馈：实时显示重启进度和结果

⏱️ 多时间单位支持

• 三种单位：秒（1-3600）、分钟（1-1440）、小时（1-24）
• 智能验证：根据单位自动调整输入限制
• 动态提示：实时更新输入框提示信息
• 范围保护：防止用户输入不合理的数值

🚀 快速操作优化

• 5分钟后关机：快速设置短时关机任务
• 重启电脑：一键重启，无需手动操作
• 明早8点开机：自动设置次日早晨开机任务
• 界面联动：快速操作会同步更新相关表单

7. 注意事项

7.1 硬件注意事项

• 确保ESP8266 01s与继电器模块完全兼容
• 检查继电器模块的工作电压是否与ESP8266匹配

7.2 网络配置注意事项

• 必须使用2.4GHz WiFi网络，ESP8266不支持5GHz
• 确保WiFi信号强度足够，避免连接不稳定
• 建议将ESP8266设备放置在路由器信号覆盖良好的位置

7.3 Arduino IDE配置注意事项

• 开发板选择至关重要：必须选择"Generic ESP8266 Module"或"ESP8266-01"
• 确保选择正确的COM端口
• 烧录时如遇问题，可尝试按住ESP8266上的RESET按钮

7.4 使用安全提醒

• 本项目涉及电脑硬件控制，请确保操作正确
• 建议先在测试环境中验证功能
• 定期检查继电器连接是否牢固

8. 故障排除

8.1 常见问题

• 无法连接WiFi：检查网络名称、密码和频段（必须2.4GHz）
• 无法烧录程序：检查开发板选择和端口设置
• 网页无法访问：检查ESP8266的IP地址和网络连接
• 继电器不工作：检查硬件连接和供电

8.2 调试建议

• 使用串口监视器查看运行日志
• 检查网络连接状态和IP地址分配
• 验证继电器模块的工作状态

8.3 获取ESP8266 IP地址的方法

1. 通过串口监视器查看：在Arduino IDE中打开串口监视器，重启ESP8266，查看输出的IP地址
2. 通过路由器管理界面：登录路由器管理页面，查看已连接设备列表
3. 使用网络扫描工具：如Advanced IP Scanner等工具扫描局域网设备

9. 总结

通过以上配置和注意事项，您应该能够成功搭建并使用ESP8266远程开机系统。2.0版本在保持原有功能的基础上，大幅提升了用户体验和功能完整性，是一个实用且可靠的远程电源控制解决方案。

如果在使用过程中遇到问题，请参考故障排除章节，或检查硬件连接和网络配置。