ESP8266-01S

# ESP8266-01S 驱动代码例程

---

## 例程一：Arduino AT指令驱动（SoftwareSerial）

```cpp
/*
 * ESP8266-01S AT指令驱动 (Arduino Uno)
 * 使用 SoftwareSerial 与模块通信
 * 
 * 接线：
 *   Arduino D2 → ESP8266 RXD (通过电平转换)
 *   Arduino D3 → ESP8266 TXD (通过电平转换)
 *   Arduino 5V → AMS1117-3.3 → ESP8266 VCC
 */

#include <SoftwareSerial.h>

#define ESP_RX  2   // Arduino D2 → ESP8266 TXD
#define ESP_TX  3   // Arduino D3 → ESP8266 RXD
#define ESP_RST 4   // 可选：接ESP8266 RST

SoftwareSerial espSerial(ESP_RX, ESP_TX);

// AT指令响应缓冲区
char response[512];
unsigned long timeout = 5000;

/**
 * @brief 发送AT指令并读取响应
 * @param cmd    AT指令字符串（不含\r\n）
 * @param expect 期望的响应关键词，如"OK"
 * @param timeout_ms 超时时间(ms)
 * @return true=收到期望响应, false=超时
 */
bool sendATCommand(const char* cmd, const char* expect, uint32_t timeout_ms) {
    espSerial.println(cmd);  // println 自动添加 \r\n
    memset(response, 0, sizeof(response));

    unsigned long start = millis();
    uint16_t idx = 0;

    while (millis() - start < timeout_ms) {
        while (espSerial.available() && idx < sizeof(response) - 1) {
            response[idx++] = espSerial.read();
        }
        if (strstr(response, expect) != NULL) {
            return true;
        }
    }
    return false;
}

/**
 * @brief 读取全部响应（不检查关键词）
 */
void readResponse(uint32_t timeout_ms) {
    memset(response, 0, sizeof(response));
    unsigned long start = millis();
    uint16_t idx = 0;
    while (millis() - start < timeout_ms) {
        while (espSerial.available() && idx < sizeof(response) - 1) {
            response[idx++] = espSerial.read();
        }
    }
}

/**
 * @brief ESP8266初始化
 * @return true=初始化成功
 */
bool ESP8266_Init(void) {
    espSerial.begin(115200);
    delay(1000);

    // 测试AT通信
    if (!sendATCommand("AT", "OK", 2000)) {
        Serial.println("[ERROR] AT通信失败，检查接线和供电");
        return false;
    }
    Serial.println("[OK] AT通信正常");

    // 检查固件版本
    sendATCommand("AT+GMR", "OK", 3000);
    Serial.print("固件版本: ");
    Serial.println(response);

    // 设置为Station模式
    sendATCommand("AT+CWMODE=1", "OK", 2000);

    // 关闭回显
    sendATCommand("ATE0", "OK", 1000);

    return true;
}

/**
 * @brief 连接WiFi
 * @param ssid   WiFi名称
 * @param pwd    WiFi密码
 * @return true=连接成功
 */
bool ESP8266_ConnectWiFi(const char* ssid, const char* pwd) {
    char cmd[128];
    snprintf(cmd, sizeof(cmd), "AT+CWJAP=\"%s\",\"%s\"", ssid, pwd);

    // WiFi连接可能较慢，给15秒超时
    if (!sendATCommand(cmd, "WIFI GOT IP", 15000)) {
        Serial.println("[ERROR] WiFi连接失败");
        return false;
    }
    Serial.println("[OK] WiFi已连接");

    // 查询IP
    sendATCommand("AT+CIFSR", "OK", 2000);
    Serial.println(response);
    return true;
}

/**
 * @brief TCP连接并发送数据
 * @param host  服务器IP
 * @param port  端口号
 * @param data  发送数据
 */
bool ESP8266_TCP_Send(const char* host, uint16_t port, const char* data) {
    char cmd[64];
    snprintf(cmd, sizeof(cmd), "AT+CIPSTART=\"TCP\",\"%s\",%d", host, port);
    if (!sendATCommand(cmd, "OK", 5000)) {
        Serial.println("[ERROR] TCP连接失败");
        return false;
    }

    // 发送数据长度
    snprintf(cmd, sizeof(cmd), "AT+CIPSEND=%d", strlen(data));
    if (!sendATCommand(cmd, ">", 3000)) {
        Serial.println("[ERROR] 未收到发送提示符");
        return false;
    }

    // 发送实际数据
    espSerial.print(data);
    delay(100);
    if (!sendATCommand("", "SEND OK", 5000)) {
        Serial.println("[ERROR] 数据发送失败");
        return false;
    }

    sendATCommand("AT+CIPCLOSE", "OK", 2000);
    return true;
}

/**
 * @brief 硬件复位
 */
void ESP8266_HardReset(void) {
    pinMode(ESP_RST, OUTPUT);
    digitalWrite(ESP_RST, LOW);
    delay(100);
    digitalWrite(ESP_RST, HIGH);
    delay(1000);
    Serial.println("ESP8266 已复位");
}

// ====== 使用示例 ======

void setup() {
    Serial.begin(9600);
    Serial.println("ESP8266-01S AT指令测试");

    ESP8266_Init();
    ESP8266_ConnectWiFi("YOUR_SSID", "YOUR_PASSWORD");

    // 发送HTTP GET请求
    ESP8266_TCP_Send("api.example.com", 80, "GET /data HTTP/1.1\r\nHost: api.example.com\r\n\r\n");
}

void loop() {
    // 处理串口数据...
}
```

---

## 例程二：ESP8266-01S 独立编程 (Arduino IDE)

```cpp
/*
 * ESP8266-01S 独立编程示例
 * 使用Arduino IDE直接编写ESP8266固件
 * 
 * 开发板选择：Generic ESP8266 Module
 * Flash Size: 1MB (FS:none)
 * 
 * 功能：WiFi LED控制 + 简易HTTP服务器
 */

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>

#define LED_PIN     2   // GPIO2 (板载LED, 低电平亮)
#define BUTTON_PIN  0   // GPIO0 (兼作按键, 内置上拉)

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASSWORD";

ESP8266WebServer server(80);

bool ledState = false;

/**
 * @brief GPIO初始化
 */
void GPIO_Init(void) {
    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, HIGH);  // 初始熄灭（低电平亮）

    pinMode(BUTTON_PIN, INPUT_PULLUP);
}

/**
 * @brief WiFi连接
 */
void WiFi_Connect(void) {
    WiFi.mode(WIFI_STA);
    WiFi.begin(ssid, password);

    Serial.print("正在连接WiFi");
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 40) {
        delay(500);
        Serial.print(".");
        // 连接过程中LED闪烁
        digitalWrite(LED_PIN, (millis() / 200) % 2 ? LOW : HIGH);
        attempts++;
    }

    if (WiFi.status() == WL_CONNECTED) {
        digitalWrite(LED_PIN, HIGH);  // 熄灭LED
        Serial.println("\nWiFi已连接");
        Serial.print("IP地址: ");
        Serial.println(WiFi.localIP());
    } else {
        Serial.println("\nWiFi连接失败");
    }
}

/**
 * @brief HTTP服务器路由配置
 */
void setupServer(void) {
    // 首页
    server.on("/", []() {
        String html = "<!DOCTYPE html><html><head><meta charset='UTF-8'>";
        html += "<title>ESP8266-01S</title></head><body>";
        html += "<h1>ESP8266-01S 控制面板</h1>";
        html += "<p>LED状态: <b>" + String(ledState ? "亮" : "灭") + "</b></p>";
        html += "<button onclick=\"fetch('/on')\">开灯</button> ";
        html += "<button onclick=\"fetch('/off')\">关灯</button> ";
        html += "<button onclick=\"fetch('/toggle')\">翻转</button>";
        html += "</body></html>";
        server.send(200, "text/html", html);
    });

    // 开灯
    server.on("/on", []() {
        ledState = true;
        digitalWrite(LED_PIN, LOW);
        server.send(200, "text/plain", "LED ON");
    });

    // 关灯
    server.on("/off", []() {
        ledState = false;
        digitalWrite(LED_PIN, HIGH);
        server.send(200, "text/plain", "LED OFF");
    });

    // 翻转
    server.on("/toggle", []() {
        ledState = !ledState;
        digitalWrite(LED_PIN, ledState ? LOW : HIGH);
        server.send(200, "text/plain", ledState ? "LED ON" : "LED OFF");
    });

    server.begin();
    Serial.println("HTTP服务器已启动");
}

/**
 * @brief 按键检测（GPIO0）
 */
void checkButton(void) {
    static unsigned long lastPress = 0;
    if (digitalRead(BUTTON_PIN) == LOW) {
        if (millis() - lastPress > 300) {  // 消抖
            lastPress = millis();
            ledState = !ledState;
            digitalWrite(LED_PIN, ledState ? LOW : HIGH);
            Serial.println("按键触发: LED " + String(ledState ? "ON" : "OFF"));
        }
    }
}

void setup() {
    Serial.begin(115200);
    delay(1000);
    Serial.println("\nESP8266-01S 启动中...");

    GPIO_Init();
    WiFi_Connect();
    setupServer();
}

void loop() {
    server.handleClient();
    checkButton();

    // 每30秒打印一次状态
    static unsigned long lastPrint = 0;
    if (millis() - lastPrint > 30000) {
        lastPrint = millis();
        Serial.printf("运行中 | 运行时间: %lu秒 | 免费堆: %d字节\n",
                      millis() / 1000, ESP.getFreeHeap());
    }
}
```

---

## 例程三：ESP8266-01S 深度睡眠与低功耗唤醒

```cpp
/*
 * ESP8266-01S 深度睡眠示例
 * 
 * GPIO16 (XPD_DCDC) 必须与 RST 引脚短接才能实现定时唤醒
 * 注意：01S模块的GPIO16未引出！此例程仅供参考架构。
 * 
 * 对于01S，可将GPIO0接外部唤醒源或使用AT+SLEEP指令
 */

#include <ESP8266WiFi.h>

#define LED_PIN 2

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

    pinMode(LED_PIN, OUTPUT);
    digitalWrite(LED_PIN, LOW);
    delay(200);
    digitalWrite(LED_PIN, HIGH);

    Serial.println("ESP8266-01S 唤醒!");
    Serial.printf("唤醒原因: %s\n",
        ESP.getResetInfoPtr()->reason == REASON_DEEP_SLEEP_AWAKE
        ? "深度睡眠定时唤醒" : "上电/外部复位");

    // 执行任务...
    Serial.println("执行任务中...");
    delay(1000);
    Serial.println("任务完成，进入深度睡眠...");

    // 进入深度睡眠5秒（需GPIO16接RST）
    // ESP.deepSleep(5e6);

    // 对于01S（无GPIO16），可通过AT指令控制：
    // AT+SLEEP=1  进入modem-sleep
    // AT+SLEEP=2  进入light-sleep（GPIO唤醒）

    // 模拟：仅延迟后重启
    Serial.println("01S无GPIO16，模拟睡眠5秒后重启...");
    delay(5000);
    ESP.restart();
}

void loop() {
    // 不会被调用（每次setup后即睡眠）
}
```

---

## 例程四：AT指令常用参考

```
// ====== 基础指令 ======
AT                  // 测试通信 → OK
AT+RST              // 软复位
AT+GMR              // 查询固件版本
ATE0                // 关闭回显
ATE1                // 开启回显

// ====== WiFi指令 ======
AT+CWMODE=1         // Station模式
AT+CWMODE=2         // SoftAP模式
AT+CWMODE=3         // Station+AP混合
AT+CWLAP            // 扫描可用AP
AT+CWJAP="ssid","pwd"   // 连接WiFi
AT+CWQAP            // 断开WiFi
AT+CIFSR            // 查询本机IP

// ====== TCP/UDP指令 ======
AT+CIPSTART="TCP","192.168.1.100",8080   // 建立TCP连接
AT+CIPSTART="UDP","192.168.1.100",8080   // 建立UDP连接
AT+CIPSEND=10       // 发送10字节 → 收到 > 后输入数据
AT+CIPCLOSE         // 关闭连接
AT+CIPSTATUS        // 查询连接状态

// ====== HTTP指令（部分固件支持）=====
AT+HTTPCLIENT=1,"GET","http://example.com/api"
```