引言
随着物联网（IoT）技术的快速发展，基于 STM32 的服务器（类似网关）在数据采集、设备控制等方面的应用越来越广泛。本文将介绍搭建一个基于 STM32 的服务器所需的技术栈，以及详细的搭建步骤和代码示例。
技术栈介绍
在搭建基于 STM32 的服务器时，我们需要用到以下技术栈和组件：
1. 硬件平台
- STM32 微控制器：选择 STM32F4 或 STM32F7 系列，根据性能需求和外设支持。
- 网络模块：可以选择 ESP8266（Wi-Fi）、ESP32（Wi-Fi + 蓝牙）或以太网模块（如 W5500）。
- 电源管理：使用稳压器或电源管理芯片，确保系统供电稳定。
2. 开发环境
- IDE：使用 STM32CubeIDE 或 Keil MDK 进行开发。
- 库和驱动：
- STM32 HAL 库：简化硬件访问。
- LWIP（轻量级IP协议栈）：实现 TCP/IP 协议栈。
- FreeRTOS（可选）：支持多任务处理。
3. 网络协议
- TCP/IP：实现基本的网络通信。
- HTTP/HTTPS：用于支持 Web 服务。
- MQTT：适合 IoT 设备间的轻量级通信。
4. 开发语言
- C/C++：主要用于 STM32 的底层开发。
- HTML/CSS/JavaScript：用于开发 Web 界面。
5. 数据存储
- Flash 存储：存储配置和小型数据。
- SD 卡（可选）：用于大容量数据存储。
6. 安全性
- TLS/SSL：实现数据加密，确保通信安全。
- 认证机制：如 JWT，确保设备和用户身份验证。
搭建步骤
下面将详细介绍如何搭建基于 STM32 的服务器，涵盖硬件连接、软件开发和测试等步骤。
一、硬件搭建
1.1 准备硬件
- 开发板：选择 STM32F4 或 STM32F7 开发板。
- 网络模块：选择 ESP8266 或 W5500 以实现网络连接。
- 其他配件：稳压电源模块、面包板、杜邦线等。
1.2 硬件连接
-
连接 STM32 和网络模块：
-
ESP8266/ESP32：
- 将 ESP 模块的 VCC 连接到 STM32 的 3.3V，GND 连接到 GND。
- 将 ESP 的 TX 接口连接到 STM32 的 RX 引脚，RX 接口连接到 STM32 的 TX 引脚。
-
W5500：
- 将 W5500 的 SPI 接口连接到 STM32 的相应引脚：
- MOSI -> STM32 MOSI
- MISO -> STM32 MISO
- SCK -> STM32 SCK
- CS -> STM32 GPIO（选择任意 GPIO 作为片选引脚）
- 连接电源（VCC 和 GND）。
- 将 W5500 的 SPI 接口连接到 STM32 的相应引脚：
-
-
确保电源管理：
- 使用适当的稳压器，确保 STM32 和其他模块的电压符合要求。
1.3 硬件连接示意图
二、软件开发
2.1 开发环境设置
2.2 引入必要的库文件
-
下载 STM32CubeIDE：
- 访问 ST 官网 下载并安装 STM32CubeIDE。
-
创建新工程：
- 打开 STM32CubeIDE，选择新建 STM32 项目。
- 选择所用的 STM32 微控制器型号。
-
配置外设：
- 在 STM32CubeMX 中，配置 UART（用于串口通信）和 SPI（如果使用 W5500）。
- 在“Pinout & Configuration”选项卡中，设置 UART 和 SPI 引脚。
-
启用 LWIP 协议栈：
- 在“Middleware”选项卡中，启用 LWIP。配置 LWIP 参数，包括 IP 地址、网络掩码和网关。
- 配置 LWIP 的使用模式（如 DHCP 或静态 IP）。
-
生成代码：
- 点击“Project”菜单，选择“Generate Code”，生成项目代码。
-
STM32 HAL 库：
- 在项目中默认已经包含 STM32 HAL 库，无需额外引入。
-
LWIP 协议栈：
- LWIP 协议栈已经在 STM32CubeMX 中配置并生成，可以直接使用。
-
FreeRTOS（可选）：
- 如果需要多任务处理，选择 FreeRTOS，设置任务优先级及堆大小。
2.3 编写代码
2.3.1 初始化代码
在 main.c 文件中，增加网络初始化和服务器启动代码。以下是基本实现步骤：
#include "lwip/init.h"
#include "lwip/netconn.h"
// 网络配置函数
void init_network() {
// 初始化硬件
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_SPI_Init(); // 如果使用W5500
MX_LWIP_Init(); // 初始化LWIP
}
// TCP/IP 服务器实现
void start_server() {
struct netconn *conn, *newconn;
err_t err;
// 创建 TCP 连接
conn = netconn_new(NETCONN_TCP);
netconn_bind(conn, NULL, 80); // 绑定到端口 80
netconn_listen(conn);
while (1) {
err = netconn_accept(conn, &newconn); // 接受新的连接
if (err == ERR_OK) {
// 处理请求
// 这里可以添加处理 HTTP 请求的代码
netconn_delete(newconn); // 处理完毕后关闭连接
}
}
}
2.3.2 主函数
在 main() 函数中调用初始化和服务器启动代码：
int main(void) {
init_network(); // 初始化网络
start_server(); // 启动TCP服务器
while (1) {
sys_check_timeouts(); // 处理 LWIP 超时
}
}
2.4 处理 HTTP 请求
为了让服务器能够响应 HTTP 请求，可以在 start_server() 函数中添加 HTTP 请求处理逻辑。以下是一个简单的 HTTP 响应示例：
void handle_request(struct netconn *newconn) {
struct netbuf *inbuf;
char *buffer;
u16_t len;
// 等待接收数据
netconn_recv(newconn, &inbuf);
netbuf_data(inbuf, (void**)&buffer, &len);
// 简单处理 HTTP GET 请求
if (strncmp(buffer, "GET ", 4) == 0) {
// 发送 HTTP 响应
const char* response = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"
"<html><body><h1>Hello, STM32!</h1></body></html>";
netconn_write(newconn, response, strlen(response), NETCONN_NOCOPY);
}
netbuf_delete(inbuf); // 释放内存
}
// 在 start_server() 中调用
if (err == ERR_OK) {
handle_request(newconn); // 处理 HTTP 请求
netconn_delete(newconn);
}
2.5 编译和上传
-
编译代码：
- 在 STM32CubeIDE 中，点击“Build”按钮编译项目，确保代码没有错误。
-
上传代码：
- 连接开发板，选择正确的调试器（如 ST-Link），点击“Run”按钮将代码上传到 STM32。
2.6 测试服务器
-
连接网络：
- 确保 STM32 开发板通过 ESP8266/ESP32 或 W5500 网络模块正确连接到网络。
- 如果使用 ESP8266/ESP32，请确保模块已连接到 Wi-Fi 网络。如果使用 W5500，请确保以太网线连接到路由器。
-
获取 IP 地址：
- 如果使用 DHCP，STM32 会自动获取 IP 地址。
- 可以在调试输出（例如使用 UART）中打印出分配的 IP 地址。可以在
lwip初始化后加入如下代码：ip_addr_t ipaddr, netmask, gw; netif_default->ip_addr.addr = netif_default->ip_addr.addr; netif_default->netmask.addr = netif_default->netmask.addr; netif_default->gw.addr = netif_default->gw.addr; printf("IP Address: %s\n", ipaddr_ntoa(&netif_default->ip_addr));
-
使用浏览器访问服务器：
- 在 PC 或手机的浏览器中输入 STM32 的 IP 地址，例如
http://192.168.1.100（请根据实际分配的 IP 地址修改）。 - 如果一切正常，您应该能看到服务器返回的 HTML 页面，显示内容为 "Hello, STM32!"。
- 在 PC 或手机的浏览器中输入 STM32 的 IP 地址，例如
-
调试：
- 如果未能访问网页，请检查以下事项：
- 确保 STM32 开发板的电源正常。
- 检查网络连接是否正常。
- 使用串口监视器查看调试信息，确认 IP 地址是否正确。
- 使用 Wireshark 等工具监控网络流量，检查请求是否到达 STM32。
- 如果未能访问网页，请检查以下事项：
3.1 增加更多的功能
处理不同的 HTTP 请求
可以根据不同的 URL 路径处理不同的请求，例如通过 GET /data 获取传感器数据。以下是如何实现的步骤：
-
修改请求处理函数：
在handle_request函数中，根据请求的 URL 处理不同的请求。void handle_request(struct netconn *newconn) { struct netbuf *inbuf; char *buffer; u16_t len; // 等待接收数据 netconn_recv(newconn, &inbuf); netbuf_data(inbuf, (void**)&buffer, &len); // 简单处理 HTTP GET 请求 if (strncmp(buffer, "GET /data", 9) == 0) { // 假设我们有一个函数获取传感器数据 char sensor_data[100]; // 假设存储传感器数据的数组 get_sensor_data(sensor_data); // 实现这个函数以获取传感器数据 // 发送 HTTP 响应 char response[150]; snprintf(response, sizeof(response), "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n%s", sensor_data); netconn_write(newconn, response, strlen(response), NETCONN_NOCOPY); } else { // 处理其他请求 const char* response = "HTTP/1.1 404 Not Found\r\n\r\n"; netconn_write(newconn, response, strlen(response), NETCONN_NOCOPY); } netbuf_delete(inbuf); // 释放内存 } void get_sensor_data(char *data) { // 模拟传感器数据 sprintf(data, "Temperature: 25.5 C\nHumidity: 60%%"); }
实现 MQTT 支持
如果需要实现 IoT 设备间的通信，可以集成 MQTT 协议。可以使用如 Paho MQTT 或 MQTT-C 等轻量级的 MQTT 客户端库。以下是实现步骤：
-
下载并集成 MQTT 库：
- 根据选定的库，下载源代码并将其添加到 STM32 项目中。
-
初始化 MQTT 客户端：
#include "MQTTClient.h" // 根据所用的 MQTT 库引入头文件 MQTTClient client; char *mqtt_broker = "tcp://broker.hivemq.com:1883"; // MQTT Broker 地址 void mqtt_init() { MQTTClient_create(&client, mqtt_broker, "stm32_client_id", MQTTCLIENT_PERSISTENCE_NONE, NULL); MQTTClient_setCallbacks(client, NULL, NULL, messageArrived, NULL); MQTTClient_connectOptions conn_opts = MQTTClient_connectOptions_initializer; conn_opts.keepAliveInterval = 20; conn_opts.cleansession = 1; if (MQTTClient_connect(client, &conn_opts) != MQTTCLIENT_SUCCESS) { printf("Failed to connect to MQTT broker\n"); return; } printf("Connected to MQTT broker\n"); } -
发布和订阅消息：
void publish_message(const char *topic, const char *payload) { MQTTClient_message pubmsg = MQTTClient_message_initializer; pubmsg.payload = (void*)payload; pubmsg.payloadlen = strlen(payload); pubmsg.qos = 1; pubmsg.retained = 0; MQTTClient_publishMessage(client, topic, &pubmsg, NULL); } void subscribe_to_topic(const char *topic) { MQTTClient_subscribe(client, topic, 1); }
3.2 数据存储
使用 Flash 存储
可以将设备配置（如 Wi-Fi SSID 和密码）存储在 Flash 中，以便在重启时自动加载。
- Flash 存储函数：
#include "stm32f4xx_hal_flash.h"
void write_flash(uint32_t address, uint8_t *data, uint16_t size) {
HAL_FLASH_Unlock(); // 解锁 Flash 写入
// 擦除页
FLASH_Erase_Sector(FLASH_SECTOR_2, VOLTAGE_RANGE_3); // 擦除选择的区域
// 写入数据
for (uint16_t i = 0; i < size; i++) {
if (HAL_FLASH_Program(TYPEPROGRAM_BYTE, address + i, data[i]) != HAL_OK) {
// 处理写入错误
return;
}
}
HAL_FLASH_Lock(); // 锁定 Flash 写入
}
void read_flash(uint32_t address, uint8_t *data, uint16_t size) {
for (uint16_t i = 0; i < size; i++) {
data[i] = *(__IO uint8_t*)(address + i); // 读取数据
}
}使用示例
-
写入 Wi-Fi 配置：
void save_wifi_config(const char* ssid, const char* password) { uint8_t ssid_len = strlen(ssid); uint8_t password_len = strlen(password); uint32_t address = 0x080E0000; // 假设选择这个地址存储配置 // 写入 SSID write_flash(address, (uint8_t *)ssid, ssid_len); // 写入密码 write_flash(address + 0x40, (uint8_t *)password, password_len); // 假设密码紧跟在 SSID 后 } -
读取 Wi-Fi 配置：
void load_wifi_config(char* ssid, char* password) { uint32_t address = 0x080E0000; // 读取配置的地址 uint8_t ssid_len = 32; // 假设 SSID 最大长度为 32 uint8_t password_len = 32; // 假设密码最大长度为 32 read_flash(address, (uint8_t *)ssid, ssid_len); read_flash(address + 0x40, (uint8_t *)password, password_len); }
使用 SD 卡存储数据
如果需要存储大量数据，可以添加 SD 卡模块，并使用 FATFS 文件系统进行数据读写。
1. 添加 SD 卡模块
- 硬件连接：
- 将 SD 卡模块连接到 STM32 的 SPI 接口（MOSI、MISO、SCK 和 CS）。
- 连接 VCC 和 GND。
2. 配置 FATFS
-
在 STM32CubeMX 中启用 FATFS：
- 在中间件部分选择 FATFS，并配置为 SPI 模式。
-
生成代码：
- 生成代码后，您将在项目中看到 FATFS 的相关文件。
3. SD 卡读写示例
-
初始化 SD 卡：
FATFS FatFs; // FatFs工作区 FIL fil; // 文件对象 FRESULT fr; // FATFS 结果 void init_sd_card() { fr = f_mount(&FatFs, "", 1); // 挂载文件系统 if (fr != FR_OK) { // 处理错误 } } -
写入数据到 SD 卡：
void write_to_sd_card(const char* filename, const char* data) { fr = f_open(&fil, filename, FA_WRITE | FA_CREATE_ALWAYS); // 打开文件 if (fr == FR_OK) { f_write(&fil, data, strlen(data), NULL); // 写入数据 f_close(&fil); // 关闭文件 } else { // 处理打开文件错误 } } -
从 SD 卡读取数据：
void read_from_sd_card(const char* filename, char* buffer, uint32_t buffer_size) { fr = f_open(&fil, filename, FA_READ); // 打开文件 if (fr == FR_OK) { f_read(&fil, buffer, buffer_size, NULL); // 读取数据 f_close(&fil); // 关闭文件 } else { // 处理打开文件错误 } }
3.3 增强安全性
启用 HTTPS
使用 TLS/SSL 库（如 mbedTLS）实现 HTTPS，确保数据传输安全。
1. 集成 mbedTLS
-
下载 mbedTLS：
- 访问 mbedTLS GitHub 页面 下载最新版本的 mbedTLS。
- 将相关源代码和头文件添加到 STM32 项目中。
-
配置 mbedTLS：
- 在
mbedtls/config.h中，启用所需功能，例如：#define MBEDTLS_SSL_CLI_C #define MBEDTLS_SSL_SRV_C #define MBEDTLS_TLS_C #define MBEDTLS_X509_CRT_PARSE_C #define MBEDTLS_SHA256_C #define MBEDTLS_AES_C
- 在
2. 初始化 mbedTLS
#include "mbedtls/net_sockets.h"
#include "mbedtls/ssl.h"
#include "mbedtls/error.h"
// 全局变量
mbedtls_ssl_context ssl;
mbedtls_ssl_config conf;
mbedtls_entropy_context entropy;
mbedtls_ctr_drbg_context ctr_drbg;
// 初始化 mbedTLS
void init_mbedtls() {
mbedtls_ssl_init(&ssl);
mbedtls_ssl_config_init(&conf);
mbedtls_entropy_init(&entropy);
mbedtls_ctr_drbg_init(&ctr_drbg);
// 设置随机数生成器
const char *pers = "ssl_client";
mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)pers, strlen(pers));
// 配置 SSL
mbedtls_ssl_config_defaults(&conf, MBEDTLS_SSL_IS_CLIENT, MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT);
mbedtls_ssl_conf_rng(&conf, mbedtls_ctr_drbg_random, &ctr_drbg);
}
// 连接到 HTTPS 服务器
int connect_https(const char *hostname, const char *port) {
mbedtls_net_context server_fd;
mbedtls_net_init(&server_fd);
// 连接到服务器
if (mbedtls_net_connect(&server_fd, hostname, port, MBEDTLS_NET_PROTO_TCP) != 0) {
return -1;
}
// 设置 SSL
mbedtls_ssl_setup(&ssl, &conf);
mbedtls_ssl_set_hostname(&ssl, hostname);
mbedtls_ssl_set_bio(&ssl, &server_fd, mbedtls_net_send, mbedtls_net_recv, NULL);
// 完成 SSL 握手
if (mbedtls_ssl_handshake(&ssl) != 0) {
mbedtls_net_free(&server_fd);
return -1;
}
return 0; // 连接成功
}
3. 发送 HTTPS 请求
void send_https_request(const char *hostname, const char *path) {
char request[512];
snprintf(request, sizeof(request),
"GET %s HTTP/1.1\r\nHost: %s\r\nConnection: close\r\n\r\n", path, hostname);
mbedtls_ssl_write(&ssl, (unsigned char *)request, strlen(request));
// 读取响应
unsigned char buf[1024];
int ret;
do {
ret = mbedtls_ssl_read(&ssl, buf, sizeof(buf) - 1);
if (ret > 0) {
buf[ret] = '\0'; // 添加字符串结束符
printf("%s", (char *)buf); // 打印响应
}
} while (ret > 0);
// 清理
mbedtls_ssl_close_notify(&ssl);
mbedtls_net_free(&server_fd);
}用户身份认证
1. JWT 生成和验证
1. 生成 JWT
使用 JWT 库生成 JSON Web Token，以下是如何生成 JWT 的示例代码：
#include "jwt.h"
// 生成 JWT
char* generate_jwt(const char *secret, const char *username) {
jwt_t *jwt = NULL;
char *token = NULL;
// 创建新的 JWT
if (jwt_new(&jwt) != 0) {
return NULL; // 处理错误
}
// 设置 JWT 的声明
jwt_add_grant(jwt, "sub", username); // 用户名
jwt_add_grant_int(jwt, "exp", time(NULL) + 3600); // 设置过期时间为1小时
// 签名 JWT
if (jwt_set_alg(jwt, JWT_ALG_HS256, (unsigned char *)secret, strlen(secret)) != 0) {
jwt_free(jwt);
return NULL; // 处理错误
}
// 获取 JWT 字符串
token = jwt_encode_str(jwt);
jwt_free(jwt); // 释放 JWT 结构体
return token; // 返回生成的 JWT
}
2. 验证 JWT
在服务器端验证 JWT，确保请求的用户身份合法。
int verify_jwt(const char *token, const char *secret) {
jwt_t *jwt = NULL;
const char *username;
// 解析 JWT
if (jwt_decode(&jwt, token, (unsigned char *)secret, strlen(secret)) != 0) {
return 0; // 验证失败
}
// 检查过期时间
if (jwt_get_grant_int(jwt, "exp") < time(NULL)) {
jwt_free(jwt);
return 0; // JWT 已过期
}
username = jwt_get_grant(jwt, "sub"); // 获取用户名
printf("Authenticated user: %s\n", username); // 打印用户信息
jwt_free(jwt); // 释放 JWT 结构体
return 1; // 验证成功
}
3. 结合 HTTP 请求与 JWT 验证
在处理 HTTP 请求时，检查 Authorization 头中是否包含有效的 JWT。
void handle_request(struct netconn *newconn) {
struct netbuf *inbuf;
char *buffer;
u16_t len;
netconn_recv(newconn, &inbuf);
netbuf_data(inbuf, (void**)&buffer, &len);
// 示例：处理 GET 请求，检查 JWT
if (strncmp(buffer, "GET /data", 9) == 0) {
// 检查 Authorization 头
char *auth_header = strstr(buffer, "Authorization: ");
if (auth_header) {
char *token = strtok(auth_header + 15, "\r\n"); // 提取 JWT (Bearer token)
if (verify_jwt(token, "your_secret_key")) { // 验证 JWT
// 返回传感器数据
char sensor_data[100];
get_sensor_data(sensor_data); // 获取传感器数据
char response[150];
snprintf(response, sizeof(response),
"HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n%s", sensor_data);
netconn_write(newconn, response, strlen(response), NETCONN_NOCOPY);
} else {
// JWT 验证失败
const char* response = "HTTP/1.1 401 Unauthorized\r\n\r\n";
netconn_write(newconn, response, strlen(response), NETCONN_NOCOPY);
}
} else {
// 未提供 JWT
const char* response = "HTTP/1.1 401 Unauthorized\r\n\r\n";
netconn_write(newconn, response, strlen(response), NETCONN_NOCOPY);
}
} else {
// 处理其他请求
const char* response = "HTTP/1.1 404 Not Found\r\n\r\n";
netconn_write(newconn, response, strlen(response), NETCONN_NOCOPY);
}
netbuf_delete(inbuf); // 释放内存
}总结
通过本文，我们详细介绍了如何搭建一个基于 STM32 的服务器（类似网关），并实现了多种功能，具体包括：
-
硬件搭建：
- 选择合适的 STM32 微控制器（如 STM32F4 或 STM32F7）和网络模块（如 ESP8266、ESP32 或 W5500）。
- 确保电源管理稳定，为系统提供稳定的电压。
-
软件开发：
- 设置开发环境，使用 STM32CubeIDE 创建项目。
- 配置并初始化网络模块，使用 LWIP 协议栈实现 TCP/IP 通信。
- 编写处理 HTTP 请求的代码，支持根据 URL 路径返回不同的响应。
-
增加更多功能：
- 处理不同的 HTTP 请求，获取传感器数据并返回。
- 集成 MQTT 协议，实现 IoT 设备间的通信。
- 提供 HTTP 服务和 MQTT 服务，增加系统的灵活性。
-
数据存储：
- 使用 Flash 存储设备配置（如 Wi-Fi SSID 和密码）。
- 使用 SD 卡模块存储大量数据，并通过 FATFS 文件系统读写数据。
-
增强安全性：
- 使用 mbedTLS 库启用 HTTPS，确保数据传输的安全性。
- 实现 JWT（JSON Web Token）身份认证，确保只有授权用户能够访问服务器。
非常感谢您阅读到这里！您的关注和支持是我不断前进的动力。跟随着我探索嵌入式领域，希望因为兴趣而成为嵌入式领域的专家。
在这个快速发展的技术时代，嵌入式系统无处不在，从智能家居到医疗设备，从自动驾驶汽车到工业控制，每一个领域都离不开嵌入式技术的支持。对我来说，嵌入式不仅仅是一门技术，更是一种激情和追求。通过不断学习和实践，我深深爱上了这个充满挑战和机遇的领域。每一次调试成功，每一个创新的实现，都是我继续前行的动力。
——by 极客小张
8321
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
