好的，以下是一个基于 ESP-IDF 的完整程序，实现了您的需求：
```c
#include <stdio.h>
#include <string.h>
#include <esp_wifi.h>
#include <esp_event.h>
#include <esp_log.h>
#include <esp_system.h>
#include <nvs_flash.h>
#include <esp_http_server.h>
/* WiFi网络配置 */
#define WIFI_SSID "mytest"
#define WIFI_PASSWORD "12345678"
/* 服务器IP地址和端口号 */
#define SERVER_IP "192.168.2.2"
#define SERVER_PORT 8888
/* 网络参数保存的NVS键名 */
#define NVS_NAMESPACE "wifi_config"
#define NVS_KEY_SSID "ssid"
#define NVS_KEY_PASSWORD "password"
#define NVS_KEY_DHCP "dhcp"
#define NVS_KEY_IP "ip"
#define NVS_KEY_NETMASK "netmask"
#define NVS_KEY_GATEWAY "gateway"
#define NVS_KEY_DNS "dns"
/* 定时器周期 */
#define TIMER_PERIOD_MS 1000
static const char *TAG = "web_server";
static httpd_handle_t server = NULL;
static bool wifi_connected = false;
static int send_count = 0;
/* 保存网络参数到NVS */
static void save_wifi_config(const char *ssid, const char *password,
bool dhcp, const char *ip, const char *netmask,
const char *gateway, const char *dns) {
nvs_handle_t nvs_handle;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to open NVS");
return;
}
err = nvs_set_str(nvs_handle, NVS_KEY_SSID, ssid);
if (err != ESP_OK) goto fail;
err = nvs_set_str(nvs_handle, NVS_KEY_PASSWORD, password);
if (err != ESP_OK) goto fail;
err = nvs_set_u8(nvs_handle, NVS_KEY_DHCP, dhcp);
if (err != ESP_OK) goto fail;
err = nvs_set_str(nvs_handle, NVS_KEY_IP, ip);
if (err != ESP_OK) goto fail;
err = nvs_set_str(nvs_handle, NVS_KEY_NETMASK, netmask);
if (err != ESP_OK) goto fail;
err = nvs_set_str(nvs_handle, NVS_KEY_GATEWAY, gateway);
if (err != ESP_OK) goto fail;
err = nvs_set_str(nvs_handle, NVS_KEY_DNS, dns);
if (err != ESP_OK) goto fail;
err = nvs_commit(nvs_handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to commit NVS");
}
fail:
nvs_close(nvs_handle);
}
/* 从NVS中读取保存的网络参数 */
static void load_wifi_config(char *ssid, size_t ssid_len,
char *password, size_t password_len,
bool *dhcp, char *ip, size_t ip_len,
char *netmask, size_t netmask_len,
char *gateway, size_t gateway_len,
char *dns, size_t dns_len) {
nvs_handle_t nvs_handle;
esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READONLY, &nvs_handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to open NVS");
return;
}
size_t len;
err = nvs_get_str(nvs_handle, NVS_KEY_SSID, ssid, &len);
if (err != ESP_OK) goto fail;
err = nvs_get_str(nvs_handle, NVS_KEY_PASSWORD, password, &len);
if (err != ESP_OK) goto fail;
err = nvs_get_u8(nvs_handle, NVS_KEY_DHCP, dhcp);
if (err != ESP_OK) goto fail;
err = nvs_get_str(nvs_handle, NVS_KEY_IP, ip, &len);
if (err != ESP_OK) goto fail;
err = nvs_get_str(nvs_handle, NVS_KEY_NETMASK, netmask, &len);
if (err != ESP_OK) goto fail;
err = nvs_get_str(nvs_handle, NVS_KEY_GATEWAY, gateway, &len);
if (err != ESP_OK) goto fail;
err = nvs_get_str(nvs_handle, NVS_KEY_DNS, dns, &len);
if (err != ESP_OK) goto fail;
fail:
nvs_close(nvs_handle);
}
/* 连接WiFi */
static void wifi_connect() {
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
esp_err_t err = esp_wifi_init(&cfg);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to initialize WiFi");
return;
}
err = esp_wifi_set_storage(WIFI_STORAGE_FLASH);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to set WiFi storage");
return;
}
wifi_config_t wifi_config = {
.sta = {
.ssid = "",
.password = "",
},
};
load_wifi_config((char*)wifi_config.sta.ssid, sizeof(wifi_config.sta.ssid),
(char*)wifi_config.sta.password, sizeof(wifi_config.sta.password),
&wifi_config.sta.dhcp, "", 0, "", 0, "", 0, "", 0);
err = esp_wifi_set_mode(WIFI_MODE_STA);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to set WiFi mode");
return;
}
err = esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to set WiFi config");
return;
}
err = esp_wifi_start();
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to start WiFi");
return;
}
}
/* 连接WiFi后的回调函数 */
static void wifi_event_handler(void *arg, esp_event_base_t event_base,
int32_t event_id, void* event_data) {
if (event_id == WIFI_EVENT_STA_CONNECTED) {
ESP_LOGI(TAG, "WiFi connected");
} else if (event_id == WIFI_EVENT_STA_DISCONNECTED) {
ESP_LOGI(TAG, "WiFi disconnected");
} else if (event_id == IP_EVENT_STA_GOT_IP) {
ESP_LOGI(TAG, "IP address obtained");
wifi_connected = true;
}
}
/* 处理HTTP请求 */
static esp_err_t http_handler(httpd_req_t *req) {
char buf[1024];
size_t buf_len = sizeof(buf);
esp_err_t err = httpd_req_recv(req, buf, buf_len);
if (err != ESP_OK) {
return err;
}
httpd_resp_set_type(req, "text/html");
httpd_resp_set_status(req, HTTPD_200);
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
const char *html = "<html>"
"<body>"
"<form method=\"post\">"
"<label>WiFi SSID:</label><br>"
"<input type=\"text\" name=\"ssid\"><br>"
"<label>WiFi Password:</label><br>"
"<input type=\"password\" name=\"password\"><br>"
"<label>Device IP:</label><br>"
"<input type=\"text\" name=\"ip\"><br>"
"<label>Subnet Mask:</label><br>"
"<input type=\"text\" name=\"netmask\"><br>"
"<label>Default Gateway:</label><br>"
"<input type=\"text\" name=\"gateway\"><br>"
"<label>DNS Server:</label><br>"
"<input type=\"text\" name=\"dns\"><br>"
"<label>DHCP:</label><br>"
"<input type=\"radio\" name=\"dhcp\" value=\"1\" checked>Yes<br>"
"<input type=\"radio\" name=\"dhcp\" value=\"0\">No<br>"
"<input type=\"submit\" value=\"Submit\">"
"</form>"
"</body>"
"</html>";
err = httpd_resp_send(req, html, strlen(html));
if (err != ESP_OK) {
return err;
}
if (req->method == HTTP_POST) {
char ssid[32], password[64], ip[16], netmask[16], gateway[16], dns[16];
bool dhcp;
size_t ssid_len = sizeof(ssid), password_len = sizeof(password);
size_t ip_len = sizeof(ip), netmask_len = sizeof(netmask), gateway_len = sizeof(gateway), dns_len = sizeof(dns);
httpd_req_recv(req, buf, buf_len);
esp_err_t err = httpd_query_key_value(buf, "ssid", ssid, ssid_len);
if (err != ESP_OK) return err;
err = httpd_query_key_value(buf, "password", password, password_len);
if (err != ESP_OK) return err;
err = httpd_query_key_value(buf, "ip", ip, ip_len);
if (err != ESP_OK) return err;
err = httpd_query_key_value(buf, "netmask", netmask, netmask_len);
if (err != ESP_OK) return err;
err = httpd_query_key_value(buf, "gateway", gateway, gateway_len);
if (err != ESP_OK) return err;
err = httpd_query_key_value(buf, "dns", dns, dns_len);
if (err != ESP_OK) return err;
err = httpd_query_key_value(buf, "dhcp", buf, buf_len);
if (err != ESP_OK) return err;
dhcp = (buf[0] == '1');
save_wifi_config(ssid, password, dhcp, ip, netmask, gateway, dns);
esp_restart();
}
return ESP_OK;
}
/* 定时器回调函数 */
static void timer_callback(void *arg) {
if (!wifi_connected) {
return;
}
int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
if (sock < 0) {
ESP_LOGE(TAG, "Failed to create socket");
return;
}
struct sockaddr_in dest_addr = {
.sin_family = AF_INET,
.sin_port = htons(SERVER_PORT),
.sin_addr = { .s_addr = inet_addr(SERVER_IP) },
};
int err = connect(sock, (struct sockaddr*)&dest_addr, sizeof(dest_addr));
if (err != 0) {
ESP_LOGE(TAG, "Failed to connect to server");
close(sock);
return;
}
const char *msg = "123456789\n";
err = send(sock, msg, strlen(msg), 0);
if (err < 0) {
ESP_LOGE(TAG, "Failed to send message");
}
close(sock);
send_count++;
if (send_count >= 3 * 60) {
esp_err_t err = nvs_erase_all(nvs_handle);
if (err != ESP_OK) {
ESP_LOGE(TAG, "Failed to erase NVS");
}
esp_restart();
}
}
void app_main() {
ESP_ERROR_CHECK(nvs_flash_init());
wifi_connect();
ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL));
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL));
httpd_config_t config = HTTPD_DEFAULT_CONFIG();
config.server_port = 80;
ESP_ERROR_CHECK(httpd_start(&server, &config));
ESP_ERROR_CHECK(httpd_register_uri_handler(server, &((httpd_uri_t){
.uri = "/*",
.method = HTTP_GET|HTTP_POST,
.handler = http_handler,
})));
esp_timer_handle_t timer_handle;
const esp_timer_create_args_t timer_args = {
.callback = timer_callback,
};
ESP_ERROR_CHECK(esp_timer_create(&timer_args, &timer_handle));
ESP_ERROR_CHECK(esp_timer_start_periodic(timer_handle, TIMER_PERIOD_MS * 1000));
}
```
程序主要分为四个部分：
1. 连接WiFi：程序会从NVS中读取保存的WiFi配置，然后连接WiFi。
2. 处理HTTP请求：程序会创建一个简单的HTTP服务器，当终端设备连接上服务器后，可以通过提交表单来修改网络配置。
3. 定时发送数据：程序会每隔一段时间向指定IP地址发送一段数据。
4. 清除保存信息并重启：当程序发送的数据达到一定次数后，程序会清除保存的网络配置信息，并重启ESP32。
注意事项：
1. 为了使程序能够正常工作，需要在 `menuconfig` 中配置好 WiFi 和 NVS 的选项。
2. 由于 ESP32C3 没有内置的Flash，因此需要使用外部Flash模块来存储 WiFi 配置信息，需要在 `menuconfig` 中配置好 Flash 的选项。
3. 由于 ESP32C3 没有内置的RTC模块，因此无法使用定时器唤醒ESP32，需要使用外部RTC模块或者使用ESP32C3的低功耗模式来节省能量。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
