ESP32构建智能配网服务

原创于 2025-12-08 16:59:04 发布 · 578 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#ESP32 #AP模式 #智能配网

AI助手已提取文章相关产品：

Wi-Fi模块AP模式实战指南：ESP32从零构建智能配网与配置服务

嵌入式物联网WiFi接入点AP模式配网配置Web服务器HTTP端口80DNS劫持CaptivePortal智能热点WiFiDirect配置页面HTML表单ESP32ArduinoIDE设置网络SSID密码超时自动关闭SoftAPStation混合模式网络服务响应处理多连接客户端管理嵌入式开发教程指南实战步骤示例代码

引言：为什么需要AP模式？

在物联网设备部署中，AP（Access Point，接入点）模式是实现设备初次配置和本地管理的核心技术。当设备首次上电或处于无网络环境时，通过开启AP模式，设备自身变成一个Wi-Fi热点，允许用户手机或电脑直接连接，并通过Web页面进行网络配置、参数设置和设备管理。相比于复杂的串口或蓝牙配网，AP模式提供了一种标准化、用户友好的配置方式。本文将深入讲解如何实现一个稳定、安全且用户友好的AP模式，包括Web服务器搭建、DNS劫持、超时管理等关键技术。

第一章：AP模式基础概念与硬件准备

1.1 AP模式工作原理

AP模式下，Wi-Fi模块作为一个独立的无线接入点运行，具有以下特点：

创建独立的Wi-Fi网络（SSID）
分配IP地址给连接的客户端（通常通过DHCP）
提供网络服务（如HTTP、DNS）
与Station模式互斥或共存（根据硬件能力）

1.2 硬件选型建议

支持AP模式的常见Wi-Fi模块：

ESP32系列：完整支持AP+STA共存模式，性能强大
ESP8266：支持AP模式，但内存有限，适合简单应用
Realtek RTL8720：支持双频AP模式
乐鑫ESP32-S2/S3：单核优化，成本更低

重要提示：对于需要同时保持网络连接和提供配置服务的应用，必须选择支持AP+STA共存模式的芯片，如ESP32系列。

1.3 软件开发环境搭建

对于所有平台用户：

安装Arduino IDE 2.0或更高版本
添加ESP32开发板支持：

text

文件 → 首选项 → 附加开发板管理器网址
添加：https://espressif.github.io/arduino-esp32/package_esp32_index.json
工具 → 开发板 → 开发板管理器 → 搜索"esp32" → 安装

安装必要库文件：

WebServer库（ESP32内置）
DNSServer库（ESP32内置）
可选：AsyncTCP和ESPAsyncWebServer（用于高性能应用）

可选步骤：安装VS Code + PlatformIO

对于更复杂的项目，推荐使用PlatformIO：

bash

# 安装VS Code后，在扩展中搜索PlatformIO IDE并安装
# 创建新项目时选择ESP32开发板

第二章：基础AP模式实现

2.1 最简单的AP模式示例

创建新文件basic_ap.ino：

cpp

#include <WiFi.h>
#include <WebServer.h>
// AP配置参数
const char* ap_ssid = "MyDevice_AP";
const char* ap_password = "12345678"; // 最少8位字符
WebServer server(80); // 在端口80创建HTTP服务器
void handleRoot() {
  String html = "<!DOCTYPE html>";
  html += "<html><head><title>设备配置</title>";
  html += "<meta charset='UTF-8'>";
  html += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
  html += "</head><body>";
  html += "<h1>设备配置页面</h1>";
  html += "<p>设备AP模式运行中</p>";
  html += "<p>当前连接设备数: " + String(WiFi.softAPgetStationNum()) + "</p>";
  html += "</body></html>";
  server.send(200, "text/html", html);
}
void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("正在启动AP模式...");
  // 配置AP参数
  WiFi.softAP(ap_ssid, ap_password);
  // 获取AP的IP地址
  IPAddress apIP = WiFi.softAPIP();
  Serial.print("AP IP地址: ");
  Serial.println(apIP);
  Serial.print("AP SSID: ");
  Serial.println(ap_ssid);
  Serial.print("AP 密码: ");
  Serial.println(ap_password);
  // 设置HTTP服务器路由
  server.on("/", handleRoot);
  // 启动Web服务器
  server.begin();
  Serial.println("HTTP服务器已启动");
}
void loop() {
  server.handleClient(); // 处理客户端请求
  delay(2); // 小延迟防止看门狗复位
}

2.2 关键函数解析

WiFi.softAP()函数的完整参数列表：

cpp

// 基本形式：
bool softAP(const char* ssid, const char* password = NULL, 
            int channel = 1, int ssid_hidden = 0, 
            int max_connection = 4);
// 参数说明：
// ssid: AP的网络名称（必需）
// password: 密码（NULL表示开放网络）
// channel: Wi-Fi信道（1-13，默认1）
// ssid_hidden: 0=广播SSID，1=隐藏SSID
// max_connection: 最大客户端连接数（1-8，ESP32最大支持10）
// 高级配置形式（ESP32专用）：
bool softAP(const char* ssid, const char* password, 
            int channel, int ssid_hidden, 
            int max_connection, bool ftm_responder);

第三章：实现Web配置页面

3.1 完整的网络配置表单

创建一个功能完整的网络配置页面：

cpp

void handleConfigForm() {
  String html = R"=====(
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Wi-Fi配置</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .container { max-width: 500px; margin: 0 auto; }
        .form-group { margin-bottom: 15px; }
        label { display: block; margin-bottom: 5px; }
        input, select { width: 100%; padding: 8px; box-sizing: border-box; }
        button { background: #4CAF50; color: white; padding: 10px 20px; border: none; cursor: pointer; }
        .status { padding: 10px; margin: 10px 0; display: none; }
        .success { background: #d4edda; color: #155724; }
        .error { background: #f8d7da; color: #721c24; }
    </style>
</head>
<body>
    <div class="container">
        <h1>设备Wi-Fi配置</h1>
        <div id="status" class="status"></div>
        <form id="wifiForm">
            <div class="form-group">
                <label for="ssid">Wi-Fi网络名称 (SSID):</label>
                <input type="text" id="ssid" name="ssid" required>
            </div>
            <div class="form-group">
                <label for="password">Wi-Fi密码:</label>
                <input type="password" id="password" name="password">
                <small>开放网络请留空</small>
            </div>
            <div class="form-group">
                <label for="device_name">设备名称:</label>
                <input type="text" id="device_name" name="device_name" value="MyIoTDevice">
            </div>
            <div class="form-group">
                <label for="server">服务器地址:</label>
                <input type="text" id="server" name="server" value="mqtt.example.com">
            </div>
            <div class="form-group">
                <label for="port">端口:</label>
                <input type="number" id="port" name="port" value="1883">
            </div>
            <button type="submit">保存配置</button>
        </form>
        <div style="margin-top: 20px;">
            <button onclick="scanNetworks()">扫描可用网络</button>
            <div id="networkList"></div>
        </div>
    </div>
    <script>
        document.getElementById('wifiForm').onsubmit = async function(e) {
            e.preventDefault();
            const formData = new FormData(this);
            const data = Object.fromEntries(formData);
            try {
                const response = await fetch('/save', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify(data)
                });
                const result = await response.json();
                showStatus(result.success ? '配置保存成功！设备将重启连接...' : '保存失败: ' + result.error, result.success);
                if(result.success) {
                    setTimeout(() => { window.location.href = '/reboot'; }, 3000);
                }
            } catch(error) {
                showStatus('网络错误: ' + error.message, false);
            }
        };
        async function scanNetworks() {
            const response = await fetch('/scan');
            const networks = await response.json();
            let html = '<h3>可用网络:</h3><ul>';
            networks.forEach(net => {
                html += `<li><strong>${net.ssid}</strong> (信号: ${net.rssi}dBm, 加密: ${net.encryption}) 
                         <button onclick="selectNetwork('${net.ssid}', ${net.encryption})">选择</button></li>`;
            });
            html += '</ul>';
            document.getElementById('networkList').innerHTML = html;
        }
        function selectNetwork(ssid, encrypted) {
            document.getElementById('ssid').value = ssid;
            if(!encrypted) {
                document.getElementById('password').value = '';
            }
        }
        function showStatus(message, isSuccess) {
            const statusDiv = document.getElementById('status');
            statusDiv.textContent = message;
            statusDiv.className = `status ${isSuccess ? 'success' : 'error'}`;
            statusDiv.style.display = 'block';
        }
    </script>
</body>
</html>
)=====";
  server.send(200, "text/html", html);
}

3.2 处理表单数据并保存配置

实现配置数据的接收和存储：

cpp

#include <Preferences.h>
Preferences preferences;
// 配置数据结构
typedef struct {
  char wifi_ssid[32];
  char wifi_password[64];
  char device_name[32];
  char server_url[64];
  int server_port;
  bool configured; // 标记是否已配置
} DeviceConfig;
void handleSaveConfig() {
  // 检查是否为POST请求
  if (server.method() != HTTP_POST) {
    server.send(405, "text/plain", "Method Not Allowed");
    return;
  }
  String contentType = server.header("Content-Type");
  if (contentType != "application/json") {
    server.send(400, "text/plain", "Bad Request: Expected JSON");
    return;
  }
  String json = server.arg("plain");
  Serial.println("收到配置数据: " + json);
  // 解析JSON（简化版，实际项目应使用ArduinoJson库）
  // 这里仅演示基本逻辑
  // 保存到Preferences
  preferences.begin("device-config", false);
  // 提取并保存各个字段（实际应解析JSON）
  preferences.putString("wifi_ssid", "用户输入的SSID");
  preferences.putString("wifi_password", "用户输入的密码");
  preferences.putString("device_name", "用户设备名");
  preferences.putString("server_url", "mqtt.example.com");
  preferences.putInt("server_port", 1883);
  preferences.putBool("configured", true);
  preferences.end();
  // 返回JSON响应
  String response = "{\"success\": true, \"message\": \"配置已保存\"}";
  server.send(200, "application/json", response);
  // 延迟重启，让客户端收到响应
  Serial.println("配置已保存，3秒后重启...");
  delay(3000);
  ESP.restart();
}

第四章：实现DNS劫持（Captive Portal）

4.1 DNS服务器配置

DNS劫持将所有域名请求重定向到配置页面：

cpp

#include <DNSServer.h>
DNSServer dnsServer;
const byte DNS_PORT = 53;
void setupDNS() {
  // 设置DNS服务器
  dnsServer.setErrorReplyCode(DNSReplyCode::NoError);
  // 劫持所有域名到本地IP
  IPAddress apIP = WiFi.softAPIP();
  dnsServer.start(DNS_PORT, "*", apIP);
  Serial.println("DNS服务器已启动，所有请求将重定向到配置页面");
}
void handleCaptivePortal() {
  // 检查请求的主机头
  String host = server.hostHeader();
  // 如果不是我们的IP，重定向到首页
  if (host != WiFi.softAPIP().toString()) {
    server.sendHeader("Location", "http://" + WiFi.softAPIP().toString(), true);
    server.send(302, "text/plain", "");
    return;
  }
  // 否则正常处理请求
  handleRoot();
}

4.2 完整DNS劫持实现

cpp

class CaptivePortalHandler {
public:
  void setup() {
    // 启动DNS服务器
    dnsServer.start(DNS_PORT, "*", WiFi.softAPIP());
    // 设置服务器路由
    server.onNotFound([&]() {
      handleCaptiveRequest();
    });
  }
  void loop() {
    dnsServer.processNextRequest();
  }
private:
  void handleCaptiveRequest() {
    // 记录访问日志
    String clientIP = server.client().remoteIP().toString();
    String requestURL = server.uri();
    Serial.printf("DNS劫持: 客户端 %s 请求 %s\n", clientIP.c_str(), requestURL.c_str());
    // 检查是否为常见探测请求
    if (isCaptiveDetection(requestURL)) {
      sendCaptiveResponse();
      return;
    }
    // 重定向到配置页面
    server.sendHeader("Location", "http://" + WiFi.softAPIP().toString(), true);
    server.send(302, "text/plain", "");
  }
  bool isCaptiveDetection(String url) {
    // 检测是否为操作系统网络连通性检查
    String detectionURLs[] = {
      "/generate_204",
      "/connecttest.txt",
      "/redirect",
      "/hotspot-detect.html",
      "/library/test/success.html",
      "/success.txt"
    };
    for (String detection : detectionURLs) {
      if (url == detection) {
        return true;
      }
    }
    return false;
  }
  void sendCaptiveResponse() {
    // 返回HTTP 204 No Content（Android/iOS网络检测）
    server.send(204, "text/plain", "");
  }
};
// 全局实例
CaptivePortalHandler captivePortal;

第五章：超时自动关闭与状态管理

5.1 实现智能超时管理

cpp

class APTimeoutManager {
private:
  enum APState {
    STATE_ACTIVE,
    STATE_IDLE,
    STATE_SHUTDOWN_PENDING,
    STATE_OFF
  };
  APState currentState = STATE_ACTIVE;
  unsigned long lastActivityTime = 0;
  unsigned long apStartTime = 0;
  const unsigned long IDLE_TIMEOUT = 5 * 60 * 1000;    // 5分钟无活动超时
  const unsigned long MAX_AP_TIME = 30 * 60 * 1000;    // 最大开启30分钟
public:
  void begin() {
    apStartTime = millis();
    lastActivityTime = millis();
    currentState = STATE_ACTIVE;
    Serial.println("AP超时管理器已启动");
  }
  void update() {
    unsigned long currentTime = millis();
    switch (currentState) {
      case STATE_ACTIVE:
        // 检查是否有客户端连接
        if (WiFi.softAPgetStationNum() > 0) {
          lastActivityTime = currentTime;
        }
        // 检查超时条件
        if (currentTime - lastActivityTime > IDLE_TIMEOUT) {
          Serial.println("无活动超时，进入空闲状态");
          currentState = STATE_IDLE;
          broadcastShutdownWarning(60); // 广播60秒后关闭警告
        }
        // 检查最大开启时间
        if (currentTime - apStartTime > MAX_AP_TIME) {
          Serial.println("达到最大开启时间，准备关闭AP");
          currentState = STATE_SHUTDOWN_PENDING;
        }
        break;
      case STATE_IDLE:
        if (WiFi.softAPgetStationNum() > 0) {
          // 有客户端重新连接，返回活动状态
          Serial.println("检测到客户端连接，返回活动状态");
          currentState = STATE_ACTIVE;
          lastActivityTime = currentTime;
        } else if (currentTime - lastActivityTime > IDLE_TIMEOUT + 60000) {
          // 空闲超时后额外等待1分钟，然后关闭
          Serial.println("空闲超时，关闭AP");
          shutdownAP();
        }
        break;
      case STATE_SHUTDOWN_PENDING:
        // 等待所有客户端断开
        if (WiFi.softAPgetStationNum() == 0) {
          shutdownAP();
        } else {
          // 每30秒广播一次关闭通知
          static unsigned long lastBroadcast = 0;
          if (currentTime - lastBroadcast > 30000) {
            broadcastShutdownWarning(30);
            lastBroadcast = currentTime;
          }
        }
        break;
    }
  }
  void recordActivity() {
    lastActivityTime = millis();
  }
private:
  void broadcastShutdownWarning(int seconds) {
    // 向所有连接的客户端发送关闭警告
    // 可以通过WebSocket或HTTP推送实现
    Serial.printf("广播: AP将在%d秒后关闭\n", seconds);
    // 这里可以添加WebSocket广播代码
  }
  void shutdownAP() {
    Serial.println("正在关闭AP模式...");
    // 发送最终关闭页面
    server.send(200, "text/html", 
      "<html><body><h1>AP模式已关闭</h1><p>设备将切换到Station模式</p></body></html>");
    delay(1000);
    // 关闭Web服务器
    server.stop();
    // 关闭AP
    WiFi.softAPdisconnect(true);
    currentState = STATE_OFF;
    // 切换到Station模式
    switchToStationMode();
  }
  void switchToStationMode() {
    // 加载保存的Wi-Fi配置
    preferences.begin("device-config", true);
    String savedSSID = preferences.getString("wifi_ssid", "");
    String savedPassword = preferences.getString("wifi_password", "");
    preferences.end();
    if (savedSSID.length() > 0) {
      Serial.println("切换到Station模式，连接保存的网络...");
      WiFi.begin(savedSSID.c_str(), savedPassword.c_str());
    } else {
      Serial.println("无保存的网络配置，保持关闭状态");
    }
  }
};
// 全局实例
APTimeoutManager apTimeout;

5.2 集成活动检测

修改HTTP请求处理以记录活动：

cpp

void setupServerRoutes() {
  // 所有请求都记录活动
  server.on("/", []() {
    apTimeout.recordActivity();
    handleRoot();
  });
  server.on("/config", []() {
    apTimeout.recordActivity();
    handleConfigForm();
  });
  server.on("/save", HTTP_POST, []() {
    apTimeout.recordActivity();
    handleSaveConfig();
  });
  server.on("/scan", []() {
    apTimeout.recordActivity();
    handleScanNetworks();
  });
  server.on("/status", []() {
    apTimeout.recordActivity();
    handleStatus();
  });
}

第六章：AP+STA混合模式

6.1 实现同时运行模式

重要警告：AP+STA模式会显著增加功耗和内存使用，仅在有此需求时启用。

cpp

void setupHybridMode() {
  Serial.println("启动AP+STA混合模式...");
  // 首先连接到已有网络（Station模式）
  preferences.begin("device-config", true);
  String savedSSID = preferences.getString("wifi_ssid", "");
  String savedPassword = preferences.getString("wifi_password", "");
  preferences.end();
  if (savedSSID.length() > 0) {
    WiFi.begin(savedSSID.c_str(), savedPassword.c_str());
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 20) {
      delay(500);
      Serial.print(".");
      attempts++;
    }
    if (WiFi.status() == WL_CONNECTED) {
      Serial.println("\nStation模式连接成功");
      Serial.print("IP地址: ");
      Serial.println(WiFi.localIP());
    }
  }
  // 同时启动AP模式
  WiFi.softAP("Device_Config_" + String(ESP.getEfuseMac(), HEX), "config123");
  Serial.println("混合模式启动完成");
  Serial.print("AP IP: ");
  Serial.println(WiFi.softAPIP());
  if (WiFi.status() == WL_CONNECTED) {
    Serial.print("STA IP: ");
    Serial.println(WiFi.localIP());
  }
}

6.2 网络服务路由管理

在混合模式下，需要区分本地和远程请求：

cpp

void handleRequest() {
  // 获取客户端IP
  IPAddress clientIP = server.client().remoteIP();
  // 判断请求来源
  IPAddress apNetwork = WiFi.softAPIP();
  apNetwork[3] = 0; // 获取网络地址
  IPAddress clientNetwork = clientIP;
  clientNetwork[3] = 0;
  if (clientNetwork == apNetwork) {
    // 来自AP本地网络的请求
    handleLocalRequest();
  } else {
    // 来自外部网络的请求（通过Station模式）
    handleRemoteRequest();
  }
}

第七章：完整示例项目

7.1 工业级AP模式配置服务器

cpp

#include <WiFi.h>
#include <WebServer.h>
#include <DNSServer.h>
#include <Preferences.h>
#include <ArduinoJson.h>
// 全局对象
WebServer server(80);
DNSServer dnsServer;
Preferences preferences;
APTimeoutManager timeoutManager;
// 配置参数
const char* AP_SSID_PREFIX = "IoT_Device_";
const char* AP_PASSWORD = "configure_me";
const int AP_CHANNEL = 6;
class DeviceConfigurator {
private:
  String deviceID;
  bool configurationComplete = false;
public:
  void begin() {
    // 生成设备唯一ID
    deviceID = String(ESP.getEfuseMac(), HEX);
    // 初始化存储
    preferences.begin("iot-config", false);
    // 检查是否已配置
    configurationComplete = preferences.getBool("configured", false);
    if (!configurationComplete) {
      startConfigurationMode();
    } else {
      startNormalMode();
    }
  }
  void loop() {
    if (!configurationComplete) {
      server.handleClient();
      dnsServer.processNextRequest();
      timeoutManager.update();
    }
  }
private:
  void startConfigurationMode() {
    Serial.println("进入配置模式");
    // 生成唯一的AP名称
    String apSSID = AP_SSID_PREFIX + deviceID.substring(deviceID.length() - 4);
    // 启动AP
    WiFi.mode(WIFI_AP);
    WiFi.softAP(apSSID.c_str(), AP_PASSWORD, AP_CHANNEL, 0, 4);
    Serial.print("AP已启动: ");
    Serial.println(apSSID);
    Serial.print("IP地址: ");
    Serial.println(WiFi.softAPIP());
    // 启动DNS劫持
    dnsServer.start(53, "*", WiFi.softAPIP());
    // 设置Web服务器路由
    setupServerRoutes();
    server.begin();
    // 启动超时管理器
    timeoutManager.begin();
    Serial.println("配置服务器已就绪");
  }
  void startNormalMode() {
    Serial.println("进入正常工作模式");
    // 连接到保存的网络
    String ssid = preferences.getString("wifi_ssid", "");
    String password = preferences.getString("wifi_password", "");
    if (ssid.length() > 0) {
      WiFi.begin(ssid.c_str(), password.c_str());
      waitForConnection();
    }
    // 启动应用特定功能
    startApplication();
  }
  void setupServerRoutes() {
    // 主页
    server.on("/", []() {
      timeoutManager.recordActivity();
      String html = R"=====(
<!DOCTYPE html>
<html>
<head>
    <title>设备配置</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <style>
        /* 添加响应式样式 */
    </style>
</head>
<body>
    <div class="container">
        <h1>设备配置向导</h1>
        <div class="step" id="step1">
            <h2>步骤1: 网络设置</h2>
            <!-- 配置表单 -->
        </div>
    </div>
</body>
</html>
)=====";
      server.send(200, "text/html", html);
    });
    // API端点
    server.on("/api/scan", HTTP_GET, []() {
      timeoutManager.recordActivity();
      handleScanAPI();
    });
    server.on("/api/config", HTTP_POST, []() {
      timeoutManager.recordActivity();
      handleConfigAPI();
    });
    server.on("/api/status", HTTP_GET, []() {
      timeoutManager.recordActivity();
      handleStatusAPI();
    });
    // 404处理
    server.onNotFound([]() {
      timeoutManager.recordActivity();
      // 如果是AP网络内的请求，重定向到主页
      if (server.client().localIP() == WiFi.softAPIP()) {
        server.sendHeader("Location", "/", true);
        server.send(302, "text/plain", "");
      } else {
        server.send(404, "text/plain", "Not Found");
      }
    });
  }
  void handleScanAPI() {
    // 扫描Wi-Fi网络
    int n = WiFi.scanNetworks();
    DynamicJsonDocument doc(2048);
    JsonArray networks = doc.to<JsonArray>();
    for (int i = 0; i < n; i++) {
      JsonObject network = networks.createNestedObject();
      network["ssid"] = WiFi.SSID(i);
      network["rssi"] = WiFi.RSSI(i);
      network["channel"] = WiFi.channel(i);
      network["encryption"] = (WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? "none" : "encrypted";
    }
    String response;
    serializeJson(doc, response);
    server.send(200, "application/json", response);
  }
  void handleConfigAPI() {
    // 解析JSON配置
    DynamicJsonDocument doc(1024);
    DeserializationError error = deserializeJson(doc, server.arg("plain"));
    if (error) {
      server.send(400, "application/json", "{\"error\":\"JSON解析失败\"}");
      return;
    }
    // 保存配置
    preferences.putString("wifi_ssid", doc["ssid"].as<String>());
    preferences.putString("wifi_password", doc["password"].as<String>());
    preferences.putString("device_name", doc["device_name"].as<String>());
    preferences.putBool("configured", true);
    // 返回成功响应
    server.send(200, "application/json", "{\"success\":true,\"message\":\"配置已保存\"}");
    // 延迟重启
    delay(2000);
    ESP.restart();
  }
  void waitForConnection() {
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 30) {
      delay(500);
      Serial.print(".");
      attempts++;
    }
    if (WiFi.status() == WL_CONNECTED) {
      Serial.println("\n连接成功");
    } else {
      Serial.println("\n连接失败");
    }
  }
  void startApplication() {
    // 这里启动主要的应用程序
    Serial.println("应用程序已启动");
  }
};
// 全局实例
DeviceConfigurator configurator;
void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("\n=== IoT设备启动 ===");
  Serial.printf("芯片ID: %llX\n", ESP.getEfuseMac());
  Serial.printf("SDK版本: %s\n", ESP.getSdkVersion());
  configurator.begin();
}
void loop() {
  configurator.loop();
}

第八章：安全增强措施

8.1 防止未授权访问

cpp

class SecurityManager {
private:
  String adminToken;
  unsigned long tokenExpiry;
public:
  void setup() {
    // 生成随机的管理员令牌
    adminToken = generateRandomToken();
    tokenExpiry = millis() + 3600000; // 1小时有效
    Serial.println("安全管理器已初始化");
  }
  bool validateRequest(WebServer &server) {
    // 检查API密钥（用于外部访问）
    if (server.hasArg("apikey")) {
      String apiKey = server.arg("apikey");
      return validateAPIKey(apiKey);
    }
    // 检查会话令牌（用于Web界面）
    if (server.hasHeader("X-Auth-Token")) {
      String token = server.header("X-Auth-Token");
      return validateToken(token);
    }
    // 对于配置页面，允许本地网络访问
    if (server.client().localIP() == WiFi.softAPIP()) {
      return true;
    }
    // 其他情况需要认证
    server.sendHeader("WWW-Authenticate", "Basic realm=\"Device Configuration\"");
    server.send(401, "text/plain", "Authentication Required");
    return false;
  }
  String generateRandomToken() {
    // 生成随机令牌
    char token[33];
    for (int i = 0; i < 32; i++) {
      token[i] = random(16) < 8 ? random('a', 'z' + 1) : random('0', '9' + 1);
    }
    token[32] = '\0';
    return String(token);
  }
private:
  bool validateAPIKey(String apiKey) {
    // 从存储中验证API密钥
    preferences.begin("security", true);
    String storedKey = preferences.getString("api_key", "");
    preferences.end();
    return apiKey == storedKey;
  }
  bool validateToken(String token) {
    if (token != adminToken) return false;
    if (millis() > tokenExpiry) return false;
    return true;
  }
};

8.2 安全配置建议

密码强度要求：

cpp

bool validatePassword(String password) {
  if (password.length() < 8) return false;
  bool hasUpper = false, hasLower = false, hasDigit = false;
  for (char c : password) {
    if (isUpperCase(c)) hasUpper = true;
    if (isLowerCase(c)) hasLower = true;
    if (isDigit(c)) hasDigit = true;
  }
  return hasUpper && hasLower && hasDigit;
}

防止暴力破解：

cpp

class RateLimiter {
private:
  struct ClientInfo {
    IPAddress ip;
    int attempts;
    unsigned long lastAttempt;
    unsigned long blockUntil;
  };
  std::vector<ClientInfo> clients;
public:
  bool allowRequest(IPAddress clientIP) {
    // 实现请求频率限制
    // 每个IP每分钟最多10次尝试
  }
};

第九章：生产环境部署

9.1 配置参数优化

cpp

// 生产环境配置结构
typedef struct {
  // AP配置
  char ap_ssid_prefix[16];
  char ap_default_password[16];
  int ap_channel;
  int ap_max_clients;
  bool ap_hidden;
  // 超时配置
  unsigned long ap_idle_timeout;
  unsigned long ap_max_uptime;
  // 安全配置
  bool require_secure_config;
  int min_password_length;
  // 网络配置
  bool enable_captive_portal;
  bool enable_dns_server;
  // 日志配置
  bool enable_request_logging;
  int log_retention_days;
} ProductionConfig;
// 默认生产配置
const ProductionConfig defaultConfig = {
  .ap_ssid_prefix = "IoT_",
  .ap_default_password = "ChangeMe123",
  .ap_channel = 11,  // 通常较空闲的信道
  .ap_max_clients = 4,
  .ap_hidden = false,
  .ap_idle_timeout = 300000,  // 5分钟
  .ap_max_uptime = 1800000,   // 30分钟
  .require_secure_config = true,
  .min_password_length = 12,
  .enable_captive_portal = true,
  .enable_dns_server = true,
  .enable_request_logging = true,
  .log_retention_days = 7
};

9.2 固件更新与维护

OTA更新支持：

cpp

void setupOTA() {
  // 设置OTA更新
  ArduinoOTA.setHostname("iot-device");
  ArduinoOTA.setPassword("ota-password");
  ArduinoOTA.onStart([]() {
    Serial.println("OTA更新开始");
    // 停止所有网络服务
    server.stop();
  });
  ArduinoOTA.begin();
}

配置备份与恢复：

cpp

void backupConfiguration() {
  // 导出配置到SD卡或远程服务器
}
void restoreConfiguration() {
  // 从备份恢复配置
}

故障排除指南

常见问题与解决方案

问题1：AP无法启动

可能原因：

信道冲突 → 尝试不同信道（1,6,11通常最稳定）
内存不足 → 减少最大客户端数或简化Web页面
硬件故障 → 检查模块供电和天线连接

问题2：Web页面无法访问

排查步骤：

确认客户端已连接到设备AP
检查IP地址是否正确（通常是192.168.4.1）
尝试清除浏览器缓存
检查防火墙设置

问题3：DNS劫持不工作

调试方法：

cpp

// 启用详细DNS日志
void debugDNS() {
  Serial.print("DNS服务器状态: ");
  Serial.println(dnsServer.isRunning() ? "运行中" : "已停止");
  Serial.print("客户端数: ");
  Serial.println(WiFi.softAPgetStationNum());
  // 测试DNS解析
  // 在客户端执行: nslookup anydomain.com 192.168.4.1
}

问题4：设备频繁重启

优化建议：

增加看门狗喂狗频率
减少HTTP请求处理时间
优化内存使用，避免内存碎片
检查电源稳定性

附录：Android/iOS连接优化

针对移动设备的优化

cpp

// 检测设备类型并提供优化界面
String detectUserAgent() {
  String ua = server.header("User-Agent");
  if (ua.indexOf("Android") != -1) {
    return "android";
  } else if (ua.indexOf("iPhone") != -1 || ua.indexOf("iPad") != -1) {
    return "ios";
  } else {
    return "desktop";
  }
}
// 提供移动设备专用的简化页面
void handleMobilePage() {
  String deviceType = detectUserAgent();
  if (deviceType == "android" || deviceType == "ios") {
    // 提供移动优化页面
    server.send(200, "text/html", getMobileOptimizedHTML());
  } else {
    server.send(200, "text/html", getDesktopHTML());
  }
}