简介：CH340N串口模块，板载3.3V 300mA LDO

好的，作为一名高级嵌入式软件开发工程师，我将基于你提供的 CH340N 串口模块图片，详细阐述一个完整的嵌入式系统开发流程，并深入探讨最适合的代码设计架构，最终提供超过 3000 行的 C 代码示例。我们将从需求分析开始，历经系统设计、实现、测试验证，直至维护升级，确保构建一个可靠、高效、可扩展的嵌入式系统平台。
关注微信公众号，提前获取相关推文

项目背景：CH340N 串口模块嵌入式系统开发

硬件描述：

• 核心模块： CH340N USB 转串口芯片。这款芯片广泛应用于嵌入式系统中，用于将 USB 接口转换为 UART 串口，实现上位机与嵌入式设备之间的通信。
• 板载 LDO： 3.3V 300mA LDO（低压差线性稳压器）。为 CH340N 芯片和可能的外围电路提供稳定的 3.3V 电源。这表明该模块设计用于 3.3V 系统，与常见的 3.3V 微控制器（如 STM32、ESP32 等）兼容。
• 接口： USB Type-C 接口用于连接上位机，排针接口用于连接嵌入式系统的微控制器或其他外围设备。

项目目标：

构建一个基于 CH340N 串口模块的嵌入式系统平台，该平台需要具备以下特点：

1. 可靠性： 系统运行稳定可靠，能够长时间无故障运行，数据传输准确无误。
2. 高效性： 系统资源利用率高，代码执行效率高，响应速度快。
3. 可扩展性： 系统架构设计灵活，易于扩展新的功能和模块，适应未来需求变化。
4. 易维护性： 代码结构清晰，注释完善，方便后期维护和升级。

系统开发流程

一个完整的嵌入式系统开发流程通常包括以下几个阶段：

1. 需求分析阶段
2. 系统设计阶段
3. 系统实现阶段
4. 测试验证阶段
5. 维护升级阶段

1. 需求分析阶段

在需求分析阶段，我们需要明确系统的功能需求、性能需求、可靠性需求、接口需求、环境需求等。针对 CH340N 串口模块嵌入式系统，我们可以定义如下需求：

• 功能需求：
  • 实现 USB 到 UART 的双向数据转换。
  • 支持可配置的 UART 波特率、数据位、停止位、校验位等参数。
  • 提供数据接收和发送功能。
  • 可以通过上位机配置模块参数。
  • 可以作为嵌入式系统的调试串口。
• 性能需求：
  • 数据传输速率满足实际应用需求，例如，最高支持 CH340N 芯片支持的波特率。
  • 数据传输延迟尽可能低。
  • 系统资源占用率低。
• 可靠性需求：
  • 数据传输可靠性高，误码率低。
  • 系统运行稳定，不易崩溃。
  • 具备一定的错误处理能力。
• 接口需求：
  • USB Type-C 接口与上位机连接。
  • 排针接口与微控制器或其他外围设备连接。
  • 提供电源输入接口。
• 环境需求：
  • 工作温度范围：例如 -20℃ ~ +70℃ （根据实际应用场景确定）。
  • 供电电压范围：例如 USB 供电 5V。
  • 湿度范围：例如 5% ~ 95% RH（无凝结）。

2. 系统设计阶段

系统设计阶段是根据需求分析结果，设计系统的硬件架构和软件架构。

2.1 硬件架构设计

由于我们已经有了 CH340N 串口模块的硬件，硬件架构设计主要集中在如何将该模块集成到更大的嵌入式系统中。通常，CH340N 模块会连接到微控制器的 UART 接口。

• 微控制器选择： 选择合适的微控制器是关键。常见的选择包括 STM32 系列、ESP32 系列、NXP Kinetis 系列等。这里我们假设选择 STM32F103C8T6，这是一款常用的、性价比高的 ARM Cortex-M3 微控制器。
• 连接方式：
  • CH340N 模块的 UART TX 引脚连接到 STM32 的 UART RX 引脚。
  • CH340N 模块的 UART RX 引脚连接到 STM32 的 UART TX 引脚。
  • CH340N 模块的 GND 引脚和 STM32 的 GND 引脚连接。
  • CH340N 模块的 VCC 引脚（3.3V）可以作为 STM32 外围设备的电源，但通常 STM32 会有自己的电源系统。

2.2 软件架构设计

软件架构设计是整个嵌入式系统开发的核心。一个良好的软件架构能够提高代码的可读性、可维护性、可扩展性和可靠性。针对 CH340N 串口模块嵌入式系统，我们推荐采用分层架构和模块化设计相结合的方式。

分层架构：

分层架构将系统软件划分为不同的层次，每一层负责不同的功能，层与层之间通过明确的接口进行交互。常见的嵌入式系统分层架构包括：

• 硬件抽象层 (HAL - Hardware Abstraction Layer)： 最底层，直接与硬件交互，封装硬件细节，向上层提供统一的硬件访问接口。对于 CH340N 模块，HAL 层主要负责配置 STM32 的 UART 端口，以及基本的 UART 数据发送和接收操作。
• 驱动层 (Driver Layer)： 构建在 HAL 层之上，负责管理和控制硬件设备。对于 CH340N 模块，驱动层可以提供更高级的串口操作接口，例如，带缓冲的数据收发、串口参数配置等。
• 服务层 (Service Layer)： 构建在驱动层之上，提供一些通用的服务功能，例如，日志服务、配置管理服务、命令解析服务等。对于串口系统，可以包含串口数据解析、协议处理等服务。
• 应用层 (Application Layer)： 最上层，实现具体的应用逻辑。例如，数据采集、数据处理、控制算法、用户界面等。对于串口系统，应用层可能负责接收来自串口的数据，并根据数据执行相应的操作，或者向上位机发送数据。

模块化设计：

模块化设计将系统分解为多个独立的模块，每个模块负责特定的功能，模块之间通过接口进行交互。这有助于提高代码的可维护性和可扩展性。

对于 CH340N 串口模块嵌入式系统，我们可以设计以下模块：

• UART 驱动模块： 封装 UART 硬件操作，提供串口数据收发功能。
• 数据接收模块： 负责接收串口数据，并进行初步处理（例如，数据校验、数据缓冲）。
• 数据发送模块： 负责将数据通过串口发送出去。
• 命令解析模块： 解析接收到的串口命令，并执行相应的操作。
• 配置管理模块： 负责管理系统配置参数，例如，串口波特率、数据位等。
• 日志模块： 记录系统运行日志，方便调试和问题排查。
• 应用模块： 实现具体的应用逻辑，例如，串口数据回环测试、简单的数据处理应用等。

最佳代码设计架构：事件驱动型、分层模块化架构

综合考虑嵌入式系统的特点和 CH340N 串口模块的应用场景，我们认为最佳的代码设计架构是 事件驱动型、分层模块化架构。

• 事件驱动型： 系统基于事件进行驱动，例如，串口接收到数据事件、定时器事件等。事件驱动架构能够提高系统的实时性和响应速度，降低 CPU 资源占用。
• 分层模块化： 如前所述，分层架构和模块化设计能够提高代码的可读性、可维护性、可扩展性和可靠性。

架构图示：

+---------------------+
|    应用层 (Application)    |  例如：数据处理、命令响应
+---------------------+
         ^
         | 服务接口
         v
+---------------------+
|    服务层 (Service)     |  例如：命令解析、配置管理、日志
+---------------------+
         ^
         | 驱动接口
         v
+---------------------+
|    驱动层 (Driver)      |  UART 驱动
+---------------------+
         ^
         | HAL 接口
         v
+---------------------+
|    硬件抽象层 (HAL)    |  STM32 UART HAL
+---------------------+
         ^
         | 硬件接口
         v
+---------------------+
|     硬件 (Hardware)     |  STM32 MCU, CH340N 模块
+---------------------+

3. 系统实现阶段

系统实现阶段是根据系统设计，编写代码实现各个模块的功能。以下是基于 STM32F103C8T6 和 CH340N 模块的 C 代码示例，代码量将超过 3000 行，力求详细和完整。

为了更好地组织代码，我们将代码分为多个文件：

• main.c: 主程序文件，包含主函数 main() 和系统初始化代码。
• bsp.h / bsp.c: 板级支持包 (BSP) 文件，包含系统时钟配置、外设初始化等。
• hal_uart.h / hal_uart.c: UART 硬件抽象层 (HAL) 文件，封装 STM32 UART 硬件操作。
• drv_uart.h / drv_uart.c: UART 驱动层文件，提供更高级的 UART 操作接口，例如，带缓冲的收发。
• service_cmd.h / service_cmd.c: 命令解析服务层文件，解析串口命令。
• service_log.h / service_log.c: 日志服务层文件，提供日志记录功能。
• config.h / config.c: 配置管理模块文件，管理系统配置参数。
• app.h / app.c: 应用层文件，实现具体的应用逻辑。

3.1 bsp.h - 板级支持包头文件

#ifndef BSP_H
#define BSP_H

#include "stm32f10x.h"

// 系统时钟配置
void SystemClock_Config(void);

// 初始化系统滴答定时器 (SysTick)
void SysTick_Init(void);

// 延时函数 (毫秒级)
void Delay_ms(uint32_t ms);

// LED 初始化 (假设板载 LED，方便调试)
void LED_Init(void);
void LED_Toggle(void);

#endif // BSP_H

3.2 bsp.c - 板级支持包源文件

#include "bsp.h"

// 系统时钟配置 (使用 72MHz 外部晶振)
void SystemClock_Config(void) {
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  // 配置高速外部时钟 (HSE)
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9; // HSE * 9 = 72MHz
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK) {
    Error_Handler(); // 错误处理函数，需要实现
  }

  // 配置系统时钟 (SYSCLK), HCLK, PCLK1, PCLK2
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2; // PCLK1 = 36MHz
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1; // PCLK2 = 72MHz
  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK) {
    Error_Handler();
  }
}

// 初始化系统滴答定时器 (SysTick) - 用于延时
void SysTick_Init(void) {
  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / 1000); // 1ms 中断一次
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}

// 延时函数 (毫秒级) - 基于 SysTick
void Delay_ms(uint32_t ms) {
  HAL_Delay(ms);
}

// LED 初始化 (假设 LED 连接到 GPIOA Pin 5)
void LED_Init(void) {
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  // 使能 GPIOA 时钟
  __HAL_RCC_GPIOA_CLK_ENABLE();

  // 配置 GPIOA Pin 5 为输出模式
  GPIO_InitStruct.Pin = GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  // 默认关闭 LED
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);
}

// LED 翻转
void LED_Toggle(void) {
  HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
}

// 错误处理函数 (示例，需要根据实际情况完善)
void Error_Handler(void) {
  while(1) {
    LED_Toggle(); // LED 闪烁提示错误
    Delay_ms(500);
  }
}

3.3 hal_uart.h - UART HAL 头文件

#ifndef HAL_UART_H
#define HAL_UART_H

#include "stm32f10x.h"

// UART 句柄类型定义
typedef UART_HandleTypeDef HAL_UART_HandleTypeDef;

// UART 初始化配置结构体
typedef struct {
  uint32_t BaudRate;       // 波特率
  uint32_t WordLength;     // 数据位长度
  uint32_t StopBits;       // 停止位
  uint32_t Parity;         // 校验位
  uint32_t HardwareFlowControl; // 硬件流控
  uint32_t Mode;           // 模式 (发送/接收/收发)
} HAL_UART_InitTypeDef;

// 初始化 UART 端口
HAL_UART_HandleTypeDef* HAL_UART_Init(UART_TypeDef* UARTx, HAL_UART_InitTypeDef* init);

// 发送一个字节数据
HAL_StatusTypeDef HAL_UART_Transmit(HAL_UART_HandleTypeDef* huart, uint8_t data);

// 发送多个字节数据
HAL_StatusTypeDef HAL_UART_TransmitBuffer(HAL_UART_HandleTypeDef* huart, uint8_t *pData, uint16_t Size);

// 接收一个字节数据 (阻塞模式)
HAL_StatusTypeDef HAL_UART_Receive(HAL_UART_HandleTypeDef* huart, uint8_t *pData);

// 接收多个字节数据 (阻塞模式)
HAL_StatusTypeDef HAL_UART_ReceiveBuffer(HAL_UART_HandleTypeDef* huart, uint8_t *pData, uint16_t Size);

// 启用 UART 接收中断
HAL_StatusTypeDef HAL_UART_EnableReceiveInterrupt(HAL_UART_HandleTypeDef* huart);

// 禁用 UART 接收中断
HAL_StatusTypeDef HAL_UART_DisableReceiveInterrupt(HAL_UART_HandleTypeDef* huart);

// UART 中断处理函数 (需要在 STM32 的中断服务例程中调用)
void HAL_UART_IRQHandler(HAL_UART_HandleTypeDef* huart);

// 获取 UART 句柄
HAL_UART_HandleTypeDef* HAL_UART_GetHandle(UART_TypeDef* UARTx);

#endif // HAL_UART_H

3.4 hal_uart.c - UART HAL 源文件

#include "hal_uart.h"
#include "bsp.h" // 包含错误处理函数

// UART 句柄数组 (可以支持多个 UART 端口)
static HAL_UART_HandleTypeDef huart_handles[USART_COUNT] = {0}; // USART_COUNT 需要根据 STM32 具体型号定义

// 初始化 UART 端口
HAL_UART_HandleTypeDef* HAL_UART_Init(UART_TypeDef* UARTx, HAL_UART_InitTypeDef* init) {
  HAL_UART_HandleTypeDef* huart = NULL;
  IRQn_Type irqn;

  if (UARTx == USART1) {
    __HAL_RCC_USART1_CLK_ENABLE();
    irqn = USART1_IRQn;
    huart = &huart_handles[0];
  } else if (UARTx == USART2) {
    __HAL_RCC_USART2_CLK_ENABLE();
    irqn = USART2_IRQn;
    huart = &huart_handles[1];
  } else if (UARTx == USART3) {
    __HAL_RCC_USART3_CLK_ENABLE();
    irqn = USART3_IRQn;
    huart = &huart_handles[2];
  } else {
    return NULL; // 不支持的 UART 端口
  }

  huart->Instance = UARTx;
  huart->Init.BaudRate = init->BaudRate;
  huart->Init.WordLength = init->WordLength;
  huart->Init.StopBits = init->StopBits;
  huart->Init.Parity = init->Parity;
  huart->Init.HwFlowCtl = init->HardwareFlowControl;
  huart->Init.Mode = init->Mode;
  huart->Init.OverSampling = UART_OVERSAMPLING_16;

  if (HAL_UART_Init(huart) != HAL_OK) { // 调用 STM32 HAL 库的 UART 初始化函数
    Error_Handler();
    return NULL;
  }

  // 配置 NVIC 中断
  HAL_NVIC_SetPriority(irqn, 0, 0);
  HAL_NVIC_EnableIRQ(irqn);

  return huart;
}

// 发送一个字节数据
HAL_StatusTypeDef HAL_UART_Transmit(HAL_UART_HandleTypeDef* huart, uint8_t data) {
  return HAL_UART_Transmit(huart, &data, 1, HAL_MAX_DELAY);
}

// 发送多个字节数据
HAL_StatusTypeDef HAL_UART_TransmitBuffer(HAL_UART_HandleTypeDef* huart, uint8_t *pData, uint16_t Size) {
  return HAL_UART_Transmit(huart, pData, Size, HAL_MAX_DELAY);
}

// 接收一个字节数据 (阻塞模式)
HAL_StatusTypeDef HAL_UART_Receive(HAL_UART_HandleTypeDef* huart, uint8_t *pData) {
  return HAL_UART_Receive(huart, pData, 1, HAL_MAX_DELAY);
}

// 接收多个字节数据 (阻塞模式)
HAL_StatusTypeDef HAL_UART_ReceiveBuffer(HAL_UART_HandleTypeDef* huart, uint8_t *pData, uint16_t Size) {
  return HAL_UART_Receive(huart, pData, Size, HAL_MAX_DELAY);
}

// 启用 UART 接收中断
HAL_StatusTypeDef HAL_UART_EnableReceiveInterrupt(HAL_UART_HandleTypeDef* huart) {
  return HAL_UART_Receive_IT(huart, &huart->RxXferSize); // 接收数据到 huart->pRxBuffPtr (需要进一步配置)
}

// 禁用 UART 接收中断
HAL_StatusTypeDef HAL_UART_DisableReceiveInterrupt(HAL_UART_HandleTypeDef* huart) {
  return HAL_UART_AbortReceive_IT(huart);
}

// UART 中断处理函数 (需要在 STM32 的中断服务例程中调用)
void HAL_UART_IRQHandler(HAL_UART_HandleTypeDef* huart) {
  HAL_UART_IRQHandler(huart); // 调用 STM32 HAL 库的中断处理函数
}

// 获取 UART 句柄
HAL_UART_HandleTypeDef* HAL_UART_GetHandle(UART_TypeDef* UARTx) {
  if (UARTx == USART1) {
    return &huart_handles[0];
  } else if (UARTx == USART2) {
    return &huart_handles[1];
  } else if (UARTx == USART3) {
    return &huart_handles[2];
  } else {
    return NULL;
  }
}

3.5 drv_uart.h - UART 驱动层头文件

#ifndef DRV_UART_H
#define DRV_UART_H

#include "hal_uart.h"
#include "stdint.h"

#define UART_RX_BUFFER_SIZE 256 // 定义 UART 接收缓冲区大小

// UART 驱动句柄类型定义
typedef struct {
  HAL_UART_HandleTypeDef* hal_uart_handle; // HAL UART 句柄
  uint8_t rx_buffer[UART_RX_BUFFER_SIZE]; // 接收缓冲区
  uint16_t rx_head;                      // 接收缓冲区头指针
  uint16_t rx_tail;                      // 接收缓冲区尾指针
  void (*rx_callback)(uint8_t data);    // 接收数据回调函数
} DRV_UART_HandleTypeDef;

// 初始化 UART 驱动
DRV_UART_HandleTypeDef* DRV_UART_Init(UART_TypeDef* UARTx, HAL_UART_InitTypeDef* hal_init);

// 发送一个字节数据
HAL_StatusTypeDef DRV_UART_Transmit(DRV_UART_HandleTypeDef* duart, uint8_t data);

// 发送多个字节数据
HAL_StatusTypeDef DRV_UART_TransmitBuffer(DRV_UART_HandleTypeDef* duart, uint8_t *pData, uint16_t Size);

// 从接收缓冲区读取一个字节数据
HAL_StatusTypeDef DRV_UART_ReceiveByte(DRV_UART_HandleTypeDef* duart, uint8_t *data);

// 获取接收缓冲区可用数据长度
uint16_t DRV_UART_AvailableData(DRV_UART_HandleTypeDef* duart);

// 设置接收数据回调函数
void DRV_UART_SetRxCallback(DRV_UART_HandleTypeDef* duart, void (*callback)(uint8_t data));

// UART 中断处理函数 (需要在 STM32 的 UART 中断服务例程中调用)
void DRV_UART_IRQHandler(DRV_UART_HandleTypeDef* duart);

// 获取 UART 驱动句柄
DRV_UART_HandleTypeDef* DRV_UART_GetHandle(UART_TypeDef* UARTx);

#endif // DRV_UART_H

3.6 drv_uart.c - UART 驱动层源文件

#include "drv_uart.h"
#include "bsp.h" // 包含错误处理函数

// UART 驱动句柄数组
static DRV_UART_HandleTypeDef duart_handles[USART_COUNT] = {0};

// 初始化 UART 驱动
DRV_UART_HandleTypeDef* DRV_UART_Init(UART_TypeDef* UARTx, HAL_UART_InitTypeDef* hal_init) {
  DRV_UART_HandleTypeDef* duart = NULL;

  if (UARTx == USART1) {
    duart = &duart_handles[0];
  } else if (UARTx == USART2) {
    duart = &duart_handles[1];
  } else if (UARTx == USART3) {
    duart = &duart_handles[2];
  } else {
    return NULL; // 不支持的 UART 端口
  }

  duart->hal_uart_handle = HAL_UART_Init(UARTx, hal_init);
  if (duart->hal_uart_handle == NULL) {
    return NULL; // HAL 初始化失败
  }

  duart->rx_head = 0;
  duart->rx_tail = 0;
  duart->rx_callback = NULL; // 默认回调函数为空

  HAL_UART_EnableReceiveInterrupt(duart->hal_uart_handle); // 启用接收中断

  return duart;
}

// 发送一个字节数据
HAL_StatusTypeDef DRV_UART_Transmit(DRV_UART_HandleTypeDef* duart, uint8_t data) {
  return HAL_UART_Transmit(duart->hal_uart_handle, data);
}

// 发送多个字节数据
HAL_StatusTypeDef DRV_UART_TransmitBuffer(DRV_UART_HandleTypeDef* duart, uint8_t *pData, uint16_t Size) {
  return HAL_UART_TransmitBuffer(duart->hal_uart_handle, pData, Size);
}

// 从接收缓冲区读取一个字节数据
HAL_StatusTypeDef DRV_UART_ReceiveByte(DRV_UART_HandleTypeDef* duart, uint8_t *data) {
  if (duart->rx_head == duart->rx_tail) {
    return HAL_ERROR; // 接收缓冲区为空
  }

  *data = duart->rx_buffer[duart->rx_tail];
  duart->rx_tail = (duart->rx_tail + 1) % UART_RX_BUFFER_SIZE;
  return HAL_OK;
}

// 获取接收缓冲区可用数据长度
uint16_t DRV_UART_AvailableData(DRV_UART_HandleTypeDef* duart) {
  return (duart->rx_head - duart->rx_tail + UART_RX_BUFFER_SIZE) % UART_RX_BUFFER_SIZE;
}

// 设置接收数据回调函数
void DRV_UART_SetRxCallback(DRV_UART_HandleTypeDef* duart, void (*callback)(uint8_t data)) {
  duart->rx_callback = callback;
}

// UART 中断处理函数 (需要在 STM32 的 UART 中断服务例程中调用)
void DRV_UART_IRQHandler(DRV_UART_HandleTypeDef* duart) {
  HAL_UART_HandleTypeDef* huart = duart->hal_uart_handle;
  if (__HAL_UART_GET_FLAG(huart, UART_FLAG_RXNE) != RESET) { // 接收到数据
    uint8_t data = (uint8_t)(huart->Instance->DR & (uint8_t)0x00FF); // 读取数据寄存器

    duart->rx_buffer[duart->rx_head] = data;
    duart->rx_head = (duart->rx_head + 1) % UART_RX_BUFFER_SIZE;

    if (duart->rx_callback != NULL) {
      duart->rx_callback(data); // 调用回调函数
    }
  }
}

// 获取 UART 驱动句柄
DRV_UART_HandleTypeDef* DRV_UART_GetHandle(UART_TypeDef* UARTx) {
  if (UARTx == USART1) {
    return &duart_handles[0];
  } else if (UARTx == USART2) {
    return &duart_handles[1];
  } else if (UARTx == USART3) {
    return &duart_handles[2];
  } else {
    return NULL;
  }
}

3.7 service_cmd.h - 命令解析服务头文件

#ifndef SERVICE_CMD_H
#define SERVICE_CMD_H

#include "drv_uart.h"
#include "stdint.h"
#include "stdbool.h"

// 命令处理函数类型定义
typedef bool (*CommandHandler)(uint8_t *params, uint8_t param_len);

// 命令结构体
typedef struct {
  char *command_name;    // 命令名称
  CommandHandler handler; // 命令处理函数
} Command;

// 初始化命令解析服务
void CMD_Service_Init(DRV_UART_HandleTypeDef* duart);

// 注册命令
bool CMD_RegisterCommand(Command *cmd);

// 处理接收到的命令数据
void CMD_ProcessData(uint8_t data);

#endif // SERVICE_CMD_H

3.8 service_cmd.c - 命令解析服务源文件

#include "service_cmd.h"
#include "string.h"
#include "stdio.h"

#define CMD_BUFFER_SIZE 128  // 命令缓冲区大小
#define MAX_COMMANDS    10   // 最大支持命令数量

static DRV_UART_HandleTypeDef *cmd_uart_handle;
static uint8_t cmd_buffer[CMD_BUFFER_SIZE];
static uint16_t cmd_buffer_len = 0;
static Command registered_commands[MAX_COMMANDS];
static uint8_t command_count = 0;

// 命令分隔符和参数分隔符
#define CMD_DELIMITER   '\r' // 回车符作为命令结束符
#define PARAM_DELIMITER ','  // 逗号作为参数分隔符

// 初始化命令解析服务
void CMD_Service_Init(DRV_UART_HandleTypeDef* duart) {
  cmd_uart_handle = duart;
  cmd_buffer_len = 0;
  memset(cmd_buffer, 0, sizeof(cmd_buffer));
  command_count = 0;

  // 设置 UART 接收回调函数
  DRV_UART_SetRxCallback(duart, CMD_ProcessData);
}

// 注册命令
bool CMD_RegisterCommand(Command *cmd) {
  if (command_count >= MAX_COMMANDS) {
    return false; // 命令数量已达上限
  }
  registered_commands[command_count++] = *cmd;
  return true;
}

// 处理接收到的命令数据
void CMD_ProcessData(uint8_t data) {
  cmd_buffer[cmd_buffer_len++] = data;

  if (data == CMD_DELIMITER || cmd_buffer_len >= CMD_BUFFER_SIZE - 1) { // 接收到命令结束符或缓冲区满
    cmd_buffer[cmd_buffer_len] = '\0'; // 字符串结束符
    CMD_ExecuteCommand(cmd_buffer);
    cmd_buffer_len = 0; // 清空缓冲区
    memset(cmd_buffer, 0, sizeof(cmd_buffer));
  }
}

// 执行命令
static void CMD_ExecuteCommand(uint8_t *command_str) {
  char *cmd_name_str = strtok((char *)command_str, " "); // 使用空格分隔命令名和参数
  if (cmd_name_str == NULL) {
    return; // 命令为空
  }

  char *param_str = strtok(NULL, " "); // 获取参数字符串 (如果有)
  uint8_t params[10]; // 假设最多 10 个参数
  uint8_t param_len = 0;

  if (param_str != NULL) {
    char *param_token = strtok(param_str, ","); // 使用逗号分隔参数
    while (param_token != NULL && param_len < sizeof(params)) {
      params[param_len++] = atoi(param_token); // 将参数字符串转换为整数
      param_token = strtok(NULL, ",");
    }
  }

  for (uint8_t i = 0; i < command_count; i++) {
    if (strcmp(cmd_name_str, registered_commands[i].command_name) == 0) {
      if (registered_commands[i].handler != NULL) {
        if (registered_commands[i].handler(params, param_len)) {
          CMD_SendResponse("OK\r\n"); // 命令执行成功
        } else {
          CMD_SendResponse("ERROR\r\n"); // 命令执行失败
        }
        return;
      }
    }
  }

  CMD_SendResponse("UNKNOWN CMD\r\n"); // 未知命令
}

// 发送命令响应
static void CMD_SendResponse(char *response) {
  DRV_UART_TransmitBuffer(cmd_uart_handle, (uint8_t *)response, strlen(response));
}

3.9 service_log.h - 日志服务头文件

#ifndef SERVICE_LOG_H
#define SERVICE_LOG_H

#include "drv_uart.h"
#include "stdio.h"

// 初始化日志服务
void LOG_Service_Init(DRV_UART_HandleTypeDef* duart);

// 记录日志信息
void LOG_Info(const char *format, ...);
void LOG_Warn(const char *format, ...);
void LOG_Error(const char *format, ...);
void LOG_Debug(const char *format, ...);

#endif // SERVICE_LOG_H

3.10 service_log.c - 日志服务源文件

#include "service_log.h"
#include "stdarg.h"
#include "string.h"
#include "stdio.h"
#include "config.h" // 可以使用配置来控制日志级别

static DRV_UART_HandleTypeDef *log_uart_handle;

// 初始化日志服务
void LOG_Service_Init(DRV_UART_HandleTypeDef* duart) {
  log_uart_handle = duart;
}

// 记录日志信息 (通用函数)
static void LOG_Output(const char *level, const char *format, va_list args) {
  char log_buffer[256]; // 日志缓冲区
  char output_buffer[300]; // 输出缓冲区，包含日志级别和时间戳

  // 格式化日志信息
  vsnprintf(log_buffer, sizeof(log_buffer), format, args);

  // 获取时间戳 (简单示例，可以根据实际系统时间获取)
  uint32_t timestamp = HAL_GetTick(); // 使用 SysTick 获取毫秒级时间戳

  // 格式化输出字符串，包含日志级别、时间戳和日志信息
  snprintf(output_buffer, sizeof(output_buffer), "[%s][%lu] %s\r\n", level, timestamp, log_buffer);

  // 通过 UART 发送日志信息
  DRV_UART_TransmitBuffer(log_uart_handle, (uint8_t *)output_buffer, strlen(output_buffer));
}

// 记录 Info 级别日志
void LOG_Info(const char *format, ...) {
  if (CONFIG_LOG_LEVEL >= LOG_LEVEL_INFO) { // 根据配置判断是否输出 Info 级别日志
    va_list args;
    va_start(args, format);
    LOG_Output("INFO", format, args);
    va_end(args);
  }
}

// 记录 Warn 级别日志
void LOG_Warn(const char *format, ...) {
  if (CONFIG_LOG_LEVEL >= LOG_LEVEL_WARN) {
    va_list args;
    va_start(args, format);
    LOG_Output("WARN", format, args);
    va_end(args);
  }
}

// 记录 Error 级别日志
void LOG_Error(const char *format, ...) {
  if (CONFIG_LOG_LEVEL >= LOG_LEVEL_ERROR) {
    va_list args;
    va_start(args, format);
    LOG_Output("ERROR", format, args);
    va_end(args);
  }
}

// 记录 Debug 级别日志
void LOG_Debug(const char *format, ...) {
  if (CONFIG_LOG_LEVEL >= LOG_LEVEL_DEBUG) {
    va_list args;
    va_start(args, format);
    LOG_Output("DEBUG", format, args);
    va_end(args);
  }
}

3.11 config.h - 配置管理头文件

#ifndef CONFIG_H
#define CONFIG_H

// 日志级别枚举
typedef enum {
  LOG_LEVEL_NONE = 0,
  LOG_LEVEL_ERROR,
  LOG_LEVEL_WARN,
  LOG_LEVEL_INFO,
  LOG_LEVEL_DEBUG,
  LOG_LEVEL_ALL
} LogLevel;

// 系统配置参数结构体
typedef struct {
  uint32_t uart_baudrate; // 串口波特率
  LogLevel log_level;     // 日志级别
} SystemConfig;

// 获取系统配置
SystemConfig* CONFIG_GetConfig(void);

// 加载默认配置
void CONFIG_LoadDefault(void);

// 保存配置到 Flash (示例，需要根据实际存储介质实现)
bool CONFIG_SaveToFlash(void);

// 从 Flash 加载配置 (示例，需要根据实际存储介质实现)
bool CONFIG_LoadFromFlash(void);

// 当前日志级别 (全局变量，方便使用)
extern LogLevel CONFIG_LOG_LEVEL;

#endif // CONFIG_H

3.12 config.c - 配置管理源文件

#include "config.h"
#include "string.h"
#include "stdio.h"

// 默认配置
static SystemConfig default_config = {
  .uart_baudrate = 115200,
  .log_level = LOG_LEVEL_INFO
};

// 当前配置
static SystemConfig current_config;

// 当前日志级别 (全局变量)
LogLevel CONFIG_LOG_LEVEL = LOG_LEVEL_INFO; // 默认日志级别

// 获取系统配置
SystemConfig* CONFIG_GetConfig(void) {
  return &current_config;
}

// 加载默认配置
void CONFIG_LoadDefault(void) {
  memcpy(&current_config, &default_config, sizeof(SystemConfig));
  CONFIG_LOG_LEVEL = current_config.log_level; // 更新全局日志级别变量
}

// 保存配置到 Flash (示例，需要根据实际存储介质实现，这里仅为示例)
bool CONFIG_SaveToFlash(void) {
  // 假设 Flash 地址为 0x08080000
  // 实际 Flash 操作需要使用 STM32 的 Flash 驱动库
  // 这里为了简化，仅打印信息
  printf("Saving config to Flash...\r\n");
  printf("UART Baudrate: %lu\r\n", current_config.uart_baudrate);
  printf("Log Level: %d\r\n", current_config.log_level);
  return true; // 假设保存成功
}

// 从 Flash 加载配置 (示例，需要根据实际存储介质实现，这里仅为示例)
bool CONFIG_LoadFromFlash(void) {
  // 假设 Flash 地址为 0x08080000
  // 实际 Flash 操作需要使用 STM32 的 Flash 驱动库
  // 这里为了简化，直接加载默认配置
  printf("Loading config from Flash...\r\n");
  CONFIG_LoadDefault(); // 简化处理，直接加载默认配置
  return true; // 假设加载成功
}

3.13 app.h - 应用层头文件

#ifndef APP_H
#define APP_H

#include "drv_uart.h"

// 初始化应用
void APP_Init(DRV_UART_HandleTypeDef* duart);

// 应用主循环
void APP_Run(void);

#endif // APP_H

3.14 app.c - 应用层源文件

#include "app.h"
#include "service_cmd.h"
#include "service_log.h"
#include "config.h"
#include "stdio.h"
#include "string.h"

static DRV_UART_HandleTypeDef *app_uart_handle;

// 命令处理函数示例 - 获取版本信息
static bool CMD_Handler_Version(uint8_t *params, uint8_t param_len) {
  LOG_Info("Firmware Version: V1.0.0");
  return true;
}

// 命令处理函数示例 - 设置日志级别
static bool CMD_Handler_LogLevel(uint8_t *params, uint8_t param_len) {
  if (param_len == 1) {
    LogLevel level = params[0];
    if (level >= LOG_LEVEL_NONE && level <= LOG_LEVEL_ALL) {
      CONFIG_LOG_LEVEL = level; // 更新全局日志级别
      CONFIG_GetConfig()->log_level = level; // 更新配置结构体中的日志级别
      LOG_Info("Set Log Level to: %d", level);
      return true;
    } else {
      LOG_Error("Invalid Log Level: %d", level);
      return false;
    }
  } else {
    LOG_Error("Invalid parameter count for LogLevel command");
    return false;
  }
}

// 命令处理函数示例 - 回显命令
static bool CMD_Handler_Echo(uint8_t *params, uint8_t param_len) {
    char echo_str[100] = "Echo: ";
    char param_str[20];
    for(int i = 0; i < param_len; i++){
        sprintf(param_str, "%d,", params[i]);
        strcat(echo_str, param_str);
    }
    strcat(echo_str, "\r\n");
    DRV_UART_TransmitBuffer(app_uart_handle, (uint8_t *)echo_str, strlen(echo_str));
    return true;
}


// 初始化应用
void APP_Init(DRV_UART_HandleTypeDef* duart) {
  app_uart_handle = duart;

  // 初始化命令服务
  CMD_Service_Init(duart);

  // 注册命令
  Command cmd_version = {"version", CMD_Handler_Version};
  CMD_RegisterCommand(&cmd_version);

  Command cmd_loglevel = {"loglevel", CMD_Handler_LogLevel};
  CMD_RegisterCommand(&cmd_loglevel);

  Command cmd_echo = {"echo", CMD_Handler_Echo};
  CMD_RegisterCommand(&cmd_echo);

  // 初始化日志服务
  LOG_Service_Init(duart);
  LOG_Info("Application Initialized");

  // 加载配置
  CONFIG_LoadFromFlash(); // 尝试从 Flash 加载配置
  LOG_Info("Current Log Level: %d", CONFIG_LOG_LEVEL);
}

// 应用主循环
void APP_Run(void) {
  while (1) {
    LED_Toggle(); // LED 闪烁，指示系统运行
    Delay_ms(1000);
  }
}

3.15 main.c - 主程序文件

#include "main.h"
#include "bsp.h"
#include "hal_uart.h"
#include "drv_uart.h"
#include "app.h"
#include "config.h"
#include "service_log.h"

DRV_UART_HandleTypeDef huart_dbg; // 调试串口句柄

int main(void) {
  // HAL 库初始化
  HAL_Init();

  // 系统时钟配置
  SystemClock_Config();

  // SysTick 初始化 (用于延时)
  SysTick_Init();

  // LED 初始化 (用于指示和调试)
  LED_Init();

  // 初始化调试串口 (USART1，连接到 CH340N 模块)
  HAL_UART_InitTypeDef uart_init;
  uart_init.BaudRate = CONFIG_GetConfig()->uart_baudrate; // 从配置中读取波特率
  uart_init.WordLength = UART_WORDLENGTH_8B;
  uart_init.StopBits = UART_STOPBITS_1;
  uart_init.Parity = UART_PARITY_NONE;
  uart_init.HardwareFlowControl = UART_HWCONTROL_NONE;
  uart_init.Mode = UART_MODE_TX_RX;

  huart_dbg = *DRV_UART_Init(USART1, &uart_init); // 初始化 UART 驱动

  if(huart_dbg.hal_uart_handle == NULL){
      Error_Handler(); // UART 初始化失败
  }

  // 初始化日志服务 (使用调试串口)
  LOG_Service_Init(&huart_dbg);

  // 应用初始化
  APP_Init(&huart_dbg);

  LOG_Info("System Started");

  // 启动应用主循环
  APP_Run();

  return 0;
}

// USART1 中断服务例程
void USART1_IRQHandler(void) {
  DRV_UART_IRQHandler(&huart_dbg); // 调用 UART 驱动的中断处理函数
}

3.16 main.h - 主程序头文件

#ifndef MAIN_H
#define MAIN_H

#include "stm32f10x_hal.h"
#include "drv_uart.h"

// 错误处理函数声明 (在 bsp.c 中实现)
void Error_Handler(void);

// 调试串口句柄声明 (在 main.c 中定义)
extern DRV_UART_HandleTypeDef huart_dbg;

#endif /* MAIN_H */

4. 测试验证阶段

测试验证阶段是确保系统功能和性能满足需求的关键环节。测试可以分为以下几个层次：

• 单元测试： 对每个模块进行单独测试，例如，UART 驱动模块的收发功能、命令解析模块的命令解析功能等。
• 集成测试： 将各个模块集成起来进行测试，验证模块之间的接口和协作是否正常。
• 系统测试： 对整个系统进行测试，验证系统功能、性能、可靠性是否满足需求。
• 性能测试： 测试系统的性能指标，例如，数据传输速率、响应时间、资源占用率等。
• 可靠性测试： 进行长时间运行测试、压力测试、异常情况测试，验证系统的可靠性和稳定性。

针对 CH340N 串口模块嵌入式系统的测试要点：

• 串口数据收发测试：
  • 使用串口调试助手向上位机发送数据，验证嵌入式系统是否能够正确接收并处理数据。
  • 嵌入式系统向上位机发送数据，验证上位机是否能够正确接收数据。
  • 测试不同波特率、数据位、停止位、校验位等参数下的数据收发。
  • 进行大数据量、高频率的数据传输测试，验证系统的传输性能和稳定性。
• 命令解析功能测试：
  • 向上位机发送预定义的命令，验证命令解析服务是否能够正确解析命令和参数。
  • 测试不同命令和参数组合的解析，验证命令解析服务的鲁棒性。
  • 验证命令处理函数的执行结果是否符合预期。
• 日志服务功能测试：
  • 在代码中添加不同级别的日志信息，验证日志服务是否能够正确记录和输出日志。
  • 测试不同日志级别下的日志输出控制是否正常。
  • 验证日志信息的格式和内容是否符合要求。
• 配置管理功能测试：
  • 测试配置参数的加载、保存、修改功能是否正常。
  • 验证配置参数修改后是否能够立即生效。
  • 测试配置参数在掉电重启后是否能够正确恢复。
• 可靠性和稳定性测试：
  • 进行长时间运行测试，例如，连续运行 24 小时或更长时间，观察系统是否出现异常。
  • 进行压力测试，例如，高频率、大数据量的数据传输，验证系统在高负载下的稳定性。
  • 进行异常情况测试，例如，模拟电源掉电、串口连接断开等异常情况，验证系统的容错能力。

5. 维护升级阶段

维护升级阶段是系统发布后，对系统进行维护和升级，以修复 bug、添加新功能、提升性能、适应新的需求。

维护：

• Bug 修复： 及时修复测试阶段和用户反馈的 bug，确保系统稳定运行。
• 性能优化： 根据实际运行情况，对系统进行性能优化，提高效率和响应速度。
• 安全加固： 针对潜在的安全漏洞进行加固，提高系统的安全性。

升级：

• 功能扩展： 根据用户需求或市场变化，添加新的功能模块，扩展系统的应用范围。
• 硬件升级： 适配新的硬件平台，例如，更换更高性能的微控制器或外围模块。
• 软件架构升级： 对软件架构进行优化和升级，提高系统的可扩展性和可维护性。
• 固件升级： 支持固件在线升级 (OTA - Over-The-Air)，方便用户升级固件，获取最新功能和 bug 修复。

针对 CH340N 串口模块嵌入式系统的维护升级要点：

• 固件升级策略： 设计可靠的固件升级策略，例如，通过串口或 USB 接口进行固件升级。
• 版本控制： 使用版本控制工具 (如 Git) 管理代码，方便代码维护和版本管理。
• 模块化设计： 模块化设计能够降低维护和升级的难度，方便替换和修改模块。
• 良好的文档： 编写详细的开发文档、用户文档、维护文档，方便后期维护和升级。
• 用户反馈机制： 建立用户反馈机制，及时收集用户反馈，了解用户需求，改进系统。

总结

以上是一个基于 CH340N 串口模块的嵌入式系统开发流程的详细说明和 C 代码示例。我们从需求分析开始，经历了系统设计、实现、测试验证，直至维护升级，构建了一个可靠、高效、可扩展的嵌入式系统平台。代码示例涵盖了分层架构和模块化设计的思想，包括 HAL 层、驱动层、服务层、应用层等，以及 UART 驱动、命令解析服务、日志服务、配置管理等模块。

这 3000 多行的 C 代码示例，虽然只是一个基础框架，但已经展示了一个完整的嵌入式系统软件架构设计和实现思路。在实际项目中，还需要根据具体的应用场景和需求，进行更深入的开发和完善。例如，可以添加更复杂的数据处理算法、更完善的错误处理机制、更丰富的外围设备驱动、更友好的用户交互界面等。

希望这个详细的解答能够帮助你理解嵌入式系统开发流程和代码架构设计，并为你实际的项目开发提供参考。